org.apache.shardingsphere.sql.parser.autogen.OpenGaussStatementParser Maven / Gradle / Ivy
The newest version!
// 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, SIGNED_LEFT_SHIFT_E_=75, SIGNED_RIGHT_SHIFT_E_=76,
DN_=77, CUBE_ROOT_=78, WS=79, SELECT=80, INSERT=81, UPDATE=82, DELETE=83,
CREATE=84, ALTER=85, DROP=86, TRUNCATE=87, SCHEMA=88, GRANT=89, REVOKE=90,
ADD=91, SET=92, TABLE=93, COLUMN=94, INDEX=95, CONSTRAINT=96, PRIMARY=97,
UNIQUE=98, FOREIGN=99, KEY=100, POSITION=101, PRECISION=102, FUNCTION=103,
TRIGGER=104, PROCEDURE=105, VIEW=106, INTO=107, VALUES=108, WITH=109,
UNION=110, DISTINCT=111, MAXSIZE=112, CASE=113, WHEN=114, CAST=115, TRIM=116,
SUBSTRING=117, FROM=118, NATURAL=119, JOIN=120, FULL=121, INNER=122, OUTER=123,
LEFT=124, RIGHT=125, CROSS=126, USING=127, WHERE=128, AS=129, ON=130,
IF=131, ELSE=132, THEN=133, FOR=134, TO=135, AND=136, OR=137, IS=138,
NOT=139, NULL=140, TRUE=141, FALSE=142, EXISTS=143, BETWEEN=144, IN=145,
ALL=146, ANY=147, LIKE=148, ORDER=149, GROUP=150, BY=151, ASC=152, DESC=153,
HAVING=154, LIMIT=155, OFFSET=156, BEGIN=157, COMMIT=158, ROLLBACK=159,
SAVEPOINT=160, BOOLEAN=161, DOUBLE=162, CHAR=163, CHARACTER=164, ARRAY=165,
INTERVAL=166, DATE=167, TIME=168, TIMESTAMP=169, LOCALTIME=170, LOCALTIMESTAMP=171,
YEAR=172, QUARTER=173, MONTH=174, WEEK=175, DAY=176, HOUR=177, MINUTE=178,
SECOND=179, MICROSECOND=180, DEFAULT=181, CURRENT=182, ENABLE=183, DISABLE=184,
CALL=185, INSTANCE=186, PRESERVE=187, DO=188, DEFINER=189, CURRENT_USER=190,
SQL=191, CASCADED=192, LOCAL=193, CLOSE=194, OPEN=195, NEXT=196, NAME=197,
COLLATION=198, NAMES=199, INTEGER=200, REAL=201, DECIMAL=202, TYPE=203,
SMALLINT=204, BIGINT=205, NUMERIC=206, TEXT=207, REPEATABLE=208, CURRENT_DATE=209,
CURRENT_TIME=210, CURRENT_TIMESTAMP=211, NULLIF=212, VARYING=213, NATIONAL=214,
NCHAR=215, VALUE=216, BOTH=217, LEADING=218, TRAILING=219, COALESCE=220,
INTERSECT=221, EXCEPT=222, PACKAGE=223, MINUS=224, TIES=225, FETCH=226,
CUBE=227, GROUPING=228, SETS=229, WINDOW=230, OTHERS=231, OVERLAPS=232,
SOME=233, AT=234, DEC=235, END=236, LESS=237, THAN=238, MAXVALUE=239,
FOR_GENERATOR=240, ADMIN=241, BINARY=242, ESCAPE=243, EXCLUDE=244, MOD=245,
PARTITION=246, ROW=247, UNKNOWN=248, ALWAYS=249, CASCADE=250, CHECK=251,
GENERATED=252, ISOLATION=253, LEVEL=254, NO=255, OPTION=256, PRIVILEGES=257,
READ=258, REFERENCES=259, ROLE=260, ROWS=261, START=262, TRANSACTION=263,
USER=264, ACTION=265, CACHE=266, CHARACTERISTICS=267, CLUSTER=268, COLLATE=269,
COMMENTS=270, CONCURRENTLY=271, CONNECT=272, CONSTRAINTS=273, CYCLE=274,
DATA=275, DATABASE=276, DEFAULTS=277, DEFERRABLE=278, DEFERRED=279, DEPENDS=280,
DOMAIN=281, EXCLUDING=282, EXECUTE=283, EXTENDED=284, EXTENSION=285, EXTERNAL=286,
EXTRACT=287, FILTER=288, FIRST=289, FOLLOWING=290, FORCE=291, GLOBAL=292,
IDENTITY=293, IMMEDIATE=294, INCLUDING=295, INCREMENT=296, INDEXES=297,
INHERIT=298, INHERITS=299, INITIALLY=300, INCLUDE=301, LANGUAGE=302, LARGE=303,
LAST=304, LOGGED=305, MAIN=306, MATCH=307, MINVALUE=308, NOTHING=309,
NULLS=310, OBJECT=311, OIDS=312, ONLY=313, OVER=314, OWNED=315, OWNER=316,
PARTIAL=317, PLAIN=318, PRECEDING=319, RANGE=320, RENAME=321, REPLICA=322,
RESET=323, RESTART=324, RESTRICT=325, ROUTINE=326, SYNONYM=327, RULE=328,
SECURITY=329, SEQUENCE=330, SESSION=331, SESSION_USER=332, SHOW=333, SIMPLE=334,
STATISTICS=335, STORAGE=336, TABLESPACE=337, TEMP=338, TEMPORARY=339,
UNBOUNDED=340, UNLOGGED=341, USAGE=342, VALID=343, VALIDATE=344, WITHIN=345,
WITHOUT=346, ZONE=347, OF=348, UESCAPE=349, GROUPS=350, RECURSIVE=351,
INT=352, INT2=353, INT4=354, INT8=355, FLOAT=356, FLOAT4=357, FLOAT8=358,
SMALLSERIAL=359, SERIAL=360, BIGSERIAL=361, VARCHAR=362, BYTEA=363, ENUM=364,
POINT=365, LINE=366, LSEG=367, BOX=368, PATH=369, POLYGON=370, CIRCLE=371,
CIDR=372, INET=373, MACADDR=374, MACADDR8=375, BIT=376, VARBIT=377, TSVECTOR=378,
TSQUERY=379, XML=380, JSON=381, INT4RANGE=382, INT8RANGE=383, NUMRANGE=384,
TSRANGE=385, TSTZRANGE=386, DATERANGE=387, TABLESAMPLE=388, ORDINALITY=389,
CURRENT_ROLE=390, CURRENT_CATALOG=391, CURRENT_SCHEMA=392, NORMALIZE=393,
OVERLAY=394, XMLCONCAT=395, XMLELEMENT=396, XMLEXISTS=397, XMLFOREST=398,
XMLPARSE=399, XMLPI=400, XMLROOT=401, XMLSERIALIZE=402, TREAT=403, SETOF=404,
NFC=405, NFD=406, NFKC=407, NFKD=408, XMLATTRIBUTES=409, REF=410, PASSING=411,
VERSION=412, YES=413, STANDALONE=414, GREATEST=415, LEAST=416, MATERIALIZED=417,
OPERATOR=418, SHARE=419, ROLLUP=420, ILIKE=421, SIMILAR=422, ISNULL=423,
NOTNULL=424, SYMMETRIC=425, DOCUMENT=426, NORMALIZED=427, ASYMMETRIC=428,
VARIADIC=429, NOWAIT=430, LOCKED=431, XMLTABLE=432, COLUMNS=433, CONTENT=434,
STRIP=435, WHITESPACE=436, XMLNAMESPACES=437, PLACING=438, RETURNING=439,
LATERAL=440, NONE=441, ANALYSE=442, ANALYZE=443, CONFLICT=444, OVERRIDING=445,
SYSTEM=446, ABORT=447, ABSOLUTE=448, ACCESS=449, AFTER=450, AGGREGATE=451,
ALSO=452, ATTACH=453, ATTRIBUTE=454, BACKWARD=455, BEFORE=456, ASSERTION=457,
ASSIGNMENT=458, CONTINUE=459, CONVERSION=460, COPY=461, COST=462, CSV=463,
CALLED=464, CATALOG=465, CHAIN=466, CHECKPOINT=467, CLASS=468, CONFIGURATION=469,
COMMENT=470, DETACH=471, DICTIONARY=472, DIRECTORY=473, EXPRESSION=474,
INSENSITIVE=475, DISCARD=476, OFF=477, INSTEAD=478, EXPLAIN=479, INPUT=480,
INLINE=481, PARALLEL=482, LEAKPROOF=483, COMMITTED=484, ENCODING=485,
IMPLICIT=486, DELIMITER=487, CURSOR=488, EACH=489, EVENT=490, DEALLOCATE=491,
CONNECTION=492, DECLARE=493, FAMILY=494, FORWARD=495, EXCLUSIVE=496, FUNCTIONS=497,
LOCATION=498, LABEL=499, DELIMITERS=500, HANDLER=501, HEADER=502, IMMUTABLE=503,
GRANTED=504, HOLD=505, MAPPING=506, OLD=507, METHOD=508, LOAD=509, LISTEN=510,
MODE=511, MOVE=512, PROCEDURAL=513, PARSER=514, PROCEDURES=515, ENCRYPTED=516,
PUBLICATION=517, PROGRAM=518, REFERENCING=519, PLANS=520, REINDEX=521,
PRIOR=522, PASSWORD=523, RELATIVE=524, QUOTE=525, ROUTINES=526, REPLACE=527,
SNAPSHOT=528, REFRESH=529, PREPARE=530, OPTIONS=531, IMPORT=532, INVOKER=533,
NEW=534, PREPARED=535, SCROLL=536, SEQUENCES=537, SYSID=538, REASSIGN=539,
SERVER=540, SUBSCRIPTION=541, SEARCH=542, SCHEMAS=543, RECHECK=544, POLICY=545,
NOTIFY=546, LOCK=547, RELEASE=548, SERIALIZABLE=549, RETURNS=550, STATEMENT=551,
STDIN=552, STDOUT=553, TABLES=554, SUPPORT=555, STABLE=556, TEMPLATE=557,
UNENCRYPTED=558, VIEWS=559, UNCOMMITTED=560, TRANSFORM=561, UNLISTEN=562,
TRUSTED=563, VALIDATOR=564, UNTIL=565, VACUUM=566, VOLATILE=567, STORED=568,
WRITE=569, STRICT=570, TYPES=571, WRAPPER=572, WORK=573, FREEZE=574, AUTHORIZATION=575,
VERBOSE=576, PERFORMANCE=577, PARAM=578, OUT=579, INOUT=580, DUPLICATE=581,
PREDICT=582, FEATURES=583, TS_REWRITE=584, INT16=585, INT1=586, ELEM_CONTAINED_BY_RANGE=587,
LOWER_INF=588, UPPER_INF=589, ABBREV=590, SET_MASKLEN=591, TRUNC=592,
CLIENT_MASTER_KEY=593, COLUMN_ENCRYPTION_KEY=594, IDENTIFIER_=595, STRING_=596,
NUMBER_=597, HEX_DIGIT_=598, BIT_NUM_=599, FILESIZE_LITERAL=600;
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_checkpoint = 17, RULE_lock = 18, RULE_lockType = 19, RULE_insert = 20,
RULE_insertTarget = 21, RULE_insertRest = 22, RULE_overrideKind = 23,
RULE_insertColumnList = 24, RULE_insertColumnItem = 25, RULE_optOnDuplicateKey = 26,
RULE_assignment = 27, RULE_update = 28, RULE_setClauseList = 29, RULE_setClause = 30,
RULE_setTarget = 31, RULE_setTargetList = 32, RULE_returningClause = 33,
RULE_delete = 34, RULE_relationExprOptAlias = 35, RULE_usingClause = 36,
RULE_select = 37, RULE_selectWithParens = 38, RULE_selectNoParens = 39,
RULE_selectClauseN = 40, RULE_simpleSelect = 41, RULE_withClause = 42,
RULE_intoClause = 43, RULE_optTempTableName = 44, RULE_cteList = 45, RULE_commonTableExpr = 46,
RULE_optMaterialized = 47, RULE_optNameList = 48, RULE_preparableStmt = 49,
RULE_forLockingClause = 50, RULE_forLockingItems = 51, RULE_forLockingItem = 52,
RULE_nowaitOrSkip = 53, RULE_forLockingStrength = 54, RULE_lockedRelsList = 55,
RULE_qualifiedNameList = 56, RULE_selectLimit = 57, RULE_valuesClause = 58,
RULE_limitClause = 59, RULE_offsetClause = 60, RULE_selectLimitValue = 61,
RULE_selectOffsetValue = 62, RULE_selectFetchValue = 63, RULE_rowOrRows = 64,
RULE_firstOrNext = 65, RULE_onlyOrWithTies = 66, RULE_targetList = 67,
RULE_targetEl = 68, RULE_groupClause = 69, RULE_groupByList = 70, RULE_groupByItem = 71,
RULE_emptyGroupingSet = 72, RULE_rollupClause = 73, RULE_cubeClause = 74,
RULE_groupingSetsClause = 75, RULE_windowClause = 76, RULE_windowDefinitionList = 77,
RULE_windowDefinition = 78, RULE_windowSpecification = 79, RULE_existingWindowName = 80,
RULE_partitionClause = 81, RULE_frameClause = 82, RULE_frameExtent = 83,
RULE_frameBound = 84, RULE_optWindowExclusionClause = 85, RULE_alias = 86,
RULE_fromClause = 87, RULE_fromList = 88, RULE_tableReference = 89, RULE_joinedTable = 90,
RULE_crossJoinType = 91, RULE_innerJoinType = 92, RULE_outerJoinType = 93,
RULE_naturalJoinType = 94, RULE_joinQual = 95, RULE_relationExpr = 96,
RULE_whereClause = 97, RULE_whereOrCurrentClause = 98, RULE_havingClause = 99,
RULE_doStatement = 100, RULE_dostmtOptList = 101, RULE_dostmtOptItem = 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_modelName = 128, RULE_tableNames = 129, RULE_columnNames = 130, RULE_collationName = 131,
RULE_indexName = 132, RULE_constraintName = 133, RULE_primaryKey = 134,
RULE_andOperator = 135, RULE_orOperator = 136, RULE_comparisonOperator = 137,
RULE_inetOperator = 138, RULE_patternMatchingOperator = 139, RULE_cursorName = 140,
RULE_aExpr = 141, RULE_bExpr = 142, RULE_cExpr = 143, RULE_indirection = 144,
RULE_optIndirection = 145, RULE_indirectionEl = 146, RULE_sliceBound = 147,
RULE_inExpr = 148, RULE_caseExpr = 149, RULE_whenClauseList = 150, RULE_whenClause = 151,
RULE_caseDefault = 152, RULE_caseArg = 153, RULE_columnref = 154, RULE_qualOp = 155,
RULE_subqueryOp = 156, RULE_allOp = 157, RULE_op = 158, RULE_mathOperator = 159,
RULE_jsonOperator = 160, RULE_geometricOperator = 161, RULE_qualAllOp = 162,
RULE_ascDesc = 163, RULE_anyOperator = 164, RULE_windowExclusionClause = 165,
RULE_row = 166, RULE_explicitRow = 167, RULE_implicitRow = 168, RULE_subType = 169,
RULE_arrayExpr = 170, RULE_arrayExprList = 171, RULE_funcArgList = 172,
RULE_paramName = 173, RULE_funcArgExpr = 174, RULE_typeList = 175, RULE_funcApplication = 176,
RULE_funcName = 177, RULE_aexprConst = 178, RULE_numberConst = 179, RULE_qualifiedName = 180,
RULE_colId = 181, RULE_typeFunctionName = 182, RULE_functionTable = 183,
RULE_xmlTable = 184, RULE_xmlTableColumnList = 185, RULE_xmlTableColumnEl = 186,
RULE_xmlTableColumnOptionList = 187, RULE_xmlTableColumnOptionEl = 188,
RULE_xmlNamespaceList = 189, RULE_xmlNamespaceEl = 190, RULE_funcExpr = 191,
RULE_withinGroupClause = 192, RULE_filterClause = 193, RULE_functionExprWindowless = 194,
RULE_ordinality = 195, RULE_functionExprCommonSubexpr = 196, RULE_typeName = 197,
RULE_simpleTypeName = 198, RULE_constTypeName = 199, RULE_exprList = 200,
RULE_extractList = 201, RULE_extractArg = 202, RULE_genericType = 203,
RULE_typeModifiers = 204, RULE_numeric = 205, RULE_constDatetime = 206,
RULE_timezone = 207, RULE_character = 208, RULE_characterWithLength = 209,
RULE_characterWithoutLength = 210, RULE_characterClause = 211, RULE_optFloat = 212,
RULE_attrs = 213, RULE_attrName = 214, RULE_colLable = 215, RULE_bit = 216,
RULE_bitWithLength = 217, RULE_bitWithoutLength = 218, RULE_constInterval = 219,
RULE_optInterval = 220, RULE_optArrayBounds = 221, RULE_intervalSecond = 222,
RULE_unicodeNormalForm = 223, RULE_trimList = 224, RULE_overlayList = 225,
RULE_overlayPlacing = 226, RULE_substrFrom = 227, RULE_substrFor = 228,
RULE_positionList = 229, RULE_substrList = 230, RULE_xmlAttributes = 231,
RULE_xmlAttributeList = 232, RULE_xmlAttributeEl = 233, RULE_xmlExistsArgument = 234,
RULE_xmlPassingMech = 235, RULE_documentOrContent = 236, RULE_xmlWhitespaceOption = 237,
RULE_xmlRootVersion = 238, RULE_xmlRootStandalone = 239, RULE_rowsFromItem = 240,
RULE_rowsFromList = 241, RULE_columnDefList = 242, RULE_tableFuncElementList = 243,
RULE_tableFuncElement = 244, RULE_collateClause = 245, RULE_anyName = 246,
RULE_aliasClause = 247, RULE_directoryName = 248, RULE_packageName = 249,
RULE_pathString = 250, RULE_nameList = 251, RULE_funcAliasClause = 252,
RULE_tablesampleClause = 253, RULE_repeatableClause = 254, RULE_allOrDistinct = 255,
RULE_sortClause = 256, RULE_sortbyList = 257, RULE_sortby = 258, RULE_nullsOrder = 259,
RULE_distinctClause = 260, RULE_distinct = 261, RULE_overClause = 262,
RULE_windowName = 263, RULE_indexParams = 264, RULE_indexElemOptions = 265,
RULE_indexElem = 266, RULE_collate = 267, RULE_optClass = 268, RULE_reloptions = 269,
RULE_reloptionList = 270, RULE_reloptionElem = 271, RULE_defArg = 272,
RULE_funcType = 273, RULE_dataType = 274, RULE_dataTypeName = 275, RULE_dataTypeLength = 276,
RULE_characterSet = 277, RULE_ignoredIdentifier = 278, RULE_ignoredIdentifiers = 279,
RULE_signedIconst = 280, RULE_booleanOrString = 281, RULE_nonReservedWord = 282,
RULE_colNameKeyword = 283, RULE_databaseName = 284, RULE_roleSpec = 285,
RULE_varName = 286, RULE_varList = 287, RULE_varValue = 288, RULE_zoneValue = 289,
RULE_numericOnly = 290, RULE_isoLevel = 291, RULE_columnDef = 292, RULE_colQualList = 293,
RULE_colConstraint = 294, RULE_constraintAttr = 295, RULE_colConstraintElem = 296,
RULE_parenthesizedSeqOptList = 297, RULE_seqOptList = 298, RULE_seqOptElem = 299,
RULE_optColumnList = 300, RULE_columnElem = 301, RULE_columnList = 302,
RULE_generatedWhen = 303, RULE_noInherit = 304, RULE_consTableSpace = 305,
RULE_definition = 306, RULE_defList = 307, RULE_defElem = 308, RULE_colLabel = 309,
RULE_keyActions = 310, RULE_keyDelete = 311, RULE_keyUpdate = 312, RULE_keyAction = 313,
RULE_keyMatch = 314, RULE_createGenericOptions = 315, RULE_genericOptionList = 316,
RULE_genericOptionElem = 317, RULE_genericOptionArg = 318, RULE_genericOptionName = 319,
RULE_replicaIdentity = 320, RULE_operArgtypes = 321, RULE_funcArg = 322,
RULE_argClass = 323, RULE_funcArgsList = 324, RULE_nonReservedWordOrSconst = 325,
RULE_fileName = 326, RULE_roleList = 327, RULE_setResetClause = 328, RULE_setRest = 329,
RULE_transactionModeList = 330, RULE_transactionModeItem = 331, RULE_setRestMore = 332,
RULE_encoding = 333, RULE_genericSet = 334, RULE_variableResetStmt = 335,
RULE_resetRest = 336, RULE_genericReset = 337, RULE_relationExprList = 338,
RULE_commonFuncOptItem = 339, RULE_functionSetResetClause = 340, RULE_rowSecurityCmd = 341,
RULE_event = 342, RULE_typeNameList = 343, RULE_ifNotExists = 344, RULE_ifExists = 345,
RULE_grant = 346, RULE_revoke = 347, RULE_optionForClause = 348, RULE_createUser = 349,
RULE_createOptRoleElem = 350, RULE_alterOptRoleElem = 351, RULE_dropBehavior = 352,
RULE_dropUser = 353, RULE_alterUser = 354, RULE_alterUserClauses = 355,
RULE_alterOptRoleList = 356, RULE_createRole = 357, RULE_dropRole = 358,
RULE_alterRole = 359, RULE_createGroup = 360, RULE_dropDroup = 361, RULE_reassignOwned = 362,
RULE_createTable = 363, RULE_executeParamClause = 364, RULE_partitionBoundSpec = 365,
RULE_hashPartbound = 366, RULE_hashPartboundElem = 367, RULE_typedTableElementList = 368,
RULE_typedTableElement = 369, RULE_columnOptions = 370, RULE_withData = 371,
RULE_tableSpace = 372, RULE_onCommitOption = 373, RULE_withOption = 374,
RULE_tableAccessMethodClause = 375, RULE_accessMethod = 376, RULE_createIndex = 377,
RULE_include = 378, RULE_indexIncludingParams = 379, RULE_accessMethodClause = 380,
RULE_createDatabase = 381, RULE_createView = 382, RULE_dropDatabase = 383,
RULE_dropDirectory = 384, RULE_createDatabaseSpecification = 385, RULE_createdbOptName = 386,
RULE_alterTable = 387, RULE_alterIndex = 388, RULE_dropTable = 389, RULE_dropTableOpt = 390,
RULE_dropIndex = 391, RULE_dropIndexOpt = 392, RULE_truncateTable = 393,
RULE_restartSeqs = 394, RULE_createTableSpecification = 395, RULE_createDefinitionClause = 396,
RULE_createDefinition = 397, RULE_columnDefinition = 398, RULE_columnConstraint = 399,
RULE_constraintClause = 400, RULE_columnConstraintOption = 401, RULE_checkOption = 402,
RULE_defaultExpr = 403, RULE_sequenceOptions = 404, RULE_sequenceOption = 405,
RULE_indexParameters = 406, RULE_action = 407, RULE_constraintOptionalParam = 408,
RULE_likeOption = 409, RULE_tableConstraint = 410, RULE_tableConstraintOption = 411,
RULE_exclusionWhereClause = 412, RULE_exclusionConstraintList = 413, RULE_exclusionConstraintElem = 414,
RULE_inheritClause = 415, RULE_partitionSpec = 416, RULE_partParams = 417,
RULE_partElem = 418, RULE_funcExprWindowless = 419, RULE_partStrategy = 420,
RULE_createIndexSpecification = 421, RULE_concurrentlyClause = 422, RULE_onlyClause = 423,
RULE_fileSizeLiteral = 424, RULE_asteriskClause = 425, RULE_alterDefinitionClause = 426,
RULE_partitionCmd = 427, RULE_alterIndexDefinitionClause = 428, RULE_indexPartitionCmd = 429,
RULE_renameIndexSpecification = 430, RULE_alterIndexDependsOnExtension = 431,
RULE_alterIndexSetTableSpace = 432, RULE_tableNamesClause = 433, RULE_tableNameClause = 434,
RULE_alterTableActions = 435, RULE_alterTableAction = 436, RULE_addColumnSpecification = 437,
RULE_dropColumnSpecification = 438, RULE_modifyColumnSpecification = 439,
RULE_modifyColumn = 440, RULE_alterColumnSetOption = 441, RULE_attributeOptions = 442,
RULE_attributeOption = 443, RULE_addConstraintSpecification = 444, RULE_tableConstraintUsingIndex = 445,
RULE_modifyConstraintSpecification = 446, RULE_validateConstraintSpecification = 447,
RULE_dropConstraintSpecification = 448, RULE_storageParameterWithValue = 449,
RULE_storageParameter = 450, RULE_renameColumnSpecification = 451, RULE_renameConstraint = 452,
RULE_renameTableSpecification = 453, RULE_indexNames = 454, RULE_alterDatabase = 455,
RULE_alterDatabaseClause = 456, RULE_createdbOptItems = 457, RULE_createdbOptItem = 458,
RULE_alterTableCmds = 459, RULE_alterTableCmd = 460, RULE_constraintAttributeSpec = 461,
RULE_constraintAttributeElem = 462, RULE_alterGenericOptions = 463, RULE_alterGenericOptionList = 464,
RULE_alterGenericOptionElem = 465, RULE_alterUsing = 466, RULE_setData = 467,
RULE_alterIdentityColumnOptionList = 468, RULE_alterIdentityColumnOption = 469,
RULE_alterColumnDefault = 470, RULE_alterOperator = 471, RULE_alterOperatorClass = 472,
RULE_alterOperatorClassClauses = 473, RULE_alterOperatorFamily = 474,
RULE_alterOperatorFamilyClauses = 475, RULE_opclassItemList = 476, RULE_opclassItem = 477,
RULE_opclassPurpose = 478, RULE_alterOperatorClauses = 479, RULE_operatorDefList = 480,
RULE_operatorDefElem = 481, RULE_operatorDefArg = 482, RULE_operatorWithArgtypes = 483,
RULE_alterAggregate = 484, RULE_aggregateSignature = 485, RULE_aggrArgs = 486,
RULE_aggrArgsList = 487, RULE_aggrArg = 488, RULE_alterAggregateDefinitionClause = 489,
RULE_alterCollation = 490, RULE_alterCollationClause = 491, RULE_alterSynonym = 492,
RULE_alterDirectory = 493, RULE_alterConversion = 494, RULE_alterConversionClause = 495,
RULE_alterDefaultPrivileges = 496, RULE_defACLAction = 497, RULE_grantGrantOption = 498,
RULE_granteeList = 499, RULE_grantee = 500, RULE_defaclPrivilegeTarget = 501,
RULE_privileges = 502, RULE_privilegeList = 503, RULE_privilege = 504,
RULE_defACLOptionList = 505, RULE_defACLOption = 506, RULE_schemaNameList = 507,
RULE_alterDomain = 508, RULE_alterDomainClause = 509, RULE_alterEventTrigger = 510,
RULE_alterEventTriggerClause = 511, RULE_tiggerName = 512, RULE_alterExtension = 513,
RULE_createSynonym = 514, RULE_alterExtensionClauses = 515, RULE_functionWithArgtypes = 516,
RULE_funcArgs = 517, RULE_aggregateWithArgtypes = 518, RULE_alterExtensionOptList = 519,
RULE_alterExtensionOptItem = 520, RULE_alterForeignDataWrapper = 521,
RULE_alterForeignDataWrapperClauses = 522, RULE_fdwOptions = 523, RULE_fdwOption = 524,
RULE_handlerName = 525, RULE_alterGroup = 526, RULE_alterGroupClauses = 527,
RULE_alterLanguage = 528, RULE_alterLargeObject = 529, RULE_alterMaterializedView = 530,
RULE_alterMaterializedViewClauses = 531, RULE_declare = 532, RULE_cursor = 533,
RULE_cursorOptions = 534, RULE_cursorOption = 535, RULE_executeStmt = 536,
RULE_createMaterializedView = 537, RULE_createMvTarget = 538, RULE_refreshMatViewStmt = 539,
RULE_alterPolicy = 540, RULE_alterPolicyClauses = 541, RULE_alterProcedure = 542,
RULE_alterProcedureClauses = 543, RULE_alterfuncOptList = 544, RULE_alterFunction = 545,
RULE_alterFunctionClauses = 546, RULE_alterPublication = 547, RULE_alterRoutine = 548,
RULE_alterRule = 549, RULE_alterSequence = 550, RULE_alterSequenceClauses = 551,
RULE_alterServer = 552, RULE_foreignServerVersion = 553, RULE_alterStatistics = 554,
RULE_alterSubscription = 555, RULE_publicationNameList = 556, RULE_publicationNameItem = 557,
RULE_alterSystem = 558, RULE_alterTablespace = 559, RULE_alterTextSearchConfiguration = 560,
RULE_alterTextSearchConfigurationClauses = 561, RULE_anyNameList = 562,
RULE_alterTextSearchDictionary = 563, RULE_alterTextSearchParser = 564,
RULE_alterTextSearchTemplate = 565, RULE_alterTrigger = 566, RULE_alterType = 567,
RULE_alterTypeClauses = 568, RULE_alterTypeCmds = 569, RULE_alterTypeCmd = 570,
RULE_alterUserMapping = 571, RULE_authIdent = 572, RULE_alterView = 573,
RULE_alterViewClauses = 574, RULE_close = 575, RULE_cluster = 576, RULE_clusterIndexSpecification = 577,
RULE_comment = 578, RULE_commentClauses = 579, RULE_objectTypeNameOnAnyName = 580,
RULE_objectTypeName = 581, RULE_dropTypeName = 582, RULE_objectTypeAnyName = 583,
RULE_commentText = 584, RULE_createAccessMethod = 585, RULE_createAggregate = 586,
RULE_oldAggrDefinition = 587, RULE_oldAggrList = 588, RULE_oldAggrElem = 589,
RULE_createCast = 590, RULE_castContext = 591, RULE_createCollation = 592,
RULE_createConversion = 593, RULE_createDomain = 594, RULE_createEventTrigger = 595,
RULE_eventTriggerWhenList = 596, RULE_eventTriggerWhenItem = 597, RULE_eventTriggerValueList = 598,
RULE_createExtension = 599, RULE_createExtensionOptList = 600, RULE_createExtensionOptItem = 601,
RULE_createForeignDataWrapper = 602, RULE_createForeignTable = 603, RULE_createForeignTableClauses = 604,
RULE_tableElementList = 605, RULE_tableElement = 606, RULE_tableLikeClause = 607,
RULE_tableLikeOptionList = 608, RULE_tableLikeOption = 609, RULE_createFunction = 610,
RULE_tableFuncColumnList = 611, RULE_tableFuncColumn = 612, RULE_createfuncOptList = 613,
RULE_createfuncOptItem = 614, RULE_transformTypeList = 615, RULE_funcAs = 616,
RULE_funcReturn = 617, RULE_funcArgsWithDefaults = 618, RULE_funcArgsWithDefaultsList = 619,
RULE_funcArgWithDefault = 620, RULE_createLanguage = 621, RULE_transformElementList = 622,
RULE_validatorClause = 623, RULE_createPolicy = 624, RULE_createProcedure = 625,
RULE_createPublication = 626, RULE_publicationForTables = 627, RULE_createRule = 628,
RULE_ruleActionList = 629, RULE_ruleActionStmt = 630, RULE_ruleActionMulti = 631,
RULE_notifyStmt = 632, RULE_createTrigger = 633, RULE_triggerEvents = 634,
RULE_triggerOneEvent = 635, RULE_triggerActionTime = 636, RULE_triggerFuncArgs = 637,
RULE_triggerFuncArg = 638, RULE_triggerWhen = 639, RULE_triggerForSpec = 640,
RULE_triggerReferencing = 641, RULE_triggerTransitions = 642, RULE_triggerTransition = 643,
RULE_transitionRelName = 644, RULE_transitionRowOrTable = 645, RULE_transitionOldOrNew = 646,
RULE_createSequence = 647, RULE_tempOption = 648, RULE_createServer = 649,
RULE_createStatistics = 650, RULE_createSubscription = 651, RULE_createTablespace = 652,
RULE_createTextSearch = 653, RULE_createTransform = 654, RULE_createType = 655,
RULE_createTypeClauses = 656, RULE_enumValList = 657, RULE_createUserMapping = 658,
RULE_discard = 659, RULE_dropAccessMethod = 660, RULE_dropAggregate = 661,
RULE_aggregateWithArgtypesList = 662, RULE_dropCast = 663, RULE_dropCollation = 664,
RULE_dropConversion = 665, RULE_dropDomain = 666, RULE_dropEventTrigger = 667,
RULE_dropExtension = 668, RULE_dropForeignDataWrapper = 669, RULE_dropForeignTable = 670,
RULE_dropFunction = 671, RULE_functionWithArgtypesList = 672, RULE_dropLanguage = 673,
RULE_dropMaterializedView = 674, RULE_dropOperator = 675, RULE_operatorWithArgtypesList = 676,
RULE_dropOperatorClass = 677, RULE_dropOperatorFamily = 678, RULE_dropOwned = 679,
RULE_dropPolicy = 680, RULE_dropProcedure = 681, RULE_dropPublication = 682,
RULE_dropRoutine = 683, RULE_dropRule = 684, RULE_dropSequence = 685,
RULE_dropSynonym = 686, RULE_dropServer = 687, RULE_dropStatistics = 688,
RULE_dropSubscription = 689, RULE_dropTablespace = 690, RULE_dropTextSearch = 691,
RULE_dropTransform = 692, RULE_dropTrigger = 693, RULE_dropType = 694,
RULE_dropUserMapping = 695, RULE_dropView = 696, RULE_importForeignSchema = 697,
RULE_importQualification = 698, RULE_importQualificationType = 699, RULE_listen = 700,
RULE_move = 701, RULE_prepare = 702, RULE_deallocate = 703, RULE_prepTypeClause = 704,
RULE_refreshMaterializedView = 705, RULE_reIndex = 706, RULE_reIndexClauses = 707,
RULE_reindexOptionList = 708, RULE_reindexOptionElem = 709, RULE_reindexTargetMultitable = 710,
RULE_reindexTargetType = 711, RULE_alterForeignTable = 712, RULE_alterForeignTableClauses = 713,
RULE_createOperator = 714, RULE_createOperatorClass = 715, RULE_createOperatorFamily = 716,
RULE_securityLabelStmt = 717, RULE_securityLabel = 718, RULE_securityLabelClausces = 719,
RULE_unlisten = 720, RULE_createSchema = 721, RULE_createSchemaClauses = 722,
RULE_schemaEltList = 723, RULE_schemaStmt = 724, RULE_privilegeClause = 725,
RULE_roleClause = 726, RULE_privilegeTypes = 727, RULE_onObjectClause = 728,
RULE_numericOnlyList = 729, RULE_privilegeLevel = 730, RULE_routineName = 731,
RULE_privilegeType = 732, RULE_createDirectory = 733, RULE_alterSchema = 734,
RULE_dropSchema = 735, RULE_fetch = 736, RULE_alterPackage = 737, RULE_direction = 738,
RULE_show = 739, RULE_set = 740, RULE_runtimeScope = 741, RULE_timeZoneClause = 742,
RULE_configurationParameterClause = 743, RULE_resetParameter = 744, RULE_explain = 745,
RULE_explainableStmt = 746, RULE_explainOptionList = 747, RULE_explainOptionElem = 748,
RULE_explainOptionArg = 749, RULE_explainOptionName = 750, RULE_analyzeKeyword = 751,
RULE_analyzeTable = 752, RULE_vacuumRelationList = 753, RULE_vacuumRelation = 754,
RULE_vacAnalyzeOptionList = 755, RULE_vacAnalyzeOptionElem = 756, RULE_vacAnalyzeOptionArg = 757,
RULE_vacAnalyzeOptionName = 758, RULE_load = 759, RULE_vacuum = 760, RULE_emptyStatement = 761,
RULE_call = 762, RULE_callClauses = 763;
private static String[] makeRuleNames() {
return new String[] {
"execute", "setTransaction", "beginTransaction", "commit", "savepoint",
"abort", "startTransaction", "end", "rollback", "releaseSavepoint", "rollbackToSavepoint",
"prepareTransaction", "commitPrepared", "rollbackPrepared", "setConstraints",
"constraintsSetMode", "constraintsSetList", "checkpoint", "lock", "lockType",
"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", "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", "modelName", "tableNames", "columnNames",
"collationName", "indexName", "constraintName", "primaryKey", "andOperator",
"orOperator", "comparisonOperator", "inetOperator", "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",
"dropBehavior", "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", "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_", "SIGNED_LEFT_SHIFT_E_",
"SIGNED_RIGHT_SHIFT_E_", "DN_", "CUBE_ROOT_", "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", "PREDICT", "FEATURES", "TS_REWRITE",
"INT16", "INT1", "ELEM_CONTAINED_BY_RANGE", "LOWER_INF", "UPPER_INF",
"ABBREV", "SET_MASKLEN", "TRUNC", "CLIENT_MASTER_KEY", "COLUMN_ENCRYPTION_KEY",
"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(1646);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(1528);
select();
}
break;
case 2:
{
setState(1529);
insert();
}
break;
case 3:
{
setState(1530);
update();
}
break;
case 4:
{
setState(1531);
delete();
}
break;
case 5:
{
setState(1532);
createIndex();
}
break;
case 6:
{
setState(1533);
alterIndex();
}
break;
case 7:
{
setState(1534);
dropIndex();
}
break;
case 8:
{
setState(1535);
createTable();
}
break;
case 9:
{
setState(1536);
alterTable();
}
break;
case 10:
{
setState(1537);
dropTable();
}
break;
case 11:
{
setState(1538);
truncateTable();
}
break;
case 12:
{
setState(1539);
setTransaction();
}
break;
case 13:
{
setState(1540);
beginTransaction();
}
break;
case 14:
{
setState(1541);
startTransaction();
}
break;
case 15:
{
setState(1542);
end();
}
break;
case 16:
{
setState(1543);
commit();
}
break;
case 17:
{
setState(1544);
commitPrepared();
}
break;
case 18:
{
setState(1545);
rollback();
}
break;
case 19:
{
setState(1546);
rollbackPrepared();
}
break;
case 20:
{
setState(1547);
abort();
}
break;
case 21:
{
setState(1548);
savepoint();
}
break;
case 22:
{
setState(1549);
releaseSavepoint();
}
break;
case 23:
{
setState(1550);
rollbackToSavepoint();
}
break;
case 24:
{
setState(1551);
grant();
}
break;
case 25:
{
setState(1552);
revoke();
}
break;
case 26:
{
setState(1553);
createUser();
}
break;
case 27:
{
setState(1554);
dropUser();
}
break;
case 28:
{
setState(1555);
alterUser();
}
break;
case 29:
{
setState(1556);
createRole();
}
break;
case 30:
{
setState(1557);
dropRole();
}
break;
case 31:
{
setState(1558);
alterRole();
}
break;
case 32:
{
setState(1559);
show();
}
break;
case 33:
{
setState(1560);
set();
}
break;
case 34:
{
setState(1561);
resetParameter();
}
break;
case 35:
{
setState(1562);
call();
}
break;
case 36:
{
setState(1563);
alterAggregate();
}
break;
case 37:
{
setState(1564);
alterFunction();
}
break;
case 38:
{
setState(1565);
alterDatabase();
}
break;
case 39:
{
setState(1566);
alterDomain();
}
break;
case 40:
{
setState(1567);
alterDefaultPrivileges();
}
break;
case 41:
{
setState(1568);
alterForeignTable();
}
break;
case 42:
{
setState(1569);
alterGroup();
}
break;
case 43:
{
setState(1570);
alterMaterializedView();
}
break;
case 44:
{
setState(1571);
alterProcedure();
}
break;
case 45:
{
setState(1572);
alterServer();
}
break;
case 46:
{
setState(1573);
alterSequence();
}
break;
case 47:
{
setState(1574);
alterView();
}
break;
case 48:
{
setState(1575);
comment();
}
break;
case 49:
{
setState(1576);
createDatabase();
}
break;
case 50:
{
setState(1577);
createFunction();
}
break;
case 51:
{
setState(1578);
createProcedure();
}
break;
case 52:
{
setState(1579);
createServer();
}
break;
case 53:
{
setState(1580);
createTrigger();
}
break;
case 54:
{
setState(1581);
createView();
}
break;
case 55:
{
setState(1582);
createSequence();
}
break;
case 56:
{
setState(1583);
createDomain();
}
break;
case 57:
{
setState(1584);
createRule();
}
break;
case 58:
{
setState(1585);
createSchema();
}
break;
case 59:
{
setState(1586);
alterSchema();
}
break;
case 60:
{
setState(1587);
dropSchema();
}
break;
case 61:
{
setState(1588);
createType();
}
break;
case 62:
{
setState(1589);
dropType();
}
break;
case 63:
{
setState(1590);
createTextSearch();
}
break;
case 64:
{
setState(1591);
dropDatabase();
}
break;
case 65:
{
setState(1592);
dropFunction();
}
break;
case 66:
{
setState(1593);
dropProcedure();
}
break;
case 67:
{
setState(1594);
dropRule();
}
break;
case 68:
{
setState(1595);
dropServer();
}
break;
case 69:
{
setState(1596);
dropTrigger();
}
break;
case 70:
{
setState(1597);
dropView();
}
break;
case 71:
{
setState(1598);
dropSequence();
}
break;
case 72:
{
setState(1599);
dropDomain();
}
break;
case 73:
{
setState(1600);
vacuum();
}
break;
case 74:
{
setState(1601);
prepare();
}
break;
case 75:
{
setState(1602);
executeStmt();
}
break;
case 76:
{
setState(1603);
deallocate();
}
break;
case 77:
{
setState(1604);
explain();
}
break;
case 78:
{
setState(1605);
analyzeTable();
}
break;
case 79:
{
setState(1606);
load();
}
break;
case 80:
{
setState(1607);
createTablespace();
}
break;
case 81:
{
setState(1608);
alterTablespace();
}
break;
case 82:
{
setState(1609);
dropTablespace();
}
break;
case 83:
{
setState(1610);
setConstraints();
}
break;
case 84:
{
setState(1611);
copy();
}
break;
case 85:
{
setState(1612);
createLanguage();
}
break;
case 86:
{
setState(1613);
alterLanguage();
}
break;
case 87:
{
setState(1614);
dropLanguage();
}
break;
case 88:
{
setState(1615);
createConversion();
}
break;
case 89:
{
setState(1616);
alterConversion();
}
break;
case 90:
{
setState(1617);
dropConversion();
}
break;
case 91:
{
setState(1618);
alterTextSearchDictionary();
}
break;
case 92:
{
setState(1619);
alterTextSearchTemplate();
}
break;
case 93:
{
setState(1620);
alterTextSearchParser();
}
break;
case 94:
{
setState(1621);
createExtension();
}
break;
case 95:
{
setState(1622);
alterExtension();
}
break;
case 96:
{
setState(1623);
dropExtension();
}
break;
case 97:
{
setState(1624);
dropTextSearch();
}
break;
case 98:
{
setState(1625);
createSynonym();
}
break;
case 99:
{
setState(1626);
alterSynonym();
}
break;
case 100:
{
setState(1627);
dropSynonym();
}
break;
case 101:
{
setState(1628);
declare();
}
break;
case 102:
{
setState(1629);
cursor();
}
break;
case 103:
{
setState(1630);
close();
}
break;
case 104:
{
setState(1631);
move();
}
break;
case 105:
{
setState(1632);
fetch();
}
break;
case 106:
{
setState(1633);
createDirectory();
}
break;
case 107:
{
setState(1634);
alterDirectory();
}
break;
case 108:
{
setState(1635);
dropDirectory();
}
break;
case 109:
{
setState(1636);
createCast();
}
break;
case 110:
{
setState(1637);
dropCast();
}
break;
case 111:
{
setState(1638);
alterRule();
}
break;
case 112:
{
setState(1639);
checkpoint();
}
break;
case 113:
{
setState(1640);
alterType();
}
break;
case 114:
{
setState(1641);
createPublication();
}
break;
case 115:
{
setState(1642);
dropPublication();
}
break;
case 116:
{
setState(1643);
createAggregate();
}
break;
case 117:
{
setState(1644);
alterPackage();
}
break;
case 118:
{
setState(1645);
emptyStatement();
}
break;
}
setState(1649);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEMI_) {
{
setState(1648);
match(SEMI_);
}
}
setState(1651);
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(1665);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1653);
match(SET);
setState(1657);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SESSION) {
{
setState(1654);
match(SESSION);
setState(1655);
match(CHARACTERISTICS);
setState(1656);
match(AS);
}
}
setState(1659);
match(TRANSACTION);
setState(1660);
transactionModeList();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1661);
match(SET);
setState(1662);
match(TRANSACTION);
setState(1663);
match(SNAPSHOT);
setState(1664);
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(1667);
match(BEGIN);
setState(1669);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION || _la==WORK) {
{
setState(1668);
_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(1672);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT || ((((_la - 253)) & ~0x3f) == 0 && ((1L << (_la - 253)) & ((1L << (ISOLATION - 253)) | (1L << (READ - 253)) | (1L << (DEFERRABLE - 253)))) != 0)) {
{
setState(1671);
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(1674);
match(COMMIT);
setState(1676);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION || _la==WORK) {
{
setState(1675);
_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(1683);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(1678);
match(AND);
setState(1680);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NO) {
{
setState(1679);
match(NO);
}
}
setState(1682);
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(1685);
match(SAVEPOINT);
setState(1686);
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(1688);
match(ABORT);
setState(1690);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION || _la==WORK) {
{
setState(1689);
_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(1697);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(1692);
match(AND);
setState(1694);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NO) {
{
setState(1693);
match(NO);
}
}
setState(1696);
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(1699);
match(START);
setState(1700);
match(TRANSACTION);
setState(1702);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT || ((((_la - 253)) & ~0x3f) == 0 && ((1L << (_la - 253)) & ((1L << (ISOLATION - 253)) | (1L << (READ - 253)) | (1L << (DEFERRABLE - 253)))) != 0)) {
{
setState(1701);
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(1704);
match(END);
setState(1706);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION || _la==WORK) {
{
setState(1705);
_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(1713);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(1708);
match(AND);
setState(1710);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NO) {
{
setState(1709);
match(NO);
}
}
setState(1712);
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(1715);
match(ROLLBACK);
setState(1717);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION || _la==WORK) {
{
setState(1716);
_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(1724);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(1719);
match(AND);
setState(1721);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NO) {
{
setState(1720);
match(NO);
}
}
setState(1723);
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(1726);
match(RELEASE);
setState(1728);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
{
setState(1727);
match(SAVEPOINT);
}
break;
}
setState(1730);
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(1732);
match(ROLLBACK);
setState(1734);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION || _la==WORK) {
{
setState(1733);
_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(1736);
match(TO);
setState(1738);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
{
setState(1737);
match(SAVEPOINT);
}
break;
}
setState(1740);
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(1742);
match(PREPARE);
setState(1743);
match(TRANSACTION);
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 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(1746);
match(COMMIT);
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 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(1750);
match(ROLLBACK);
setState(1751);
match(PREPARED);
setState(1752);
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(1754);
match(SET);
setState(1755);
match(CONSTRAINTS);
setState(1756);
constraintsSetList();
setState(1757);
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(1759);
_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(1763);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALL:
enterOuterAlt(_localctx, 1);
{
setState(1761);
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 POSITION:
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 INT2:
case INT4:
case FLOAT4:
case BYTEA:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case INET:
case TSQUERY:
case XML:
case JSON:
case INT4RANGE:
case INT8RANGE:
case NUMRANGE:
case DATERANGE:
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 INT16:
case INT1:
case ELEM_CONTAINED_BY_RANGE:
case IDENTIFIER_:
enterOuterAlt(_localctx, 2);
{
setState(1762);
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 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, 34, RULE_checkpoint);
try {
enterOuterAlt(_localctx, 1);
{
setState(1765);
match(CHECKPOINT);
}
}
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, 36, RULE_lock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1767);
match(LOCK);
setState(1769);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(1768);
match(TABLE);
}
}
setState(1771);
relationExprList();
setState(1776);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IN) {
{
setState(1772);
match(IN);
setState(1773);
lockType();
setState(1774);
match(MODE);
}
}
setState(1779);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOWAIT) {
{
setState(1778);
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, 38, RULE_lockType);
try {
setState(1797);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1781);
match(ACCESS);
setState(1782);
match(SHARE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1783);
match(ROW);
setState(1784);
match(SHARE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1785);
match(ROW);
setState(1786);
match(EXCLUSIVE);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1787);
match(SHARE);
setState(1788);
match(UPDATE);
setState(1789);
match(EXCLUSIVE);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1790);
match(SHARE);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1791);
match(SHARE);
setState(1792);
match(ROW);
setState(1793);
match(EXCLUSIVE);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1794);
match(EXCLUSIVE);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1795);
match(ACCESS);
setState(1796);
match(EXCLUSIVE);
}
break;
}
}
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, 40, RULE_insert);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1800);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(1799);
withClause();
}
}
setState(1802);
match(INSERT);
setState(1803);
match(INTO);
setState(1804);
insertTarget();
setState(1805);
insertRest();
setState(1807);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(1806);
optOnDuplicateKey();
}
}
setState(1810);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(1809);
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, 42, RULE_insertTarget);
try {
setState(1817);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1812);
qualifiedName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1813);
qualifiedName();
setState(1814);
match(AS);
setState(1815);
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, 44, RULE_insertRest);
try {
setState(1840);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1819);
select();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1820);
match(OVERRIDING);
setState(1821);
overrideKind();
setState(1822);
match(VALUE);
setState(1823);
select();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1825);
match(LP_);
setState(1826);
insertColumnList(0);
setState(1827);
match(RP_);
setState(1828);
select();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1830);
match(LP_);
setState(1831);
insertColumnList(0);
setState(1832);
match(RP_);
setState(1833);
match(OVERRIDING);
setState(1834);
overrideKind();
setState(1835);
match(VALUE);
setState(1836);
select();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1838);
match(DEFAULT);
setState(1839);
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, 46, RULE_overrideKind);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1842);
_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 = 48;
enterRecursionRule(_localctx, 48, RULE_insertColumnList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1845);
insertColumnItem();
}
_ctx.stop = _input.LT(-1);
setState(1852);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,32,_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(1847);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1848);
match(COMMA_);
setState(1849);
insertColumnItem();
}
}
}
setState(1854);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,32,_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, 50, RULE_insertColumnItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(1855);
colId();
setState(1856);
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, 52, RULE_optOnDuplicateKey);
int _la;
try {
setState(1875);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1858);
match(ON);
setState(1859);
match(DUPLICATE);
setState(1860);
match(KEY);
setState(1861);
match(UPDATE);
setState(1862);
assignment();
setState(1867);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA_) {
{
{
setState(1863);
match(COMMA_);
setState(1864);
assignment();
}
}
setState(1869);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1870);
match(ON);
setState(1871);
match(DUPLICATE);
setState(1872);
match(KEY);
setState(1873);
match(UPDATE);
setState(1874);
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, 54, RULE_assignment);
try {
setState(1888);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1877);
setTarget();
setState(1878);
match(EQ_);
setState(1879);
aExpr(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1881);
setTarget();
setState(1882);
match(EQ_);
setState(1883);
match(VALUES);
setState(1884);
match(LP_);
setState(1885);
name();
setState(1886);
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, 56, RULE_update);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1891);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(1890);
withClause();
}
}
setState(1893);
match(UPDATE);
setState(1894);
relationExprOptAlias();
setState(1895);
match(SET);
setState(1896);
setClauseList(0);
setState(1898);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(1897);
fromClause();
}
}
setState(1901);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(1900);
whereOrCurrentClause();
}
}
setState(1904);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(1903);
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 = 58;
enterRecursionRule(_localctx, 58, RULE_setClauseList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1907);
setClause();
}
_ctx.stop = _input.LT(-1);
setState(1914);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,40,_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(1909);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1910);
match(COMMA_);
setState(1911);
setClause();
}
}
}
setState(1916);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,40,_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, 60, RULE_setClause);
try {
setState(1927);
_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 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 INT2:
case INT4:
case FLOAT4:
case BYTEA:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case INET:
case TSQUERY:
case XML:
case JSON:
case INT4RANGE:
case INT8RANGE:
case NUMRANGE:
case DATERANGE:
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 INT16:
case INT1:
case ELEM_CONTAINED_BY_RANGE:
case IDENTIFIER_:
enterOuterAlt(_localctx, 1);
{
setState(1917);
setTarget();
setState(1918);
match(EQ_);
setState(1919);
aExpr(0);
}
break;
case LP_:
enterOuterAlt(_localctx, 2);
{
setState(1921);
match(LP_);
setState(1922);
setTargetList(0);
setState(1923);
match(RP_);
setState(1924);
match(EQ_);
setState(1925);
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, 62, RULE_setTarget);
try {
enterOuterAlt(_localctx, 1);
{
setState(1929);
colId();
setState(1932);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
case 1:
{
setState(1930);
match(DOT_);
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 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 = 64;
enterRecursionRule(_localctx, 64, RULE_setTargetList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1935);
setTarget();
}
_ctx.stop = _input.LT(-1);
setState(1942);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,43,_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(1937);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1938);
match(COMMA_);
setState(1939);
setTarget();
}
}
}
setState(1944);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,43,_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, 66, RULE_returningClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1945);
match(RETURNING);
setState(1946);
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, 68, RULE_delete);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1949);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(1948);
withClause();
}
}
setState(1951);
match(DELETE);
setState(1952);
match(FROM);
setState(1953);
relationExprOptAlias();
setState(1955);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(1954);
usingClause();
}
}
setState(1958);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(1957);
whereOrCurrentClause();
}
}
setState(1961);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(1960);
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, 70, RULE_relationExprOptAlias);
try {
setState(1971);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1963);
relationExpr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1964);
relationExpr();
setState(1965);
colId();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1967);
relationExpr();
setState(1968);
match(AS);
setState(1969);
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, 72, RULE_usingClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1973);
match(USING);
setState(1974);
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, 74, RULE_select);
try {
setState(1978);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1976);
selectNoParens();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1977);
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, 76, RULE_selectWithParens);
try {
setState(1988);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1980);
match(LP_);
setState(1981);
selectNoParens();
setState(1982);
match(RP_);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1984);
match(LP_);
setState(1985);
selectWithParens();
setState(1986);
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, 78, RULE_selectNoParens);
int _la;
try {
setState(2029);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1990);
selectClauseN(0);
setState(1992);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(1991);
sortClause();
}
}
setState(2002);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FOR:
{
setState(1994);
forLockingClause();
setState(1996);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIMIT || _la==OFFSET || _la==FETCH) {
{
setState(1995);
selectLimit();
}
}
}
break;
case LIMIT:
case OFFSET:
case FETCH:
{
setState(1998);
selectLimit();
setState(2000);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOR) {
{
setState(1999);
forLockingClause();
}
}
}
break;
case EOF:
case RP_:
case SEMI_:
case CREATE:
case GRANT:
case WITH:
case ON:
case EXECUTE:
case RETURNING:
break;
default:
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2004);
withClause();
setState(2005);
selectClauseN(0);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2007);
withClause();
setState(2008);
selectClauseN(0);
setState(2009);
sortClause();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2011);
withClause();
setState(2012);
selectClauseN(0);
setState(2014);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(2013);
sortClause();
}
}
setState(2016);
forLockingClause();
setState(2018);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIMIT || _la==OFFSET || _la==FETCH) {
{
setState(2017);
selectLimit();
}
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2020);
withClause();
setState(2021);
selectClauseN(0);
setState(2023);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(2022);
sortClause();
}
}
setState(2025);
selectLimit();
setState(2027);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOR) {
{
setState(2026);
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 = 80;
enterRecursionRule(_localctx, 80, RULE_selectClauseN, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2034);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
case TABLE:
case VALUES:
{
setState(2032);
simpleSelect();
}
break;
case LP_:
{
setState(2033);
selectWithParens();
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(2050);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,64,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(2048);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) {
case 1:
{
_localctx = new SelectClauseNContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_selectClauseN);
setState(2036);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(2037);
match(INTERSECT);
setState(2039);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2038);
allOrDistinct();
}
}
setState(2041);
selectClauseN(3);
}
break;
case 2:
{
_localctx = new SelectClauseNContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_selectClauseN);
setState(2042);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2043);
_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(2045);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2044);
allOrDistinct();
}
}
setState(2047);
selectClauseN(2);
}
break;
}
}
}
setState(2052);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,64,_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, 82, RULE_simpleSelect);
try {
setState(2102);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2053);
match(SELECT);
setState(2055);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
{
setState(2054);
match(ALL);
}
break;
}
setState(2058);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
case 1:
{
setState(2057);
targetList(0);
}
break;
}
setState(2061);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
case 1:
{
setState(2060);
intoClause();
}
break;
}
setState(2064);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
case 1:
{
setState(2063);
fromClause();
}
break;
}
setState(2067);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
case 1:
{
setState(2066);
whereClause();
}
break;
}
setState(2070);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
case 1:
{
setState(2069);
groupClause();
}
break;
}
setState(2073);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
case 1:
{
setState(2072);
havingClause();
}
break;
}
setState(2076);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
case 1:
{
setState(2075);
windowClause();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2078);
match(SELECT);
setState(2079);
distinctClause();
setState(2080);
targetList(0);
setState(2082);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) {
case 1:
{
setState(2081);
intoClause();
}
break;
}
setState(2085);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
case 1:
{
setState(2084);
fromClause();
}
break;
}
setState(2088);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
case 1:
{
setState(2087);
whereClause();
}
break;
}
setState(2091);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
case 1:
{
setState(2090);
groupClause();
}
break;
}
setState(2094);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
case 1:
{
setState(2093);
havingClause();
}
break;
}
setState(2097);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
case 1:
{
setState(2096);
windowClause();
}
break;
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2099);
valuesClause(0);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2100);
match(TABLE);
setState(2101);
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, 84, RULE_withClause);
try {
setState(2109);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2104);
match(WITH);
setState(2105);
cteList();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2106);
match(WITH);
setState(2107);
match(RECURSIVE);
setState(2108);
cteList();
}
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, 86, RULE_intoClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2111);
match(INTO);
setState(2112);
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, 88, RULE_optTempTableName);
int _la;
try {
setState(2158);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2114);
match(TEMPORARY);
setState(2116);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2115);
match(TABLE);
}
}
setState(2118);
qualifiedName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2119);
match(TEMP);
setState(2121);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2120);
match(TABLE);
}
}
setState(2123);
qualifiedName();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2124);
match(LOCAL);
setState(2125);
match(TEMPORARY);
setState(2127);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2126);
match(TABLE);
}
}
setState(2129);
qualifiedName();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2130);
match(LOCAL);
setState(2131);
match(TEMP);
setState(2133);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2132);
match(TABLE);
}
}
setState(2135);
qualifiedName();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2136);
match(GLOBAL);
setState(2137);
match(TEMPORARY);
setState(2139);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2138);
match(TABLE);
}
}
setState(2141);
qualifiedName();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2142);
match(GLOBAL);
setState(2143);
match(TEMP);
setState(2145);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2144);
match(TABLE);
}
}
setState(2147);
qualifiedName();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2148);
match(UNLOGGED);
setState(2150);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2149);
match(TABLE);
}
}
setState(2152);
qualifiedName();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2154);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2153);
match(TABLE);
}
}
setState(2156);
qualifiedName();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2157);
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 List commonTableExpr() {
return getRuleContexts(CommonTableExprContext.class);
}
public CommonTableExprContext commonTableExpr(int i) {
return getRuleContext(CommonTableExprContext.class,i);
}
public List COMMA_() { return getTokens(OpenGaussStatementParser.COMMA_); }
public TerminalNode COMMA_(int i) {
return getToken(OpenGaussStatementParser.COMMA_, i);
}
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 {
CteListContext _localctx = new CteListContext(_ctx, getState());
enterRule(_localctx, 90, RULE_cteList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2160);
commonTableExpr();
setState(2165);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA_) {
{
{
setState(2161);
match(COMMA_);
setState(2162);
commonTableExpr();
}
}
setState(2167);
_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 CommonTableExprContext extends ParserRuleContext {
public AliasContext alias() {
return getRuleContext(AliasContext.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, 92, RULE_commonTableExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(2168);
alias();
setState(2169);
optNameList();
setState(2170);
match(AS);
setState(2171);
optMaterialized();
setState(2172);
match(LP_);
setState(2173);
preparableStmt();
setState(2174);
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, 94, RULE_optMaterialized);
try {
setState(2180);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MATERIALIZED:
enterOuterAlt(_localctx, 1);
{
setState(2176);
match(MATERIALIZED);
}
break;
case NOT:
enterOuterAlt(_localctx, 2);
{
setState(2177);
match(NOT);
setState(2178);
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, 96, RULE_optNameList);
try {
setState(2187);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LP_:
enterOuterAlt(_localctx, 1);
{
setState(2182);
match(LP_);
setState(2183);
nameList(0);
setState(2184);
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, 98, RULE_preparableStmt);
try {
setState(2193);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2189);
select();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2190);
insert();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2191);
update();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2192);
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, 100, RULE_forLockingClause);
try {
setState(2199);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2195);
forLockingItems(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2196);
match(FOR);
setState(2197);
match(READ);
setState(2198);
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 = 102;
enterRecursionRule(_localctx, 102, RULE_forLockingItems, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2202);
forLockingItem();
}
_ctx.stop = _input.LT(-1);
setState(2208);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,95,_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(2204);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2205);
forLockingItem();
}
}
}
setState(2210);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,95,_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, 104, RULE_forLockingItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(2211);
forLockingStrength();
setState(2213);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
case 1:
{
setState(2212);
lockedRelsList();
}
break;
}
setState(2216);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
case 1:
{
setState(2215);
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, 106, RULE_nowaitOrSkip);
try {
setState(2221);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NOWAIT:
enterOuterAlt(_localctx, 1);
{
setState(2218);
match(NOWAIT);
}
break;
case T__0:
enterOuterAlt(_localctx, 2);
{
setState(2219);
match(T__0);
setState(2220);
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, 108, RULE_forLockingStrength);
try {
setState(2234);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2223);
match(FOR);
setState(2224);
match(UPDATE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2225);
match(FOR);
setState(2226);
match(NO);
setState(2227);
match(KEY);
setState(2228);
match(UPDATE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2229);
match(FOR);
setState(2230);
match(SHARE);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2231);
match(FOR);
setState(2232);
match(KEY);
setState(2233);
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, 110, RULE_lockedRelsList);
try {
enterOuterAlt(_localctx, 1);
{
setState(2236);
match(OF);
setState(2237);
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 = 112;
enterRecursionRule(_localctx, 112, RULE_qualifiedNameList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2240);
qualifiedName();
}
_ctx.stop = _input.LT(-1);
setState(2247);
_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 QualifiedNameListContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_qualifiedNameList);
setState(2242);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2243);
match(COMMA_);
setState(2244);
qualifiedName();
}
}
}
setState(2249);
_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 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, 114, RULE_selectLimit);
int _la;
try {
setState(2258);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LIMIT:
case FETCH:
enterOuterAlt(_localctx, 1);
{
setState(2250);
limitClause();
setState(2252);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OFFSET) {
{
setState(2251);
offsetClause();
}
}
}
break;
case OFFSET:
enterOuterAlt(_localctx, 2);
{
setState(2254);
offsetClause();
setState(2256);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIMIT || _la==FETCH) {
{
setState(2255);
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 = 116;
enterRecursionRule(_localctx, 116, RULE_valuesClause, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2261);
match(VALUES);
setState(2262);
match(LP_);
setState(2263);
exprList(0);
setState(2264);
match(RP_);
}
_ctx.stop = _input.LT(-1);
setState(2274);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,104,_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(2266);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2267);
match(COMMA_);
setState(2268);
match(LP_);
setState(2269);
exprList(0);
setState(2270);
match(RP_);
}
}
}
setState(2276);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,104,_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, 118, RULE_limitClause);
try {
setState(2292);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2277);
match(LIMIT);
setState(2278);
selectLimitValue();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2279);
match(LIMIT);
setState(2280);
selectOffsetValue();
setState(2281);
match(COMMA_);
setState(2282);
selectLimitValue();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2284);
match(FETCH);
setState(2285);
firstOrNext();
setState(2287);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) {
case 1:
{
setState(2286);
selectFetchValue();
}
break;
}
setState(2289);
rowOrRows();
setState(2290);
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, 120, RULE_offsetClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2294);
match(OFFSET);
setState(2295);
selectOffsetValue();
setState(2297);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROW || _la==ROWS) {
{
setState(2296);
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, 122, RULE_selectLimitValue);
try {
setState(2301);
_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 BYTEA:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case INET:
case BIT:
case TSQUERY:
case XML:
case JSON:
case INT4RANGE:
case INT8RANGE:
case NUMRANGE:
case DATERANGE:
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 PREDICT:
case TS_REWRITE:
case INT16:
case INT1:
case ELEM_CONTAINED_BY_RANGE:
case LOWER_INF:
case UPPER_INF:
case ABBREV:
case SET_MASKLEN:
case TRUNC:
case IDENTIFIER_:
case STRING_:
case NUMBER_:
enterOuterAlt(_localctx, 1);
{
setState(2299);
cExpr();
}
break;
case ALL:
enterOuterAlt(_localctx, 2);
{
setState(2300);
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, 124, RULE_selectOffsetValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(2303);
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, 126, RULE_selectFetchValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(2305);
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, 128, RULE_rowOrRows);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2307);
_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, 130, RULE_firstOrNext);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2309);
_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, 132, RULE_onlyOrWithTies);
try {
setState(2314);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ONLY:
enterOuterAlt(_localctx, 1);
{
setState(2311);
match(ONLY);
}
break;
case WITH:
enterOuterAlt(_localctx, 2);
{
setState(2312);
match(WITH);
setState(2313);
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 = 134;
enterRecursionRule(_localctx, 134, RULE_targetList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2317);
targetEl();
}
_ctx.stop = _input.LT(-1);
setState(2324);
_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 TargetListContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_targetList);
setState(2319);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2320);
match(COMMA_);
setState(2321);
targetEl();
}
}
}
setState(2326);
_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 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, 136, RULE_targetEl);
try {
setState(2338);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2327);
colId();
setState(2328);
match(DOT_ASTERISK_);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2330);
aExpr(0);
setState(2332);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) {
case 1:
{
setState(2331);
match(AS);
}
break;
}
setState(2335);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) {
case 1:
{
setState(2334);
identifier();
}
break;
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2337);
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, 138, RULE_groupClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2340);
match(GROUP);
setState(2341);
match(BY);
setState(2342);
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, 140, RULE_groupByList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2344);
groupByItem();
setState(2349);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,114,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2345);
match(COMMA_);
setState(2346);
groupByItem();
}
}
}
setState(2351);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,114,_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, 142, RULE_groupByItem);
try {
setState(2357);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2352);
aExpr(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2353);
emptyGroupingSet();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2354);
cubeClause();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2355);
rollupClause();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2356);
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, 144, RULE_emptyGroupingSet);
try {
enterOuterAlt(_localctx, 1);
{
setState(2359);
match(LP_);
setState(2360);
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, 146, RULE_rollupClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2362);
match(ROLLUP);
setState(2363);
match(LP_);
setState(2364);
exprList(0);
setState(2365);
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, 148, RULE_cubeClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2367);
match(CUBE);
setState(2368);
match(LP_);
setState(2369);
exprList(0);
setState(2370);
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, 150, RULE_groupingSetsClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2372);
match(GROUPING);
setState(2373);
match(SETS);
setState(2374);
match(LP_);
setState(2375);
groupByList();
setState(2376);
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, 152, RULE_windowClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2378);
match(WINDOW);
setState(2379);
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 = 154;
enterRecursionRule(_localctx, 154, RULE_windowDefinitionList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2382);
windowDefinition();
}
_ctx.stop = _input.LT(-1);
setState(2389);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,116,_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(2384);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2385);
match(COMMA_);
setState(2386);
windowDefinition();
}
}
}
setState(2391);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,116,_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, 156, RULE_windowDefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(2392);
colId();
setState(2393);
match(AS);
setState(2394);
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, 158, RULE_windowSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2396);
match(LP_);
setState(2398);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) {
case 1:
{
setState(2397);
existingWindowName();
}
break;
}
setState(2401);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(2400);
partitionClause();
}
}
setState(2404);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(2403);
sortClause();
}
}
setState(2407);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROWS || _la==RANGE || _la==GROUPS) {
{
setState(2406);
frameClause();
}
}
setState(2409);
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, 160, RULE_existingWindowName);
try {
enterOuterAlt(_localctx, 1);
{
setState(2411);
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, 162, RULE_partitionClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2413);
match(PARTITION);
setState(2414);
match(BY);
setState(2415);
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, 164, RULE_frameClause);
try {
setState(2429);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RANGE:
enterOuterAlt(_localctx, 1);
{
setState(2417);
match(RANGE);
setState(2418);
frameExtent();
setState(2419);
optWindowExclusionClause();
}
break;
case ROWS:
enterOuterAlt(_localctx, 2);
{
setState(2421);
match(ROWS);
setState(2422);
frameExtent();
setState(2423);
optWindowExclusionClause();
}
break;
case GROUPS:
enterOuterAlt(_localctx, 3);
{
setState(2425);
match(GROUPS);
setState(2426);
frameExtent();
setState(2427);
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, 166, RULE_frameExtent);
try {
setState(2437);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OR_:
case TILDE_:
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 DN_:
case CUBE_ROOT_:
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 BYTEA:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case INET:
case BIT:
case TSQUERY:
case XML:
case JSON:
case INT4RANGE:
case INT8RANGE:
case NUMRANGE:
case DATERANGE:
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 PREDICT:
case TS_REWRITE:
case INT16:
case INT1:
case ELEM_CONTAINED_BY_RANGE:
case LOWER_INF:
case UPPER_INF:
case ABBREV:
case SET_MASKLEN:
case TRUNC:
case IDENTIFIER_:
case STRING_:
case NUMBER_:
enterOuterAlt(_localctx, 1);
{
setState(2431);
frameBound();
}
break;
case BETWEEN:
enterOuterAlt(_localctx, 2);
{
setState(2432);
match(BETWEEN);
setState(2433);
frameBound();
setState(2434);
match(AND);
setState(2435);
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, 168, RULE_frameBound);
try {
setState(2451);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2439);
match(UNBOUNDED);
setState(2440);
match(PRECEDING);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2441);
match(UNBOUNDED);
setState(2442);
match(FOLLOWING);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2443);
match(CURRENT);
setState(2444);
match(ROW);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2445);
aExpr(0);
setState(2446);
match(PRECEDING);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2448);
aExpr(0);
setState(2449);
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, 170, RULE_optWindowExclusionClause);
try {
setState(2464);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2453);
match(EXCLUDE);
setState(2454);
match(CURRENT);
setState(2455);
match(ROW);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2456);
match(EXCLUDE);
setState(2457);
match(GROUP);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2458);
match(EXCLUDE);
setState(2459);
match(TIES);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2460);
match(EXCLUDE);
setState(2461);
match(NO);
setState(2462);
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, 172, RULE_alias);
try {
setState(2468);
_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 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 INT2:
case INT4:
case FLOAT4:
case BYTEA:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case INET:
case TSQUERY:
case XML:
case JSON:
case INT4RANGE:
case INT8RANGE:
case NUMRANGE:
case DATERANGE:
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 INT16:
case INT1:
case ELEM_CONTAINED_BY_RANGE:
case IDENTIFIER_:
enterOuterAlt(_localctx, 1);
{
setState(2466);
identifier();
}
break;
case STRING_:
enterOuterAlt(_localctx, 2);
{
setState(2467);
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, 174, RULE_fromClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2470);
match(FROM);
setState(2471);
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 = 176;
enterRecursionRule(_localctx, 176, RULE_fromList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2474);
tableReference(0);
}
_ctx.stop = _input.LT(-1);
setState(2481);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,126,_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(2476);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2477);
match(COMMA_);
setState(2478);
tableReference(0);
}
}
}
setState(2483);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,126,_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 = 178;
enterRecursionRule(_localctx, 178, RULE_tableReference, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2529);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
case 1:
{
setState(2485);
relationExpr();
setState(2487);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
case 1:
{
setState(2486);
aliasClause();
}
break;
}
}
break;
case 2:
{
setState(2489);
relationExpr();
setState(2491);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==UNICODE_ESCAPE || ((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & ((1L << (INSERT - 81)) | (1L << (UPDATE - 81)) | (1L << (DELETE - 81)) | (1L << (ALTER - 81)) | (1L << (DROP - 81)) | (1L << (TRUNCATE - 81)) | (1L << (SCHEMA - 81)) | (1L << (REVOKE - 81)) | (1L << (ADD - 81)) | (1L << (SET - 81)) | (1L << (INDEX - 81)) | (1L << (KEY - 81)) | (1L << (POSITION - 81)) | (1L << (FUNCTION - 81)) | (1L << (TRIGGER - 81)) | (1L << (PROCEDURE - 81)) | (1L << (VIEW - 81)) | (1L << (AS - 81)) | (1L << (IF - 81)))) != 0) || ((((_la - 151)) & ~0x3f) == 0 && ((1L << (_la - 151)) & ((1L << (BY - 151)) | (1L << (BEGIN - 151)) | (1L << (COMMIT - 151)) | (1L << (ROLLBACK - 151)) | (1L << (SAVEPOINT - 151)) | (1L << (DOUBLE - 151)) | (1L << (INTERVAL - 151)) | (1L << (TIME - 151)) | (1L << (TIMESTAMP - 151)) | (1L << (YEAR - 151)) | (1L << (MONTH - 151)) | (1L << (DAY - 151)) | (1L << (HOUR - 151)) | (1L << (MINUTE - 151)) | (1L << (SECOND - 151)) | (1L << (CURRENT - 151)) | (1L << (ENABLE - 151)) | (1L << (DISABLE - 151)) | (1L << (CALL - 151)) | (1L << (PRESERVE - 151)) | (1L << (DEFINER - 151)) | (1L << (SQL - 151)) | (1L << (CASCADED - 151)) | (1L << (LOCAL - 151)) | (1L << (CLOSE - 151)) | (1L << (NEXT - 151)) | (1L << (NAME - 151)) | (1L << (NAMES - 151)) | (1L << (TYPE - 151)) | (1L << (TEXT - 151)) | (1L << (REPEATABLE - 151)) | (1L << (VARYING - 151)) | (1L << (NATIONAL - 151)))) != 0) || ((((_la - 216)) & ~0x3f) == 0 && ((1L << (_la - 216)) & ((1L << (VALUE - 216)) | (1L << (TIES - 216)) | (1L << (CUBE - 216)) | (1L << (SETS - 216)) | (1L << (OTHERS - 216)) | (1L << (AT - 216)) | (1L << (MAXVALUE - 216)) | (1L << (ADMIN - 216)) | (1L << (ESCAPE - 216)) | (1L << (EXCLUDE - 216)) | (1L << (MOD - 216)) | (1L << (PARTITION - 216)) | (1L << (UNKNOWN - 216)) | (1L << (ALWAYS - 216)) | (1L << (CASCADE - 216)) | (1L << (GENERATED - 216)) | (1L << (ISOLATION - 216)) | (1L << (LEVEL - 216)) | (1L << (NO - 216)) | (1L << (OPTION - 216)) | (1L << (PRIVILEGES - 216)) | (1L << (READ - 216)) | (1L << (ROLE - 216)) | (1L << (ROWS - 216)) | (1L << (START - 216)) | (1L << (TRANSACTION - 216)) | (1L << (ACTION - 216)) | (1L << (CACHE - 216)) | (1L << (CHARACTERISTICS - 216)) | (1L << (CLUSTER - 216)) | (1L << (COMMENTS - 216)) | (1L << (CONSTRAINTS - 216)) | (1L << (CYCLE - 216)) | (1L << (DATA - 216)) | (1L << (DATABASE - 216)) | (1L << (DEFAULTS - 216)) | (1L << (DEFERRED - 216)))) != 0) || ((((_la - 280)) & ~0x3f) == 0 && ((1L << (_la - 280)) & ((1L << (DEPENDS - 280)) | (1L << (DOMAIN - 280)) | (1L << (EXCLUDING - 280)) | (1L << (EXECUTE - 280)) | (1L << (EXTENDED - 280)) | (1L << (EXTENSION - 280)) | (1L << (EXTERNAL - 280)) | (1L << (FILTER - 280)) | (1L << (FIRST - 280)) | (1L << (FOLLOWING - 280)) | (1L << (FORCE - 280)) | (1L << (GLOBAL - 280)) | (1L << (IDENTITY - 280)) | (1L << (IMMEDIATE - 280)) | (1L << (INCLUDING - 280)) | (1L << (INCREMENT - 280)) | (1L << (INDEXES - 280)) | (1L << (INHERIT - 280)) | (1L << (INHERITS - 280)) | (1L << (INCLUDE - 280)) | (1L << (LANGUAGE - 280)) | (1L << (LARGE - 280)) | (1L << (LAST - 280)) | (1L << (LOGGED - 280)) | (1L << (MAIN - 280)) | (1L << (MATCH - 280)) | (1L << (MINVALUE - 280)) | (1L << (NOTHING - 280)) | (1L << (NULLS - 280)) | (1L << (OBJECT - 280)) | (1L << (OIDS - 280)) | (1L << (OVER - 280)) | (1L << (OWNED - 280)) | (1L << (OWNER - 280)) | (1L << (PARTIAL - 280)) | (1L << (PLAIN - 280)) | (1L << (PRECEDING - 280)) | (1L << (RANGE - 280)) | (1L << (RENAME - 280)) | (1L << (REPLICA - 280)) | (1L << (RESET - 280)) | (1L << (RESTART - 280)) | (1L << (RESTRICT - 280)) | (1L << (ROUTINE - 280)) | (1L << (RULE - 280)) | (1L << (SECURITY - 280)) | (1L << (SEQUENCE - 280)) | (1L << (SESSION - 280)) | (1L << (SHOW - 280)) | (1L << (SIMPLE - 280)) | (1L << (STATISTICS - 280)) | (1L << (STORAGE - 280)) | (1L << (TABLESPACE - 280)) | (1L << (TEMP - 280)) | (1L << (TEMPORARY - 280)) | (1L << (UNBOUNDED - 280)) | (1L << (UNLOGGED - 280)) | (1L << (VALID - 280)))) != 0) || ((((_la - 344)) & ~0x3f) == 0 && ((1L << (_la - 344)) & ((1L << (VALIDATE - 344)) | (1L << (WITHIN - 344)) | (1L << (WITHOUT - 344)) | (1L << (ZONE - 344)) | (1L << (OF - 344)) | (1L << (UESCAPE - 344)) | (1L << (GROUPS - 344)) | (1L << (RECURSIVE - 344)) | (1L << (INT2 - 344)) | (1L << (INT4 - 344)) | (1L << (FLOAT4 - 344)) | (1L << (BYTEA - 344)) | (1L << (ENUM - 344)) | (1L << (POINT - 344)) | (1L << (LSEG - 344)) | (1L << (BOX - 344)) | (1L << (PATH - 344)) | (1L << (POLYGON - 344)) | (1L << (CIRCLE - 344)) | (1L << (INET - 344)) | (1L << (TSQUERY - 344)) | (1L << (XML - 344)) | (1L << (JSON - 344)) | (1L << (INT4RANGE - 344)) | (1L << (INT8RANGE - 344)) | (1L << (NUMRANGE - 344)) | (1L << (DATERANGE - 344)) | (1L << (ORDINALITY - 344)) | (1L << (NFC - 344)) | (1L << (NFD - 344)) | (1L << (NFKC - 344)))) != 0) || ((((_la - 408)) & ~0x3f) == 0 && ((1L << (_la - 408)) & ((1L << (NFKD - 408)) | (1L << (REF - 408)) | (1L << (PASSING - 408)) | (1L << (VERSION - 408)) | (1L << (YES - 408)) | (1L << (STANDALONE - 408)) | (1L << (MATERIALIZED - 408)) | (1L << (OPERATOR - 408)) | (1L << (SHARE - 408)) | (1L << (ROLLUP - 408)) | (1L << (DOCUMENT - 408)) | (1L << (NORMALIZED - 408)) | (1L << (NOWAIT - 408)) | (1L << (LOCKED - 408)) | (1L << (COLUMNS - 408)) | (1L << (CONTENT - 408)) | (1L << (STRIP - 408)) | (1L << (WHITESPACE - 408)) | (1L << (CONFLICT - 408)) | (1L << (OVERRIDING - 408)) | (1L << (SYSTEM - 408)) | (1L << (ABORT - 408)) | (1L << (ABSOLUTE - 408)) | (1L << (ACCESS - 408)) | (1L << (AFTER - 408)) | (1L << (AGGREGATE - 408)) | (1L << (ALSO - 408)) | (1L << (ATTACH - 408)) | (1L << (ATTRIBUTE - 408)) | (1L << (BACKWARD - 408)) | (1L << (BEFORE - 408)) | (1L << (ASSERTION - 408)) | (1L << (ASSIGNMENT - 408)) | (1L << (CONTINUE - 408)) | (1L << (CONVERSION - 408)) | (1L << (COPY - 408)) | (1L << (COST - 408)) | (1L << (CSV - 408)) | (1L << (CALLED - 408)) | (1L << (CATALOG - 408)) | (1L << (CHAIN - 408)) | (1L << (CHECKPOINT - 408)) | (1L << (CLASS - 408)) | (1L << (CONFIGURATION - 408)) | (1L << (COMMENT - 408)) | (1L << (DETACH - 408)))) != 0) || ((((_la - 472)) & ~0x3f) == 0 && ((1L << (_la - 472)) & ((1L << (DICTIONARY - 472)) | (1L << (EXPRESSION - 472)) | (1L << (INSENSITIVE - 472)) | (1L << (DISCARD - 472)) | (1L << (OFF - 472)) | (1L << (INSTEAD - 472)) | (1L << (EXPLAIN - 472)) | (1L << (INPUT - 472)) | (1L << (INLINE - 472)) | (1L << (PARALLEL - 472)) | (1L << (LEAKPROOF - 472)) | (1L << (COMMITTED - 472)) | (1L << (ENCODING - 472)) | (1L << (IMPLICIT - 472)) | (1L << (DELIMITER - 472)) | (1L << (CURSOR - 472)) | (1L << (EACH - 472)) | (1L << (EVENT - 472)) | (1L << (DEALLOCATE - 472)) | (1L << (CONNECTION - 472)) | (1L << (DECLARE - 472)) | (1L << (FAMILY - 472)) | (1L << (FORWARD - 472)) | (1L << (EXCLUSIVE - 472)) | (1L << (FUNCTIONS - 472)) | (1L << (LOCATION - 472)) | (1L << (LABEL - 472)) | (1L << (DELIMITERS - 472)) | (1L << (HANDLER - 472)) | (1L << (HEADER - 472)) | (1L << (IMMUTABLE - 472)) | (1L << (GRANTED - 472)) | (1L << (HOLD - 472)) | (1L << (MAPPING - 472)) | (1L << (OLD - 472)) | (1L << (METHOD - 472)) | (1L << (LOAD - 472)) | (1L << (LISTEN - 472)) | (1L << (MODE - 472)) | (1L << (MOVE - 472)) | (1L << (PROCEDURAL - 472)) | (1L << (PARSER - 472)) | (1L << (PROCEDURES - 472)) | (1L << (ENCRYPTED - 472)) | (1L << (PUBLICATION - 472)) | (1L << (PROGRAM - 472)) | (1L << (REFERENCING - 472)) | (1L << (PLANS - 472)) | (1L << (REINDEX - 472)) | (1L << (PRIOR - 472)) | (1L << (PASSWORD - 472)) | (1L << (RELATIVE - 472)) | (1L << (QUOTE - 472)) | (1L << (ROUTINES - 472)) | (1L << (REPLACE - 472)) | (1L << (SNAPSHOT - 472)) | (1L << (REFRESH - 472)) | (1L << (PREPARE - 472)) | (1L << (OPTIONS - 472)) | (1L << (IMPORT - 472)) | (1L << (INVOKER - 472)) | (1L << (NEW - 472)) | (1L << (PREPARED - 472)))) != 0) || ((((_la - 536)) & ~0x3f) == 0 && ((1L << (_la - 536)) & ((1L << (SCROLL - 536)) | (1L << (SEQUENCES - 536)) | (1L << (SYSID - 536)) | (1L << (REASSIGN - 536)) | (1L << (SERVER - 536)) | (1L << (SUBSCRIPTION - 536)) | (1L << (SEARCH - 536)) | (1L << (SCHEMAS - 536)) | (1L << (RECHECK - 536)) | (1L << (POLICY - 536)) | (1L << (NOTIFY - 536)) | (1L << (LOCK - 536)) | (1L << (RELEASE - 536)) | (1L << (SERIALIZABLE - 536)) | (1L << (RETURNS - 536)) | (1L << (STATEMENT - 536)) | (1L << (STDIN - 536)) | (1L << (STDOUT - 536)) | (1L << (TABLES - 536)) | (1L << (SUPPORT - 536)) | (1L << (STABLE - 536)) | (1L << (TEMPLATE - 536)) | (1L << (UNENCRYPTED - 536)) | (1L << (VIEWS - 536)) | (1L << (UNCOMMITTED - 536)) | (1L << (TRANSFORM - 536)) | (1L << (UNLISTEN - 536)) | (1L << (TRUSTED - 536)) | (1L << (VALIDATOR - 536)) | (1L << (UNTIL - 536)) | (1L << (VACUUM - 536)) | (1L << (VOLATILE - 536)) | (1L << (STORED - 536)) | (1L << (WRITE - 536)) | (1L << (STRICT - 536)) | (1L << (TYPES - 536)) | (1L << (WRAPPER - 536)) | (1L << (WORK - 536)) | (1L << (INT16 - 536)) | (1L << (INT1 - 536)) | (1L << (ELEM_CONTAINED_BY_RANGE - 536)) | (1L << (IDENTIFIER_ - 536)))) != 0)) {
{
setState(2490);
aliasClause();
}
}
setState(2493);
tablesampleClause();
}
break;
case 3:
{
setState(2495);
functionTable();
setState(2497);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
case 1:
{
setState(2496);
funcAliasClause();
}
break;
}
}
break;
case 4:
{
setState(2499);
match(LATERAL);
setState(2500);
functionTable();
setState(2502);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
case 1:
{
setState(2501);
funcAliasClause();
}
break;
}
}
break;
case 5:
{
setState(2504);
xmlTable();
setState(2506);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
case 1:
{
setState(2505);
aliasClause();
}
break;
}
}
break;
case 6:
{
setState(2508);
match(LATERAL);
setState(2509);
xmlTable();
setState(2511);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
case 1:
{
setState(2510);
aliasClause();
}
break;
}
}
break;
case 7:
{
setState(2513);
selectWithParens();
setState(2515);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) {
case 1:
{
setState(2514);
aliasClause();
}
break;
}
}
break;
case 8:
{
setState(2517);
match(LATERAL);
setState(2518);
selectWithParens();
setState(2520);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) {
case 1:
{
setState(2519);
aliasClause();
}
break;
}
}
break;
case 9:
{
setState(2522);
match(LP_);
setState(2523);
tableReference(0);
setState(2524);
joinedTable();
setState(2525);
match(RP_);
setState(2527);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) {
case 1:
{
setState(2526);
aliasClause();
}
break;
}
}
break;
}
_ctx.stop = _input.LT(-1);
setState(2535);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,137,_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(2531);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(2532);
joinedTable();
}
}
}
setState(2537);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,137,_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, 180, RULE_joinedTable);
try {
setState(2552);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CROSS:
enterOuterAlt(_localctx, 1);
{
setState(2538);
crossJoinType();
setState(2539);
tableReference(0);
}
break;
case JOIN:
case INNER:
enterOuterAlt(_localctx, 2);
{
setState(2541);
innerJoinType();
setState(2542);
tableReference(0);
setState(2543);
joinQual();
}
break;
case FULL:
case LEFT:
case RIGHT:
enterOuterAlt(_localctx, 3);
{
setState(2545);
outerJoinType();
setState(2546);
tableReference(0);
setState(2547);
joinQual();
}
break;
case NATURAL:
enterOuterAlt(_localctx, 4);
{
setState(2549);
naturalJoinType();
setState(2550);
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, 182, RULE_crossJoinType);
try {
enterOuterAlt(_localctx, 1);
{
setState(2554);
match(CROSS);
setState(2555);
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, 184, RULE_innerJoinType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2558);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INNER) {
{
setState(2557);
match(INNER);
}
}
setState(2560);
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, 186, RULE_outerJoinType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2562);
_la = _input.LA(1);
if ( !(((((_la - 121)) & ~0x3f) == 0 && ((1L << (_la - 121)) & ((1L << (FULL - 121)) | (1L << (LEFT - 121)) | (1L << (RIGHT - 121)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2564);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(2563);
match(OUTER);
}
}
setState(2566);
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, 188, RULE_naturalJoinType);
int _la;
try {
setState(2579);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2568);
match(NATURAL);
setState(2570);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INNER) {
{
setState(2569);
match(INNER);
}
}
setState(2572);
match(JOIN);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2573);
match(NATURAL);
setState(2574);
_la = _input.LA(1);
if ( !(((((_la - 121)) & ~0x3f) == 0 && ((1L << (_la - 121)) & ((1L << (FULL - 121)) | (1L << (LEFT - 121)) | (1L << (RIGHT - 121)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2576);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(2575);
match(OUTER);
}
}
setState(2578);
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, 190, RULE_joinQual);
try {
setState(2588);
_errHandler.sync(this);
switch (_input.LA(1)) {
case USING:
enterOuterAlt(_localctx, 1);
{
setState(2581);
match(USING);
setState(2582);
match(LP_);
setState(2583);
nameList(0);
setState(2584);
match(RP_);
}
break;
case ON:
enterOuterAlt(_localctx, 2);
{
setState(2586);
match(ON);
setState(2587);
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, 192, RULE_relationExpr);
try {
setState(2601);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2590);
qualifiedName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2591);
qualifiedName();
setState(2592);
match(ASTERISK_);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2594);
match(ONLY);
setState(2595);
qualifiedName();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2596);
match(ONLY);
setState(2597);
match(LP_);
setState(2598);
qualifiedName();
setState(2599);
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, 194, RULE_whereClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2603);
match(WHERE);
setState(2604);
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, 196, RULE_whereOrCurrentClause);
try {
setState(2611);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2606);
whereClause();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2607);
match(WHERE);
setState(2608);
match(CURRENT);
setState(2609);
match(OF);
setState(2610);
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, 198, RULE_havingClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2613);
match(HAVING);
setState(2614);
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, 200, RULE_doStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(2616);
match(DO);
setState(2617);
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, 202, RULE_dostmtOptList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2620);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(2619);
dostmtOptItem();
}
}
setState(2622);
_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, 204, RULE_dostmtOptItem);
try {
setState(2627);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_:
enterOuterAlt(_localctx, 1);
{
setState(2624);
match(STRING_);
}
break;
case LANGUAGE:
enterOuterAlt(_localctx, 2);
{
setState(2625);
match(LANGUAGE);
setState(2626);
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 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(2669);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2629);
match(COPY);
setState(2631);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BINARY) {
{
setState(2630);
match(BINARY);
}
}
setState(2633);
qualifiedName();
setState(2638);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LP_) {
{
setState(2634);
match(LP_);
setState(2635);
columnList();
setState(2636);
match(RP_);
}
}
setState(2640);
_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(2642);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PROGRAM) {
{
setState(2641);
match(PROGRAM);
}
}
setState(2644);
_la = _input.LA(1);
if ( !(((((_la - 552)) & ~0x3f) == 0 && ((1L << (_la - 552)) & ((1L << (STDIN - 552)) | (1L << (STDOUT - 552)) | (1L << (STRING_ - 552)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2646);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING || _la==DELIMITERS) {
{
setState(2645);
copyDelimiter();
}
}
setState(2649);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(2648);
match(WITH);
}
}
setState(2651);
copyOptions();
setState(2653);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(2652);
whereClause();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2655);
match(COPY);
setState(2656);
match(LP_);
setState(2657);
preparableStmt();
setState(2658);
match(RP_);
setState(2659);
match(TO);
setState(2661);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PROGRAM) {
{
setState(2660);
match(PROGRAM);
}
}
setState(2663);
_la = _input.LA(1);
if ( !(((((_la - 552)) & ~0x3f) == 0 && ((1L << (_la - 552)) & ((1L << (STDIN - 552)) | (1L << (STDOUT - 552)) | (1L << (STRING_ - 552)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2665);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(2664);
match(WITH);
}
}
setState(2667);
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(2676);
_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(2671);
copyOptList();
}
break;
case LP_:
enterOuterAlt(_localctx, 2);
{
setState(2672);
match(LP_);
setState(2673);
copyGenericOptList();
setState(2674);
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(2678);
copyGenericOptElem();
setState(2683);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA_) {
{
{
setState(2679);
match(COMMA_);
setState(2680);
copyGenericOptElem();
}
}
setState(2685);
_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(2686);
colLabel();
setState(2687);
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(2696);
_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 INT2:
case INT4:
case FLOAT:
case FLOAT4:
case VARCHAR:
case BYTEA:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case INET:
case BIT:
case TSQUERY:
case XML:
case JSON:
case INT4RANGE:
case INT8RANGE:
case NUMRANGE:
case DATERANGE:
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 INT16:
case INT1:
case ELEM_CONTAINED_BY_RANGE:
case IDENTIFIER_:
case STRING_:
enterOuterAlt(_localctx, 1);
{
setState(2689);
booleanOrString();
}
break;
case PLUS_:
case MINUS_:
case NUMBER_:
enterOuterAlt(_localctx, 2);
{
setState(2690);
numericOnly();
}
break;
case ASTERISK_:
enterOuterAlt(_localctx, 3);
{
setState(2691);
match(ASTERISK_);
}
break;
case LP_:
enterOuterAlt(_localctx, 4);
{
setState(2692);
match(LP_);
setState(2693);
copyGenericOptArgList();
setState(2694);
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(2698);
copyGenericOptArgListItem();
setState(2703);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA_) {
{
{
setState(2699);
match(COMMA_);
setState(2700);
copyGenericOptArgListItem();
}
}
setState(2705);
_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(2706);
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(2711);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NULL || ((((_la - 242)) & ~0x3f) == 0 && ((1L << (_la - 242)) & ((1L << (BINARY - 242)) | (1L << (ESCAPE - 242)) | (1L << (FORCE - 242)))) != 0) || ((((_la - 463)) & ~0x3f) == 0 && ((1L << (_la - 463)) & ((1L << (CSV - 463)) | (1L << (ENCODING - 463)) | (1L << (DELIMITER - 463)) | (1L << (HEADER - 463)) | (1L << (QUOTE - 463)))) != 0) || _la==FREEZE) {
{
{
setState(2708);
copyOptItem();
}
}
setState(2713);
_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(2753);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2714);
match(BINARY);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2715);
match(FREEZE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2716);
match(DELIMITER);
setState(2718);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2717);
match(AS);
}
}
setState(2720);
match(STRING_);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2721);
match(NULL);
setState(2723);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2722);
match(AS);
}
}
setState(2725);
match(STRING_);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2726);
match(CSV);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2727);
match(HEADER);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2728);
match(QUOTE);
setState(2730);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2729);
match(AS);
}
}
setState(2732);
match(STRING_);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2733);
match(ESCAPE);
setState(2735);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2734);
match(AS);
}
}
setState(2737);
match(STRING_);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2738);
match(FORCE);
setState(2739);
match(QUOTE);
setState(2740);
columnList();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2741);
match(FORCE);
setState(2742);
match(QUOTE);
setState(2743);
match(ASTERISK_);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(2744);
match(FORCE);
setState(2745);
match(NOT);
setState(2746);
match(NULL);
setState(2747);
columnList();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(2748);
match(FORCE);
setState(2749);
match(NULL);
setState(2750);
columnList();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(2751);
match(ENCODING);
setState(2752);
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(2756);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(2755);
match(USING);
}
}
setState(2758);
match(DELIMITERS);
setState(2759);
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(2767);
_errHandler.sync(this);
switch (_input.LA(1)) {
case QUESTION_:
enterOuterAlt(_localctx, 1);
{
setState(2761);
match(QUESTION_);
setState(2763);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
case 1:
{
setState(2762);
literalsType();
}
break;
}
}
break;
case DOLLAR_:
enterOuterAlt(_localctx, 2);
{
setState(2765);
match(DOLLAR_);
setState(2766);
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(2769);
_la = _input.LA(1);
if ( !(((((_la - 80)) & ~0x3f) == 0 && ((1L << (_la - 80)) & ((1L << (SELECT - 80)) | (1L << (CREATE - 80)) | (1L << (GRANT - 80)) | (1L << (TABLE - 80)) | (1L << (COLUMN - 80)) | (1L << (CONSTRAINT - 80)) | (1L << (PRIMARY - 80)) | (1L << (UNIQUE - 80)) | (1L << (FOREIGN - 80)) | (1L << (INTO - 80)) | (1L << (WITH - 80)) | (1L << (UNION - 80)) | (1L << (DISTINCT - 80)) | (1L << (CASE - 80)) | (1L << (WHEN - 80)) | (1L << (CAST - 80)) | (1L << (FROM - 80)) | (1L << (USING - 80)) | (1L << (WHERE - 80)) | (1L << (AS - 80)) | (1L << (ON - 80)) | (1L << (ELSE - 80)) | (1L << (THEN - 80)) | (1L << (FOR - 80)) | (1L << (TO - 80)) | (1L << (AND - 80)) | (1L << (OR - 80)) | (1L << (NOT - 80)) | (1L << (NULL - 80)) | (1L << (TRUE - 80)) | (1L << (FALSE - 80)))) != 0) || ((((_la - 145)) & ~0x3f) == 0 && ((1L << (_la - 145)) & ((1L << (IN - 145)) | (1L << (ALL - 145)) | (1L << (ANY - 145)) | (1L << (ORDER - 145)) | (1L << (GROUP - 145)) | (1L << (ASC - 145)) | (1L << (DESC - 145)) | (1L << (HAVING - 145)) | (1L << (LIMIT - 145)) | (1L << (OFFSET - 145)) | (1L << (ARRAY - 145)) | (1L << (LOCALTIME - 145)) | (1L << (LOCALTIMESTAMP - 145)) | (1L << (DEFAULT - 145)) | (1L << (DO - 145)) | (1L << (CURRENT_USER - 145)))) != 0) || ((((_la - 209)) & ~0x3f) == 0 && ((1L << (_la - 209)) & ((1L << (CURRENT_DATE - 209)) | (1L << (CURRENT_TIME - 209)) | (1L << (CURRENT_TIMESTAMP - 209)) | (1L << (BOTH - 209)) | (1L << (LEADING - 209)) | (1L << (TRAILING - 209)) | (1L << (INTERSECT - 209)) | (1L << (EXCEPT - 209)) | (1L << (FETCH - 209)) | (1L << (WINDOW - 209)) | (1L << (SOME - 209)) | (1L << (END - 209)) | (1L << (ROW - 209)) | (1L << (CHECK - 209)) | (1L << (REFERENCES - 209)) | (1L << (USER - 209)) | (1L << (COLLATE - 209)))) != 0) || ((((_la - 278)) & ~0x3f) == 0 && ((1L << (_la - 278)) & ((1L << (DEFERRABLE - 278)) | (1L << (INITIALLY - 278)) | (1L << (ONLY - 278)) | (1L << (SESSION_USER - 278)))) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & ((1L << (CURRENT_ROLE - 390)) | (1L << (CURRENT_CATALOG - 390)) | (1L << (SYMMETRIC - 390)) | (1L << (ASYMMETRIC - 390)) | (1L << (VARIADIC - 390)) | (1L << (PLACING - 390)) | (1L << (RETURNING - 390)) | (1L << (LATERAL - 390)) | (1L << (ANALYSE - 390)) | (1L << (ANALYZE - 390)))) != 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(2772);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS_) {
{
setState(2771);
match(MINUS_);
}
}
setState(2774);
match(NUMBER_);
setState(2776);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TYPE_CAST_) {
{
setState(2775);
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(2778);
match(TYPE_CAST_);
setState(2779);
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(2789);
_errHandler.sync(this);
switch (_input.LA(1)) {
case UNICODE_ESCAPE:
case IDENTIFIER_:
enterOuterAlt(_localctx, 1);
{
setState(2782);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==UNICODE_ESCAPE) {
{
setState(2781);
match(UNICODE_ESCAPE);
}
}
setState(2784);
match(IDENTIFIER_);
setState(2786);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) {
case 1:
{
setState(2785);
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 POSITION:
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 INT2:
case INT4:
case FLOAT4:
case BYTEA:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case INET:
case TSQUERY:
case XML:
case JSON:
case INT4RANGE:
case INT8RANGE:
case NUMRANGE:
case DATERANGE:
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 INT16:
case INT1:
case ELEM_CONTAINED_BY_RANGE:
enterOuterAlt(_localctx, 2);
{
setState(2788);
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(2791);
match(UESCAPE);
setState(2792);
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 BYTEA() { return getToken(OpenGaussStatementParser.BYTEA, 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 TerminalNode POSITION() { return getToken(OpenGaussStatementParser.POSITION, 0); }
public TerminalNode INET() { return getToken(OpenGaussStatementParser.INET, 0); }
public TerminalNode INT1() { return getToken(OpenGaussStatementParser.INT1, 0); }
public TerminalNode INT2() { return getToken(OpenGaussStatementParser.INT2, 0); }
public TerminalNode INT4() { return getToken(OpenGaussStatementParser.INT4, 0); }
public TerminalNode INT16() { return getToken(OpenGaussStatementParser.INT16, 0); }
public TerminalNode FLOAT4() { return getToken(OpenGaussStatementParser.FLOAT4, 0); }
public TerminalNode ELEM_CONTAINED_BY_RANGE() { return getToken(OpenGaussStatementParser.ELEM_CONTAINED_BY_RANGE, 0); }
public TerminalNode INT8RANGE() { return getToken(OpenGaussStatementParser.INT8RANGE, 0); }
public TerminalNode INT4RANGE() { return getToken(OpenGaussStatementParser.INT4RANGE, 0); }
public TerminalNode NUMRANGE() { return getToken(OpenGaussStatementParser.NUMRANGE, 0); }
public TerminalNode DATERANGE() { return getToken(OpenGaussStatementParser.DATERANGE, 0); }
public TerminalNode TSQUERY() { return getToken(OpenGaussStatementParser.TSQUERY, 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(2794);
_la = _input.LA(1);
if ( !(((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & ((1L << (INSERT - 81)) | (1L << (UPDATE - 81)) | (1L << (DELETE - 81)) | (1L << (ALTER - 81)) | (1L << (DROP - 81)) | (1L << (TRUNCATE - 81)) | (1L << (SCHEMA - 81)) | (1L << (REVOKE - 81)) | (1L << (ADD - 81)) | (1L << (SET - 81)) | (1L << (INDEX - 81)) | (1L << (KEY - 81)) | (1L << (POSITION - 81)) | (1L << (FUNCTION - 81)) | (1L << (TRIGGER - 81)) | (1L << (PROCEDURE - 81)) | (1L << (VIEW - 81)) | (1L << (IF - 81)))) != 0) || ((((_la - 151)) & ~0x3f) == 0 && ((1L << (_la - 151)) & ((1L << (BY - 151)) | (1L << (BEGIN - 151)) | (1L << (COMMIT - 151)) | (1L << (ROLLBACK - 151)) | (1L << (SAVEPOINT - 151)) | (1L << (DOUBLE - 151)) | (1L << (INTERVAL - 151)) | (1L << (TIME - 151)) | (1L << (TIMESTAMP - 151)) | (1L << (YEAR - 151)) | (1L << (MONTH - 151)) | (1L << (DAY - 151)) | (1L << (HOUR - 151)) | (1L << (MINUTE - 151)) | (1L << (SECOND - 151)) | (1L << (CURRENT - 151)) | (1L << (ENABLE - 151)) | (1L << (DISABLE - 151)) | (1L << (CALL - 151)) | (1L << (PRESERVE - 151)) | (1L << (DEFINER - 151)) | (1L << (SQL - 151)) | (1L << (CASCADED - 151)) | (1L << (LOCAL - 151)) | (1L << (CLOSE - 151)) | (1L << (NEXT - 151)) | (1L << (NAME - 151)) | (1L << (NAMES - 151)) | (1L << (TYPE - 151)) | (1L << (TEXT - 151)) | (1L << (REPEATABLE - 151)) | (1L << (VARYING - 151)) | (1L << (NATIONAL - 151)))) != 0) || ((((_la - 216)) & ~0x3f) == 0 && ((1L << (_la - 216)) & ((1L << (VALUE - 216)) | (1L << (TIES - 216)) | (1L << (CUBE - 216)) | (1L << (SETS - 216)) | (1L << (OTHERS - 216)) | (1L << (AT - 216)) | (1L << (MAXVALUE - 216)) | (1L << (ADMIN - 216)) | (1L << (ESCAPE - 216)) | (1L << (EXCLUDE - 216)) | (1L << (MOD - 216)) | (1L << (PARTITION - 216)) | (1L << (UNKNOWN - 216)) | (1L << (ALWAYS - 216)) | (1L << (CASCADE - 216)) | (1L << (GENERATED - 216)) | (1L << (ISOLATION - 216)) | (1L << (LEVEL - 216)) | (1L << (NO - 216)) | (1L << (OPTION - 216)) | (1L << (PRIVILEGES - 216)) | (1L << (READ - 216)) | (1L << (ROLE - 216)) | (1L << (ROWS - 216)) | (1L << (START - 216)) | (1L << (TRANSACTION - 216)) | (1L << (ACTION - 216)) | (1L << (CACHE - 216)) | (1L << (CHARACTERISTICS - 216)) | (1L << (CLUSTER - 216)) | (1L << (COMMENTS - 216)) | (1L << (CONSTRAINTS - 216)) | (1L << (CYCLE - 216)) | (1L << (DATA - 216)) | (1L << (DATABASE - 216)) | (1L << (DEFAULTS - 216)) | (1L << (DEFERRED - 216)))) != 0) || ((((_la - 280)) & ~0x3f) == 0 && ((1L << (_la - 280)) & ((1L << (DEPENDS - 280)) | (1L << (DOMAIN - 280)) | (1L << (EXCLUDING - 280)) | (1L << (EXECUTE - 280)) | (1L << (EXTENDED - 280)) | (1L << (EXTENSION - 280)) | (1L << (EXTERNAL - 280)) | (1L << (FILTER - 280)) | (1L << (FIRST - 280)) | (1L << (FOLLOWING - 280)) | (1L << (FORCE - 280)) | (1L << (GLOBAL - 280)) | (1L << (IDENTITY - 280)) | (1L << (IMMEDIATE - 280)) | (1L << (INCLUDING - 280)) | (1L << (INCREMENT - 280)) | (1L << (INDEXES - 280)) | (1L << (INHERIT - 280)) | (1L << (INHERITS - 280)) | (1L << (INCLUDE - 280)) | (1L << (LANGUAGE - 280)) | (1L << (LARGE - 280)) | (1L << (LAST - 280)) | (1L << (LOGGED - 280)) | (1L << (MAIN - 280)) | (1L << (MATCH - 280)) | (1L << (MINVALUE - 280)) | (1L << (NOTHING - 280)) | (1L << (NULLS - 280)) | (1L << (OBJECT - 280)) | (1L << (OIDS - 280)) | (1L << (OVER - 280)) | (1L << (OWNED - 280)) | (1L << (OWNER - 280)) | (1L << (PARTIAL - 280)) | (1L << (PLAIN - 280)) | (1L << (PRECEDING - 280)) | (1L << (RANGE - 280)) | (1L << (RENAME - 280)) | (1L << (REPLICA - 280)) | (1L << (RESET - 280)) | (1L << (RESTART - 280)) | (1L << (RESTRICT - 280)) | (1L << (ROUTINE - 280)) | (1L << (RULE - 280)) | (1L << (SECURITY - 280)) | (1L << (SEQUENCE - 280)) | (1L << (SESSION - 280)) | (1L << (SHOW - 280)) | (1L << (SIMPLE - 280)) | (1L << (STATISTICS - 280)) | (1L << (STORAGE - 280)) | (1L << (TABLESPACE - 280)) | (1L << (TEMP - 280)) | (1L << (TEMPORARY - 280)) | (1L << (UNBOUNDED - 280)) | (1L << (UNLOGGED - 280)) | (1L << (VALID - 280)))) != 0) || ((((_la - 344)) & ~0x3f) == 0 && ((1L << (_la - 344)) & ((1L << (VALIDATE - 344)) | (1L << (WITHIN - 344)) | (1L << (WITHOUT - 344)) | (1L << (ZONE - 344)) | (1L << (OF - 344)) | (1L << (UESCAPE - 344)) | (1L << (GROUPS - 344)) | (1L << (RECURSIVE - 344)) | (1L << (INT2 - 344)) | (1L << (INT4 - 344)) | (1L << (FLOAT4 - 344)) | (1L << (BYTEA - 344)) | (1L << (ENUM - 344)) | (1L << (POINT - 344)) | (1L << (LSEG - 344)) | (1L << (BOX - 344)) | (1L << (PATH - 344)) | (1L << (POLYGON - 344)) | (1L << (CIRCLE - 344)) | (1L << (INET - 344)) | (1L << (TSQUERY - 344)) | (1L << (XML - 344)) | (1L << (JSON - 344)) | (1L << (INT4RANGE - 344)) | (1L << (INT8RANGE - 344)) | (1L << (NUMRANGE - 344)) | (1L << (DATERANGE - 344)) | (1L << (ORDINALITY - 344)) | (1L << (NFC - 344)) | (1L << (NFD - 344)) | (1L << (NFKC - 344)))) != 0) || ((((_la - 408)) & ~0x3f) == 0 && ((1L << (_la - 408)) & ((1L << (NFKD - 408)) | (1L << (REF - 408)) | (1L << (PASSING - 408)) | (1L << (VERSION - 408)) | (1L << (YES - 408)) | (1L << (STANDALONE - 408)) | (1L << (MATERIALIZED - 408)) | (1L << (OPERATOR - 408)) | (1L << (SHARE - 408)) | (1L << (ROLLUP - 408)) | (1L << (DOCUMENT - 408)) | (1L << (NORMALIZED - 408)) | (1L << (NOWAIT - 408)) | (1L << (LOCKED - 408)) | (1L << (COLUMNS - 408)) | (1L << (CONTENT - 408)) | (1L << (STRIP - 408)) | (1L << (WHITESPACE - 408)) | (1L << (CONFLICT - 408)) | (1L << (OVERRIDING - 408)) | (1L << (SYSTEM - 408)) | (1L << (ABORT - 408)) | (1L << (ABSOLUTE - 408)) | (1L << (ACCESS - 408)) | (1L << (AFTER - 408)) | (1L << (AGGREGATE - 408)) | (1L << (ALSO - 408)) | (1L << (ATTACH - 408)) | (1L << (ATTRIBUTE - 408)) | (1L << (BACKWARD - 408)) | (1L << (BEFORE - 408)) | (1L << (ASSERTION - 408)) | (1L << (ASSIGNMENT - 408)) | (1L << (CONTINUE - 408)) | (1L << (CONVERSION - 408)) | (1L << (COPY - 408)) | (1L << (COST - 408)) | (1L << (CSV - 408)) | (1L << (CALLED - 408)) | (1L << (CATALOG - 408)) | (1L << (CHAIN - 408)) | (1L << (CHECKPOINT - 408)) | (1L << (CLASS - 408)) | (1L << (CONFIGURATION - 408)) | (1L << (COMMENT - 408)) | (1L << (DETACH - 408)))) != 0) || ((((_la - 472)) & ~0x3f) == 0 && ((1L << (_la - 472)) & ((1L << (DICTIONARY - 472)) | (1L << (EXPRESSION - 472)) | (1L << (INSENSITIVE - 472)) | (1L << (DISCARD - 472)) | (1L << (OFF - 472)) | (1L << (INSTEAD - 472)) | (1L << (EXPLAIN - 472)) | (1L << (INPUT - 472)) | (1L << (INLINE - 472)) | (1L << (PARALLEL - 472)) | (1L << (LEAKPROOF - 472)) | (1L << (COMMITTED - 472)) | (1L << (ENCODING - 472)) | (1L << (IMPLICIT - 472)) | (1L << (DELIMITER - 472)) | (1L << (CURSOR - 472)) | (1L << (EACH - 472)) | (1L << (EVENT - 472)) | (1L << (DEALLOCATE - 472)) | (1L << (CONNECTION - 472)) | (1L << (DECLARE - 472)) | (1L << (FAMILY - 472)) | (1L << (FORWARD - 472)) | (1L << (EXCLUSIVE - 472)) | (1L << (FUNCTIONS - 472)) | (1L << (LOCATION - 472)) | (1L << (LABEL - 472)) | (1L << (DELIMITERS - 472)) | (1L << (HANDLER - 472)) | (1L << (HEADER - 472)) | (1L << (IMMUTABLE - 472)) | (1L << (GRANTED - 472)) | (1L << (HOLD - 472)) | (1L << (MAPPING - 472)) | (1L << (OLD - 472)) | (1L << (METHOD - 472)) | (1L << (LOAD - 472)) | (1L << (LISTEN - 472)) | (1L << (MODE - 472)) | (1L << (MOVE - 472)) | (1L << (PROCEDURAL - 472)) | (1L << (PARSER - 472)) | (1L << (PROCEDURES - 472)) | (1L << (ENCRYPTED - 472)) | (1L << (PUBLICATION - 472)) | (1L << (PROGRAM - 472)) | (1L << (REFERENCING - 472)) | (1L << (PLANS - 472)) | (1L << (REINDEX - 472)) | (1L << (PRIOR - 472)) | (1L << (PASSWORD - 472)) | (1L << (RELATIVE - 472)) | (1L << (QUOTE - 472)) | (1L << (ROUTINES - 472)) | (1L << (REPLACE - 472)) | (1L << (SNAPSHOT - 472)) | (1L << (REFRESH - 472)) | (1L << (PREPARE - 472)) | (1L << (OPTIONS - 472)) | (1L << (IMPORT - 472)) | (1L << (INVOKER - 472)) | (1L << (NEW - 472)) | (1L << (PREPARED - 472)))) != 0) || ((((_la - 536)) & ~0x3f) == 0 && ((1L << (_la - 536)) & ((1L << (SCROLL - 536)) | (1L << (SEQUENCES - 536)) | (1L << (SYSID - 536)) | (1L << (REASSIGN - 536)) | (1L << (SERVER - 536)) | (1L << (SUBSCRIPTION - 536)) | (1L << (SEARCH - 536)) | (1L << (SCHEMAS - 536)) | (1L << (RECHECK - 536)) | (1L << (POLICY - 536)) | (1L << (NOTIFY - 536)) | (1L << (LOCK - 536)) | (1L << (RELEASE - 536)) | (1L << (SERIALIZABLE - 536)) | (1L << (RETURNS - 536)) | (1L << (STATEMENT - 536)) | (1L << (STDIN - 536)) | (1L << (STDOUT - 536)) | (1L << (TABLES - 536)) | (1L << (SUPPORT - 536)) | (1L << (STABLE - 536)) | (1L << (TEMPLATE - 536)) | (1L << (UNENCRYPTED - 536)) | (1L << (VIEWS - 536)) | (1L << (UNCOMMITTED - 536)) | (1L << (TRANSFORM - 536)) | (1L << (UNLISTEN - 536)) | (1L << (TRUSTED - 536)) | (1L << (VALIDATOR - 536)) | (1L << (UNTIL - 536)) | (1L << (VACUUM - 536)) | (1L << (VOLATILE - 536)) | (1L << (STORED - 536)) | (1L << (WRITE - 536)) | (1L << (STRICT - 536)) | (1L << (TYPES - 536)) | (1L << (WRAPPER - 536)) | (1L << (WORK - 536)) | (1L << (INT16 - 536)) | (1L << (INT1 - 536)) | (1L << (ELEM_CONTAINED_BY_RANGE - 536)))) != 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(2796);
_la = _input.LA(1);
if ( !(((((_la - 119)) & ~0x3f) == 0 && ((1L << (_la - 119)) & ((1L << (NATURAL - 119)) | (1L << (JOIN - 119)) | (1L << (FULL - 119)) | (1L << (INNER - 119)) | (1L << (OUTER - 119)) | (1L << (LEFT - 119)) | (1L << (RIGHT - 119)) | (1L << (CROSS - 119)) | (1L << (IS - 119)) | (1L << (LIKE - 119)))) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & ((1L << (COLLATION - 198)) | (1L << (OVERLAPS - 198)) | (1L << (BINARY - 198)))) != 0) || _la==CONCURRENTLY || ((((_la - 388)) & ~0x3f) == 0 && ((1L << (_la - 388)) & ((1L << (TABLESAMPLE - 388)) | (1L << (CURRENT_SCHEMA - 388)) | (1L << (ILIKE - 388)) | (1L << (SIMILAR - 388)) | (1L << (ISNULL - 388)) | (1L << (NOTNULL - 388)))) != 0) || ((((_la - 574)) & ~0x3f) == 0 && ((1L << (_la - 574)) & ((1L << (FREEZE - 574)) | (1L << (AUTHORIZATION - 574)) | (1L << (VERBOSE - 574)))) != 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(2798);
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(2800);
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(2805);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,176,_ctx) ) {
case 1:
{
setState(2802);
owner();
setState(2803);
match(DOT_);
}
break;
}
setState(2807);
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(2812);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
case 1:
{
setState(2809);
owner();
setState(2810);
match(DOT_);
}
break;
}
setState(2814);
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(2819);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) {
case 1:
{
setState(2816);
owner();
setState(2817);
match(DOT_);
}
break;
}
setState(2821);
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(2823);
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(2825);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ModelNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ModelNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_modelName; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitModelName(this);
else return visitor.visitChildren(this);
}
}
public final ModelNameContext modelName() throws RecognitionException {
ModelNameContext _localctx = new ModelNameContext(_ctx, getState());
enterRule(_localctx, 256, RULE_modelName);
try {
enterOuterAlt(_localctx, 1);
{
setState(2827);
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, 258, RULE_tableNames);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2830);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LP_) {
{
setState(2829);
match(LP_);
}
}
setState(2832);
tableName();
setState(2837);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA_) {
{
{
setState(2833);
match(COMMA_);
setState(2834);
tableName();
}
}
setState(2839);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2841);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RP_) {
{
setState(2840);
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, 260, RULE_columnNames);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2843);
match(LP_);
setState(2844);
columnName();
setState(2849);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA_) {
{
{
setState(2845);
match(COMMA_);
setState(2846);
columnName();
}
}
setState(2851);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2852);
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, 262, RULE_collationName);
try {
setState(2856);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_:
enterOuterAlt(_localctx, 1);
{
setState(2854);
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 POSITION:
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 INT2:
case INT4:
case FLOAT4:
case BYTEA:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case INET:
case TSQUERY:
case XML:
case JSON:
case INT4RANGE:
case INT8RANGE:
case NUMRANGE:
case DATERANGE:
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 INT16:
case INT1:
case ELEM_CONTAINED_BY_RANGE:
case IDENTIFIER_:
enterOuterAlt(_localctx, 2);
{
setState(2855);
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, 264, RULE_indexName);
try {
enterOuterAlt(_localctx, 1);
{
setState(2858);
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, 266, RULE_constraintName);
try {
enterOuterAlt(_localctx, 1);
{
setState(2860);
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, 268, RULE_primaryKey);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2863);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PRIMARY) {
{
setState(2862);
match(PRIMARY);
}
}
setState(2865);
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, 270, RULE_andOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2867);
_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, 272, RULE_orOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2869);
_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, 274, RULE_comparisonOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2871);
_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 InetOperatorContext extends ParserRuleContext {
public TerminalNode SIGNED_LEFT_SHIFT_() { return getToken(OpenGaussStatementParser.SIGNED_LEFT_SHIFT_, 0); }
public TerminalNode SIGNED_LEFT_SHIFT_E_() { return getToken(OpenGaussStatementParser.SIGNED_LEFT_SHIFT_E_, 0); }
public TerminalNode SIGNED_RIGHT_SHIFT_() { return getToken(OpenGaussStatementParser.SIGNED_RIGHT_SHIFT_, 0); }
public TerminalNode SIGNED_RIGHT_SHIFT_E_() { return getToken(OpenGaussStatementParser.SIGNED_RIGHT_SHIFT_E_, 0); }
public InetOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inetOperator; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitInetOperator(this);
else return visitor.visitChildren(this);
}
}
public final InetOperatorContext inetOperator() throws RecognitionException {
InetOperatorContext _localctx = new InetOperatorContext(_ctx, getState());
enterRule(_localctx, 276, RULE_inetOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2873);
_la = _input.LA(1);
if ( !(_la==SIGNED_LEFT_SHIFT_ || _la==SIGNED_RIGHT_SHIFT_ || _la==SIGNED_LEFT_SHIFT_E_ || _la==SIGNED_RIGHT_SHIFT_E_) ) {
_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, 278, RULE_patternMatchingOperator);
try {
setState(2898);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2875);
match(LIKE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2876);
match(TILDE_TILDE_);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2877);
match(NOT);
setState(2878);
match(LIKE);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2879);
match(NOT_TILDE_TILDE_);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2880);
match(ILIKE);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2881);
match(ILIKE_);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2882);
match(NOT);
setState(2883);
match(ILIKE);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2884);
match(NOT_ILIKE_);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2885);
match(SIMILAR);
setState(2886);
match(TO);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2887);
match(NOT);
setState(2888);
match(SIMILAR);
setState(2889);
match(TO);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(2890);
match(TILDE_);
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(2891);
match(NOT_);
setState(2892);
match(TILDE_);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(2893);
match(TILDE_);
setState(2894);
match(ASTERISK_);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(2895);
match(NOT_);
setState(2896);
match(TILDE_);
setState(2897);
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, 280, RULE_cursorName);
try {
enterOuterAlt(_localctx, 1);
{
setState(2900);
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 TerminalNode DN_() { return getToken(OpenGaussStatementParser.DN_, 0); }
public TerminalNode TILDE_() { return getToken(OpenGaussStatementParser.TILDE_, 0); }
public TerminalNode CUBE_ROOT_() { return getToken(OpenGaussStatementParser.CUBE_ROOT_, 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 POUND_() { return getToken(OpenGaussStatementParser.POUND_, 0); }
public TerminalNode VERTICAL_BAR_() { return getToken(OpenGaussStatementParser.VERTICAL_BAR_, 0); }
public ComparisonOperatorContext comparisonOperator() {
return getRuleContext(ComparisonOperatorContext.class,0);
}
public InetOperatorContext inetOperator() {
return getRuleContext(InetOperatorContext.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 NOT_() { return getToken(OpenGaussStatementParser.NOT_, 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 = 282;
enterRecursionRule(_localctx, 282, RULE_aExpr, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2926);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) {
case 1:
{
setState(2903);
cExpr();
}
break;
case 2:
{
setState(2904);
match(PLUS_);
setState(2905);
aExpr(56);
}
break;
case 3:
{
setState(2906);
match(MINUS_);
setState(2907);
aExpr(55);
}
break;
case 4:
{
setState(2908);
match(DN_);
setState(2909);
aExpr(47);
}
break;
case 5:
{
setState(2910);
match(TILDE_);
setState(2911);
aExpr(44);
}
break;
case 6:
{
setState(2912);
match(CUBE_ROOT_);
setState(2913);
aExpr(43);
}
break;
case 7:
{
setState(2914);
qualOp();
setState(2915);
aExpr(40);
}
break;
case 8:
{
setState(2917);
match(NOT);
setState(2918);
aExpr(36);
}
break;
case 9:
{
setState(2919);
row();
setState(2920);
match(OVERLAPS);
setState(2921);
row();
}
break;
case 10:
{
setState(2923);
match(UNIQUE);
setState(2924);
selectWithParens();
}
break;
case 11:
{
setState(2925);
match(DEFAULT);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(3138);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,190,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(3136);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,189,_ctx) ) {
case 1:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2928);
if (!(precpred(_ctx, 57))) throw new FailedPredicateException(this, "precpred(_ctx, 57)");
setState(2929);
match(AT);
setState(2930);
match(TIME);
setState(2931);
match(ZONE);
setState(2932);
aExpr(58);
}
break;
case 2:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2933);
if (!(precpred(_ctx, 54))) throw new FailedPredicateException(this, "precpred(_ctx, 54)");
setState(2934);
match(PLUS_);
setState(2935);
aExpr(55);
}
break;
case 3:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2936);
if (!(precpred(_ctx, 53))) throw new FailedPredicateException(this, "precpred(_ctx, 53)");
setState(2937);
match(MINUS_);
setState(2938);
aExpr(54);
}
break;
case 4:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2939);
if (!(precpred(_ctx, 52))) throw new FailedPredicateException(this, "precpred(_ctx, 52)");
setState(2940);
match(ASTERISK_);
setState(2941);
aExpr(53);
}
break;
case 5:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2942);
if (!(precpred(_ctx, 51))) throw new FailedPredicateException(this, "precpred(_ctx, 51)");
setState(2943);
match(SLASH_);
setState(2944);
aExpr(52);
}
break;
case 6:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2945);
if (!(precpred(_ctx, 50))) throw new FailedPredicateException(this, "precpred(_ctx, 50)");
setState(2946);
match(MOD_);
setState(2947);
aExpr(51);
}
break;
case 7:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2948);
if (!(precpred(_ctx, 49))) throw new FailedPredicateException(this, "precpred(_ctx, 49)");
setState(2949);
match(CARET_);
setState(2950);
aExpr(50);
}
break;
case 8:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2951);
if (!(precpred(_ctx, 48))) throw new FailedPredicateException(this, "precpred(_ctx, 48)");
setState(2952);
match(AMPERSAND_);
setState(2953);
aExpr(49);
}
break;
case 9:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2954);
if (!(precpred(_ctx, 45))) throw new FailedPredicateException(this, "precpred(_ctx, 45)");
setState(2955);
match(POUND_);
setState(2956);
aExpr(46);
}
break;
case 10:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2957);
if (!(precpred(_ctx, 42))) throw new FailedPredicateException(this, "precpred(_ctx, 42)");
setState(2958);
match(VERTICAL_BAR_);
setState(2959);
aExpr(43);
}
break;
case 11:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2960);
if (!(precpred(_ctx, 41))) throw new FailedPredicateException(this, "precpred(_ctx, 41)");
setState(2961);
qualOp();
setState(2962);
aExpr(42);
}
break;
case 12:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2964);
if (!(precpred(_ctx, 38))) throw new FailedPredicateException(this, "precpred(_ctx, 38)");
setState(2965);
comparisonOperator();
setState(2966);
aExpr(39);
}
break;
case 13:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2968);
if (!(precpred(_ctx, 37))) throw new FailedPredicateException(this, "precpred(_ctx, 37)");
setState(2969);
inetOperator();
setState(2970);
aExpr(38);
}
break;
case 14:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2972);
if (!(precpred(_ctx, 35))) throw new FailedPredicateException(this, "precpred(_ctx, 35)");
setState(2973);
patternMatchingOperator();
setState(2974);
aExpr(0);
setState(2975);
match(ESCAPE);
setState(2976);
aExpr(36);
}
break;
case 15:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2978);
if (!(precpred(_ctx, 34))) throw new FailedPredicateException(this, "precpred(_ctx, 34)");
setState(2979);
patternMatchingOperator();
setState(2980);
aExpr(35);
}
break;
case 16:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2982);
if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)");
setState(2983);
match(IS);
setState(2984);
match(DISTINCT);
setState(2985);
match(FROM);
setState(2986);
aExpr(23);
}
break;
case 17:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2987);
if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)");
setState(2988);
match(IS);
setState(2989);
match(NOT);
setState(2990);
match(DISTINCT);
setState(2991);
match(FROM);
setState(2992);
aExpr(22);
}
break;
case 18:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2993);
if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
setState(2994);
match(BETWEEN);
setState(2996);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASYMMETRIC) {
{
setState(2995);
match(ASYMMETRIC);
}
}
setState(2998);
bExpr(0);
setState(2999);
match(AND);
setState(3000);
aExpr(19);
}
break;
case 19:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3002);
if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
setState(3003);
match(NOT);
setState(3004);
match(BETWEEN);
setState(3006);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASYMMETRIC) {
{
setState(3005);
match(ASYMMETRIC);
}
}
setState(3008);
bExpr(0);
setState(3009);
match(AND);
setState(3010);
aExpr(18);
}
break;
case 20:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3012);
if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
setState(3013);
match(BETWEEN);
setState(3014);
match(SYMMETRIC);
setState(3015);
bExpr(0);
setState(3016);
match(AND);
setState(3017);
aExpr(17);
}
break;
case 21:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3019);
if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
setState(3020);
match(NOT);
setState(3021);
match(BETWEEN);
setState(3022);
match(SYMMETRIC);
setState(3023);
bExpr(0);
setState(3024);
match(AND);
setState(3025);
aExpr(16);
}
break;
case 22:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3027);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(3028);
andOperator();
setState(3029);
aExpr(4);
}
break;
case 23:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3031);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(3032);
orOperator();
setState(3033);
aExpr(3);
}
break;
case 24:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3035);
if (!(precpred(_ctx, 59))) throw new FailedPredicateException(this, "precpred(_ctx, 59)");
setState(3036);
match(TYPE_CAST_);
setState(3037);
typeName();
}
break;
case 25:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3038);
if (!(precpred(_ctx, 58))) throw new FailedPredicateException(this, "precpred(_ctx, 58)");
setState(3039);
match(COLLATE);
setState(3040);
anyName();
}
break;
case 26:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3041);
if (!(precpred(_ctx, 46))) throw new FailedPredicateException(this, "precpred(_ctx, 46)");
setState(3042);
match(NOT_);
}
break;
case 27:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3043);
if (!(precpred(_ctx, 39))) throw new FailedPredicateException(this, "precpred(_ctx, 39)");
setState(3044);
qualOp();
}
break;
case 28:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3045);
if (!(precpred(_ctx, 33))) throw new FailedPredicateException(this, "precpred(_ctx, 33)");
setState(3046);
match(IS);
setState(3047);
match(NULL);
}
break;
case 29:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3048);
if (!(precpred(_ctx, 32))) throw new FailedPredicateException(this, "precpred(_ctx, 32)");
setState(3049);
match(ISNULL);
}
break;
case 30:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3050);
if (!(precpred(_ctx, 31))) throw new FailedPredicateException(this, "precpred(_ctx, 31)");
setState(3051);
match(IS);
setState(3052);
match(NOT);
setState(3053);
match(NULL);
}
break;
case 31:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3054);
if (!(precpred(_ctx, 30))) throw new FailedPredicateException(this, "precpred(_ctx, 30)");
setState(3055);
match(NOTNULL);
}
break;
case 32:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3056);
if (!(precpred(_ctx, 28))) throw new FailedPredicateException(this, "precpred(_ctx, 28)");
setState(3057);
match(IS);
setState(3058);
match(TRUE);
}
break;
case 33:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3059);
if (!(precpred(_ctx, 27))) throw new FailedPredicateException(this, "precpred(_ctx, 27)");
setState(3060);
match(IS);
setState(3061);
match(NOT);
setState(3062);
match(TRUE);
}
break;
case 34:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3063);
if (!(precpred(_ctx, 26))) throw new FailedPredicateException(this, "precpred(_ctx, 26)");
setState(3064);
match(IS);
setState(3065);
match(FALSE);
}
break;
case 35:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3066);
if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)");
setState(3067);
match(IS);
setState(3068);
match(NOT);
setState(3069);
match(FALSE);
}
break;
case 36:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3070);
if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)");
setState(3071);
match(IS);
setState(3072);
match(UNKNOWN);
}
break;
case 37:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3073);
if (!(precpred(_ctx, 23))) throw new FailedPredicateException(this, "precpred(_ctx, 23)");
setState(3074);
match(IS);
setState(3075);
match(NOT);
setState(3076);
match(UNKNOWN);
}
break;
case 38:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3077);
if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
setState(3078);
match(IS);
setState(3079);
match(OF);
setState(3080);
match(LP_);
setState(3081);
typeList();
setState(3082);
match(RP_);
}
break;
case 39:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3084);
if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)");
setState(3085);
match(IS);
setState(3086);
match(NOT);
setState(3087);
match(OF);
setState(3088);
match(LP_);
setState(3089);
typeList();
setState(3090);
match(RP_);
}
break;
case 40:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3092);
if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
setState(3093);
match(IN);
setState(3094);
inExpr();
}
break;
case 41:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3095);
if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
setState(3096);
match(NOT);
setState(3097);
match(IN);
setState(3098);
inExpr();
}
break;
case 42:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3099);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(3100);
subqueryOp();
setState(3101);
subType();
setState(3102);
selectWithParens();
}
break;
case 43:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3104);
if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
setState(3105);
subqueryOp();
setState(3106);
subType();
setState(3107);
match(LP_);
setState(3108);
aExpr(0);
setState(3109);
match(RP_);
}
break;
case 44:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3111);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(3112);
match(IS);
setState(3113);
match(DOCUMENT);
}
break;
case 45:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3114);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
setState(3115);
match(IS);
setState(3116);
match(NOT);
setState(3117);
match(DOCUMENT);
}
break;
case 46:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3118);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(3119);
match(IS);
setState(3120);
match(NORMALIZED);
}
break;
case 47:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3121);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(3122);
match(IS);
setState(3123);
unicodeNormalForm();
setState(3124);
match(NORMALIZED);
}
break;
case 48:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3126);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(3127);
match(IS);
setState(3128);
match(NOT);
setState(3129);
match(NORMALIZED);
}
break;
case 49:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3130);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(3131);
match(IS);
setState(3132);
match(NOT);
setState(3133);
unicodeNormalForm();
setState(3134);
match(NORMALIZED);
}
break;
}
}
}
setState(3140);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,190,_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 = 284;
enterRecursionRule(_localctx, 284, RULE_bExpr, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(3150);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,191,_ctx) ) {
case 1:
{
setState(3142);
cExpr();
}
break;
case 2:
{
setState(3143);
match(PLUS_);
setState(3144);
bExpr(11);
}
break;
case 3:
{
setState(3145);
match(MINUS_);
setState(3146);
bExpr(10);
}
break;
case 4:
{
setState(3147);
qualOp();
setState(3148);
bExpr(8);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(3196);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,193,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(3194);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) {
case 1:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3152);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(3153);
qualOp();
setState(3154);
bExpr(10);
}
break;
case 2:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3156);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(3157);
match(IS);
setState(3158);
match(DISTINCT);
setState(3159);
match(FROM);
setState(3160);
bExpr(7);
}
break;
case 3:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3161);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(3162);
match(IS);
setState(3163);
match(NOT);
setState(3164);
match(DISTINCT);
setState(3165);
match(FROM);
setState(3166);
bExpr(6);
}
break;
case 4:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3167);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(3168);
match(TYPE_CAST_);
setState(3169);
typeName();
}
break;
case 5:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3170);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(3171);
qualOp();
}
break;
case 6:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3172);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(3173);
match(IS);
setState(3174);
match(OF);
setState(3175);
match(LP_);
setState(3176);
typeList();
setState(3177);
match(RP_);
}
break;
case 7:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3179);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(3180);
match(IS);
setState(3181);
match(NOT);
setState(3182);
match(OF);
setState(3183);
match(LP_);
setState(3184);
typeList();
setState(3185);
match(RP_);
}
break;
case 8:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3187);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(3188);
match(IS);
setState(3189);
match(DOCUMENT);
}
break;
case 9:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3190);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(3191);
match(IS);
setState(3192);
match(NOT);
setState(3193);
match(DOCUMENT);
}
break;
}
}
}
setState(3198);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,193,_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, 286, RULE_cExpr);
try {
setState(3230);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(3199);
parameterMarker();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(3200);
columnref();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(3201);
aexprConst();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(3202);
match(PARAM);
setState(3204);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,194,_ctx) ) {
case 1:
{
setState(3203);
indirectionEl();
}
break;
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(3206);
match(LP_);
setState(3207);
aExpr(0);
setState(3208);
match(RP_);
setState(3209);
optIndirection(0);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(3211);
caseExpr();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(3212);
funcExpr();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(3213);
selectWithParens();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(3214);
selectWithParens();
setState(3215);
indirection(0);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(3217);
match(EXISTS);
setState(3218);
selectWithParens();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(3219);
match(ARRAY);
setState(3220);
selectWithParens();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(3221);
match(ARRAY);
setState(3222);
arrayExpr();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(3223);
explicitRow();
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(3224);
implicitRow();
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(3225);
match(GROUPING);
setState(3226);
match(LP_);
setState(3227);
exprList(0);
setState(3228);
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 = 288;
enterRecursionRule(_localctx, 288, RULE_indirection, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(3233);
indirectionEl();
}
_ctx.stop = _input.LT(-1);
setState(3239);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,196,_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(3235);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(3236);
indirectionEl();
}
}
}
setState(3241);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,196,_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 = 290;
enterRecursionRule(_localctx, 290, RULE_optIndirection, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
}
_ctx.stop = _input.LT(-1);
setState(3247);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,197,_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(3243);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(3244);
indirectionEl();
}
}
}
setState(3249);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,197,_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, 292, RULE_indirectionEl);
int _la;
try {
setState(3267);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(3250);
match(DOT_);
setState(3251);
attrName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(3252);
match(DOT_);
setState(3253);
match(ASTERISK_);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(3254);
match(LBT_);
setState(3255);
aExpr(0);
setState(3256);
match(RBT_);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(3258);
match(LBT_);
setState(3260);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OR_) | (1L << TILDE_) | (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 << (DN_ - 64)) | (1L << (CUBE_ROOT_ - 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)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (IF - 131)) | (1L << (IS - 131)) | (1L << (NOT - 131)) | (1L << (NULL - 131)) | (1L << (TRUE - 131)) | (1L << (FALSE - 131)) | (1L << (EXISTS - 131)) | (1L << (LIKE - 131)) | (1L << (BY - 131)) | (1L << (BEGIN - 131)) | (1L << (COMMIT - 131)) | (1L << (ROLLBACK - 131)) | (1L << (SAVEPOINT - 131)) | (1L << (BOOLEAN - 131)) | (1L << (DOUBLE - 131)) | (1L << (CHAR - 131)) | (1L << (CHARACTER - 131)) | (1L << (ARRAY - 131)) | (1L << (INTERVAL - 131)) | (1L << (DATE - 131)) | (1L << (TIME - 131)) | (1L << (TIMESTAMP - 131)) | (1L << (LOCALTIME - 131)) | (1L << (LOCALTIMESTAMP - 131)) | (1L << (YEAR - 131)) | (1L << (MONTH - 131)) | (1L << (DAY - 131)) | (1L << (HOUR - 131)) | (1L << (MINUTE - 131)) | (1L << (SECOND - 131)) | (1L << (DEFAULT - 131)) | (1L << (CURRENT - 131)) | (1L << (ENABLE - 131)) | (1L << (DISABLE - 131)) | (1L << (CALL - 131)) | (1L << (PRESERVE - 131)) | (1L << (DEFINER - 131)) | (1L << (CURRENT_USER - 131)) | (1L << (SQL - 131)) | (1L << (CASCADED - 131)) | (1L << (LOCAL - 131)) | (1L << (CLOSE - 131)))) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & ((1L << (NEXT - 196)) | (1L << (NAME - 196)) | (1L << (COLLATION - 196)) | (1L << (NAMES - 196)) | (1L << (INTEGER - 196)) | (1L << (REAL - 196)) | (1L << (DECIMAL - 196)) | (1L << (TYPE - 196)) | (1L << (SMALLINT - 196)) | (1L << (BIGINT - 196)) | (1L << (NUMERIC - 196)) | (1L << (TEXT - 196)) | (1L << (REPEATABLE - 196)) | (1L << (CURRENT_DATE - 196)) | (1L << (CURRENT_TIME - 196)) | (1L << (CURRENT_TIMESTAMP - 196)) | (1L << (NULLIF - 196)) | (1L << (VARYING - 196)) | (1L << (NATIONAL - 196)) | (1L << (NCHAR - 196)) | (1L << (VALUE - 196)) | (1L << (COALESCE - 196)) | (1L << (TIES - 196)) | (1L << (CUBE - 196)) | (1L << (GROUPING - 196)) | (1L << (SETS - 196)) | (1L << (OTHERS - 196)) | (1L << (OVERLAPS - 196)) | (1L << (AT - 196)) | (1L << (DEC - 196)) | (1L << (MAXVALUE - 196)) | (1L << (ADMIN - 196)) | (1L << (BINARY - 196)) | (1L << (ESCAPE - 196)) | (1L << (EXCLUDE - 196)) | (1L << (MOD - 196)) | (1L << (PARTITION - 196)) | (1L << (ROW - 196)) | (1L << (UNKNOWN - 196)) | (1L << (ALWAYS - 196)) | (1L << (CASCADE - 196)) | (1L << (GENERATED - 196)) | (1L << (ISOLATION - 196)) | (1L << (LEVEL - 196)) | (1L << (NO - 196)) | (1L << (OPTION - 196)) | (1L << (PRIVILEGES - 196)) | (1L << (READ - 196)))) != 0) || ((((_la - 260)) & ~0x3f) == 0 && ((1L << (_la - 260)) & ((1L << (ROLE - 260)) | (1L << (ROWS - 260)) | (1L << (START - 260)) | (1L << (TRANSACTION - 260)) | (1L << (USER - 260)) | (1L << (ACTION - 260)) | (1L << (CACHE - 260)) | (1L << (CHARACTERISTICS - 260)) | (1L << (CLUSTER - 260)) | (1L << (COMMENTS - 260)) | (1L << (CONCURRENTLY - 260)) | (1L << (CONSTRAINTS - 260)) | (1L << (CYCLE - 260)) | (1L << (DATA - 260)) | (1L << (DATABASE - 260)) | (1L << (DEFAULTS - 260)) | (1L << (DEFERRED - 260)) | (1L << (DEPENDS - 260)) | (1L << (DOMAIN - 260)) | (1L << (EXCLUDING - 260)) | (1L << (EXECUTE - 260)) | (1L << (EXTENDED - 260)) | (1L << (EXTENSION - 260)) | (1L << (EXTERNAL - 260)) | (1L << (EXTRACT - 260)) | (1L << (FILTER - 260)) | (1L << (FIRST - 260)) | (1L << (FOLLOWING - 260)) | (1L << (FORCE - 260)) | (1L << (GLOBAL - 260)) | (1L << (IDENTITY - 260)) | (1L << (IMMEDIATE - 260)) | (1L << (INCLUDING - 260)) | (1L << (INCREMENT - 260)) | (1L << (INDEXES - 260)) | (1L << (INHERIT - 260)) | (1L << (INHERITS - 260)) | (1L << (INCLUDE - 260)) | (1L << (LANGUAGE - 260)) | (1L << (LARGE - 260)) | (1L << (LAST - 260)) | (1L << (LOGGED - 260)) | (1L << (MAIN - 260)) | (1L << (MATCH - 260)) | (1L << (MINVALUE - 260)) | (1L << (NOTHING - 260)) | (1L << (NULLS - 260)) | (1L << (OBJECT - 260)) | (1L << (OIDS - 260)) | (1L << (OVER - 260)) | (1L << (OWNED - 260)) | (1L << (OWNER - 260)) | (1L << (PARTIAL - 260)) | (1L << (PLAIN - 260)) | (1L << (PRECEDING - 260)) | (1L << (RANGE - 260)) | (1L << (RENAME - 260)) | (1L << (REPLICA - 260)) | (1L << (RESET - 260)))) != 0) || ((((_la - 324)) & ~0x3f) == 0 && ((1L << (_la - 324)) & ((1L << (RESTART - 324)) | (1L << (RESTRICT - 324)) | (1L << (ROUTINE - 324)) | (1L << (RULE - 324)) | (1L << (SECURITY - 324)) | (1L << (SEQUENCE - 324)) | (1L << (SESSION - 324)) | (1L << (SESSION_USER - 324)) | (1L << (SHOW - 324)) | (1L << (SIMPLE - 324)) | (1L << (STATISTICS - 324)) | (1L << (STORAGE - 324)) | (1L << (TABLESPACE - 324)) | (1L << (TEMP - 324)) | (1L << (TEMPORARY - 324)) | (1L << (UNBOUNDED - 324)) | (1L << (UNLOGGED - 324)) | (1L << (VALID - 324)) | (1L << (VALIDATE - 324)) | (1L << (WITHIN - 324)) | (1L << (WITHOUT - 324)) | (1L << (ZONE - 324)) | (1L << (OF - 324)) | (1L << (UESCAPE - 324)) | (1L << (GROUPS - 324)) | (1L << (RECURSIVE - 324)) | (1L << (INT - 324)) | (1L << (INT2 - 324)) | (1L << (INT4 - 324)) | (1L << (INT8 - 324)) | (1L << (FLOAT - 324)) | (1L << (FLOAT4 - 324)) | (1L << (FLOAT8 - 324)) | (1L << (VARCHAR - 324)) | (1L << (BYTEA - 324)) | (1L << (ENUM - 324)) | (1L << (POINT - 324)) | (1L << (LSEG - 324)) | (1L << (BOX - 324)) | (1L << (PATH - 324)) | (1L << (POLYGON - 324)) | (1L << (CIRCLE - 324)) | (1L << (INET - 324)) | (1L << (BIT - 324)) | (1L << (TSQUERY - 324)) | (1L << (XML - 324)) | (1L << (JSON - 324)) | (1L << (INT4RANGE - 324)) | (1L << (INT8RANGE - 324)) | (1L << (NUMRANGE - 324)) | (1L << (DATERANGE - 324)))) != 0) || ((((_la - 388)) & ~0x3f) == 0 && ((1L << (_la - 388)) & ((1L << (TABLESAMPLE - 388)) | (1L << (ORDINALITY - 388)) | (1L << (CURRENT_ROLE - 388)) | (1L << (CURRENT_CATALOG - 388)) | (1L << (CURRENT_SCHEMA - 388)) | (1L << (NORMALIZE - 388)) | (1L << (OVERLAY - 388)) | (1L << (XMLCONCAT - 388)) | (1L << (XMLELEMENT - 388)) | (1L << (XMLEXISTS - 388)) | (1L << (XMLFOREST - 388)) | (1L << (XMLPARSE - 388)) | (1L << (XMLPI - 388)) | (1L << (XMLROOT - 388)) | (1L << (XMLSERIALIZE - 388)) | (1L << (TREAT - 388)) | (1L << (NFC - 388)) | (1L << (NFD - 388)) | (1L << (NFKC - 388)) | (1L << (NFKD - 388)) | (1L << (REF - 388)) | (1L << (PASSING - 388)) | (1L << (VERSION - 388)) | (1L << (YES - 388)) | (1L << (STANDALONE - 388)) | (1L << (GREATEST - 388)) | (1L << (LEAST - 388)) | (1L << (MATERIALIZED - 388)) | (1L << (OPERATOR - 388)) | (1L << (SHARE - 388)) | (1L << (ROLLUP - 388)) | (1L << (ILIKE - 388)) | (1L << (SIMILAR - 388)) | (1L << (ISNULL - 388)) | (1L << (NOTNULL - 388)) | (1L << (DOCUMENT - 388)) | (1L << (NORMALIZED - 388)) | (1L << (NOWAIT - 388)) | (1L << (LOCKED - 388)) | (1L << (COLUMNS - 388)) | (1L << (CONTENT - 388)) | (1L << (STRIP - 388)) | (1L << (WHITESPACE - 388)) | (1L << (CONFLICT - 388)) | (1L << (OVERRIDING - 388)) | (1L << (SYSTEM - 388)) | (1L << (ABORT - 388)) | (1L << (ABSOLUTE - 388)) | (1L << (ACCESS - 388)) | (1L << (AFTER - 388)) | (1L << (AGGREGATE - 388)))) != 0) || ((((_la - 452)) & ~0x3f) == 0 && ((1L << (_la - 452)) & ((1L << (ALSO - 452)) | (1L << (ATTACH - 452)) | (1L << (ATTRIBUTE - 452)) | (1L << (BACKWARD - 452)) | (1L << (BEFORE - 452)) | (1L << (ASSERTION - 452)) | (1L << (ASSIGNMENT - 452)) | (1L << (CONTINUE - 452)) | (1L << (CONVERSION - 452)) | (1L << (COPY - 452)) | (1L << (COST - 452)) | (1L << (CSV - 452)) | (1L << (CALLED - 452)) | (1L << (CATALOG - 452)) | (1L << (CHAIN - 452)) | (1L << (CHECKPOINT - 452)) | (1L << (CLASS - 452)) | (1L << (CONFIGURATION - 452)) | (1L << (COMMENT - 452)) | (1L << (DETACH - 452)) | (1L << (DICTIONARY - 452)) | (1L << (EXPRESSION - 452)) | (1L << (INSENSITIVE - 452)) | (1L << (DISCARD - 452)) | (1L << (OFF - 452)) | (1L << (INSTEAD - 452)) | (1L << (EXPLAIN - 452)) | (1L << (INPUT - 452)) | (1L << (INLINE - 452)) | (1L << (PARALLEL - 452)) | (1L << (LEAKPROOF - 452)) | (1L << (COMMITTED - 452)) | (1L << (ENCODING - 452)) | (1L << (IMPLICIT - 452)) | (1L << (DELIMITER - 452)) | (1L << (CURSOR - 452)) | (1L << (EACH - 452)) | (1L << (EVENT - 452)) | (1L << (DEALLOCATE - 452)) | (1L << (CONNECTION - 452)) | (1L << (DECLARE - 452)) | (1L << (FAMILY - 452)) | (1L << (FORWARD - 452)) | (1L << (EXCLUSIVE - 452)) | (1L << (FUNCTIONS - 452)) | (1L << (LOCATION - 452)) | (1L << (LABEL - 452)) | (1L << (DELIMITERS - 452)) | (1L << (HANDLER - 452)) | (1L << (HEADER - 452)) | (1L << (IMMUTABLE - 452)) | (1L << (GRANTED - 452)) | (1L << (HOLD - 452)) | (1L << (MAPPING - 452)) | (1L << (OLD - 452)) | (1L << (METHOD - 452)) | (1L << (LOAD - 452)) | (1L << (LISTEN - 452)) | (1L << (MODE - 452)) | (1L << (MOVE - 452)) | (1L << (PROCEDURAL - 452)) | (1L << (PARSER - 452)) | (1L << (PROCEDURES - 452)))) != 0) || ((((_la - 516)) & ~0x3f) == 0 && ((1L << (_la - 516)) & ((1L << (ENCRYPTED - 516)) | (1L << (PUBLICATION - 516)) | (1L << (PROGRAM - 516)) | (1L << (REFERENCING - 516)) | (1L << (PLANS - 516)) | (1L << (REINDEX - 516)) | (1L << (PRIOR - 516)) | (1L << (PASSWORD - 516)) | (1L << (RELATIVE - 516)) | (1L << (QUOTE - 516)) | (1L << (ROUTINES - 516)) | (1L << (REPLACE - 516)) | (1L << (SNAPSHOT - 516)) | (1L << (REFRESH - 516)) | (1L << (PREPARE - 516)) | (1L << (OPTIONS - 516)) | (1L << (IMPORT - 516)) | (1L << (INVOKER - 516)) | (1L << (NEW - 516)) | (1L << (PREPARED - 516)) | (1L << (SCROLL - 516)) | (1L << (SEQUENCES - 516)) | (1L << (SYSID - 516)) | (1L << (REASSIGN - 516)) | (1L << (SERVER - 516)) | (1L << (SUBSCRIPTION - 516)) | (1L << (SEARCH - 516)) | (1L << (SCHEMAS - 516)) | (1L << (RECHECK - 516)) | (1L << (POLICY - 516)) | (1L << (NOTIFY - 516)) | (1L << (LOCK - 516)) | (1L << (RELEASE - 516)) | (1L << (SERIALIZABLE - 516)) | (1L << (RETURNS - 516)) | (1L << (STATEMENT - 516)) | (1L << (STDIN - 516)) | (1L << (STDOUT - 516)) | (1L << (TABLES - 516)) | (1L << (SUPPORT - 516)) | (1L << (STABLE - 516)) | (1L << (TEMPLATE - 516)) | (1L << (UNENCRYPTED - 516)) | (1L << (VIEWS - 516)) | (1L << (UNCOMMITTED - 516)) | (1L << (TRANSFORM - 516)) | (1L << (UNLISTEN - 516)) | (1L << (TRUSTED - 516)) | (1L << (VALIDATOR - 516)) | (1L << (UNTIL - 516)) | (1L << (VACUUM - 516)) | (1L << (VOLATILE - 516)) | (1L << (STORED - 516)) | (1L << (WRITE - 516)) | (1L << (STRICT - 516)) | (1L << (TYPES - 516)) | (1L << (WRAPPER - 516)) | (1L << (WORK - 516)) | (1L << (FREEZE - 516)) | (1L << (AUTHORIZATION - 516)) | (1L << (VERBOSE - 516)) | (1L << (PARAM - 516)))) != 0) || ((((_la - 582)) & ~0x3f) == 0 && ((1L << (_la - 582)) & ((1L << (PREDICT - 582)) | (1L << (TS_REWRITE - 582)) | (1L << (INT16 - 582)) | (1L << (INT1 - 582)) | (1L << (ELEM_CONTAINED_BY_RANGE - 582)) | (1L << (LOWER_INF - 582)) | (1L << (UPPER_INF - 582)) | (1L << (ABBREV - 582)) | (1L << (SET_MASKLEN - 582)) | (1L << (TRUNC - 582)) | (1L << (IDENTIFIER_ - 582)) | (1L << (STRING_ - 582)) | (1L << (NUMBER_ - 582)))) != 0)) {
{
setState(3259);
sliceBound();
}
}
setState(3262);
match(COLON_);
setState(3264);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OR_) | (1L << TILDE_) | (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 << (DN_ - 64)) | (1L << (CUBE_ROOT_ - 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)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (IF - 131)) | (1L << (IS - 131)) | (1L << (NOT - 131)) | (1L << (NULL - 131)) | (1L << (TRUE - 131)) | (1L << (FALSE - 131)) | (1L << (EXISTS - 131)) | (1L << (LIKE - 131)) | (1L << (BY - 131)) | (1L << (BEGIN - 131)) | (1L << (COMMIT - 131)) | (1L << (ROLLBACK - 131)) | (1L << (SAVEPOINT - 131)) | (1L << (BOOLEAN - 131)) | (1L << (DOUBLE - 131)) | (1L << (CHAR - 131)) | (1L << (CHARACTER - 131)) | (1L << (ARRAY - 131)) | (1L << (INTERVAL - 131)) | (1L << (DATE - 131)) | (1L << (TIME - 131)) | (1L << (TIMESTAMP - 131)) | (1L << (LOCALTIME - 131)) | (1L << (LOCALTIMESTAMP - 131)) | (1L << (YEAR - 131)) | (1L << (MONTH - 131)) | (1L << (DAY - 131)) | (1L << (HOUR - 131)) | (1L << (MINUTE - 131)) | (1L << (SECOND - 131)) | (1L << (DEFAULT - 131)) | (1L << (CURRENT - 131)) | (1L << (ENABLE - 131)) | (1L << (DISABLE - 131)) | (1L << (CALL - 131)) | (1L << (PRESERVE - 131)) | (1L << (DEFINER - 131)) | (1L << (CURRENT_USER - 131)) | (1L << (SQL - 131)) | (1L << (CASCADED - 131)) | (1L << (LOCAL - 131)) | (1L << (CLOSE - 131)))) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & ((1L << (NEXT - 196)) | (1L << (NAME - 196)) | (1L << (COLLATION - 196)) | (1L << (NAMES - 196)) | (1L << (INTEGER - 196)) | (1L << (REAL - 196)) | (1L << (DECIMAL - 196)) | (1L << (TYPE - 196)) | (1L << (SMALLINT - 196)) | (1L << (BIGINT - 196)) | (1L << (NUMERIC - 196)) | (1L << (TEXT - 196)) | (1L << (REPEATABLE - 196)) | (1L << (CURRENT_DATE - 196)) | (1L << (CURRENT_TIME - 196)) | (1L << (CURRENT_TIMESTAMP - 196)) | (1L << (NULLIF - 196)) | (1L << (VARYING - 196)) | (1L << (NATIONAL - 196)) | (1L << (NCHAR - 196)) | (1L << (VALUE - 196)) | (1L << (COALESCE - 196)) | (1L << (TIES - 196)) | (1L << (CUBE - 196)) | (1L << (GROUPING - 196)) | (1L << (SETS - 196)) | (1L << (OTHERS - 196)) | (1L << (OVERLAPS - 196)) | (1L << (AT - 196)) | (1L << (DEC - 196)) | (1L << (MAXVALUE - 196)) | (1L << (ADMIN - 196)) | (1L << (BINARY - 196)) | (1L << (ESCAPE - 196)) | (1L << (EXCLUDE - 196)) | (1L << (MOD - 196)) | (1L << (PARTITION - 196)) | (1L << (ROW - 196)) | (1L << (UNKNOWN - 196)) | (1L << (ALWAYS - 196)) | (1L << (CASCADE - 196)) | (1L << (GENERATED - 196)) | (1L << (ISOLATION - 196)) | (1L << (LEVEL - 196)) | (1L << (NO - 196)) | (1L << (OPTION - 196)) | (1L << (PRIVILEGES - 196)) | (1L << (READ - 196)))) != 0) || ((((_la - 260)) & ~0x3f) == 0 && ((1L << (_la - 260)) & ((1L << (ROLE - 260)) | (1L << (ROWS - 260)) | (1L << (START - 260)) | (1L << (TRANSACTION - 260)) | (1L << (USER - 260)) | (1L << (ACTION - 260)) | (1L << (CACHE - 260)) | (1L << (CHARACTERISTICS - 260)) | (1L << (CLUSTER - 260)) | (1L << (COMMENTS - 260)) | (1L << (CONCURRENTLY - 260)) | (1L << (CONSTRAINTS - 260)) | (1L << (CYCLE - 260)) | (1L << (DATA - 260)) | (1L << (DATABASE - 260)) | (1L << (DEFAULTS - 260)) | (1L << (DEFERRED - 260)) | (1L << (DEPENDS - 260)) | (1L << (DOMAIN - 260)) | (1L << (EXCLUDING - 260)) | (1L << (EXECUTE - 260)) | (1L << (EXTENDED - 260)) | (1L << (EXTENSION - 260)) | (1L << (EXTERNAL - 260)) | (1L << (EXTRACT - 260)) | (1L << (FILTER - 260)) | (1L << (FIRST - 260)) | (1L << (FOLLOWING - 260)) | (1L << (FORCE - 260)) | (1L << (GLOBAL - 260)) | (1L << (IDENTITY - 260)) | (1L << (IMMEDIATE - 260)) | (1L << (INCLUDING - 260)) | (1L << (INCREMENT - 260)) | (1L << (INDEXES - 260)) | (1L << (INHERIT - 260)) | (1L << (INHERITS - 260)) | (1L << (INCLUDE - 260)) | (1L << (LANGUAGE - 260)) | (1L << (LARGE - 260)) | (1L << (LAST - 260)) | (1L << (LOGGED - 260)) | (1L << (MAIN - 260)) | (1L << (MATCH - 260)) | (1L << (MINVALUE - 260)) | (1L << (NOTHING - 260)) | (1L << (NULLS - 260)) | (1L << (OBJECT - 260)) | (1L << (OIDS - 260)) | (1L << (OVER - 260)) | (1L << (OWNED - 260)) | (1L << (OWNER - 260)) | (1L << (PARTIAL - 260)) | (1L << (PLAIN - 260)) | (1L << (PRECEDING - 260)) | (1L << (RANGE - 260)) | (1L << (RENAME - 260)) | (1L << (REPLICA - 260)) | (1L << (RESET - 260)))) != 0) || ((((_la - 324)) & ~0x3f) == 0 && ((1L << (_la - 324)) & ((1L << (RESTART - 324)) | (1L << (RESTRICT - 324)) | (1L << (ROUTINE - 324)) | (1L << (RULE - 324)) | (1L << (SECURITY - 324)) | (1L << (SEQUENCE - 324)) | (1L << (SESSION - 324)) | (1L << (SESSION_USER - 324)) | (1L << (SHOW - 324)) | (1L << (SIMPLE - 324)) | (1L << (STATISTICS - 324)) | (1L << (STORAGE - 324)) | (1L << (TABLESPACE - 324)) | (1L << (TEMP - 324)) | (1L << (TEMPORARY - 324)) | (1L << (UNBOUNDED - 324)) | (1L << (UNLOGGED - 324)) | (1L << (VALID - 324)) | (1L << (VALIDATE - 324)) | (1L << (WITHIN - 324)) | (1L << (WITHOUT - 324)) | (1L << (ZONE - 324)) | (1L << (OF - 324)) | (1L << (UESCAPE - 324)) | (1L << (GROUPS - 324)) | (1L << (RECURSIVE - 324)) | (1L << (INT - 324)) | (1L << (INT2 - 324)) | (1L << (INT4 - 324)) | (1L << (INT8 - 324)) | (1L << (FLOAT - 324)) | (1L << (FLOAT4 - 324)) | (1L << (FLOAT8 - 324)) | (1L << (VARCHAR - 324)) | (1L << (BYTEA - 324)) | (1L << (ENUM - 324)) | (1L << (POINT - 324)) | (1L << (LSEG - 324)) | (1L << (BOX - 324)) | (1L << (PATH - 324)) | (1L << (POLYGON - 324)) | (1L << (CIRCLE - 324)) | (1L << (INET - 324)) | (1L << (BIT - 324)) | (1L << (TSQUERY - 324)) | (1L << (XML - 324)) | (1L << (JSON - 324)) | (1L << (INT4RANGE - 324)) | (1L << (INT8RANGE - 324)) | (1L << (NUMRANGE - 324)) | (1L << (DATERANGE - 324)))) != 0) || ((((_la - 388)) & ~0x3f) == 0 && ((1L << (_la - 388)) & ((1L << (TABLESAMPLE - 388)) | (1L << (ORDINALITY - 388)) | (1L << (CURRENT_ROLE - 388)) | (1L << (CURRENT_CATALOG - 388)) | (1L << (CURRENT_SCHEMA - 388)) | (1L << (NORMALIZE - 388)) | (1L << (OVERLAY - 388)) | (1L << (XMLCONCAT - 388)) | (1L << (XMLELEMENT - 388)) | (1L << (XMLEXISTS - 388)) | (1L << (XMLFOREST - 388)) | (1L << (XMLPARSE - 388)) | (1L << (XMLPI - 388)) | (1L << (XMLROOT - 388)) | (1L << (XMLSERIALIZE - 388)) | (1L << (TREAT - 388)) | (1L << (NFC - 388)) | (1L << (NFD - 388)) | (1L << (NFKC - 388)) | (1L << (NFKD - 388)) | (1L << (REF - 388)) | (1L << (PASSING - 388)) | (1L << (VERSION - 388)) | (1L << (YES - 388)) | (1L << (STANDALONE - 388)) | (1L << (GREATEST - 388)) | (1L << (LEAST - 388)) | (1L << (MATERIALIZED - 388)) | (1L << (OPERATOR - 388)) | (1L << (SHARE - 388)) | (1L << (ROLLUP - 388)) | (1L << (ILIKE - 388)) | (1L << (SIMILAR - 388)) | (1L << (ISNULL - 388)) | (1L << (NOTNULL - 388)) | (1L << (DOCUMENT - 388)) | (1L << (NORMALIZED - 388)) | (1L << (NOWAIT - 388)) | (1L << (LOCKED - 388)) | (1L << (COLUMNS - 388)) | (1L << (CONTENT - 388)) | (1L << (STRIP - 388)) | (1L << (WHITESPACE - 388)) | (1L << (CONFLICT - 388)) | (1L << (OVERRIDING - 388)) | (1L << (SYSTEM - 388)) | (1L << (ABORT - 388)) | (1L << (ABSOLUTE - 388)) | (1L << (ACCESS - 388)) | (1L << (AFTER - 388)) | (1L << (AGGREGATE - 388)))) != 0) || ((((_la - 452)) & ~0x3f) == 0 && ((1L << (_la - 452)) & ((1L << (ALSO - 452)) | (1L << (ATTACH - 452)) | (1L << (ATTRIBUTE - 452)) | (1L << (BACKWARD - 452)) | (1L << (BEFORE - 452)) | (1L << (ASSERTION - 452)) | (1L << (ASSIGNMENT - 452)) | (1L << (CONTINUE - 452)) | (1L << (CONVERSION - 452)) | (1L << (COPY - 452)) | (1L << (COST - 452)) | (1L << (CSV - 452)) | (1L << (CALLED - 452)) | (1L << (CATALOG - 452)) | (1L << (CHAIN - 452)) | (1L << (CHECKPOINT - 452)) | (1L << (CLASS - 452)) | (1L << (CONFIGURATION - 452)) | (1L << (COMMENT - 452)) | (1L << (DETACH - 452)) | (1L << (DICTIONARY - 452)) | (1L << (EXPRESSION - 452)) | (1L << (INSENSITIVE - 452)) | (1L << (DISCARD - 452)) | (1L << (OFF - 452)) | (1L << (INSTEAD - 452)) | (1L << (EXPLAIN - 452)) | (1L << (INPUT - 452)) | (1L << (INLINE - 452)) | (1L << (PARALLEL - 452)) | (1L << (LEAKPROOF - 452)) | (1L << (COMMITTED - 452)) | (1L << (ENCODING - 452)) | (1L << (IMPLICIT - 452)) | (1L << (DELIMITER - 452)) | (1L << (CURSOR - 452)) | (1L << (EACH - 452)) | (1L << (EVENT - 452)) | (1L << (DEALLOCATE - 452)) | (1L << (CONNECTION - 452)) | (1L << (DECLARE - 452)) | (1L << (FAMILY - 452)) | (1L << (FORWARD - 452)) | (1L << (EXCLUSIVE - 452)) | (1L << (FUNCTIONS - 452)) | (1L << (LOCATION - 452)) | (1L << (LABEL - 452)) | (1L << (DELIMITERS - 452)) | (1L << (HANDLER - 452)) | (1L << (HEADER - 452)) | (1L << (IMMUTABLE - 452)) | (1L << (GRANTED - 452)) | (1L << (HOLD - 452)) | (1L << (MAPPING - 452)) | (1L << (OLD - 452)) | (1L << (METHOD - 452)) | (1L << (LOAD - 452)) | (1L << (LISTEN - 452)) | (1L << (MODE - 452)) | (1L << (MOVE - 452)) | (1L << (PROCEDURAL - 452)) | (1L << (PARSER - 452)) | (1L << (PROCEDURES - 452)))) != 0) || ((((_la - 516)) & ~0x3f) == 0 && ((1L << (_la - 516)) & ((1L << (ENCRYPTED - 516)) | (1L << (PUBLICATION - 516)) | (1L << (PROGRAM - 516)) | (1L << (REFERENCING - 516)) | (1L << (PLANS - 516)) | (1L << (REINDEX - 516)) | (1L << (PRIOR - 516)) | (1L << (PASSWORD - 516)) | (1L << (RELATIVE - 516)) | (1L << (QUOTE - 516)) | (1L << (ROUTINES - 516)) | (1L << (REPLACE - 516)) | (1L << (SNAPSHOT - 516)) | (1L << (REFRESH - 516)) | (1L << (PREPARE - 516)) | (1L << (OPTIONS - 516)) | (1L << (IMPORT - 516)) | (1L << (INVOKER - 516)) | (1L << (NEW - 516)) | (1L << (PREPARED - 516)) | (1L << (SCROLL - 516)) | (1L << (SEQUENCES - 516)) | (1L << (SYSID - 516)) | (1L << (REASSIGN - 516)) | (1L << (SERVER - 516)) | (1L << (SUBSCRIPTION - 516)) | (1L << (SEARCH - 516)) | (1L << (SCHEMAS - 516)) | (1L << (RECHECK - 516)) | (1L << (POLICY - 516)) | (1L << (NOTIFY - 516)) | (1L << (LOCK - 516)) | (1L << (RELEASE - 516)) | (1L << (SERIALIZABLE - 516)) | (1L << (RETURNS - 516)) | (1L << (STATEMENT - 516)) | (1L << (STDIN - 516)) | (1L << (STDOUT - 516)) | (1L << (TABLES - 516)) | (1L << (SUPPORT - 516)) | (1L << (STABLE - 516)) | (1L << (TEMPLATE - 516)) | (1L << (UNENCRYPTED - 516)) | (1L << (VIEWS - 516)) | (1L << (UNCOMMITTED - 516)) | (1L << (TRANSFORM - 516)) | (1L << (UNLISTEN - 516)) | (1L << (TRUSTED - 516)) | (1L << (VALIDATOR - 516)) | (1L << (UNTIL - 516)) | (1L << (VACUUM - 516)) | (1L << (VOLATILE - 516)) | (1L << (STORED - 516)) | (1L << (WRITE - 516)) | (1L << (STRICT - 516)) | (1L << (TYPES - 516)) | (1L << (WRAPPER - 516)) | (1L << (WORK - 516)) | (1L << (FREEZE - 516)) | (1L << (AUTHORIZATION - 516)) | (1L << (VERBOSE - 516)) | (1L << (PARAM - 516)))) != 0) || ((((_la - 582)) & ~0x3f) == 0 && ((1L << (_la - 582)) & ((1L << (PREDICT - 582)) | (1L << (TS_REWRITE - 582)) | (1L << (INT16 - 582)) | (1L << (INT1 - 582)) | (1L << (ELEM_CONTAINED_BY_RANGE - 582)) | (1L << (LOWER_INF - 582)) | (1L << (UPPER_INF - 582)) | (1L << (ABBREV - 582)) | (1L << (SET_MASKLEN - 582)) | (1L << (TRUNC - 582)) | (1L << (IDENTIFIER_ - 582)) | (1L << (STRING_ - 582)) | (1L << (NUMBER_ - 582)))) != 0)) {
{
setState(3263);
sliceBound();
}
}
setState(3266);
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, 294, RULE_sliceBound);
try {
enterOuterAlt(_localctx, 1);
{
setState(3269);
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, 296, RULE_inExpr);
try {
setState(3276);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(3271);
selectWithParens();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(3272);
match(LP_);
setState(3273);
exprList(0);
setState(3274);
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, 298, RULE_caseExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3278);
match(CASE);
setState(3280);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OR_) | (1L << TILDE_) | (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 << (DN_ - 64)) | (1L << (CUBE_ROOT_ - 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)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (IF - 131)) | (1L << (IS - 131)) | (1L << (NOT - 131)) | (1L << (NULL - 131)) | (1L << (TRUE - 131)) | (1L << (FALSE - 131)) | (1L << (EXISTS - 131)) | (1L << (LIKE - 131)) | (1L << (BY - 131)) | (1L << (BEGIN - 131)) | (1L << (COMMIT - 131)) | (1L << (ROLLBACK - 131)) | (1L << (SAVEPOINT - 131)) | (1L << (BOOLEAN - 131)) | (1L << (DOUBLE - 131)) | (1L << (CHAR - 131)) | (1L << (CHARACTER - 131)) | (1L << (ARRAY - 131)) | (1L << (INTERVAL - 131)) | (1L << (DATE - 131)) | (1L << (TIME - 131)) | (1L << (TIMESTAMP - 131)) | (1L << (LOCALTIME - 131)) | (1L << (LOCALTIMESTAMP - 131)) | (1L << (YEAR - 131)) | (1L << (MONTH - 131)) | (1L << (DAY - 131)) | (1L << (HOUR - 131)) | (1L << (MINUTE - 131)) | (1L << (SECOND - 131)) | (1L << (DEFAULT - 131)) | (1L << (CURRENT - 131)) | (1L << (ENABLE - 131)) | (1L << (DISABLE - 131)) | (1L << (CALL - 131)) | (1L << (PRESERVE - 131)) | (1L << (DEFINER - 131)) | (1L << (CURRENT_USER - 131)) | (1L << (SQL - 131)) | (1L << (CASCADED - 131)) | (1L << (LOCAL - 131)) | (1L << (CLOSE - 131)))) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & ((1L << (NEXT - 196)) | (1L << (NAME - 196)) | (1L << (COLLATION - 196)) | (1L << (NAMES - 196)) | (1L << (INTEGER - 196)) | (1L << (REAL - 196)) | (1L << (DECIMAL - 196)) | (1L << (TYPE - 196)) | (1L << (SMALLINT - 196)) | (1L << (BIGINT - 196)) | (1L << (NUMERIC - 196)) | (1L << (TEXT - 196)) | (1L << (REPEATABLE - 196)) | (1L << (CURRENT_DATE - 196)) | (1L << (CURRENT_TIME - 196)) | (1L << (CURRENT_TIMESTAMP - 196)) | (1L << (NULLIF - 196)) | (1L << (VARYING - 196)) | (1L << (NATIONAL - 196)) | (1L << (NCHAR - 196)) | (1L << (VALUE - 196)) | (1L << (COALESCE - 196)) | (1L << (TIES - 196)) | (1L << (CUBE - 196)) | (1L << (GROUPING - 196)) | (1L << (SETS - 196)) | (1L << (OTHERS - 196)) | (1L << (OVERLAPS - 196)) | (1L << (AT - 196)) | (1L << (DEC - 196)) | (1L << (MAXVALUE - 196)) | (1L << (ADMIN - 196)) | (1L << (BINARY - 196)) | (1L << (ESCAPE - 196)) | (1L << (EXCLUDE - 196)) | (1L << (MOD - 196)) | (1L << (PARTITION - 196)) | (1L << (ROW - 196)) | (1L << (UNKNOWN - 196)) | (1L << (ALWAYS - 196)) | (1L << (CASCADE - 196)) | (1L << (GENERATED - 196)) | (1L << (ISOLATION - 196)) | (1L << (LEVEL - 196)) | (1L << (NO - 196)) | (1L << (OPTION - 196)) | (1L << (PRIVILEGES - 196)) | (1L << (READ - 196)))) != 0) || ((((_la - 260)) & ~0x3f) == 0 && ((1L << (_la - 260)) & ((1L << (ROLE - 260)) | (1L << (ROWS - 260)) | (1L << (START - 260)) | (1L << (TRANSACTION - 260)) | (1L << (USER - 260)) | (1L << (ACTION - 260)) | (1L << (CACHE - 260)) | (1L << (CHARACTERISTICS - 260)) | (1L << (CLUSTER - 260)) | (1L << (COMMENTS - 260)) | (1L << (CONCURRENTLY - 260)) | (1L << (CONSTRAINTS - 260)) | (1L << (CYCLE - 260)) | (1L << (DATA - 260)) | (1L << (DATABASE - 260)) | (1L << (DEFAULTS - 260)) | (1L << (DEFERRED - 260)) | (1L << (DEPENDS - 260)) | (1L << (DOMAIN - 260)) | (1L << (EXCLUDING - 260)) | (1L << (EXECUTE - 260)) | (1L << (EXTENDED - 260)) | (1L << (EXTENSION - 260)) | (1L << (EXTERNAL - 260)) | (1L << (EXTRACT - 260)) | (1L << (FILTER - 260)) | (1L << (FIRST - 260)) | (1L << (FOLLOWING - 260)) | (1L << (FORCE - 260)) | (1L << (GLOBAL - 260)) | (1L << (IDENTITY - 260)) | (1L << (IMMEDIATE - 260)) | (1L << (INCLUDING - 260)) | (1L << (INCREMENT - 260)) | (1L << (INDEXES - 260)) | (1L << (INHERIT - 260)) | (1L << (INHERITS - 260)) | (1L << (INCLUDE - 260)) | (1L << (LANGUAGE - 260)) | (1L << (LARGE - 260)) | (1L << (LAST - 260)) | (1L << (LOGGED - 260)) | (1L << (MAIN - 260)) | (1L << (MATCH - 260)) | (1L << (MINVALUE - 260)) | (1L << (NOTHING - 260)) | (1L << (NULLS - 260)) | (1L << (OBJECT - 260)) | (1L << (OIDS - 260)) | (1L << (OVER - 260)) | (1L << (OWNED - 260)) | (1L << (OWNER - 260)) | (1L << (PARTIAL - 260)) | (1L << (PLAIN - 260)) | (1L << (PRECEDING - 260)) | (1L << (RANGE - 260)) | (1L << (RENAME - 260)) | (1L << (REPLICA - 260)) | (1L << (RESET - 260)))) != 0) || ((((_la - 324)) & ~0x3f) == 0 && ((1L << (_la - 324)) & ((1L << (RESTART - 324)) | (1L << (RESTRICT - 324)) | (1L << (ROUTINE - 324)) | (1L << (RULE - 324)) | (1L << (SECURITY - 324)) | (1L << (SEQUENCE - 324)) | (1L << (SESSION - 324)) | (1L << (SESSION_USER - 324)) | (1L << (SHOW - 324)) | (1L << (SIMPLE - 324)) | (1L << (STATISTICS - 324)) | (1L << (STORAGE - 324)) | (1L << (TABLESPACE - 324)) | (1L << (TEMP - 324)) | (1L << (TEMPORARY - 324)) | (1L << (UNBOUNDED - 324)) | (1L << (UNLOGGED - 324)) | (1L << (VALID - 324)) | (1L << (VALIDATE - 324)) | (1L << (WITHIN - 324)) | (1L << (WITHOUT - 324)) | (1L << (ZONE - 324)) | (1L << (OF - 324)) | (1L << (UESCAPE - 324)) | (1L << (GROUPS - 324)) | (1L << (RECURSIVE - 324)) | (1L << (INT - 324)) | (1L << (INT2 - 324)) | (1L << (INT4 - 324)) | (1L << (INT8 - 324)) | (1L << (FLOAT - 324)) | (1L << (FLOAT4 - 324)) | (1L << (FLOAT8 - 324)) | (1L << (VARCHAR - 324)) | (1L << (BYTEA - 324)) | (1L << (ENUM - 324)) | (1L << (POINT - 324)) | (1L << (LSEG - 324)) | (1L << (BOX - 324)) | (1L << (PATH - 324)) | (1L << (POLYGON - 324)) | (1L << (CIRCLE - 324)) | (1L << (INET - 324)) | (1L << (BIT - 324)) | (1L << (TSQUERY - 324)) | (1L << (XML - 324)) | (1L << (JSON - 324)) | (1L << (INT4RANGE - 324)) | (1L << (INT8RANGE - 324)) | (1L << (NUMRANGE - 324)) | (1L << (DATERANGE - 324)))) != 0) || ((((_la - 388)) & ~0x3f) == 0 && ((1L << (_la - 388)) & ((1L << (TABLESAMPLE - 388)) | (1L << (ORDINALITY - 388)) | (1L << (CURRENT_ROLE - 388)) | (1L << (CURRENT_CATALOG - 388)) | (1L << (CURRENT_SCHEMA - 388)) | (1L << (NORMALIZE - 388)) | (1L << (OVERLAY - 388)) | (1L << (XMLCONCAT - 388)) | (1L << (XMLELEMENT - 388)) | (1L << (XMLEXISTS - 388)) | (1L << (XMLFOREST - 388)) | (1L << (XMLPARSE - 388)) | (1L << (XMLPI - 388)) | (1L << (XMLROOT - 388)) | (1L << (XMLSERIALIZE - 388)) | (1L << (TREAT - 388)) | (1L << (NFC - 388)) | (1L << (NFD - 388)) | (1L << (NFKC - 388)) | (1L << (NFKD - 388)) | (1L << (REF - 388)) | (1L << (PASSING - 388)) | (1L << (VERSION - 388)) | (1L << (YES - 388)) | (1L << (STANDALONE - 388)) | (1L << (GREATEST - 388)) | (1L << (LEAST - 388)) | (1L << (MATERIALIZED - 388)) | (1L << (OPERATOR - 388)) | (1L << (SHARE - 388)) | (1L << (ROLLUP - 388)) | (1L << (ILIKE - 388)) | (1L << (SIMILAR - 388)) | (1L << (ISNULL - 388)) | (1L << (NOTNULL - 388)) | (1L << (DOCUMENT - 388)) | (1L << (NORMALIZED - 388)) | (1L << (NOWAIT - 388)) | (1L << (LOCKED - 388)) | (1L << (COLUMNS - 388)) | (1L << (CONTENT - 388)) | (1L << (STRIP - 388)) | (1L << (WHITESPACE - 388)) | (1L << (CONFLICT - 388)) | (1L << (OVERRIDING - 388)) | (1L << (SYSTEM - 388)) | (1L << (ABORT - 388)) | (1L << (ABSOLUTE - 388)) | (1L << (ACCESS - 388)) | (1L << (AFTER - 388)) | (1L << (AGGREGATE - 388)))) != 0) || ((((_la - 452)) & ~0x3f) == 0 && ((1L << (_la - 452)) & ((1L << (ALSO - 452)) | (1L << (ATTACH - 452)) | (1L << (ATTRIBUTE - 452)) | (1L << (BACKWARD - 452)) | (1L << (BEFORE - 452)) | (1L << (ASSERTION - 452)) | (1L << (ASSIGNMENT - 452)) | (1L << (CONTINUE - 452)) | (1L << (CONVERSION - 452)) | (1L << (COPY - 452)) | (1L << (COST - 452)) | (1L << (CSV - 452)) | (1L << (CALLED - 452)) | (1L << (CATALOG - 452)) | (1L << (CHAIN - 452)) | (1L << (CHECKPOINT - 452)) | (1L << (CLASS - 452)) | (1L << (CONFIGURATION - 452)) | (1L << (COMMENT - 452)) | (1L << (DETACH - 452)) | (1L << (DICTIONARY - 452)) | (1L << (EXPRESSION - 452)) | (1L << (INSENSITIVE - 452)) | (1L << (DISCARD - 452)) | (1L << (OFF - 452)) | (1L << (INSTEAD - 452)) | (1L << (EXPLAIN - 452)) | (1L << (INPUT - 452)) | (1L << (INLINE - 452)) | (1L << (PARALLEL - 452)) | (1L << (LEAKPROOF - 452)) | (1L << (COMMITTED - 452)) | (1L << (ENCODING - 452)) | (1L << (IMPLICIT - 452)) | (1L << (DELIMITER - 452)) | (1L << (CURSOR - 452)) | (1L << (EACH - 452)) | (1L << (EVENT - 452)) | (1L << (DEALLOCATE - 452)) | (1L << (CONNECTION - 452)) | (1L << (DECLARE - 452)) | (1L << (FAMILY - 452)) | (1L << (FORWARD - 452)) | (1L << (EXCLUSIVE - 452)) | (1L << (FUNCTIONS - 452)) | (1L << (LOCATION - 452)) | (1L << (LABEL - 452)) | (1L << (DELIMITERS - 452)) | (1L << (HANDLER - 452)) | (1L << (HEADER - 452)) | (1L << (IMMUTABLE - 452)) | (1L << (GRANTED - 452)) | (1L << (HOLD - 452)) | (1L << (MAPPING - 452)) | (1L << (OLD - 452)) | (1L << (METHOD - 452)) | (1L << (LOAD - 452)) | (1L << (LISTEN - 452)) | (1L << (MODE - 452)) | (1L << (MOVE - 452)) | (1L << (PROCEDURAL - 452)) | (1L << (PARSER - 452)) | (1L << (PROCEDURES - 452)))) != 0) || ((((_la - 516)) & ~0x3f) == 0 && ((1L << (_la - 516)) & ((1L << (ENCRYPTED - 516)) | (1L << (PUBLICATION - 516)) | (1L << (PROGRAM - 516)) | (1L << (REFERENCING - 516)) | (1L << (PLANS - 516)) | (1L << (REINDEX - 516)) | (1L << (PRIOR - 516)) | (1L << (PASSWORD - 516)) | (1L << (RELATIVE - 516)) | (1L << (QUOTE - 516)) | (1L << (ROUTINES - 516)) | (1L << (REPLACE - 516)) | (1L << (SNAPSHOT - 516)) | (1L << (REFRESH - 516)) | (1L << (PREPARE - 516)) | (1L << (OPTIONS - 516)) | (1L << (IMPORT - 516)) | (1L << (INVOKER - 516)) | (1L << (NEW - 516)) | (1L << (PREPARED - 516)) | (1L << (SCROLL - 516)) | (1L << (SEQUENCES - 516)) | (1L << (SYSID - 516)) | (1L << (REASSIGN - 516)) | (1L << (SERVER - 516)) | (1L << (SUBSCRIPTION - 516)) | (1L << (SEARCH - 516)) | (1L << (SCHEMAS - 516)) | (1L << (RECHECK - 516)) | (1L << (POLICY - 516)) | (1L << (NOTIFY - 516)) | (1L << (LOCK - 516)) | (1L << (RELEASE - 516)) | (1L << (SERIALIZABLE - 516)) | (1L << (RETURNS - 516)) | (1L << (STATEMENT - 516)) | (1L << (STDIN - 516)) | (1L << (STDOUT - 516)) | (1L << (TABLES - 516)) | (1L << (SUPPORT - 516)) | (1L << (STABLE - 516)) | (1L << (TEMPLATE - 516)) | (1L << (UNENCRYPTED - 516)) | (1L << (VIEWS - 516)) | (1L << (UNCOMMITTED - 516)) | (1L << (TRANSFORM - 516)) | (1L << (UNLISTEN - 516)) | (1L << (TRUSTED - 516)) | (1L << (VALIDATOR - 516)) | (1L << (UNTIL - 516)) | (1L << (VACUUM - 516)) | (1L << (VOLATILE - 516)) | (1L << (STORED - 516)) | (1L << (WRITE - 516)) | (1L << (STRICT - 516)) | (1L << (TYPES - 516)) | (1L << (WRAPPER - 516)) | (1L << (WORK - 516)) | (1L << (FREEZE - 516)) | (1L << (AUTHORIZATION - 516)) | (1L << (VERBOSE - 516)) | (1L << (PARAM - 516)))) != 0) || ((((_la - 582)) & ~0x3f) == 0 && ((1L << (_la - 582)) & ((1L << (PREDICT - 582)) | (1L << (TS_REWRITE - 582)) | (1L << (INT16 - 582)) | (1L << (INT1 - 582)) | (1L << (ELEM_CONTAINED_BY_RANGE - 582)) | (1L << (LOWER_INF - 582)) | (1L << (UPPER_INF - 582)) | (1L << (ABBREV - 582)) | (1L << (SET_MASKLEN - 582)) | (1L << (TRUNC - 582)) | (1L << (IDENTIFIER_ - 582)) | (1L << (STRING_ - 582)) | (1L << (NUMBER_ - 582)))) != 0)) {
{
setState(3279);
caseArg();
}
}
setState(3282);
whenClauseList();
setState(3284);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(3283);
caseDefault();
}
}
setState(3286);
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, 300, RULE_whenClauseList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3289);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(3288);
whenClause();
}
}
setState(3291);
_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, 302, RULE_whenClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(3293);
match(WHEN);
setState(3294);
aExpr(0);
setState(3295);
match(THEN);
setState(3296);
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, 304, RULE_caseDefault);
try {
enterOuterAlt(_localctx, 1);
{
setState(3298);
match(ELSE);
setState(3299);
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, 306, RULE_caseArg);
try {
enterOuterAlt(_localctx, 1);
{
setState(3301);
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, 308, RULE_columnref);
try {
setState(3307);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,205,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(3303);
colId();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(3304);
colId();
setState(3305);
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, 310, RULE_qualOp);
try {
setState(3316);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(3309);
jsonOperator();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(3310);
geometricOperator();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(3311);
match(OPERATOR);
setState(3312);
match(LP_);
setState(3313);
anyOperator();
setState(3314);
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, 312, RULE_subqueryOp);
try {
setState(3330);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,207,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(3318);
allOp();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(3319);
match(OPERATOR);
setState(3320);
match(LP_);
setState(3321);
anyOperator();
setState(3322);
match(RP_);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(3324);
match(LIKE);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(3325);
match(NOT);
setState(3326);
match(LIKE);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(3327);
match(TILDE_);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(3328);
match(NOT_);
setState(3329);
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, 314, RULE_allOp);
try {
setState(3334);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(3332);
op();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(3333);
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