// Code generated from PostgreSQLParser.g4 by ANTLR 4.13.1. DO NOT EDIT. package parser // PostgreSQLParser import ( "fmt" "strconv" "sync" "github.com/antlr4-go/antlr/v4" ) // Suppress unused import errors var _ = fmt.Printf var _ = strconv.Itoa var _ = sync.Once{} type PostgreSQLParser struct { PostgreSQLParserBase } var PostgreSQLParserParserStaticData struct { once sync.Once serializedATN []int32 LiteralNames []string SymbolicNames []string RuleNames []string PredictionContextCache *antlr.PredictionContextCache atn *antlr.ATN decisionToDFA []*antlr.DFA } func postgresqlparserParserInit() { staticData := &PostgreSQLParserParserStaticData staticData.LiteralNames = []string{ "", "'$'", "'('", "')'", "'['", "']'", "','", "';'", "':'", "'*'", "'='", "'.'", "'+'", "'-'", "'/'", "'^'", "'<'", "'>'", "'<<'", "'>>'", "':='", "'<='", "'=>'", "'>='", "'..'", "'<>'", "'::'", "'%'", "", "", "'ALL'", "'ANALYSE'", "'ANALYZE'", "'AND'", "'ANY'", "'ARRAY'", "'AS'", "'ASC'", "'ASYMMETRIC'", "'BOTH'", "'CASE'", "'CAST'", "'CHECK'", "'COLLATE'", "'COLUMN'", "'CONSTRAINT'", "'CREATE'", "'CURRENT_CATALOG'", "'CURRENT_DATE'", "'CURRENT_ROLE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", "'CURRENT_USER'", "'DEFAULT'", "'DEFERRABLE'", "'DESC'", "'DISTINCT'", "'DO'", "'ELSE'", "'EXCEPT'", "'FALSE'", "'FETCH'", "'FOR'", "'FOREIGN'", "'FROM'", "'GRANT'", "'GROUP'", "'HAVING'", "'IN'", "'INITIALLY'", "'INTERSECT'", "'INTO'", "'LATERAL'", "'LEADING'", "'LIMIT'", "'LOCALTIME'", "'LOCALTIMESTAMP'", "'NOT'", "'NULL'", "'OFFSET'", "'ON'", "'ONLY'", "'OR'", "'ORDER'", "'PLACING'", "'PRIMARY'", "'REFERENCES'", "'RETURNING'", "'SELECT'", "'SESSION_USER'", "'SOME'", "'SYMMETRIC'", "'TABLE'", "'THEN'", "'TO'", "'TRAILING'", "'TRUE'", "'UNION'", "'UNIQUE'", "'USER'", "'USING'", "'VARIADIC'", "'WHEN'", "'WHERE'", "'WINDOW'", "'WITH'", "'AUTHORIZATION'", "'BINARY'", "'COLLATION'", "'CONCURRENTLY'", "'CROSS'", "'CURRENT_SCHEMA'", "'FREEZE'", "'FULL'", "'ILIKE'", "'INNER'", "'IS'", "'ISNULL'", "'JOIN'", "'LEFT'", "'LIKE'", "'NATURAL'", "'NOTNULL'", "'OUTER'", "'OVER'", "'OVERLAPS'", "'RIGHT'", "'SIMILAR'", "'VERBOSE'", "'ABORT'", "'ABSOLUTE'", "'ACCESS'", "'ACTION'", "'ADD'", "'ADMIN'", "'AFTER'", "'AGGREGATE'", "'ALSO'", "'ALTER'", "'ALWAYS'", "'ASSERTION'", "'ASSIGNMENT'", "'AT'", "'ATTRIBUTE'", "'BACKWARD'", "'BEFORE'", "'BEGIN'", "'BY'", "'CACHE'", "'CALLED'", "'CASCADE'", "'CASCADED'", "'CATALOG'", "'CHAIN'", "'CHARACTERISTICS'", "'CHECKPOINT'", "'CLASS'", "'CLOSE'", "'CLUSTER'", "'COMMENT'", "'COMMENTS'", "'COMMIT'", "'COMMITTED'", "'CONFIGURATION'", "'CONNECTION'", "'CONSTRAINTS'", "'CONTENT'", "'CONTINUE'", "'CONVERSION'", "'COPY'", "'COST'", "'CSV'", "'CURSOR'", "'CYCLE'", "'DATA'", "'DATABASE'", "'DAY'", "'DEALLOCATE'", "'DECLARE'", "'DEFAULTS'", "'DEFERRED'", "'DEFINER'", "'DELETE'", "'DELIMITER'", "'DELIMITERS'", "'DICTIONARY'", "'DISABLE'", "'DISCARD'", "'DOCUMENT'", "'DOMAIN'", "'DOUBLE'", "'DROP'", "'EACH'", "'ENABLE'", "'ENCODING'", "'ENCRYPTED'", "'ENUM'", "'ESCAPE'", "'EVENT'", "'EXCLUDE'", "'EXCLUDING'", "'EXCLUSIVE'", "'EXECUTE'", "'EXPLAIN'", "'EXTENSION'", "'EXTERNAL'", "'FAMILY'", "'FIRST'", "'FOLLOWING'", "'FORCE'", "'FORWARD'", "'FUNCTION'", "'FUNCTIONS'", "'GLOBAL'", "'GRANTED'", "'HANDLER'", "'HEADER'", "'HOLD'", "'HOUR'", "'IDENTITY'", "'IF'", "'IMMEDIATE'", "'IMMUTABLE'", "'IMPLICIT'", "'INCLUDING'", "'INCREMENT'", "'INDEX'", "'INDEXES'", "'INHERIT'", "'INHERITS'", "'INLINE'", "'INSENSITIVE'", "'INSERT'", "'INSTEAD'", "'INVOKER'", "'ISOLATION'", "'KEY'", "'LABEL'", "'LANGUAGE'", "'LARGE'", "'LAST'", "'LEAKPROOF'", "'LEVEL'", "'LISTEN'", "'LOAD'", "'LOCAL'", "'LOCATION'", "'LOCK'", "'MAPPING'", "'MATCH'", "'MATCHED'", "'MATERIALIZED'", "'MAXVALUE'", "'MERGE'", "'MINUTE'", "'MINVALUE'", "'MODE'", "'MONTH'", "'MOVE'", "'NAME'", "'NAMES'", "'NEXT'", "'NO'", "'NOTHING'", "'NOTIFY'", "'NOWAIT'", "'NULLS'", "'OBJECT'", "'OF'", "'OFF'", "'OIDS'", "'OPERATOR'", "'OPTION'", "'OPTIONS'", "'OWNED'", "'OWNER'", "'PARSER'", "'PARTIAL'", "'PARTITION'", "'PASSING'", "'PASSWORD'", "'PLANS'", "'PRECEDING'", "'PREPARE'", "'PREPARED'", "'PRESERVE'", "'PRIOR'", "'PRIVILEGES'", "'PROCEDURAL'", "'PROCEDURE'", "'PROGRAM'", "'QUOTE'", "'RANGE'", "'READ'", "'REASSIGN'", "'RECHECK'", "'RECURSIVE'", "'REF'", "'REFRESH'", "'REINDEX'", "'RELATIVE'", "'RELEASE'", "'RENAME'", "'REPEATABLE'", "'REPLACE'", "'REPLICA'", "'RESET'", "'RESTART'", "'RESTRICT'", "'RETURNS'", "'REVOKE'", "'ROLE'", "'ROLLBACK'", "'ROWS'", "'RULE'", "'SAVEPOINT'", "'SCHEMA'", "'SCROLL'", "'SEARCH'", "'SECOND'", "'SECURITY'", "'SEQUENCE'", "'SEQUENCES'", "'SERIALIZABLE'", "'SERVER'", "'SESSION'", "'SET'", "'SHARE'", "'SHOW'", "'SIMPLE'", "'SNAPSHOT'", "'STABLE'", "'STANDALONE'", "'START'", "'STATEMENT'", "'STATISTICS'", "'STDIN'", "'STDOUT'", "'STORAGE'", "'STRICT'", "'STRIP'", "'SYSID'", "'SYSTEM'", "'TABLES'", "'TABLESPACE'", "'TEMP'", "'TEMPLATE'", "'TEMPORARY'", "'TEXT'", "'TRANSACTION'", "'TRIGGER'", "'TRUNCATE'", "'TRUSTED'", "'TYPE'", "'TYPES'", "'UNBOUNDED'", "'UNCOMMITTED'", "'UNENCRYPTED'", "'UNKNOWN'", "'UNLISTEN'", "'UNLOGGED'", "'UNTIL'", "'UPDATE'", "'VACUUM'", "'VALID'", "'VALIDATE'", "'VALIDATOR'", "'VARYING'", "'VERSION'", "'VIEW'", "'VOLATILE'", "'WHITESPACE'", "'WITHOUT'", "'WORK'", "'WRAPPER'", "'WRITE'", "'XML'", "'YEAR'", "'YES'", "'ZONE'", "'BETWEEN'", "'BIGINT'", "'BIT'", "'BOOLEAN'", "'CHAR'", "'CHARACTER'", "'COALESCE'", "'DEC'", "'DECIMAL'", "'EXISTS'", "'EXTRACT'", "'FLOAT'", "'GREATEST'", "'INOUT'", "'INT'", "'INTEGER'", "'INTERVAL'", "'LEAST'", "'NATIONAL'", "'NCHAR'", "'NONE'", "'NULLIF'", "'NUMERIC'", "'OVERLAY'", "'POSITION'", "'PRECISION'", "'REAL'", "'ROW'", "'SETOF'", "'SMALLINT'", "'SUBSTRING'", "'TIME'", "'TIMESTAMP'", "'TREAT'", "'TRIM'", "'VALUES'", "'VARCHAR'", "'XMLATTRIBUTES'", "'XMLCOMMENT'", "'XMLAGG'", "'XML_IS_WELL_FORMED'", "'XML_IS_WELL_FORMED_DOCUMENT'", "'XML_IS_WELL_FORMED_CONTENT'", "'XPATH'", "'XPATH_EXISTS'", "'XMLCONCAT'", "'XMLELEMENT'", "'XMLEXISTS'", "'XMLFOREST'", "'XMLPARSE'", "'XMLPI'", "'XMLROOT'", "'XMLSERIALIZE'", "'CALL'", "'CURRENT'", "'ATTACH'", "'DETACH'", "'EXPRESSION'", "'GENERATED'", "'LOGGED'", "'STORED'", "'INCLUDE'", "'ROUTINE'", "'TRANSFORM'", "'IMPORT'", "'POLICY'", "'METHOD'", "'REFERENCING'", "'NEW'", "'OLD'", "'VALUE'", "'SUBSCRIPTION'", "'PUBLICATION'", "'OUT'", "'END'", "'ROUTINES'", "'SCHEMAS'", "'PROCEDURES'", "'INPUT'", "'SUPPORT'", "'PARALLEL'", "'SQL'", "'DEPENDS'", "'OVERRIDING'", "'CONFLICT'", "'SKIP'", "'LOCKED'", "'TIES'", "'ROLLUP'", "'CUBE'", "'GROUPING'", "'SETS'", "'TABLESAMPLE'", "'ORDINALITY'", "'XMLTABLE'", "'COLUMNS'", "'XMLNAMESPACES'", "'ROWTYPE'", "'NORMALIZED'", "'WITHIN'", "'FILTER'", "'GROUPS'", "'OTHERS'", "'NFC'", "'NFD'", "'NFKC'", "'NFKD'", "'UESCAPE'", "'VIEWS'", "'NORMALIZE'", "'DUMP'", "'PRINT_STRICT_PARAMS'", "'VARIABLE_CONFLICT'", "'ERROR'", "'USE_VARIABLE'", "'USE_COLUMN'", "'ALIAS'", "'CONSTANT'", "'PERFORM'", "'GET'", "'DIAGNOSTICS'", "'STACKED'", "'ELSIF'", "'WHILE'", "'REVERSE'", "'FOREACH'", "'SLICE'", "'EXIT'", "'RETURN'", "'QUERY'", "'RAISE'", "'SQLSTATE'", "'DEBUG'", "'LOG'", "'INFO'", "'NOTICE'", "'WARNING'", "'EXCEPTION'", "'ASSERT'", "'LOOP'", "'OPEN'", "'ABS'", "'CBRT'", "'CEIL'", "'CEILING'", "'DEGREES'", "'DIV'", "'EXP'", "'FACTORIAL'", "'FLOOR'", "'GCD'", "'LCM'", "'LN'", "'LOG10'", "'MIN_SCALE'", "'MOD'", "'PI'", "'POWER'", "'RADIANS'", "'ROUND'", "'SCALE'", "'SIGN'", "'SQRT'", "'TRIM_SCALE'", "'TRUNC'", "'WIDTH_BUCKET'", "'RANDOM'", "'SETSEED'", "'ACOS'", "'ACOSD'", "'ASIN'", "'ASIND'", "'ATAN'", "'ATAND'", "'ATAN2'", "'ATAN2D'", "'COS'", "'COSD'", "'COT'", "'COTD'", "'SIN'", "'SIND'", "'TAN'", "'TAND'", "'SINH'", "'COSH'", "'TANH'", "'ASINH'", "'ACOSH'", "'ATANH'", "'BIT_LENGTH'", "'CHAR_LENGTH'", "'CHARACTER_LENGTH'", "'LOWER'", "'OCTET_LENGTH'", "'UPPER'", "'ASCII'", "'BTRIM'", "'CHR'", "'CONCAT'", "'CONCAT_WS'", "'FORMAT'", "'INITCAP'", "'LENGTH'", "'LPAD'", "'LTRIM'", "'MD5'", "'PARSE_IDENT'", "'PG_CLIENT_ENCODING'", "'QUOTE_IDENT'", "'QUOTE_LITERAL'", "'QUOTE_NULLABLE'", "'REGEXP_COUNT'", "'REGEXP_INSTR'", "'REGEXP_LIKE'", "'REGEXP_MATCH'", "'REGEXP_MATCHES'", "'REGEXP_REPLACE'", "'REGEXP_SPLIT_TO_ARRAY'", "'REGEXP_SPLIT_TO_TABLE'", "'REGEXP_SUBSTR'", "'REPEAT'", "'RPAD'", "'RTRIM'", "'SPLIT_PART'", "'STARTS_WITH'", "'STRING_TO_ARRAY'", "'STRING_TO_TABLE'", "'STRPOS'", "'SUBSTR'", "'TO_ASCII'", "'TO_HEX'", "'TRANSLATE'", "'UNISTR'", "'AGE'", "'CLOCK_TIMESTAMP'", "'DATE_BIN'", "'DATE_PART'", "'DATE_TRUNC'", "'ISFINITE'", "'JUSTIFY_DAYS'", "'JUSTIFY_HOURS'", "'JUSTIFY_INTERVAL'", "'MAKE_DATE'", "'MAKE_INTERVAL'", "'MAKE_TIME'", "'MAKE_TIMESTAMP'", "'MAKE_TIMESTAMPTZ'", "'NOW'", "'STATEMENT_TIMESTAMP'", "'TIMEOFDAY'", "'TRANSACTION_TIMESTAMP'", "'TO_TIMESTAMP'", "'TO_CHAR'", "'TO_DATE'", "'TO_NUMBER'", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "'\\\\'", "", "", "", "", "", "", "", "", "", "'''", } staticData.SymbolicNames = []string{ "", "Dollar", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACKET", "CLOSE_BRACKET", "COMMA", "SEMI", "COLON", "STAR", "EQUAL", "DOT", "PLUS", "MINUS", "SLASH", "CARET", "LT", "GT", "LESS_LESS", "GREATER_GREATER", "COLON_EQUALS", "LESS_EQUALS", "EQUALS_GREATER", "GREATER_EQUALS", "DOT_DOT", "NOT_EQUALS", "TYPECAST", "PERCENT", "PARAM", "Operator", "ALL", "ANALYSE", "ANALYZE", "AND", "ANY", "ARRAY", "AS", "ASC", "ASYMMETRIC", "BOTH", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "CONSTRAINT", "CREATE", "CURRENT_CATALOG", "CURRENT_DATE", "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "DEFAULT", "DEFERRABLE", "DESC", "DISTINCT", "DO", "ELSE", "EXCEPT", "FALSE_P", "FETCH", "FOR", "FOREIGN", "FROM", "GRANT", "GROUP_P", "HAVING", "IN_P", "INITIALLY", "INTERSECT", "INTO", "LATERAL_P", "LEADING", "LIMIT", "LOCALTIME", "LOCALTIMESTAMP", "NOT", "NULL_P", "OFFSET", "ON", "ONLY", "OR", "ORDER", "PLACING", "PRIMARY", "REFERENCES", "RETURNING", "SELECT", "SESSION_USER", "SOME", "SYMMETRIC", "TABLE", "THEN", "TO", "TRAILING", "TRUE_P", "UNION", "UNIQUE", "USER", "USING", "VARIADIC", "WHEN", "WHERE", "WINDOW", "WITH", "AUTHORIZATION", "BINARY", "COLLATION", "CONCURRENTLY", "CROSS", "CURRENT_SCHEMA", "FREEZE", "FULL", "ILIKE", "INNER_P", "IS", "ISNULL", "JOIN", "LEFT", "LIKE", "NATURAL", "NOTNULL", "OUTER_P", "OVER", "OVERLAPS", "RIGHT", "SIMILAR", "VERBOSE", "ABORT_P", "ABSOLUTE_P", "ACCESS", "ACTION", "ADD_P", "ADMIN", "AFTER", "AGGREGATE", "ALSO", "ALTER", "ALWAYS", "ASSERTION", "ASSIGNMENT", "AT", "ATTRIBUTE", "BACKWARD", "BEFORE", "BEGIN_P", "BY", "CACHE", "CALLED", "CASCADE", "CASCADED", "CATALOG", "CHAIN", "CHARACTERISTICS", "CHECKPOINT", "CLASS", "CLOSE", "CLUSTER", "COMMENT", "COMMENTS", "COMMIT", "COMMITTED", "CONFIGURATION", "CONNECTION", "CONSTRAINTS", "CONTENT_P", "CONTINUE_P", "CONVERSION_P", "COPY", "COST", "CSV", "CURSOR", "CYCLE", "DATA_P", "DATABASE", "DAY_P", "DEALLOCATE", "DECLARE", "DEFAULTS", "DEFERRED", "DEFINER", "DELETE_P", "DELIMITER", "DELIMITERS", "DICTIONARY", "DISABLE_P", "DISCARD", "DOCUMENT_P", "DOMAIN_P", "DOUBLE_P", "DROP", "EACH", "ENABLE_P", "ENCODING", "ENCRYPTED", "ENUM_P", "ESCAPE", "EVENT", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXECUTE", "EXPLAIN", "EXTENSION", "EXTERNAL", "FAMILY", "FIRST_P", "FOLLOWING", "FORCE", "FORWARD", "FUNCTION", "FUNCTIONS", "GLOBAL", "GRANTED", "HANDLER", "HEADER_P", "HOLD", "HOUR_P", "IDENTITY_P", "IF_P", "IMMEDIATE", "IMMUTABLE", "IMPLICIT_P", "INCLUDING", "INCREMENT", "INDEX", "INDEXES", "INHERIT", "INHERITS", "INLINE_P", "INSENSITIVE", "INSERT", "INSTEAD", "INVOKER", "ISOLATION", "KEY", "LABEL", "LANGUAGE", "LARGE_P", "LAST_P", "LEAKPROOF", "LEVEL", "LISTEN", "LOAD", "LOCAL", "LOCATION", "LOCK_P", "MAPPING", "MATCH", "MATCHED", "MATERIALIZED", "MAXVALUE", "MERGE", "MINUTE_P", "MINVALUE", "MODE", "MONTH_P", "MOVE", "NAME_P", "NAMES", "NEXT", "NO", "NOTHING", "NOTIFY", "NOWAIT", "NULLS_P", "OBJECT_P", "OF", "OFF", "OIDS", "OPERATOR", "OPTION", "OPTIONS", "OWNED", "OWNER", "PARSER", "PARTIAL", "PARTITION", "PASSING", "PASSWORD", "PLANS", "PRECEDING", "PREPARE", "PREPARED", "PRESERVE", "PRIOR", "PRIVILEGES", "PROCEDURAL", "PROCEDURE", "PROGRAM", "QUOTE", "RANGE", "READ", "REASSIGN", "RECHECK", "RECURSIVE", "REF", "REFRESH", "REINDEX", "RELATIVE_P", "RELEASE", "RENAME", "REPEATABLE", "REPLACE", "REPLICA", "RESET", "RESTART", "RESTRICT", "RETURNS", "REVOKE", "ROLE", "ROLLBACK", "ROWS", "RULE", "SAVEPOINT", "SCHEMA", "SCROLL", "SEARCH", "SECOND_P", "SECURITY", "SEQUENCE", "SEQUENCES", "SERIALIZABLE", "SERVER", "SESSION", "SET", "SHARE", "SHOW", "SIMPLE", "SNAPSHOT", "STABLE", "STANDALONE_P", "START", "STATEMENT", "STATISTICS", "STDIN", "STDOUT", "STORAGE", "STRICT_P", "STRIP_P", "SYSID", "SYSTEM_P", "TABLES", "TABLESPACE", "TEMP", "TEMPLATE", "TEMPORARY", "TEXT_P", "TRANSACTION", "TRIGGER", "TRUNCATE", "TRUSTED", "TYPE_P", "TYPES_P", "UNBOUNDED", "UNCOMMITTED", "UNENCRYPTED", "UNKNOWN", "UNLISTEN", "UNLOGGED", "UNTIL", "UPDATE", "VACUUM", "VALID", "VALIDATE", "VALIDATOR", "VARYING", "VERSION_P", "VIEW", "VOLATILE", "WHITESPACE_P", "WITHOUT", "WORK", "WRAPPER", "WRITE", "XML_P", "YEAR_P", "YES_P", "ZONE", "BETWEEN", "BIGINT", "BIT", "BOOLEAN_P", "CHAR_P", "CHARACTER", "COALESCE", "DEC", "DECIMAL_P", "EXISTS", "EXTRACT", "FLOAT_P", "GREATEST", "INOUT", "INT_P", "INTEGER", "INTERVAL", "LEAST", "NATIONAL", "NCHAR", "NONE", "NULLIF", "NUMERIC", "OVERLAY", "POSITION", "PRECISION", "REAL", "ROW", "SETOF", "SMALLINT", "SUBSTRING", "TIME", "TIMESTAMP", "TREAT", "TRIM", "VALUES", "VARCHAR", "XMLATTRIBUTES", "XMLCOMMENT", "XMLAGG", "XML_IS_WELL_FORMED", "XML_IS_WELL_FORMED_DOCUMENT", "XML_IS_WELL_FORMED_CONTENT", "XPATH", "XPATH_EXISTS", "XMLCONCAT", "XMLELEMENT", "XMLEXISTS", "XMLFOREST", "XMLPARSE", "XMLPI", "XMLROOT", "XMLSERIALIZE", "CALL", "CURRENT_P", "ATTACH", "DETACH", "EXPRESSION", "GENERATED", "LOGGED", "STORED", "INCLUDE", "ROUTINE", "TRANSFORM", "IMPORT_P", "POLICY", "METHOD", "REFERENCING", "NEW", "OLD", "VALUE_P", "SUBSCRIPTION", "PUBLICATION", "OUT_P", "END_P", "ROUTINES", "SCHEMAS", "PROCEDURES", "INPUT_P", "SUPPORT", "PARALLEL", "SQL_P", "DEPENDS", "OVERRIDING", "CONFLICT", "SKIP_P", "LOCKED", "TIES", "ROLLUP", "CUBE", "GROUPING", "SETS", "TABLESAMPLE", "ORDINALITY", "XMLTABLE", "COLUMNS", "XMLNAMESPACES", "ROWTYPE", "NORMALIZED", "WITHIN", "FILTER", "GROUPS", "OTHERS", "NFC", "NFD", "NFKC", "NFKD", "UESCAPE", "VIEWS", "NORMALIZE", "DUMP", "PRINT_STRICT_PARAMS", "VARIABLE_CONFLICT", "ERROR", "USE_VARIABLE", "USE_COLUMN", "ALIAS", "CONSTANT", "PERFORM", "GET", "DIAGNOSTICS", "STACKED", "ELSIF", "WHILE", "REVERSE", "FOREACH", "SLICE", "EXIT", "RETURN", "QUERY", "RAISE", "SQLSTATE", "DEBUG", "LOG", "INFO", "NOTICE", "WARNING", "EXCEPTION", "ASSERT", "LOOP", "OPEN", "ABS", "CBRT", "CEIL", "CEILING", "DEGREES", "DIV", "EXP", "FACTORIAL", "FLOOR", "GCD", "LCM", "LN", "LOG10", "MIN_SCALE", "MOD", "PI", "POWER", "RADIANS", "ROUND", "SCALE", "SIGN", "SQRT", "TRIM_SCALE", "TRUNC", "WIDTH_BUCKET", "RANDOM", "SETSEED", "ACOS", "ACOSD", "ASIN", "ASIND", "ATAN", "ATAND", "ATAN2", "ATAN2D", "COS", "COSD", "COT", "COTD", "SIN", "SIND", "TAN", "TAND", "SINH", "COSH", "TANH", "ASINH", "ACOSH", "ATANH", "BIT_LENGTH", "CHAR_LENGTH", "CHARACTER_LENGTH", "LOWER", "OCTET_LENGTH", "UPPER", "ASCII", "BTRIM", "CHR", "CONCAT", "CONCAT_WS", "FORMAT", "INITCAP", "LENGTH", "LPAD", "LTRIM", "MD5", "PARSE_IDENT", "PG_CLIENT_ENCODING", "QUOTE_IDENT", "QUOTE_LITERAL", "QUOTE_NULLABLE", "REGEXP_COUNT", "REGEXP_INSTR", "REGEXP_LIKE", "REGEXP_MATCH", "REGEXP_MATCHES", "REGEXP_REPLACE", "REGEXP_SPLIT_TO_ARRAY", "REGEXP_SPLIT_TO_TABLE", "REGEXP_SUBSTR", "REPEAT", "RPAD", "RTRIM", "SPLIT_PART", "STARTS_WITH", "STRING_TO_ARRAY", "STRING_TO_TABLE", "STRPOS", "SUBSTR", "TO_ASCII", "TO_HEX", "TRANSLATE", "UNISTR", "AGE", "CLOCK_TIMESTAMP", "DATE_BIN", "DATE_PART", "DATE_TRUNC", "ISFINITE", "JUSTIFY_DAYS", "JUSTIFY_HOURS", "JUSTIFY_INTERVAL", "MAKE_DATE", "MAKE_INTERVAL", "MAKE_TIME", "MAKE_TIMESTAMP", "MAKE_TIMESTAMPTZ", "NOW", "STATEMENT_TIMESTAMP", "TIMEOFDAY", "TRANSACTION_TIMESTAMP", "TO_TIMESTAMP", "TO_CHAR", "TO_DATE", "TO_NUMBER", "Identifier", "QuotedIdentifier", "UnterminatedQuotedIdentifier", "InvalidQuotedIdentifier", "InvalidUnterminatedQuotedIdentifier", "UnicodeQuotedIdentifier", "UnterminatedUnicodeQuotedIdentifier", "InvalidUnicodeQuotedIdentifier", "InvalidUnterminatedUnicodeQuotedIdentifier", "StringConstant", "UnterminatedStringConstant", "UnicodeEscapeStringConstant", "UnterminatedUnicodeEscapeStringConstant", "BeginDollarStringConstant", "BinaryStringConstant", "UnterminatedBinaryStringConstant", "InvalidBinaryStringConstant", "InvalidUnterminatedBinaryStringConstant", "HexadecimalStringConstant", "UnterminatedHexadecimalStringConstant", "InvalidHexadecimalStringConstant", "InvalidUnterminatedHexadecimalStringConstant", "Integral", "NumericFail", "Numeric", "PLSQLVARIABLENAME", "PLSQLIDENTIFIER", "Whitespace", "Newline", "LineComment", "BlockComment", "UnterminatedBlockComment", "MetaCommand", "EndMetaCommand", "ErrorCharacter", "EscapeStringConstant", "UnterminatedEscapeStringConstant", "InvalidEscapeStringConstant", "InvalidUnterminatedEscapeStringConstant", "AfterEscapeStringConstantMode_NotContinued", "AfterEscapeStringConstantWithNewlineMode_NotContinued", "DollarText", "EndDollarStringConstant", "AfterEscapeStringConstantWithNewlineMode_Continued", } staticData.RuleNames = []string{ "root", "plsqlroot", "stmtblock", "stmtmulti", "stmt", "plsqlconsolecommand", "callstmt", "createrolestmt", "opt_with", "optrolelist", "alteroptrolelist", "alteroptroleelem", "createoptroleelem", "createuserstmt", "alterrolestmt", "opt_in_database", "alterrolesetstmt", "droprolestmt", "creategroupstmt", "altergroupstmt", "add_drop", "createschemastmt", "optschemaname", "optschemaeltlist", "schema_stmt", "variablesetstmt", "set_rest", "generic_set", "set_rest_more", "var_name", "var_list", "var_value", "iso_level", "opt_boolean_or_string", "zone_value", "opt_encoding", "nonreservedword_or_sconst", "variableresetstmt", "reset_rest", "generic_reset", "setresetclause", "functionsetresetclause", "variableshowstmt", "constraintssetstmt", "constraints_set_list", "constraints_set_mode", "checkpointstmt", "discardstmt", "altertablestmt", "alter_table_cmds", "partition_cmd", "index_partition_cmd", "alter_table_cmd", "alter_column_default", "opt_drop_behavior", "opt_collate_clause", "alter_using", "replica_identity", "reloptions", "opt_reloptions", "reloption_list", "reloption_elem", "alter_identity_column_option_list", "alter_identity_column_option", "partitionboundspec", "hash_partbound_elem", "hash_partbound", "altercompositetypestmt", "alter_type_cmds", "alter_type_cmd", "closeportalstmt", "copystmt", "copy_from", "opt_program", "copy_file_name", "copy_options", "copy_opt_list", "copy_opt_item", "opt_binary", "copy_delimiter", "opt_using", "copy_generic_opt_list", "copy_generic_opt_elem", "copy_generic_opt_arg", "copy_generic_opt_arg_list", "copy_generic_opt_arg_list_item", "createstmt", "opttemp", "opttableelementlist", "opttypedtableelementlist", "tableelementlist", "typedtableelementlist", "tableelement", "typedtableelement", "columnDef", "columnOptions", "colquallist", "colconstraint", "colconstraintelem", "generated_when", "constraintattr", "tablelikeclause", "tablelikeoptionlist", "tablelikeoption", "tableconstraint", "constraintelem", "opt_no_inherit", "opt_column_list", "columnlist", "columnElem", "opt_c_include", "key_match", "exclusionconstraintlist", "exclusionconstraintelem", "exclusionwhereclause", "key_actions", "key_update", "key_delete", "key_action", "optinherit", "optpartitionspec", "partitionspec", "part_params", "part_elem", "table_access_method_clause", "optwith", "oncommitoption", "opttablespace", "optconstablespace", "existingindex", "createstatsstmt", "alterstatsstmt", "createasstmt", "create_as_target", "opt_with_data", "creatematviewstmt", "create_mv_target", "optnolog", "refreshmatviewstmt", "createseqstmt", "alterseqstmt", "optseqoptlist", "optparenthesizedseqoptlist", "seqoptlist", "seqoptelem", "opt_by", "numericonly", "numericonly_list", "createplangstmt", "opt_trusted", "handler_name", "opt_inline_handler", "validator_clause", "opt_validator", "opt_procedural", "createtablespacestmt", "opttablespaceowner", "droptablespacestmt", "createextensionstmt", "create_extension_opt_list", "create_extension_opt_item", "alterextensionstmt", "alter_extension_opt_list", "alter_extension_opt_item", "alterextensioncontentsstmt", "createfdwstmt", "fdw_option", "fdw_options", "opt_fdw_options", "alterfdwstmt", "create_generic_options", "generic_option_list", "alter_generic_options", "alter_generic_option_list", "alter_generic_option_elem", "generic_option_elem", "generic_option_name", "generic_option_arg", "createforeignserverstmt", "opt_type", "foreign_server_version", "opt_foreign_server_version", "alterforeignserverstmt", "createforeigntablestmt", "importforeignschemastmt", "import_qualification_type", "import_qualification", "createusermappingstmt", "auth_ident", "dropusermappingstmt", "alterusermappingstmt", "createpolicystmt", "alterpolicystmt", "rowsecurityoptionalexpr", "rowsecurityoptionalwithcheck", "rowsecuritydefaulttorole", "rowsecurityoptionaltorole", "rowsecuritydefaultpermissive", "rowsecuritydefaultforcmd", "row_security_cmd", "createamstmt", "am_type", "createtrigstmt", "triggeractiontime", "triggerevents", "triggeroneevent", "triggerreferencing", "triggertransitions", "triggertransition", "transitionoldornew", "transitionrowortable", "transitionrelname", "triggerforspec", "triggerforopteach", "triggerfortype", "triggerwhen", "function_or_procedure", "triggerfuncargs", "triggerfuncarg", "optconstrfromtable", "constraintattributespec", "constraintattributeElem", "createeventtrigstmt", "event_trigger_when_list", "event_trigger_when_item", "event_trigger_value_list", "altereventtrigstmt", "enable_trigger", "createassertionstmt", "definestmt", "definition", "def_list", "def_elem", "def_arg", "old_aggr_definition", "old_aggr_list", "old_aggr_elem", "opt_enum_val_list", "enum_val_list", "alterenumstmt", "opt_if_not_exists", "createopclassstmt", "opclass_item_list", "opclass_item", "opt_default", "opt_opfamily", "opclass_purpose", "opt_recheck", "createopfamilystmt", "alteropfamilystmt", "opclass_drop_list", "opclass_drop", "dropopclassstmt", "dropopfamilystmt", "dropownedstmt", "reassignownedstmt", "dropstmt", "object_type_any_name", "object_type_name", "drop_type_name", "object_type_name_on_any_name", "any_name_list", "any_name", "attrs", "type_name_list", "truncatestmt", "opt_restart_seqs", "commentstmt", "comment_text", "seclabelstmt", "opt_provider", "security_label", "fetchstmt", "fetch_args", "from_in", "opt_from_in", "grantstmt", "revokestmt", "privileges", "privilege_list", "privilege", "privilege_target", "grantee_list", "grantee", "opt_grant_grant_option", "grantrolestmt", "revokerolestmt", "opt_grant_admin_option", "opt_granted_by", "alterdefaultprivilegesstmt", "defacloptionlist", "defacloption", "defaclaction", "defacl_privilege_target", "indexstmt", "opt_unique", "opt_concurrently", "opt_index_name", "access_method_clause", "index_params", "index_elem_options", "index_elem", "opt_include", "index_including_params", "opt_collate", "opt_class", "opt_asc_desc", "opt_nulls_order", "createfunctionstmt", "opt_or_replace", "func_args", "func_args_list", "function_with_argtypes_list", "function_with_argtypes", "func_args_with_defaults", "func_args_with_defaults_list", "func_arg", "arg_class", "param_name", "func_return", "func_type", "func_arg_with_default", "aggr_arg", "aggr_args", "aggr_args_list", "aggregate_with_argtypes", "aggregate_with_argtypes_list", "createfunc_opt_list", "common_func_opt_item", "createfunc_opt_item", "func_as", "transform_type_list", "opt_definition", "table_func_column", "table_func_column_list", "alterfunctionstmt", "alterfunc_opt_list", "opt_restrict", "removefuncstmt", "removeaggrstmt", "removeoperstmt", "oper_argtypes", "any_operator", "operator_with_argtypes_list", "operator_with_argtypes", "dostmt", "dostmt_opt_list", "dostmt_opt_item", "createcaststmt", "cast_context", "dropcaststmt", "opt_if_exists", "createtransformstmt", "transform_element_list", "droptransformstmt", "reindexstmt", "reindex_target_type", "reindex_target_multitable", "reindex_option_list", "reindex_option_elem", "altertblspcstmt", "renamestmt", "opt_column", "opt_set_data", "alterobjectdependsstmt", "opt_no", "alterobjectschemastmt", "alteroperatorstmt", "operator_def_list", "operator_def_elem", "operator_def_arg", "altertypestmt", "alterownerstmt", "createpublicationstmt", "opt_publication_for_tables", "publication_for_tables", "alterpublicationstmt", "createsubscriptionstmt", "publication_name_list", "publication_name_item", "altersubscriptionstmt", "dropsubscriptionstmt", "rulestmt", "ruleactionlist", "ruleactionmulti", "ruleactionstmt", "ruleactionstmtOrEmpty", "event", "opt_instead", "notifystmt", "notify_payload", "listenstmt", "unlistenstmt", "transactionstmt", "opt_transaction", "transaction_mode_item", "transaction_mode_list", "transaction_mode_list_or_empty", "opt_transaction_chain", "viewstmt", "opt_check_option", "loadstmt", "createdbstmt", "createdb_opt_list", "createdb_opt_items", "createdb_opt_item", "createdb_opt_name", "opt_equal", "alterdatabasestmt", "alterdatabasesetstmt", "dropdbstmt", "drop_option_list", "drop_option", "altercollationstmt", "altersystemstmt", "createdomainstmt", "alterdomainstmt", "opt_as", "altertsdictionarystmt", "altertsconfigurationstmt", "any_with", "createconversionstmt", "clusterstmt", "cluster_index_specification", "vacuumstmt", "analyzestmt", "vac_analyze_option_list", "analyze_keyword", "vac_analyze_option_elem", "vac_analyze_option_name", "vac_analyze_option_arg", "opt_analyze", "opt_verbose", "opt_full", "opt_freeze", "opt_name_list", "vacuum_relation", "vacuum_relation_list", "opt_vacuum_relation_list", "explainstmt", "explainablestmt", "explain_option_list", "explain_option_elem", "explain_option_name", "explain_option_arg", "preparestmt", "prep_type_clause", "preparablestmt", "executestmt", "execute_param_clause", "deallocatestmt", "insertstmt", "insert_target", "insert_rest", "override_kind", "insert_column_list", "insert_column_item", "opt_on_conflict", "opt_conf_expr", "returning_clause", "mergestmt", "merge_insert_clause", "merge_update_clause", "merge_delete_clause", "deletestmt", "using_clause", "lockstmt", "opt_lock", "lock_type", "opt_nowait", "opt_nowait_or_skip", "updatestmt", "set_clause_list", "set_clause", "set_target", "set_target_list", "declarecursorstmt", "cursor_name", "cursor_options", "opt_hold", "selectstmt", "select_with_parens", "select_no_parens", "select_clause", "simple_select_intersect", "simple_select_pramary", "with_clause", "cte_list", "common_table_expr", "opt_materialized", "opt_with_clause", "into_clause", "opt_strict", "opttempTableName", "opt_table", "all_or_distinct", "distinct_clause", "opt_all_clause", "opt_sort_clause", "sort_clause", "sortby_list", "sortby", "select_limit", "opt_select_limit", "limit_clause", "offset_clause", "select_limit_value", "select_offset_value", "select_fetch_first_value", "i_or_f_const", "row_or_rows", "first_or_next", "group_clause", "group_by_list", "group_by_item", "empty_grouping_set", "rollup_clause", "cube_clause", "grouping_sets_clause", "having_clause", "for_locking_clause", "opt_for_locking_clause", "for_locking_items", "for_locking_item", "for_locking_strength", "locked_rels_list", "values_clause", "from_clause", "from_list", "non_ansi_join", "table_ref", "alias_clause", "opt_alias_clause", "table_alias_clause", "func_alias_clause", "join_type", "join_qual", "relation_expr", "relation_expr_list", "relation_expr_opt_alias", "tablesample_clause", "opt_repeatable_clause", "func_table", "rowsfrom_item", "rowsfrom_list", "opt_col_def_list", "opt_ordinality", "where_clause", "where_or_current_clause", "opttablefuncelementlist", "tablefuncelementlist", "tablefuncelement", "xmltable", "xmltable_column_list", "xmltable_column_el", "xmltable_column_option_list", "xmltable_column_option_el", "xml_namespace_list", "xml_namespace_el", "typename", "opt_array_bounds", "simpletypename", "consttypename", "generictype", "opt_type_modifiers", "numeric", "opt_float", "bit", "constbit", "bitwithlength", "bitwithoutlength", "character", "constcharacter", "character_c", "opt_varying", "constdatetime", "constinterval", "opt_timezone", "opt_interval", "interval_second", "opt_escape", "a_expr", "a_expr_qual", "a_expr_lessless", "a_expr_or", "a_expr_and", "a_expr_between", "a_expr_in", "a_expr_unary_not", "a_expr_isnull", "a_expr_is_not", "a_expr_compare", "a_expr_like", "a_expr_qual_op", "a_expr_unary_qualop", "a_expr_add", "a_expr_mul", "a_expr_caret", "a_expr_unary_sign", "a_expr_at_time_zone", "a_expr_collate", "a_expr_typecast", "b_expr", "c_expr", "plsqlvariablename", "func_application", "func_expr", "func_expr_windowless", "func_expr_common_subexpr", "xml_root_version", "opt_xml_root_standalone", "xml_attributes", "xml_attribute_list", "xml_attribute_el", "document_or_content", "xml_whitespace_option", "xmlexists_argument", "xml_passing_mech", "within_group_clause", "filter_clause", "window_clause", "window_definition_list", "window_definition", "over_clause", "window_specification", "opt_existing_window_name", "opt_partition_clause", "opt_frame_clause", "frame_extent", "frame_bound", "opt_window_exclusion_clause", "row", "explicit_row", "implicit_row", "sub_type", "all_op", "mathop", "qual_op", "qual_all_op", "subquery_Op", "expr_list", "func_arg_list", "func_arg_expr", "type_list", "array_expr", "array_expr_list", "extract_list", "extract_arg", "unicode_normal_form", "overlay_list", "position_list", "substr_list", "trim_list", "in_expr", "case_expr", "when_clause_list", "when_clause", "case_default", "case_arg", "columnref", "indirection_el", "opt_slice_bound", "indirection", "opt_indirection", "opt_target_list", "target_list", "target_el", "qualified_name_list", "qualified_name", "name_list", "name", "attr_name", "file_name", "func_name", "aexprconst", "xconst", "bconst", "fconst", "iconst", "sconst", "anysconst", "opt_uescape", "signediconst", "roleid", "rolespec", "role_list", "colid", "table_alias", "type_function_name", "nonreservedword", "collabel", "identifier", "plsqlidentifier", "unreserved_keyword", "col_name_keyword", "type_func_name_keyword", "reserved_keyword", "builtin_function_name", "pl_function", "comp_options", "comp_option", "sharp", "option_value", "opt_semi", "pl_block", "decl_sect", "decl_start", "decl_stmts", "label_decl", "decl_stmt", "decl_statement", "opt_scrollable", "decl_cursor_query", "decl_cursor_args", "decl_cursor_arglist", "decl_cursor_arg", "decl_is_for", "decl_aliasitem", "decl_varname", "decl_const", "decl_datatype", "decl_collate", "decl_notnull", "decl_defval", "decl_defkey", "assign_operator", "proc_sect", "proc_stmt", "stmt_perform", "stmt_call", "opt_expr_list", "stmt_assign", "stmt_getdiag", "getdiag_area_opt", "getdiag_list", "getdiag_list_item", "getdiag_item", "getdiag_target", "assign_var", "stmt_if", "stmt_elsifs", "stmt_else", "stmt_case", "opt_expr_until_when", "case_when_list", "case_when", "opt_case_else", "stmt_loop", "stmt_while", "stmt_for", "for_control", "opt_for_using_expression", "opt_cursor_parameters", "opt_reverse", "opt_by_expression", "for_variable", "stmt_foreach_a", "foreach_slice", "stmt_exit", "exit_type", "stmt_return", "opt_return_result", "stmt_raise", "opt_stmt_raise_level", "opt_raise_list", "opt_raise_using", "opt_raise_using_elem", "opt_raise_using_elem_list", "stmt_assert", "opt_stmt_assert_message", "loop_body", "stmt_execsql", "stmt_dynexecute", "opt_execute_using", "opt_execute_using_list", "opt_execute_into", "stmt_open", "opt_open_bound_list_item", "opt_open_bound_list", "opt_open_using", "opt_scroll_option", "opt_scroll_option_no", "stmt_fetch", "into_target", "opt_cursor_from", "opt_fetch_direction", "stmt_move", "stmt_close", "stmt_null", "stmt_commit", "stmt_rollback", "plsql_opt_transaction_chain", "stmt_set", "cursor_variable", "exception_sect", "proc_exceptions", "proc_exception", "proc_conditions", "proc_condition", "opt_block_label", "opt_loop_label", "opt_label", "opt_exitcond", "any_identifier", "plsql_unreserved_keyword", "sql_expression", "expr_until_then", "expr_until_semi", "expr_until_rightbracket", "expr_until_loop", "make_execsql_stmt", "opt_returning_clause_into", } staticData.PredictionContextCache = antlr.NewPredictionContextCache() staticData.serializedATN = []int32{ 4, 1, 679, 10695, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, 2, 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, 315, 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, 2, 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, 7, 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, 2, 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, 7, 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, 355, 2, 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, 360, 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, 364, 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, 369, 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, 373, 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, 378, 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, 382, 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, 387, 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, 391, 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, 396, 7, 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, 400, 2, 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, 405, 7, 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, 409, 2, 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, 414, 7, 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, 418, 2, 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, 423, 7, 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, 427, 2, 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, 432, 7, 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, 436, 2, 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, 441, 7, 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, 445, 2, 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, 450, 7, 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, 454, 2, 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, 459, 7, 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, 463, 2, 464, 7, 464, 2, 465, 7, 465, 2, 466, 7, 466, 2, 467, 7, 467, 2, 468, 7, 468, 2, 469, 7, 469, 2, 470, 7, 470, 2, 471, 7, 471, 2, 472, 7, 472, 2, 473, 7, 473, 2, 474, 7, 474, 2, 475, 7, 475, 2, 476, 7, 476, 2, 477, 7, 477, 2, 478, 7, 478, 2, 479, 7, 479, 2, 480, 7, 480, 2, 481, 7, 481, 2, 482, 7, 482, 2, 483, 7, 483, 2, 484, 7, 484, 2, 485, 7, 485, 2, 486, 7, 486, 2, 487, 7, 487, 2, 488, 7, 488, 2, 489, 7, 489, 2, 490, 7, 490, 2, 491, 7, 491, 2, 492, 7, 492, 2, 493, 7, 493, 2, 494, 7, 494, 2, 495, 7, 495, 2, 496, 7, 496, 2, 497, 7, 497, 2, 498, 7, 498, 2, 499, 7, 499, 2, 500, 7, 500, 2, 501, 7, 501, 2, 502, 7, 502, 2, 503, 7, 503, 2, 504, 7, 504, 2, 505, 7, 505, 2, 506, 7, 506, 2, 507, 7, 507, 2, 508, 7, 508, 2, 509, 7, 509, 2, 510, 7, 510, 2, 511, 7, 511, 2, 512, 7, 512, 2, 513, 7, 513, 2, 514, 7, 514, 2, 515, 7, 515, 2, 516, 7, 516, 2, 517, 7, 517, 2, 518, 7, 518, 2, 519, 7, 519, 2, 520, 7, 520, 2, 521, 7, 521, 2, 522, 7, 522, 2, 523, 7, 523, 2, 524, 7, 524, 2, 525, 7, 525, 2, 526, 7, 526, 2, 527, 7, 527, 2, 528, 7, 528, 2, 529, 7, 529, 2, 530, 7, 530, 2, 531, 7, 531, 2, 532, 7, 532, 2, 533, 7, 533, 2, 534, 7, 534, 2, 535, 7, 535, 2, 536, 7, 536, 2, 537, 7, 537, 2, 538, 7, 538, 2, 539, 7, 539, 2, 540, 7, 540, 2, 541, 7, 541, 2, 542, 7, 542, 2, 543, 7, 543, 2, 544, 7, 544, 2, 545, 7, 545, 2, 546, 7, 546, 2, 547, 7, 547, 2, 548, 7, 548, 2, 549, 7, 549, 2, 550, 7, 550, 2, 551, 7, 551, 2, 552, 7, 552, 2, 553, 7, 553, 2, 554, 7, 554, 2, 555, 7, 555, 2, 556, 7, 556, 2, 557, 7, 557, 2, 558, 7, 558, 2, 559, 7, 559, 2, 560, 7, 560, 2, 561, 7, 561, 2, 562, 7, 562, 2, 563, 7, 563, 2, 564, 7, 564, 2, 565, 7, 565, 2, 566, 7, 566, 2, 567, 7, 567, 2, 568, 7, 568, 2, 569, 7, 569, 2, 570, 7, 570, 2, 571, 7, 571, 2, 572, 7, 572, 2, 573, 7, 573, 2, 574, 7, 574, 2, 575, 7, 575, 2, 576, 7, 576, 2, 577, 7, 577, 2, 578, 7, 578, 2, 579, 7, 579, 2, 580, 7, 580, 2, 581, 7, 581, 2, 582, 7, 582, 2, 583, 7, 583, 2, 584, 7, 584, 2, 585, 7, 585, 2, 586, 7, 586, 2, 587, 7, 587, 2, 588, 7, 588, 2, 589, 7, 589, 2, 590, 7, 590, 2, 591, 7, 591, 2, 592, 7, 592, 2, 593, 7, 593, 2, 594, 7, 594, 2, 595, 7, 595, 2, 596, 7, 596, 2, 597, 7, 597, 2, 598, 7, 598, 2, 599, 7, 599, 2, 600, 7, 600, 2, 601, 7, 601, 2, 602, 7, 602, 2, 603, 7, 603, 2, 604, 7, 604, 2, 605, 7, 605, 2, 606, 7, 606, 2, 607, 7, 607, 2, 608, 7, 608, 2, 609, 7, 609, 2, 610, 7, 610, 2, 611, 7, 611, 2, 612, 7, 612, 2, 613, 7, 613, 2, 614, 7, 614, 2, 615, 7, 615, 2, 616, 7, 616, 2, 617, 7, 617, 2, 618, 7, 618, 2, 619, 7, 619, 2, 620, 7, 620, 2, 621, 7, 621, 2, 622, 7, 622, 2, 623, 7, 623, 2, 624, 7, 624, 2, 625, 7, 625, 2, 626, 7, 626, 2, 627, 7, 627, 2, 628, 7, 628, 2, 629, 7, 629, 2, 630, 7, 630, 2, 631, 7, 631, 2, 632, 7, 632, 2, 633, 7, 633, 2, 634, 7, 634, 2, 635, 7, 635, 2, 636, 7, 636, 2, 637, 7, 637, 2, 638, 7, 638, 2, 639, 7, 639, 2, 640, 7, 640, 2, 641, 7, 641, 2, 642, 7, 642, 2, 643, 7, 643, 2, 644, 7, 644, 2, 645, 7, 645, 2, 646, 7, 646, 2, 647, 7, 647, 2, 648, 7, 648, 2, 649, 7, 649, 2, 650, 7, 650, 2, 651, 7, 651, 2, 652, 7, 652, 2, 653, 7, 653, 2, 654, 7, 654, 2, 655, 7, 655, 2, 656, 7, 656, 2, 657, 7, 657, 2, 658, 7, 658, 2, 659, 7, 659, 2, 660, 7, 660, 2, 661, 7, 661, 2, 662, 7, 662, 2, 663, 7, 663, 2, 664, 7, 664, 2, 665, 7, 665, 2, 666, 7, 666, 2, 667, 7, 667, 2, 668, 7, 668, 2, 669, 7, 669, 2, 670, 7, 670, 2, 671, 7, 671, 2, 672, 7, 672, 2, 673, 7, 673, 2, 674, 7, 674, 2, 675, 7, 675, 2, 676, 7, 676, 2, 677, 7, 677, 2, 678, 7, 678, 2, 679, 7, 679, 2, 680, 7, 680, 2, 681, 7, 681, 2, 682, 7, 682, 2, 683, 7, 683, 2, 684, 7, 684, 2, 685, 7, 685, 2, 686, 7, 686, 2, 687, 7, 687, 2, 688, 7, 688, 2, 689, 7, 689, 2, 690, 7, 690, 2, 691, 7, 691, 2, 692, 7, 692, 2, 693, 7, 693, 2, 694, 7, 694, 2, 695, 7, 695, 2, 696, 7, 696, 2, 697, 7, 697, 2, 698, 7, 698, 2, 699, 7, 699, 2, 700, 7, 700, 2, 701, 7, 701, 2, 702, 7, 702, 2, 703, 7, 703, 2, 704, 7, 704, 2, 705, 7, 705, 2, 706, 7, 706, 2, 707, 7, 707, 2, 708, 7, 708, 2, 709, 7, 709, 2, 710, 7, 710, 2, 711, 7, 711, 2, 712, 7, 712, 2, 713, 7, 713, 2, 714, 7, 714, 2, 715, 7, 715, 2, 716, 7, 716, 2, 717, 7, 717, 2, 718, 7, 718, 2, 719, 7, 719, 2, 720, 7, 720, 2, 721, 7, 721, 2, 722, 7, 722, 2, 723, 7, 723, 2, 724, 7, 724, 2, 725, 7, 725, 2, 726, 7, 726, 2, 727, 7, 727, 2, 728, 7, 728, 2, 729, 7, 729, 2, 730, 7, 730, 2, 731, 7, 731, 2, 732, 7, 732, 2, 733, 7, 733, 2, 734, 7, 734, 2, 735, 7, 735, 2, 736, 7, 736, 2, 737, 7, 737, 2, 738, 7, 738, 2, 739, 7, 739, 2, 740, 7, 740, 2, 741, 7, 741, 2, 742, 7, 742, 2, 743, 7, 743, 2, 744, 7, 744, 2, 745, 7, 745, 2, 746, 7, 746, 2, 747, 7, 747, 2, 748, 7, 748, 2, 749, 7, 749, 2, 750, 7, 750, 2, 751, 7, 751, 2, 752, 7, 752, 2, 753, 7, 753, 2, 754, 7, 754, 2, 755, 7, 755, 2, 756, 7, 756, 2, 757, 7, 757, 2, 758, 7, 758, 2, 759, 7, 759, 2, 760, 7, 760, 2, 761, 7, 761, 2, 762, 7, 762, 2, 763, 7, 763, 2, 764, 7, 764, 2, 765, 7, 765, 2, 766, 7, 766, 2, 767, 7, 767, 2, 768, 7, 768, 2, 769, 7, 769, 2, 770, 7, 770, 2, 771, 7, 771, 2, 772, 7, 772, 2, 773, 7, 773, 2, 774, 7, 774, 2, 775, 7, 775, 2, 776, 7, 776, 2, 777, 7, 777, 2, 778, 7, 778, 2, 779, 7, 779, 2, 780, 7, 780, 2, 781, 7, 781, 2, 782, 7, 782, 2, 783, 7, 783, 2, 784, 7, 784, 2, 785, 7, 785, 2, 786, 7, 786, 2, 787, 7, 787, 2, 788, 7, 788, 2, 789, 7, 789, 2, 790, 7, 790, 2, 791, 7, 791, 2, 792, 7, 792, 2, 793, 7, 793, 2, 794, 7, 794, 2, 795, 7, 795, 2, 796, 7, 796, 2, 797, 7, 797, 2, 798, 7, 798, 2, 799, 7, 799, 2, 800, 7, 800, 2, 801, 7, 801, 2, 802, 7, 802, 2, 803, 7, 803, 2, 804, 7, 804, 2, 805, 7, 805, 2, 806, 7, 806, 2, 807, 7, 807, 2, 808, 7, 808, 2, 809, 7, 809, 2, 810, 7, 810, 2, 811, 7, 811, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 3, 3, 1634, 8, 3, 5, 3, 1636, 8, 3, 10, 3, 12, 3, 1639, 9, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1766, 8, 4, 1, 5, 1, 5, 3, 5, 1770, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 3, 8, 1783, 8, 8, 1, 9, 5, 9, 1786, 8, 9, 10, 9, 12, 9, 1789, 9, 9, 1, 10, 5, 10, 1792, 8, 10, 10, 10, 12, 10, 1795, 9, 10, 1, 11, 1, 11, 1, 11, 3, 11, 1800, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1815, 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1827, 8, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1845, 8, 15, 1, 16, 1, 16, 1, 16, 3, 16, 1850, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 1860, 8, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 1884, 8, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 1891, 8, 21, 1, 21, 1, 21, 1, 22, 1, 22, 3, 22, 1897, 8, 22, 1, 23, 5, 23, 1900, 8, 23, 10, 23, 12, 23, 1903, 9, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 1911, 8, 24, 1, 25, 1, 25, 3, 25, 1915, 8, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 1927, 8, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1958, 8, 28, 1, 29, 1, 29, 1, 29, 5, 29, 1963, 8, 29, 10, 29, 12, 29, 1966, 9, 29, 1, 30, 1, 30, 1, 30, 5, 30, 1971, 8, 30, 10, 30, 12, 30, 1974, 9, 30, 1, 31, 1, 31, 3, 31, 1978, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1985, 8, 32, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 1991, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 2008, 8, 34, 1, 35, 1, 35, 1, 35, 3, 35, 2013, 8, 35, 1, 36, 1, 36, 3, 36, 2017, 8, 36, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 2030, 8, 38, 1, 39, 1, 39, 3, 39, 2034, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 2039, 8, 40, 1, 41, 1, 41, 1, 41, 3, 41, 2044, 8, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 2056, 8, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 3, 44, 2065, 8, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2078, 8, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2083, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2094, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2105, 8, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2110, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2121, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2132, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2141, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2151, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2166, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2178, 8, 48, 1, 48, 1, 48, 1, 48, 3, 48, 2183, 8, 48, 1, 49, 1, 49, 1, 49, 5, 49, 2188, 8, 49, 10, 49, 12, 49, 2191, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 2201, 8, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2459, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 2466, 8, 53, 1, 54, 1, 54, 1, 54, 3, 54, 2471, 8, 54, 1, 55, 1, 55, 1, 55, 3, 55, 2476, 8, 55, 1, 56, 1, 56, 1, 56, 3, 56, 2481, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2489, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 3, 59, 2498, 8, 59, 1, 60, 1, 60, 1, 60, 5, 60, 2503, 8, 60, 10, 60, 12, 60, 2506, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 2515, 8, 61, 3, 61, 2517, 8, 61, 1, 62, 4, 62, 2520, 8, 62, 11, 62, 12, 62, 2521, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 2528, 8, 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 2534, 8, 63, 3, 63, 2536, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 2564, 8, 64, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 5, 66, 2572, 8, 66, 10, 66, 12, 66, 2575, 9, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 5, 68, 2585, 8, 68, 10, 68, 12, 68, 2588, 9, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 2599, 8, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 2613, 8, 69, 1, 70, 1, 70, 1, 70, 3, 70, 2618, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 2642, 8, 71, 1, 72, 1, 72, 1, 73, 1, 73, 3, 73, 2648, 8, 73, 1, 74, 1, 74, 1, 74, 3, 74, 2653, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 2660, 8, 75, 1, 76, 5, 76, 2663, 8, 76, 10, 76, 12, 76, 2666, 9, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 2703, 8, 77, 1, 78, 1, 78, 3, 78, 2707, 8, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 3, 79, 2714, 8, 79, 1, 80, 1, 80, 3, 80, 2718, 8, 80, 1, 81, 1, 81, 1, 81, 5, 81, 2723, 8, 81, 10, 81, 12, 81, 2726, 9, 81, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 2739, 8, 83, 1, 84, 1, 84, 1, 84, 5, 84, 2744, 8, 84, 10, 84, 12, 84, 2747, 9, 84, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 2757, 8, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 2790, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2800, 8, 87, 1, 88, 1, 88, 3, 88, 2804, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 2811, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 2816, 8, 90, 10, 90, 12, 90, 2819, 9, 90, 1, 91, 1, 91, 1, 91, 5, 91, 2824, 8, 91, 10, 91, 12, 91, 2827, 9, 91, 1, 92, 1, 92, 1, 92, 3, 92, 2832, 8, 92, 1, 93, 1, 93, 3, 93, 2836, 8, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 3, 95, 2846, 8, 95, 1, 95, 1, 95, 1, 96, 5, 96, 2851, 8, 96, 10, 96, 12, 96, 2854, 9, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 2864, 8, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 2896, 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 2904, 8, 98, 1, 99, 1, 99, 1, 99, 3, 99, 2909, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2916, 8, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 5, 102, 2924, 8, 102, 10, 102, 12, 102, 2927, 9, 102, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2936, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2956, 8, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2971, 8, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2996, 8, 105, 1, 106, 1, 106, 1, 106, 3, 106, 3001, 8, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 3, 107, 3008, 8, 107, 1, 108, 1, 108, 1, 108, 5, 108, 3013, 8, 108, 10, 108, 12, 108, 3016, 9, 108, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 3026, 8, 110, 1, 111, 1, 111, 1, 111, 3, 111, 3031, 8, 111, 1, 112, 1, 112, 1, 112, 5, 112, 3036, 8, 112, 10, 112, 12, 112, 3039, 9, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 3049, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 3, 114, 3057, 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 3, 115, 3068, 8, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3084, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 3092, 8, 119, 1, 120, 1, 120, 3, 120, 3096, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 5, 122, 3108, 8, 122, 10, 122, 12, 122, 3111, 9, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 3127, 8, 123, 1, 124, 1, 124, 1, 124, 3, 124, 3132, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 3139, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 3148, 8, 126, 1, 126, 3, 126, 3151, 8, 126, 1, 127, 1, 127, 1, 127, 3, 127, 3156, 8, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 3163, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 3174, 8, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 3187, 8, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 3200, 8, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, 3, 134, 3218, 8, 134, 1, 134, 3, 134, 3221, 8, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 3230, 8, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 3, 137, 3245, 8, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 3260, 8, 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 3269, 8, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 3, 141, 3276, 8, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 3, 142, 3283, 8, 142, 1, 143, 4, 143, 3286, 8, 143, 11, 143, 12, 143, 3287, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 3318, 8, 144, 3, 144, 3320, 8, 144, 1, 145, 1, 145, 3, 145, 3324, 8, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 3, 146, 3332, 8, 146, 1, 147, 1, 147, 1, 147, 5, 147, 3337, 8, 147, 10, 147, 12, 147, 3340, 9, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 3353, 8, 148, 1, 149, 1, 149, 3, 149, 3357, 8, 149, 1, 150, 1, 150, 3, 150, 3361, 8, 150, 1, 151, 1, 151, 1, 151, 3, 151, 3366, 8, 151, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3372, 8, 152, 1, 153, 1, 153, 3, 153, 3376, 8, 153, 1, 154, 1, 154, 3, 154, 3380, 8, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 3, 156, 3393, 8, 156, 1, 157, 1, 157, 1, 157, 1, 157, 3, 157, 3399, 8, 157, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 3408, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 5, 159, 3415, 8, 159, 10, 159, 12, 159, 3418, 9, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 3, 160, 3427, 8, 160, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 162, 5, 162, 3436, 8, 162, 10, 162, 12, 162, 3439, 9, 162, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 3, 164, 3548, 8, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 3566, 8, 166, 1, 167, 4, 167, 3569, 8, 167, 11, 167, 12, 167, 3570, 1, 168, 1, 168, 3, 168, 3575, 8, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 3592, 8, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3600, 8, 170, 1, 171, 1, 171, 1, 171, 5, 171, 3605, 8, 171, 10, 171, 12, 171, 3608, 9, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 5, 173, 3618, 8, 173, 10, 173, 12, 173, 3621, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 3630, 8, 174, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 3664, 8, 178, 1, 179, 1, 179, 1, 179, 3, 179, 3669, 8, 179, 1, 180, 1, 180, 1, 180, 3, 180, 3674, 8, 180, 1, 181, 1, 181, 3, 181, 3678, 8, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 3, 182, 3686, 8, 182, 3, 182, 3688, 8, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 3, 183, 3746, 8, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 3, 185, 3763, 8, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 3, 186, 3771, 8, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 3, 187, 3794, 8, 187, 1, 188, 1, 188, 3, 188, 3798, 8, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 3818, 8, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 3, 193, 3855, 8, 193, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 3, 194, 3864, 8, 194, 1, 195, 1, 195, 1, 195, 3, 195, 3869, 8, 195, 1, 196, 1, 196, 1, 196, 3, 196, 3874, 8, 196, 1, 197, 1, 197, 1, 197, 3, 197, 3879, 8, 197, 1, 198, 1, 198, 1, 198, 3, 198, 3884, 8, 198, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 3937, 8, 202, 1, 203, 1, 203, 1, 203, 1, 203, 3, 203, 3943, 8, 203, 1, 204, 1, 204, 1, 204, 5, 204, 3948, 8, 204, 10, 204, 12, 204, 3951, 9, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 3, 205, 3960, 8, 205, 1, 206, 1, 206, 1, 206, 3, 206, 3965, 8, 206, 1, 207, 4, 207, 3968, 8, 207, 11, 207, 12, 207, 3969, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 210, 1, 210, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 3, 212, 3988, 8, 212, 1, 213, 1, 213, 3, 213, 3992, 8, 213, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 3, 215, 4002, 8, 215, 1, 216, 1, 216, 1, 217, 1, 217, 3, 217, 4008, 8, 217, 1, 217, 1, 217, 5, 217, 4012, 8, 217, 10, 217, 12, 217, 4015, 9, 217, 1, 218, 1, 218, 1, 218, 1, 218, 3, 218, 4021, 8, 218, 1, 219, 1, 219, 1, 219, 3, 219, 4026, 8, 219, 1, 220, 5, 220, 4029, 8, 220, 10, 220, 12, 220, 4032, 9, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 3, 221, 4045, 8, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 3, 222, 4073, 8, 222, 1, 223, 1, 223, 1, 223, 5, 223, 4078, 8, 223, 10, 223, 12, 223, 4081, 9, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, 5, 225, 4092, 8, 225, 10, 225, 12, 225, 4095, 9, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 3, 227, 4109, 8, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 3, 229, 4226, 8, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 5, 231, 4235, 8, 231, 10, 231, 12, 231, 4238, 9, 231, 1, 232, 1, 232, 1, 232, 3, 232, 4243, 8, 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 3, 233, 4251, 8, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 5, 235, 4260, 8, 235, 10, 235, 12, 235, 4263, 9, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 3, 237, 4271, 8, 237, 1, 238, 1, 238, 1, 238, 5, 238, 4276, 8, 238, 10, 238, 12, 238, 4279, 9, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 3, 239, 4318, 8, 239, 1, 240, 1, 240, 1, 240, 1, 240, 3, 240, 4324, 8, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 5, 242, 4343, 8, 242, 10, 242, 12, 242, 4346, 9, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 3, 243, 4373, 8, 243, 1, 244, 1, 244, 3, 244, 4377, 8, 244, 1, 245, 1, 245, 1, 245, 3, 245, 4382, 8, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 3, 246, 4391, 8, 246, 1, 247, 1, 247, 3, 247, 4395, 8, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 3, 249, 4422, 8, 249, 1, 250, 1, 250, 1, 250, 5, 250, 4427, 8, 250, 10, 250, 12, 250, 4430, 9, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4444, 8, 251, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 3, 252, 4464, 8, 252, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 3, 253, 4484, 8, 253, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 3, 256, 4577, 8, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 3, 257, 4602, 8, 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 3, 258, 4609, 8, 258, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 3, 259, 4625, 8, 259, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 5, 261, 4632, 8, 261, 10, 261, 12, 261, 4635, 9, 261, 1, 262, 1, 262, 3, 262, 4639, 8, 262, 1, 263, 1, 263, 4, 263, 4643, 8, 263, 11, 263, 12, 263, 4644, 1, 264, 1, 264, 1, 264, 5, 264, 4650, 8, 264, 10, 264, 12, 264, 4653, 9, 264, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 3, 266, 4666, 8, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 3, 267, 4815, 8, 267, 1, 268, 1, 268, 3, 268, 4819, 8, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 4912, 8, 269, 1, 270, 1, 270, 1, 270, 3, 270, 4917, 8, 270, 1, 271, 1, 271, 3, 271, 4921, 8, 271, 1, 272, 1, 272, 1, 272, 1, 272, 3, 272, 4927, 8, 272, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 3, 273, 4995, 8, 273, 1, 274, 1, 274, 1, 275, 1, 275, 3, 275, 5001, 8, 275, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5030, 8, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 3, 278, 5047, 8, 278, 1, 279, 1, 279, 1, 279, 5, 279, 5052, 8, 279, 10, 279, 12, 279, 5055, 9, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 3, 280, 5066, 8, 280, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 3, 281, 5126, 8, 281, 1, 282, 1, 282, 1, 282, 5, 282, 5131, 8, 282, 10, 282, 12, 282, 5134, 9, 282, 1, 283, 1, 283, 1, 283, 3, 283, 5139, 8, 283, 1, 284, 1, 284, 1, 284, 1, 284, 3, 284, 5145, 8, 284, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 3, 286, 5171, 8, 286, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 5177, 8, 287, 1, 288, 1, 288, 1, 288, 1, 288, 3, 288, 5183, 8, 288, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 290, 5, 290, 5192, 8, 290, 10, 290, 12, 290, 5195, 9, 290, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 3, 291, 5206, 8, 291, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 3, 292, 5235, 8, 292, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 5274, 8, 294, 1, 295, 1, 295, 3, 295, 5278, 8, 295, 1, 296, 1, 296, 3, 296, 5282, 8, 296, 1, 297, 1, 297, 3, 297, 5286, 8, 297, 1, 298, 1, 298, 1, 298, 3, 298, 5291, 8, 298, 1, 299, 1, 299, 1, 299, 5, 299, 5296, 8, 299, 10, 299, 12, 299, 5299, 9, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 3, 300, 5312, 8, 300, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 3, 301, 5325, 8, 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 3, 302, 5333, 8, 302, 1, 303, 1, 303, 1, 303, 5, 303, 5338, 8, 303, 10, 303, 12, 303, 5341, 9, 303, 1, 304, 1, 304, 1, 304, 3, 304, 5346, 8, 304, 1, 305, 1, 305, 3, 305, 5350, 8, 305, 1, 306, 1, 306, 1, 306, 3, 306, 5355, 8, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 5362, 8, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 3, 308, 5376, 8, 308, 3, 308, 5378, 8, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 3, 309, 5385, 8, 309, 1, 310, 1, 310, 3, 310, 5389, 8, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 5, 311, 5396, 8, 311, 10, 311, 12, 311, 5399, 9, 311, 1, 312, 1, 312, 1, 312, 5, 312, 5404, 8, 312, 10, 312, 12, 312, 5407, 9, 312, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 3, 313, 5415, 8, 313, 3, 313, 5417, 8, 313, 1, 314, 1, 314, 3, 314, 5421, 8, 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 5, 315, 5428, 8, 315, 10, 315, 12, 315, 5431, 9, 315, 1, 316, 1, 316, 3, 316, 5435, 8, 316, 1, 316, 1, 316, 1, 316, 1, 316, 3, 316, 5441, 8, 316, 1, 316, 1, 316, 1, 316, 3, 316, 5446, 8, 316, 1, 317, 1, 317, 3, 317, 5450, 8, 317, 1, 317, 1, 317, 1, 317, 3, 317, 5455, 8, 317, 1, 318, 1, 318, 1, 318, 1, 318, 3, 318, 5461, 8, 318, 1, 319, 1, 319, 1, 320, 1, 320, 3, 320, 5467, 8, 320, 1, 320, 1, 320, 1, 320, 1, 320, 3, 320, 5473, 8, 320, 1, 320, 1, 320, 1, 320, 1, 320, 3, 320, 5479, 8, 320, 1, 321, 1, 321, 1, 321, 3, 321, 5484, 8, 321, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 3, 323, 5499, 8, 323, 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 5, 324, 5506, 8, 324, 10, 324, 12, 324, 5509, 9, 324, 1, 325, 1, 325, 1, 325, 1, 326, 1, 326, 1, 326, 5, 326, 5517, 8, 326, 10, 326, 12, 326, 5520, 9, 326, 1, 327, 4, 327, 5523, 8, 327, 11, 327, 12, 327, 5524, 1, 327, 1, 327, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 3, 328, 5564, 8, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329, 5574, 8, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 3, 330, 5581, 8, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 5, 331, 5590, 8, 331, 10, 331, 12, 331, 5593, 9, 331, 1, 332, 1, 332, 1, 332, 3, 332, 5598, 8, 332, 1, 333, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 5, 334, 5606, 8, 334, 10, 334, 12, 334, 5609, 9, 334, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 336, 4, 336, 5618, 8, 336, 11, 336, 12, 336, 5619, 1, 337, 1, 337, 3, 337, 5624, 8, 337, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 3, 338, 5662, 8, 338, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 3, 339, 5676, 8, 339, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 3, 340, 5690, 8, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 5714, 8, 341, 1, 342, 1, 342, 1, 342, 5, 342, 5719, 8, 342, 10, 342, 12, 342, 5722, 9, 342, 1, 342, 1, 342, 1, 343, 1, 343, 1, 343, 5, 343, 5729, 8, 343, 10, 343, 12, 343, 5732, 9, 343, 1, 344, 1, 344, 1, 344, 1, 345, 1, 345, 1, 345, 1, 346, 4, 346, 5741, 8, 346, 11, 346, 12, 346, 5742, 1, 347, 1, 347, 1, 347, 3, 347, 5748, 8, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 3, 348, 5784, 8, 348, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 3, 349, 5791, 8, 349, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 3, 351, 5806, 8, 351, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 3, 353, 5853, 8, 353, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 3, 355, 5890, 8, 355, 1, 356, 1, 356, 1, 357, 1, 357, 1, 358, 1, 358, 1, 358, 5, 358, 5899, 8, 358, 10, 358, 12, 358, 5902, 9, 358, 1, 359, 1, 359, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 3, 360, 5918, 8, 360, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 3, 361, 6388, 8, 361, 1, 362, 1, 362, 3, 362, 6392, 8, 362, 1, 363, 1, 363, 1, 363, 3, 363, 6397, 8, 363, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 3, 364, 6456, 8, 364, 1, 365, 1, 365, 3, 365, 6460, 8, 365, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 3, 366, 6679, 8, 366, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 368, 1, 368, 1, 368, 5, 368, 6692, 8, 368, 10, 368, 12, 368, 6695, 9, 368, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 3, 369, 6705, 8, 369, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 3, 370, 6712, 8, 370, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 6905, 8, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 374, 1, 374, 3, 374, 6915, 8, 374, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 3, 375, 6923, 8, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 3, 376, 6952, 8, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 378, 1, 378, 1, 378, 5, 378, 6966, 8, 378, 10, 378, 12, 378, 6969, 9, 378, 1, 379, 1, 379, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 3, 380, 7010, 8, 380, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 3, 381, 7024, 8, 381, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 7046, 8, 383, 1, 384, 1, 384, 1, 384, 5, 384, 7051, 8, 384, 10, 384, 12, 384, 7054, 9, 384, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 3, 385, 7061, 8, 385, 1, 386, 1, 386, 3, 386, 7065, 8, 386, 1, 387, 1, 387, 1, 388, 1, 388, 1, 388, 3, 388, 7072, 8, 388, 1, 389, 1, 389, 1, 389, 1, 389, 1, 390, 1, 390, 1, 390, 3, 390, 7081, 8, 390, 1, 391, 1, 391, 1, 391, 1, 392, 1, 392, 1, 392, 1, 392, 3, 392, 7090, 8, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 3, 393, 7142, 8, 393, 1, 394, 1, 394, 1, 394, 3, 394, 7147, 8, 394, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 3, 395, 7159, 8, 395, 1, 396, 1, 396, 3, 396, 7163, 8, 396, 1, 396, 5, 396, 7166, 8, 396, 10, 396, 12, 396, 7169, 9, 396, 1, 397, 1, 397, 3, 397, 7173, 8, 397, 1, 398, 1, 398, 3, 398, 7177, 8, 398, 1, 398, 1, 398, 3, 398, 7181, 8, 398, 1, 399, 1, 399, 1, 399, 3, 399, 7186, 8, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 3, 399, 7202, 8, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 400, 1, 400, 3, 400, 7210, 8, 400, 1, 400, 1, 400, 1, 400, 3, 400, 7215, 8, 400, 1, 401, 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 403, 1, 403, 3, 403, 7228, 8, 403, 1, 404, 4, 404, 7231, 8, 404, 11, 404, 12, 404, 7232, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 3, 405, 7240, 8, 405, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 3, 406, 7250, 8, 406, 1, 407, 1, 407, 3, 407, 7254, 8, 407, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 3, 408, 7265, 8, 408, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 410, 1, 410, 1, 410, 1, 410, 3, 410, 7276, 8, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 3, 410, 7284, 8, 410, 1, 411, 1, 411, 1, 411, 5, 411, 7289, 8, 411, 10, 411, 12, 411, 7292, 9, 411, 1, 412, 1, 412, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 3, 416, 7330, 8, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 3, 416, 7338, 8, 416, 1, 417, 1, 417, 3, 417, 7342, 8, 417, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 3, 419, 7423, 8, 419, 1, 420, 1, 420, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 3, 422, 7451, 8, 422, 1, 423, 1, 423, 1, 423, 3, 423, 7456, 8, 423, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 3, 424, 7471, 8, 424, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 3, 425, 7483, 8, 425, 1, 426, 1, 426, 1, 426, 5, 426, 7488, 8, 426, 10, 426, 12, 426, 7491, 9, 426, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, 1, 429, 1, 429, 3, 429, 7500, 8, 429, 1, 430, 1, 430, 1, 430, 3, 430, 7505, 8, 430, 1, 431, 1, 431, 3, 431, 7509, 8, 431, 1, 432, 1, 432, 3, 432, 7513, 8, 432, 1, 433, 1, 433, 3, 433, 7517, 8, 433, 1, 434, 1, 434, 3, 434, 7521, 8, 434, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 3, 435, 7528, 8, 435, 1, 436, 1, 436, 1, 436, 1, 437, 1, 437, 1, 437, 5, 437, 7536, 8, 437, 10, 437, 12, 437, 7539, 9, 437, 1, 438, 1, 438, 3, 438, 7543, 8, 438, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 3, 439, 7561, 8, 439, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 3, 440, 7572, 8, 440, 1, 441, 1, 441, 1, 441, 5, 441, 7577, 8, 441, 10, 441, 12, 441, 7580, 9, 441, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 3, 443, 7587, 8, 443, 1, 444, 1, 444, 1, 444, 3, 444, 7592, 8, 444, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 3, 446, 7605, 8, 446, 1, 447, 1, 447, 1, 447, 1, 447, 3, 447, 7611, 8, 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 7640, 8, 448, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 3, 449, 7647, 8, 449, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 3, 450, 7659, 8, 450, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 452, 1, 452, 1, 452, 3, 452, 7672, 8, 452, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 3, 453, 7687, 8, 453, 1, 453, 1, 453, 1, 453, 1, 453, 3, 453, 7693, 8, 453, 1, 454, 1, 454, 1, 455, 1, 455, 1, 455, 5, 455, 7700, 8, 455, 10, 455, 12, 455, 7703, 9, 455, 1, 456, 1, 456, 1, 456, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 3, 457, 7718, 8, 457, 1, 457, 3, 457, 7721, 8, 457, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 3, 458, 7732, 8, 458, 1, 459, 1, 459, 1, 459, 3, 459, 7737, 8, 459, 1, 460, 1, 460, 3, 460, 7741, 8, 460, 1, 460, 1, 460, 3, 460, 7745, 8, 460, 1, 460, 1, 460, 1, 460, 3, 460, 7750, 8, 460, 1, 460, 3, 460, 7753, 8, 460, 1, 460, 1, 460, 1, 460, 1, 460, 3, 460, 7759, 8, 460, 1, 460, 1, 460, 3, 460, 7763, 8, 460, 3, 460, 7765, 8, 460, 1, 460, 3, 460, 7768, 8, 460, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 3, 461, 7775, 8, 461, 1, 461, 3, 461, 7778, 8, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 3, 461, 7785, 8, 461, 1, 461, 1, 461, 1, 462, 1, 462, 1, 462, 1, 462, 3, 462, 7793, 8, 462, 1, 462, 3, 462, 7796, 8, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 463, 1, 463, 1, 463, 3, 463, 7805, 8, 463, 1, 463, 1, 463, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 465, 1, 465, 1, 465, 3, 465, 7820, 8, 465, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 3, 467, 7833, 8, 467, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 3, 468, 7844, 8, 468, 1, 468, 3, 468, 7847, 8, 468, 1, 469, 1, 469, 3, 469, 7851, 8, 469, 1, 470, 1, 470, 1, 470, 1, 470, 3, 470, 7857, 8, 470, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 472, 1, 472, 1, 472, 5, 472, 7871, 8, 472, 10, 472, 12, 472, 7874, 9, 472, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 3, 473, 7886, 8, 473, 1, 474, 1, 474, 1, 474, 1, 475, 1, 475, 1, 475, 5, 475, 7894, 8, 475, 10, 475, 12, 475, 7897, 9, 475, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 477, 1, 477, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 5, 478, 7914, 8, 478, 10, 478, 12, 478, 7917, 9, 478, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 3, 479, 7924, 8, 479, 1, 480, 1, 480, 3, 480, 7928, 8, 480, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 3, 481, 7938, 8, 481, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 3, 482, 7948, 8, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 3, 482, 7959, 8, 482, 3, 482, 7961, 8, 482, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 5, 483, 7968, 8, 483, 10, 483, 12, 483, 7971, 9, 483, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, 5, 484, 7978, 8, 484, 10, 484, 12, 484, 7981, 9, 484, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 3, 485, 7991, 8, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 3, 485, 8004, 8, 485, 1, 486, 1, 486, 3, 486, 8008, 8, 486, 1, 486, 1, 486, 1, 487, 1, 487, 1, 487, 5, 487, 8015, 8, 487, 10, 487, 12, 487, 8018, 9, 487, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 489, 1, 489, 1, 489, 1, 489, 3, 489, 8032, 8, 489, 1, 490, 1, 490, 3, 490, 8036, 8, 490, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 3, 491, 8043, 8, 491, 1, 491, 3, 491, 8046, 8, 491, 1, 492, 1, 492, 3, 492, 8050, 8, 492, 1, 493, 3, 493, 8053, 8, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 3, 493, 8066, 8, 493, 1, 494, 1, 494, 3, 494, 8070, 8, 494, 1, 495, 1, 495, 1, 495, 3, 495, 8075, 8, 495, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 3, 496, 8083, 8, 496, 1, 497, 1, 497, 3, 497, 8087, 8, 497, 1, 498, 1, 498, 3, 498, 8091, 8, 498, 1, 499, 1, 499, 1, 499, 1, 499, 1, 500, 1, 500, 1, 500, 5, 500, 8100, 8, 500, 10, 500, 12, 500, 8103, 9, 500, 1, 501, 1, 501, 1, 501, 1, 501, 3, 501, 8109, 8, 501, 1, 501, 1, 501, 1, 502, 1, 502, 3, 502, 8115, 8, 502, 1, 502, 1, 502, 3, 502, 8119, 8, 502, 3, 502, 8121, 8, 502, 1, 503, 1, 503, 3, 503, 8125, 8, 503, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 8131, 8, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 8140, 8, 504, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 8146, 8, 504, 3, 504, 8148, 8, 504, 3, 504, 8150, 8, 504, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 3, 505, 8157, 8, 505, 1, 506, 1, 506, 3, 506, 8161, 8, 506, 1, 507, 1, 507, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 3, 508, 8170, 8, 508, 1, 509, 1, 509, 3, 509, 8174, 8, 509, 1, 510, 1, 510, 1, 511, 1, 511, 1, 512, 1, 512, 1, 512, 1, 512, 3, 512, 8184, 8, 512, 1, 513, 1, 513, 1, 513, 5, 513, 8189, 8, 513, 10, 513, 12, 513, 8192, 9, 513, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 3, 514, 8199, 8, 514, 1, 515, 1, 515, 1, 515, 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 519, 1, 519, 1, 519, 3, 519, 8223, 8, 519, 1, 520, 1, 520, 1, 520, 1, 520, 3, 520, 8229, 8, 520, 1, 521, 1, 521, 3, 521, 8233, 8, 521, 1, 522, 4, 522, 8236, 8, 522, 11, 522, 12, 522, 8237, 1, 523, 1, 523, 1, 523, 1, 523, 1, 524, 1, 524, 1, 524, 3, 524, 8247, 8, 524, 1, 524, 1, 524, 3, 524, 8251, 8, 524, 1, 524, 3, 524, 8254, 8, 524, 1, 525, 1, 525, 1, 525, 3, 525, 8259, 8, 525, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 5, 526, 8270, 8, 526, 10, 526, 12, 526, 8273, 9, 526, 1, 527, 1, 527, 1, 527, 3, 527, 8278, 8, 527, 1, 528, 1, 528, 1, 528, 1, 528, 5, 528, 8284, 8, 528, 10, 528, 12, 528, 8287, 9, 528, 3, 528, 8289, 8, 528, 1, 529, 1, 529, 1, 529, 4, 529, 8294, 8, 529, 11, 529, 12, 529, 8295, 1, 530, 1, 530, 1, 530, 3, 530, 8301, 8, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 3, 530, 8322, 8, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 3, 530, 8331, 8, 530, 1, 530, 1, 530, 1, 530, 3, 530, 8336, 8, 530, 1, 530, 1, 530, 1, 530, 1, 530, 3, 530, 8342, 8, 530, 1, 530, 1, 530, 1, 530, 3, 530, 8347, 8, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 3, 530, 8354, 8, 530, 1, 530, 1, 530, 1, 530, 3, 530, 8359, 8, 530, 1, 530, 1, 530, 1, 530, 1, 530, 5, 530, 8365, 8, 530, 10, 530, 12, 530, 8368, 9, 530, 1, 531, 3, 531, 8371, 8, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 3, 531, 8378, 8, 531, 1, 532, 1, 532, 3, 532, 8382, 8, 532, 1, 533, 3, 533, 8385, 8, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 3, 533, 8392, 8, 533, 1, 534, 1, 534, 1, 534, 3, 534, 8397, 8, 534, 1, 534, 3, 534, 8400, 8, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 3, 534, 8407, 8, 534, 1, 535, 1, 535, 3, 535, 8411, 8, 535, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 3, 536, 8420, 8, 536, 1, 537, 1, 537, 3, 537, 8424, 8, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 3, 537, 8432, 8, 537, 3, 537, 8434, 8, 537, 1, 538, 1, 538, 1, 538, 5, 538, 8439, 8, 538, 10, 538, 12, 538, 8442, 9, 538, 1, 539, 1, 539, 3, 539, 8446, 8, 539, 1, 539, 3, 539, 8449, 8, 539, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 541, 1, 541, 1, 541, 1, 541, 1, 541, 1, 541, 3, 541, 8464, 8, 541, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 3, 542, 8476, 8, 542, 1, 543, 1, 543, 1, 543, 1, 544, 1, 544, 1, 544, 5, 544, 8484, 8, 544, 10, 544, 12, 544, 8487, 9, 544, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 3, 545, 8495, 8, 545, 1, 546, 1, 546, 1, 546, 3, 546, 8500, 8, 546, 1, 547, 1, 547, 1, 547, 3, 547, 8505, 8, 547, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 3, 548, 8512, 8, 548, 1, 548, 3, 548, 8515, 8, 548, 1, 549, 1, 549, 3, 549, 8519, 8, 549, 1, 550, 1, 550, 1, 550, 5, 550, 8524, 8, 550, 10, 550, 12, 550, 8527, 9, 550, 1, 551, 1, 551, 1, 551, 1, 551, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 3, 552, 8550, 8, 552, 1, 552, 1, 552, 1, 553, 1, 553, 1, 553, 5, 553, 8557, 8, 553, 10, 553, 12, 553, 8560, 9, 553, 1, 554, 1, 554, 1, 554, 3, 554, 8565, 8, 554, 1, 554, 1, 554, 3, 554, 8569, 8, 554, 1, 555, 4, 555, 8572, 8, 555, 11, 555, 12, 555, 8573, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 3, 556, 8584, 8, 556, 1, 557, 1, 557, 1, 557, 5, 557, 8589, 8, 557, 10, 557, 12, 557, 8592, 9, 557, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 3, 558, 8600, 8, 558, 1, 559, 3, 559, 8603, 8, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 8612, 8, 559, 3, 559, 8614, 8, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 8620, 8, 559, 1, 560, 1, 560, 3, 560, 8624, 8, 560, 1, 560, 5, 560, 8627, 8, 560, 10, 560, 12, 560, 8630, 9, 560, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 3, 561, 8643, 8, 561, 3, 561, 8645, 8, 561, 1, 562, 1, 562, 1, 562, 1, 562, 3, 562, 8651, 8, 562, 1, 563, 1, 563, 1, 563, 1, 563, 3, 563, 8657, 8, 563, 1, 563, 3, 563, 8660, 8, 563, 1, 563, 1, 563, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 3, 564, 8669, 8, 564, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 3, 565, 8687, 8, 565, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 3, 566, 8694, 8, 566, 1, 567, 1, 567, 3, 567, 8698, 8, 567, 1, 568, 1, 568, 3, 568, 8702, 8, 568, 1, 569, 1, 569, 1, 569, 1, 569, 1, 569, 1, 569, 1, 570, 1, 570, 1, 570, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 3, 571, 8718, 8, 571, 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 3, 572, 8725, 8, 572, 1, 573, 1, 573, 1, 573, 1, 573, 1, 573, 1, 573, 3, 573, 8733, 8, 573, 1, 574, 1, 574, 3, 574, 8737, 8, 574, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 3, 575, 8744, 8, 575, 1, 575, 1, 575, 1, 576, 1, 576, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 3, 577, 8757, 8, 577, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 3, 578, 8773, 8, 578, 1, 578, 1, 578, 1, 578, 1, 578, 3, 578, 8779, 8, 578, 1, 578, 1, 578, 1, 578, 1, 578, 3, 578, 8785, 8, 578, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 3, 579, 8792, 8, 579, 1, 580, 1, 580, 1, 580, 3, 580, 8797, 8, 580, 1, 581, 1, 581, 1, 582, 1, 582, 3, 582, 8803, 8, 582, 1, 583, 1, 583, 1, 583, 5, 583, 8808, 8, 583, 10, 583, 12, 583, 8811, 9, 583, 1, 584, 1, 584, 1, 584, 5, 584, 8816, 8, 584, 10, 584, 12, 584, 8819, 9, 584, 1, 585, 1, 585, 1, 585, 5, 585, 8824, 8, 585, 10, 585, 12, 585, 8827, 9, 585, 1, 586, 1, 586, 3, 586, 8831, 8, 586, 1, 586, 1, 586, 3, 586, 8835, 8, 586, 1, 586, 1, 586, 1, 586, 1, 586, 3, 586, 8841, 8, 586, 1, 587, 1, 587, 3, 587, 8845, 8, 587, 1, 587, 1, 587, 3, 587, 8849, 8, 587, 1, 588, 3, 588, 8852, 8, 588, 1, 588, 1, 588, 1, 589, 1, 589, 3, 589, 8858, 8, 589, 1, 590, 1, 590, 1, 590, 3, 590, 8863, 8, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 3, 590, 8879, 8, 590, 1, 590, 3, 590, 8882, 8, 590, 3, 590, 8884, 8, 590, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 3, 591, 8896, 8, 591, 3, 591, 8898, 8, 591, 1, 592, 1, 592, 3, 592, 8902, 8, 592, 1, 592, 1, 592, 1, 592, 1, 592, 3, 592, 8908, 8, 592, 1, 592, 1, 592, 1, 592, 3, 592, 8913, 8, 592, 1, 593, 1, 593, 1, 593, 1, 593, 5, 593, 8919, 8, 593, 10, 593, 12, 593, 8922, 9, 593, 1, 594, 3, 594, 8925, 8, 594, 1, 594, 1, 594, 1, 595, 1, 595, 1, 595, 5, 595, 8932, 8, 595, 10, 595, 12, 595, 8935, 9, 595, 1, 596, 1, 596, 1, 596, 5, 596, 8940, 8, 596, 10, 596, 12, 596, 8943, 9, 596, 1, 597, 1, 597, 1, 597, 3, 597, 8948, 8, 597, 1, 598, 3, 598, 8951, 8, 598, 1, 598, 1, 598, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 3, 599, 8960, 8, 599, 1, 600, 1, 600, 1, 600, 3, 600, 8965, 8, 600, 1, 601, 1, 601, 1, 601, 5, 601, 8970, 8, 601, 10, 601, 12, 601, 8973, 9, 601, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 3, 602, 8982, 8, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 3, 602, 9008, 8, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 3, 602, 9019, 8, 602, 5, 602, 9021, 8, 602, 10, 602, 12, 602, 9024, 9, 602, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 3, 603, 9031, 8, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 3, 603, 9054, 8, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 3, 603, 9062, 8, 603, 1, 604, 1, 604, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 3, 605, 9072, 8, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 3, 605, 9086, 8, 605, 1, 605, 1, 605, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 3, 606, 9096, 8, 606, 1, 607, 1, 607, 3, 607, 9100, 8, 607, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 9114, 8, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 9121, 8, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 9128, 8, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 9135, 8, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 9160, 8, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 9189, 8, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 9228, 8, 608, 3, 608, 9230, 8, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 9258, 8, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 9279, 8, 608, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 3, 609, 9286, 8, 609, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 3, 610, 9299, 8, 610, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 612, 1, 612, 1, 612, 5, 612, 9309, 8, 612, 10, 612, 12, 612, 9312, 9, 612, 1, 613, 1, 613, 1, 613, 3, 613, 9317, 8, 613, 1, 614, 1, 614, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 3, 615, 9326, 8, 615, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 3, 616, 9343, 8, 616, 1, 617, 1, 617, 1, 617, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 3, 618, 9355, 8, 618, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 3, 619, 9364, 8, 619, 1, 620, 1, 620, 1, 620, 3, 620, 9369, 8, 620, 1, 621, 1, 621, 1, 621, 5, 621, 9374, 8, 621, 10, 621, 12, 621, 9377, 9, 621, 1, 622, 1, 622, 1, 622, 1, 622, 1, 623, 1, 623, 1, 623, 3, 623, 9386, 8, 623, 1, 623, 3, 623, 9389, 8, 623, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 625, 1, 625, 3, 625, 9400, 8, 625, 1, 626, 1, 626, 1, 626, 1, 626, 3, 626, 9406, 8, 626, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 3, 627, 9421, 8, 627, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 3, 628, 9429, 8, 628, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 3, 629, 9438, 8, 629, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 3, 630, 9447, 8, 630, 1, 630, 3, 630, 9450, 8, 630, 1, 631, 1, 631, 1, 631, 3, 631, 9455, 8, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 3, 631, 9464, 8, 631, 1, 632, 1, 632, 1, 632, 3, 632, 9469, 8, 632, 1, 632, 1, 632, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 634, 1, 634, 1, 635, 1, 635, 3, 635, 9483, 8, 635, 1, 636, 1, 636, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 3, 637, 9493, 8, 637, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 3, 638, 9501, 8, 638, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 3, 639, 9515, 8, 639, 1, 640, 1, 640, 1, 640, 5, 640, 9520, 8, 640, 10, 640, 12, 640, 9523, 9, 640, 1, 641, 1, 641, 1, 641, 5, 641, 9528, 8, 641, 10, 641, 12, 641, 9531, 9, 641, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 3, 642, 9538, 8, 642, 1, 643, 1, 643, 1, 643, 5, 643, 9543, 8, 643, 10, 643, 12, 643, 9546, 9, 643, 1, 644, 1, 644, 1, 644, 3, 644, 9551, 8, 644, 1, 644, 1, 644, 1, 645, 1, 645, 1, 645, 5, 645, 9558, 8, 645, 10, 645, 12, 645, 9561, 9, 645, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 3, 646, 9568, 8, 646, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 3, 647, 9578, 8, 647, 1, 648, 1, 648, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 3, 649, 9589, 8, 649, 1, 650, 1, 650, 1, 650, 1, 650, 1, 650, 3, 650, 9596, 8, 650, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 3, 651, 9625, 8, 651, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 3, 652, 9634, 8, 652, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 3, 653, 9641, 8, 653, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 655, 4, 655, 9650, 8, 655, 11, 655, 12, 655, 9651, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 657, 1, 657, 1, 657, 3, 657, 9662, 8, 657, 1, 658, 1, 658, 3, 658, 9666, 8, 658, 1, 659, 1, 659, 3, 659, 9670, 8, 659, 1, 660, 1, 660, 1, 660, 3, 660, 9675, 8, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 3, 660, 9683, 8, 660, 1, 660, 1, 660, 3, 660, 9687, 8, 660, 1, 661, 1, 661, 3, 661, 9691, 8, 661, 1, 662, 4, 662, 9694, 8, 662, 11, 662, 12, 662, 9695, 1, 663, 5, 663, 9699, 8, 663, 10, 663, 12, 663, 9702, 9, 663, 1, 664, 1, 664, 3, 664, 9706, 8, 664, 1, 665, 1, 665, 1, 665, 5, 665, 9711, 8, 665, 10, 665, 12, 665, 9714, 9, 665, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 3, 666, 9721, 8, 666, 1, 666, 3, 666, 9724, 8, 666, 1, 667, 1, 667, 1, 667, 5, 667, 9729, 8, 667, 10, 667, 12, 667, 9732, 9, 667, 1, 668, 1, 668, 3, 668, 9736, 8, 668, 1, 669, 1, 669, 1, 669, 5, 669, 9741, 8, 669, 10, 669, 12, 669, 9744, 9, 669, 1, 670, 1, 670, 1, 671, 1, 671, 1, 672, 1, 672, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 3, 673, 9759, 8, 673, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 3, 674, 9774, 8, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 3, 674, 9788, 8, 674, 1, 674, 1, 674, 1, 674, 3, 674, 9793, 8, 674, 1, 675, 1, 675, 1, 676, 1, 676, 1, 677, 1, 677, 1, 678, 1, 678, 1, 679, 1, 679, 1, 679, 1, 680, 1, 680, 1, 680, 1, 680, 5, 680, 9810, 8, 680, 10, 680, 12, 680, 9813, 9, 680, 1, 680, 1, 680, 3, 680, 9817, 8, 680, 1, 681, 1, 681, 1, 681, 3, 681, 9822, 8, 681, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 3, 682, 9829, 8, 682, 1, 683, 1, 683, 1, 684, 1, 684, 1, 684, 3, 684, 9836, 8, 684, 1, 685, 1, 685, 1, 685, 5, 685, 9841, 8, 685, 10, 685, 12, 685, 9844, 9, 685, 1, 686, 1, 686, 1, 686, 1, 686, 1, 686, 1, 686, 3, 686, 9852, 8, 686, 1, 687, 1, 687, 1, 687, 1, 687, 3, 687, 9858, 8, 687, 1, 688, 1, 688, 1, 688, 1, 688, 3, 688, 9864, 8, 688, 1, 689, 1, 689, 1, 689, 1, 689, 3, 689, 9870, 8, 689, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 3, 690, 9878, 8, 690, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 3, 691, 9887, 8, 691, 1, 692, 1, 692, 1, 693, 1, 693, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 3, 694, 9945, 8, 694, 1, 695, 1, 695, 1, 696, 1, 696, 1, 697, 1, 697, 1, 698, 1, 698, 1, 698, 1, 698, 1, 699, 5, 699, 9958, 8, 699, 10, 699, 12, 699, 9961, 9, 699, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 3, 700, 9983, 8, 700, 1, 701, 1, 701, 1, 702, 1, 702, 1, 702, 1, 702, 3, 702, 9991, 8, 702, 1, 703, 1, 703, 3, 703, 9995, 8, 703, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 705, 1, 705, 1, 705, 3, 705, 10007, 8, 705, 3, 705, 10009, 8, 705, 1, 706, 1, 706, 1, 707, 4, 707, 10014, 8, 707, 11, 707, 12, 707, 10015, 1, 708, 1, 708, 1, 708, 1, 708, 1, 709, 1, 709, 1, 709, 3, 709, 10025, 8, 709, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 3, 710, 10043, 8, 710, 1, 710, 1, 710, 1, 711, 1, 711, 1, 711, 1, 711, 3, 711, 10051, 8, 711, 1, 712, 1, 712, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 3, 713, 10060, 8, 713, 1, 714, 1, 714, 1, 714, 5, 714, 10065, 8, 714, 10, 714, 12, 714, 10068, 9, 714, 1, 715, 1, 715, 1, 715, 1, 716, 1, 716, 1, 717, 1, 717, 3, 717, 10077, 8, 717, 1, 718, 1, 718, 1, 719, 1, 719, 3, 719, 10083, 8, 719, 1, 720, 1, 720, 1, 721, 1, 721, 1, 721, 3, 721, 10090, 8, 721, 1, 722, 1, 722, 1, 722, 3, 722, 10095, 8, 722, 1, 723, 1, 723, 1, 723, 1, 723, 3, 723, 10101, 8, 723, 1, 724, 1, 724, 3, 724, 10105, 8, 724, 1, 725, 1, 725, 1, 726, 5, 726, 10110, 8, 726, 10, 726, 12, 726, 10113, 9, 726, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 3, 727, 10142, 8, 727, 1, 728, 1, 728, 1, 728, 1, 728, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 3, 729, 10162, 8, 729, 1, 730, 1, 730, 3, 730, 10166, 8, 730, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, 1, 733, 1, 733, 1, 733, 3, 733, 10182, 8, 733, 1, 734, 1, 734, 1, 734, 5, 734, 10187, 8, 734, 10, 734, 12, 734, 10190, 9, 734, 1, 735, 1, 735, 1, 735, 1, 735, 1, 736, 1, 736, 1, 737, 1, 737, 1, 738, 1, 738, 3, 738, 10202, 8, 738, 1, 738, 1, 738, 1, 738, 1, 738, 5, 738, 10208, 8, 738, 10, 738, 12, 738, 10211, 9, 738, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 5, 740, 10228, 8, 740, 10, 740, 12, 740, 10231, 9, 740, 1, 741, 1, 741, 1, 741, 3, 741, 10236, 8, 741, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 743, 1, 743, 3, 743, 10248, 8, 743, 1, 744, 4, 744, 10251, 8, 744, 11, 744, 12, 744, 10252, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 746, 1, 746, 1, 746, 3, 746, 10263, 8, 746, 1, 747, 1, 747, 1, 747, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 3, 750, 10295, 8, 750, 1, 751, 1, 751, 1, 751, 3, 751, 10300, 8, 751, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 5, 752, 10307, 8, 752, 10, 752, 12, 752, 10310, 9, 752, 1, 752, 1, 752, 3, 752, 10314, 8, 752, 1, 753, 1, 753, 3, 753, 10318, 8, 753, 1, 754, 1, 754, 1, 754, 3, 754, 10323, 8, 754, 1, 755, 1, 755, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 757, 1, 757, 1, 757, 3, 757, 10339, 8, 757, 1, 758, 1, 758, 1, 758, 1, 758, 1, 758, 1, 759, 1, 759, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 3, 760, 10357, 8, 760, 1, 760, 3, 760, 10360, 8, 760, 1, 760, 1, 760, 1, 761, 1, 761, 3, 761, 10366, 8, 761, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 3, 762, 10394, 8, 762, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 3, 763, 10404, 8, 763, 1, 764, 1, 764, 1, 764, 4, 764, 10409, 8, 764, 11, 764, 12, 764, 10410, 3, 764, 10413, 8, 764, 1, 765, 1, 765, 1, 765, 3, 765, 10418, 8, 765, 1, 766, 1, 766, 1, 766, 1, 766, 1, 767, 1, 767, 1, 767, 5, 767, 10427, 8, 767, 10, 767, 12, 767, 10430, 9, 767, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 769, 1, 769, 1, 769, 3, 769, 10440, 8, 769, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 771, 1, 771, 1, 771, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 3, 772, 10461, 8, 772, 1, 772, 1, 772, 1, 773, 1, 773, 1, 773, 3, 773, 10468, 8, 773, 1, 774, 1, 774, 1, 774, 5, 774, 10473, 8, 774, 10, 774, 12, 774, 10476, 9, 774, 1, 775, 1, 775, 1, 775, 3, 775, 10481, 8, 775, 1, 775, 3, 775, 10484, 8, 775, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 3, 776, 10495, 8, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 3, 776, 10502, 8, 776, 3, 776, 10504, 8, 776, 1, 776, 1, 776, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 3, 777, 10513, 8, 777, 1, 778, 1, 778, 1, 778, 5, 778, 10518, 8, 778, 10, 778, 12, 778, 10521, 9, 778, 1, 779, 1, 779, 1, 779, 3, 779, 10526, 8, 779, 1, 780, 1, 780, 1, 780, 1, 780, 3, 780, 10532, 8, 780, 1, 781, 1, 781, 3, 781, 10536, 8, 781, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, 1, 783, 1, 783, 1, 784, 1, 784, 1, 784, 3, 784, 10551, 8, 784, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 3, 785, 10568, 8, 785, 3, 785, 10570, 8, 785, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 787, 1, 787, 1, 787, 1, 787, 1, 788, 1, 788, 1, 788, 1, 789, 1, 789, 1, 789, 1, 789, 1, 790, 1, 790, 1, 790, 1, 790, 1, 791, 1, 791, 3, 791, 10594, 8, 791, 1, 791, 1, 791, 3, 791, 10598, 8, 791, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 3, 792, 10609, 8, 792, 1, 792, 3, 792, 10612, 8, 792, 1, 793, 1, 793, 3, 793, 10616, 8, 793, 1, 794, 1, 794, 1, 794, 3, 794, 10621, 8, 794, 1, 795, 4, 795, 10624, 8, 795, 11, 795, 12, 795, 10625, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 797, 1, 797, 1, 797, 5, 797, 10636, 8, 797, 10, 797, 12, 797, 10639, 9, 797, 1, 798, 1, 798, 1, 798, 3, 798, 10644, 8, 798, 1, 799, 1, 799, 3, 799, 10648, 8, 799, 1, 800, 1, 800, 3, 800, 10652, 8, 800, 1, 801, 1, 801, 3, 801, 10656, 8, 801, 1, 802, 1, 802, 1, 802, 3, 802, 10661, 8, 802, 1, 803, 1, 803, 3, 803, 10665, 8, 803, 1, 804, 1, 804, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 806, 1, 806, 1, 807, 1, 807, 1, 808, 1, 808, 1, 809, 1, 809, 1, 810, 1, 810, 1, 810, 1, 811, 1, 811, 1, 811, 1, 811, 1, 811, 3, 811, 10693, 8, 811, 1, 811, 0, 1, 1204, 812, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650, 652, 654, 656, 658, 660, 662, 664, 666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696, 698, 700, 702, 704, 706, 708, 710, 712, 714, 716, 718, 720, 722, 724, 726, 728, 730, 732, 734, 736, 738, 740, 742, 744, 746, 748, 750, 752, 754, 756, 758, 760, 762, 764, 766, 768, 770, 772, 774, 776, 778, 780, 782, 784, 786, 788, 790, 792, 794, 796, 798, 800, 802, 804, 806, 808, 810, 812, 814, 816, 818, 820, 822, 824, 826, 828, 830, 832, 834, 836, 838, 840, 842, 844, 846, 848, 850, 852, 854, 856, 858, 860, 862, 864, 866, 868, 870, 872, 874, 876, 878, 880, 882, 884, 886, 888, 890, 892, 894, 896, 898, 900, 902, 904, 906, 908, 910, 912, 914, 916, 918, 920, 922, 924, 926, 928, 930, 932, 934, 936, 938, 940, 942, 944, 946, 948, 950, 952, 954, 956, 958, 960, 962, 964, 966, 968, 970, 972, 974, 976, 978, 980, 982, 984, 986, 988, 990, 992, 994, 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014, 1016, 1018, 1020, 1022, 1024, 1026, 1028, 1030, 1032, 1034, 1036, 1038, 1040, 1042, 1044, 1046, 1048, 1050, 1052, 1054, 1056, 1058, 1060, 1062, 1064, 1066, 1068, 1070, 1072, 1074, 1076, 1078, 1080, 1082, 1084, 1086, 1088, 1090, 1092, 1094, 1096, 1098, 1100, 1102, 1104, 1106, 1108, 1110, 1112, 1114, 1116, 1118, 1120, 1122, 1124, 1126, 1128, 1130, 1132, 1134, 1136, 1138, 1140, 1142, 1144, 1146, 1148, 1150, 1152, 1154, 1156, 1158, 1160, 1162, 1164, 1166, 1168, 1170, 1172, 1174, 1176, 1178, 1180, 1182, 1184, 1186, 1188, 1190, 1192, 1194, 1196, 1198, 1200, 1202, 1204, 1206, 1208, 1210, 1212, 1214, 1216, 1218, 1220, 1222, 1224, 1226, 1228, 1230, 1232, 1234, 1236, 1238, 1240, 1242, 1244, 1246, 1248, 1250, 1252, 1254, 1256, 1258, 1260, 1262, 1264, 1266, 1268, 1270, 1272, 1274, 1276, 1278, 1280, 1282, 1284, 1286, 1288, 1290, 1292, 1294, 1296, 1298, 1300, 1302, 1304, 1306, 1308, 1310, 1312, 1314, 1316, 1318, 1320, 1322, 1324, 1326, 1328, 1330, 1332, 1334, 1336, 1338, 1340, 1342, 1344, 1346, 1348, 1350, 1352, 1354, 1356, 1358, 1360, 1362, 1364, 1366, 1368, 1370, 1372, 1374, 1376, 1378, 1380, 1382, 1384, 1386, 1388, 1390, 1392, 1394, 1396, 1398, 1400, 1402, 1404, 1406, 1408, 1410, 1412, 1414, 1416, 1418, 1420, 1422, 1424, 1426, 1428, 1430, 1432, 1434, 1436, 1438, 1440, 1442, 1444, 1446, 1448, 1450, 1452, 1454, 1456, 1458, 1460, 1462, 1464, 1466, 1468, 1470, 1472, 1474, 1476, 1478, 1480, 1482, 1484, 1486, 1488, 1490, 1492, 1494, 1496, 1498, 1500, 1502, 1504, 1506, 1508, 1510, 1512, 1514, 1516, 1518, 1520, 1522, 1524, 1526, 1528, 1530, 1532, 1534, 1536, 1538, 1540, 1542, 1544, 1546, 1548, 1550, 1552, 1554, 1556, 1558, 1560, 1562, 1564, 1566, 1568, 1570, 1572, 1574, 1576, 1578, 1580, 1582, 1584, 1586, 1588, 1590, 1592, 1594, 1596, 1598, 1600, 1602, 1604, 1606, 1608, 1610, 1612, 1614, 1616, 1618, 1620, 1622, 0, 69, 2, 0, 195, 195, 357, 357, 2, 0, 66, 66, 311, 311, 2, 0, 99, 99, 311, 311, 3, 0, 66, 66, 99, 99, 311, 311, 2, 0, 133, 133, 191, 191, 2, 0, 245, 245, 325, 325, 2, 0, 10, 10, 94, 94, 2, 0, 162, 162, 356, 356, 2, 0, 180, 180, 221, 221, 5, 0, 30, 30, 281, 281, 322, 322, 345, 345, 347, 347, 2, 0, 64, 64, 94, 94, 2, 0, 345, 345, 347, 347, 2, 0, 200, 200, 224, 224, 9, 0, 30, 30, 160, 160, 165, 165, 179, 179, 219, 219, 227, 227, 335, 335, 338, 338, 438, 438, 3, 0, 113, 113, 277, 277, 329, 329, 2, 0, 53, 53, 78, 78, 3, 0, 173, 173, 252, 252, 255, 255, 5, 0, 30, 30, 88, 88, 182, 182, 232, 232, 362, 362, 2, 0, 92, 92, 226, 226, 1, 0, 448, 449, 2, 0, 92, 92, 407, 407, 2, 0, 334, 334, 407, 407, 2, 0, 211, 211, 289, 289, 3, 0, 314, 314, 350, 350, 445, 445, 2, 0, 64, 64, 68, 68, 5, 0, 212, 212, 322, 322, 343, 343, 354, 354, 455, 456, 2, 0, 10, 10, 53, 53, 3, 0, 211, 211, 289, 289, 442, 442, 5, 0, 92, 92, 175, 175, 226, 226, 316, 316, 342, 342, 3, 0, 175, 175, 316, 316, 342, 342, 3, 0, 109, 109, 128, 128, 344, 344, 4, 0, 88, 88, 182, 182, 232, 232, 362, 362, 2, 0, 151, 151, 245, 245, 2, 0, 306, 306, 326, 326, 1, 0, 31, 32, 2, 0, 99, 99, 342, 342, 2, 0, 201, 201, 327, 327, 2, 0, 59, 59, 97, 97, 2, 0, 213, 213, 245, 245, 2, 0, 313, 313, 407, 407, 2, 0, 207, 207, 261, 261, 4, 0, 113, 113, 115, 115, 119, 119, 126, 126, 2, 0, 353, 353, 477, 477, 2, 0, 384, 385, 399, 399, 1, 0, 384, 385, 1, 0, 411, 412, 1, 0, 18, 19, 2, 0, 117, 117, 122, 122, 5, 0, 10, 10, 16, 17, 21, 21, 23, 23, 25, 25, 1, 0, 12, 13, 3, 0, 9, 9, 14, 14, 27, 27, 2, 0, 30, 30, 56, 56, 3, 0, 39, 39, 73, 73, 95, 95, 2, 0, 166, 166, 188, 188, 2, 0, 297, 297, 450, 450, 2, 0, 208, 208, 282, 282, 3, 0, 30, 30, 34, 34, 90, 90, 6, 0, 9, 10, 12, 17, 21, 21, 23, 23, 25, 25, 27, 27, 2, 0, 20, 20, 22, 22, 1, 0, 483, 486, 11, 0, 124, 124, 129, 249, 251, 252, 254, 303, 305, 379, 433, 452, 455, 469, 471, 471, 473, 473, 475, 475, 478, 488, 5, 0, 106, 118, 120, 123, 125, 125, 127, 128, 472, 472, 4, 0, 30, 52, 54, 70, 72, 105, 454, 454, 5, 0, 304, 304, 418, 424, 504, 504, 513, 513, 521, 635, 2, 0, 62, 62, 116, 116, 2, 0, 10, 10, 20, 20, 2, 0, 167, 167, 507, 507, 2, 0, 144, 144, 210, 210, 36, 0, 33, 33, 35, 35, 43, 45, 53, 53, 57, 57, 61, 61, 92, 92, 116, 116, 123, 123, 130, 130, 144, 144, 153, 153, 157, 157, 161, 161, 167, 167, 172, 172, 207, 207, 210, 210, 232, 232, 240, 240, 258, 258, 261, 262, 272, 272, 286, 286, 300, 300, 306, 306, 312, 312, 316, 317, 326, 326, 353, 353, 433, 434, 477, 477, 490, 502, 506, 512, 514, 518, 520, 520, 11556, 0, 1624, 1, 0, 0, 0, 2, 1627, 1, 0, 0, 0, 4, 1629, 1, 0, 0, 0, 6, 1637, 1, 0, 0, 0, 8, 1765, 1, 0, 0, 0, 10, 1767, 1, 0, 0, 0, 12, 1771, 1, 0, 0, 0, 14, 1774, 1, 0, 0, 0, 16, 1782, 1, 0, 0, 0, 18, 1787, 1, 0, 0, 0, 20, 1793, 1, 0, 0, 0, 22, 1814, 1, 0, 0, 0, 24, 1826, 1, 0, 0, 0, 26, 1828, 1, 0, 0, 0, 28, 1834, 1, 0, 0, 0, 30, 1844, 1, 0, 0, 0, 32, 1846, 1, 0, 0, 0, 34, 1855, 1, 0, 0, 0, 36, 1863, 1, 0, 0, 0, 38, 1869, 1, 0, 0, 0, 40, 1876, 1, 0, 0, 0, 42, 1878, 1, 0, 0, 0, 44, 1896, 1, 0, 0, 0, 46, 1901, 1, 0, 0, 0, 48, 1910, 1, 0, 0, 0, 50, 1912, 1, 0, 0, 0, 52, 1926, 1, 0, 0, 0, 54, 1928, 1, 0, 0, 0, 56, 1957, 1, 0, 0, 0, 58, 1959, 1, 0, 0, 0, 60, 1967, 1, 0, 0, 0, 62, 1977, 1, 0, 0, 0, 64, 1984, 1, 0, 0, 0, 66, 1990, 1, 0, 0, 0, 68, 2007, 1, 0, 0, 0, 70, 2012, 1, 0, 0, 0, 72, 2016, 1, 0, 0, 0, 74, 2018, 1, 0, 0, 0, 76, 2029, 1, 0, 0, 0, 78, 2033, 1, 0, 0, 0, 80, 2038, 1, 0, 0, 0, 82, 2043, 1, 0, 0, 0, 84, 2045, 1, 0, 0, 0, 86, 2057, 1, 0, 0, 0, 88, 2064, 1, 0, 0, 0, 90, 2066, 1, 0, 0, 0, 92, 2068, 1, 0, 0, 0, 94, 2070, 1, 0, 0, 0, 96, 2182, 1, 0, 0, 0, 98, 2184, 1, 0, 0, 0, 100, 2200, 1, 0, 0, 0, 102, 2202, 1, 0, 0, 0, 104, 2458, 1, 0, 0, 0, 106, 2465, 1, 0, 0, 0, 108, 2470, 1, 0, 0, 0, 110, 2475, 1, 0, 0, 0, 112, 2480, 1, 0, 0, 0, 114, 2488, 1, 0, 0, 0, 116, 2490, 1, 0, 0, 0, 118, 2497, 1, 0, 0, 0, 120, 2499, 1, 0, 0, 0, 122, 2507, 1, 0, 0, 0, 124, 2519, 1, 0, 0, 0, 126, 2535, 1, 0, 0, 0, 128, 2563, 1, 0, 0, 0, 130, 2565, 1, 0, 0, 0, 132, 2568, 1, 0, 0, 0, 134, 2576, 1, 0, 0, 0, 136, 2581, 1, 0, 0, 0, 138, 2612, 1, 0, 0, 0, 140, 2614, 1, 0, 0, 0, 142, 2641, 1, 0, 0, 0, 144, 2643, 1, 0, 0, 0, 146, 2647, 1, 0, 0, 0, 148, 2652, 1, 0, 0, 0, 150, 2659, 1, 0, 0, 0, 152, 2664, 1, 0, 0, 0, 154, 2702, 1, 0, 0, 0, 156, 2706, 1, 0, 0, 0, 158, 2713, 1, 0, 0, 0, 160, 2717, 1, 0, 0, 0, 162, 2719, 1, 0, 0, 0, 164, 2727, 1, 0, 0, 0, 166, 2738, 1, 0, 0, 0, 168, 2740, 1, 0, 0, 0, 170, 2748, 1, 0, 0, 0, 172, 2750, 1, 0, 0, 0, 174, 2799, 1, 0, 0, 0, 176, 2803, 1, 0, 0, 0, 178, 2810, 1, 0, 0, 0, 180, 2812, 1, 0, 0, 0, 182, 2820, 1, 0, 0, 0, 184, 2831, 1, 0, 0, 0, 186, 2835, 1, 0, 0, 0, 188, 2837, 1, 0, 0, 0, 190, 2842, 1, 0, 0, 0, 192, 2852, 1, 0, 0, 0, 194, 2863, 1, 0, 0, 0, 196, 2903, 1, 0, 0, 0, 198, 2908, 1, 0, 0, 0, 200, 2915, 1, 0, 0, 0, 202, 2917, 1, 0, 0, 0, 204, 2925, 1, 0, 0, 0, 206, 2928, 1, 0, 0, 0, 208, 2935, 1, 0, 0, 0, 210, 2995, 1, 0, 0, 0, 212, 3000, 1, 0, 0, 0, 214, 3007, 1, 0, 0, 0, 216, 3009, 1, 0, 0, 0, 218, 3017, 1, 0, 0, 0, 220, 3025, 1, 0, 0, 0, 222, 3030, 1, 0, 0, 0, 224, 3032, 1, 0, 0, 0, 226, 3040, 1, 0, 0, 0, 228, 3056, 1, 0, 0, 0, 230, 3067, 1, 0, 0, 0, 232, 3069, 1, 0, 0, 0, 234, 3073, 1, 0, 0, 0, 236, 3083, 1, 0, 0, 0, 238, 3091, 1, 0, 0, 0, 240, 3095, 1, 0, 0, 0, 242, 3097, 1, 0, 0, 0, 244, 3104, 1, 0, 0, 0, 246, 3126, 1, 0, 0, 0, 248, 3131, 1, 0, 0, 0, 250, 3138, 1, 0, 0, 0, 252, 3150, 1, 0, 0, 0, 254, 3155, 1, 0, 0, 0, 256, 3162, 1, 0, 0, 0, 258, 3164, 1, 0, 0, 0, 260, 3168, 1, 0, 0, 0, 262, 3182, 1, 0, 0, 0, 264, 3193, 1, 0, 0, 0, 266, 3206, 1, 0, 0, 0, 268, 3220, 1, 0, 0, 0, 270, 3222, 1, 0, 0, 0, 272, 3236, 1, 0, 0, 0, 274, 3244, 1, 0, 0, 0, 276, 3246, 1, 0, 0, 0, 278, 3253, 1, 0, 0, 0, 280, 3264, 1, 0, 0, 0, 282, 3275, 1, 0, 0, 0, 284, 3282, 1, 0, 0, 0, 286, 3285, 1, 0, 0, 0, 288, 3319, 1, 0, 0, 0, 290, 3323, 1, 0, 0, 0, 292, 3331, 1, 0, 0, 0, 294, 3333, 1, 0, 0, 0, 296, 3341, 1, 0, 0, 0, 298, 3356, 1, 0, 0, 0, 300, 3358, 1, 0, 0, 0, 302, 3365, 1, 0, 0, 0, 304, 3371, 1, 0, 0, 0, 306, 3375, 1, 0, 0, 0, 308, 3379, 1, 0, 0, 0, 310, 3381, 1, 0, 0, 0, 312, 3392, 1, 0, 0, 0, 314, 3394, 1, 0, 0, 0, 316, 3402, 1, 0, 0, 0, 318, 3416, 1, 0, 0, 0, 320, 3426, 1, 0, 0, 0, 322, 3428, 1, 0, 0, 0, 324, 3437, 1, 0, 0, 0, 326, 3440, 1, 0, 0, 0, 328, 3547, 1, 0, 0, 0, 330, 3549, 1, 0, 0, 0, 332, 3565, 1, 0, 0, 0, 334, 3568, 1, 0, 0, 0, 336, 3574, 1, 0, 0, 0, 338, 3591, 1, 0, 0, 0, 340, 3599, 1, 0, 0, 0, 342, 3601, 1, 0, 0, 0, 344, 3609, 1, 0, 0, 0, 346, 3614, 1, 0, 0, 0, 348, 3629, 1, 0, 0, 0, 350, 3631, 1, 0, 0, 0, 352, 3634, 1, 0, 0, 0, 354, 3636, 1, 0, 0, 0, 356, 3663, 1, 0, 0, 0, 358, 3668, 1, 0, 0, 0, 360, 3670, 1, 0, 0, 0, 362, 3677, 1, 0, 0, 0, 364, 3679, 1, 0, 0, 0, 366, 3745, 1, 0, 0, 0, 368, 3747, 1, 0, 0, 0, 370, 3762, 1, 0, 0, 0, 372, 3770, 1, 0, 0, 0, 374, 3793, 1, 0, 0, 0, 376, 3797, 1, 0, 0, 0, 378, 3817, 1, 0, 0, 0, 380, 3819, 1, 0, 0, 0, 382, 3828, 1, 0, 0, 0, 384, 3839, 1, 0, 0, 0, 386, 3854, 1, 0, 0, 0, 388, 3863, 1, 0, 0, 0, 390, 3868, 1, 0, 0, 0, 392, 3873, 1, 0, 0, 0, 394, 3878, 1, 0, 0, 0, 396, 3883, 1, 0, 0, 0, 398, 3885, 1, 0, 0, 0, 400, 3887, 1, 0, 0, 0, 402, 3896, 1, 0, 0, 0, 404, 3936, 1, 0, 0, 0, 406, 3942, 1, 0, 0, 0, 408, 3944, 1, 0, 0, 0, 410, 3959, 1, 0, 0, 0, 412, 3964, 1, 0, 0, 0, 414, 3967, 1, 0, 0, 0, 416, 3971, 1, 0, 0, 0, 418, 3976, 1, 0, 0, 0, 420, 3978, 1, 0, 0, 0, 422, 3980, 1, 0, 0, 0, 424, 3987, 1, 0, 0, 0, 426, 3991, 1, 0, 0, 0, 428, 3993, 1, 0, 0, 0, 430, 4001, 1, 0, 0, 0, 432, 4003, 1, 0, 0, 0, 434, 4007, 1, 0, 0, 0, 436, 4020, 1, 0, 0, 0, 438, 4025, 1, 0, 0, 0, 440, 4030, 1, 0, 0, 0, 442, 4044, 1, 0, 0, 0, 444, 4072, 1, 0, 0, 0, 446, 4074, 1, 0, 0, 0, 448, 4082, 1, 0, 0, 0, 450, 4088, 1, 0, 0, 0, 452, 4096, 1, 0, 0, 0, 454, 4108, 1, 0, 0, 0, 456, 4110, 1, 0, 0, 0, 458, 4225, 1, 0, 0, 0, 460, 4227, 1, 0, 0, 0, 462, 4231, 1, 0, 0, 0, 464, 4239, 1, 0, 0, 0, 466, 4250, 1, 0, 0, 0, 468, 4252, 1, 0, 0, 0, 470, 4256, 1, 0, 0, 0, 472, 4264, 1, 0, 0, 0, 474, 4270, 1, 0, 0, 0, 476, 4272, 1, 0, 0, 0, 478, 4317, 1, 0, 0, 0, 480, 4323, 1, 0, 0, 0, 482, 4325, 1, 0, 0, 0, 484, 4339, 1, 0, 0, 0, 486, 4372, 1, 0, 0, 0, 488, 4376, 1, 0, 0, 0, 490, 4381, 1, 0, 0, 0, 492, 4390, 1, 0, 0, 0, 494, 4394, 1, 0, 0, 0, 496, 4396, 1, 0, 0, 0, 498, 4421, 1, 0, 0, 0, 500, 4423, 1, 0, 0, 0, 502, 4443, 1, 0, 0, 0, 504, 4463, 1, 0, 0, 0, 506, 4483, 1, 0, 0, 0, 508, 4485, 1, 0, 0, 0, 510, 4491, 1, 0, 0, 0, 512, 4576, 1, 0, 0, 0, 514, 4601, 1, 0, 0, 0, 516, 4608, 1, 0, 0, 0, 518, 4624, 1, 0, 0, 0, 520, 4626, 1, 0, 0, 0, 522, 4628, 1, 0, 0, 0, 524, 4636, 1, 0, 0, 0, 526, 4642, 1, 0, 0, 0, 528, 4646, 1, 0, 0, 0, 530, 4654, 1, 0, 0, 0, 532, 4665, 1, 0, 0, 0, 534, 4814, 1, 0, 0, 0, 536, 4818, 1, 0, 0, 0, 538, 4911, 1, 0, 0, 0, 540, 4916, 1, 0, 0, 0, 542, 4920, 1, 0, 0, 0, 544, 4926, 1, 0, 0, 0, 546, 4994, 1, 0, 0, 0, 548, 4996, 1, 0, 0, 0, 550, 5000, 1, 0, 0, 0, 552, 5002, 1, 0, 0, 0, 554, 5029, 1, 0, 0, 0, 556, 5046, 1, 0, 0, 0, 558, 5048, 1, 0, 0, 0, 560, 5065, 1, 0, 0, 0, 562, 5125, 1, 0, 0, 0, 564, 5127, 1, 0, 0, 0, 566, 5138, 1, 0, 0, 0, 568, 5144, 1, 0, 0, 0, 570, 5146, 1, 0, 0, 0, 572, 5170, 1, 0, 0, 0, 574, 5176, 1, 0, 0, 0, 576, 5182, 1, 0, 0, 0, 578, 5184, 1, 0, 0, 0, 580, 5193, 1, 0, 0, 0, 582, 5205, 1, 0, 0, 0, 584, 5234, 1, 0, 0, 0, 586, 5236, 1, 0, 0, 0, 588, 5273, 1, 0, 0, 0, 590, 5277, 1, 0, 0, 0, 592, 5281, 1, 0, 0, 0, 594, 5285, 1, 0, 0, 0, 596, 5290, 1, 0, 0, 0, 598, 5292, 1, 0, 0, 0, 600, 5311, 1, 0, 0, 0, 602, 5324, 1, 0, 0, 0, 604, 5332, 1, 0, 0, 0, 606, 5334, 1, 0, 0, 0, 608, 5345, 1, 0, 0, 0, 610, 5349, 1, 0, 0, 0, 612, 5354, 1, 0, 0, 0, 614, 5361, 1, 0, 0, 0, 616, 5363, 1, 0, 0, 0, 618, 5384, 1, 0, 0, 0, 620, 5386, 1, 0, 0, 0, 622, 5392, 1, 0, 0, 0, 624, 5400, 1, 0, 0, 0, 626, 5416, 1, 0, 0, 0, 628, 5418, 1, 0, 0, 0, 630, 5424, 1, 0, 0, 0, 632, 5445, 1, 0, 0, 0, 634, 5454, 1, 0, 0, 0, 636, 5460, 1, 0, 0, 0, 638, 5462, 1, 0, 0, 0, 640, 5478, 1, 0, 0, 0, 642, 5480, 1, 0, 0, 0, 644, 5485, 1, 0, 0, 0, 646, 5487, 1, 0, 0, 0, 648, 5502, 1, 0, 0, 0, 650, 5510, 1, 0, 0, 0, 652, 5513, 1, 0, 0, 0, 654, 5522, 1, 0, 0, 0, 656, 5563, 1, 0, 0, 0, 658, 5573, 1, 0, 0, 0, 660, 5580, 1, 0, 0, 0, 662, 5582, 1, 0, 0, 0, 664, 5597, 1, 0, 0, 0, 666, 5599, 1, 0, 0, 0, 668, 5602, 1, 0, 0, 0, 670, 5610, 1, 0, 0, 0, 672, 5617, 1, 0, 0, 0, 674, 5623, 1, 0, 0, 0, 676, 5661, 1, 0, 0, 0, 678, 5675, 1, 0, 0, 0, 680, 5689, 1, 0, 0, 0, 682, 5713, 1, 0, 0, 0, 684, 5720, 1, 0, 0, 0, 686, 5725, 1, 0, 0, 0, 688, 5733, 1, 0, 0, 0, 690, 5736, 1, 0, 0, 0, 692, 5740, 1, 0, 0, 0, 694, 5747, 1, 0, 0, 0, 696, 5783, 1, 0, 0, 0, 698, 5790, 1, 0, 0, 0, 700, 5792, 1, 0, 0, 0, 702, 5805, 1, 0, 0, 0, 704, 5807, 1, 0, 0, 0, 706, 5852, 1, 0, 0, 0, 708, 5854, 1, 0, 0, 0, 710, 5889, 1, 0, 0, 0, 712, 5891, 1, 0, 0, 0, 714, 5893, 1, 0, 0, 0, 716, 5895, 1, 0, 0, 0, 718, 5903, 1, 0, 0, 0, 720, 5917, 1, 0, 0, 0, 722, 6387, 1, 0, 0, 0, 724, 6391, 1, 0, 0, 0, 726, 6396, 1, 0, 0, 0, 728, 6455, 1, 0, 0, 0, 730, 6459, 1, 0, 0, 0, 732, 6678, 1, 0, 0, 0, 734, 6680, 1, 0, 0, 0, 736, 6688, 1, 0, 0, 0, 738, 6704, 1, 0, 0, 0, 740, 6711, 1, 0, 0, 0, 742, 6713, 1, 0, 0, 0, 744, 6904, 1, 0, 0, 0, 746, 6906, 1, 0, 0, 0, 748, 6914, 1, 0, 0, 0, 750, 6922, 1, 0, 0, 0, 752, 6951, 1, 0, 0, 0, 754, 6953, 1, 0, 0, 0, 756, 6962, 1, 0, 0, 0, 758, 6970, 1, 0, 0, 0, 760, 7009, 1, 0, 0, 0, 762, 7023, 1, 0, 0, 0, 764, 7025, 1, 0, 0, 0, 766, 7045, 1, 0, 0, 0, 768, 7047, 1, 0, 0, 0, 770, 7060, 1, 0, 0, 0, 772, 7064, 1, 0, 0, 0, 774, 7066, 1, 0, 0, 0, 776, 7071, 1, 0, 0, 0, 778, 7073, 1, 0, 0, 0, 780, 7080, 1, 0, 0, 0, 782, 7082, 1, 0, 0, 0, 784, 7089, 1, 0, 0, 0, 786, 7141, 1, 0, 0, 0, 788, 7146, 1, 0, 0, 0, 790, 7158, 1, 0, 0, 0, 792, 7160, 1, 0, 0, 0, 794, 7172, 1, 0, 0, 0, 796, 7180, 1, 0, 0, 0, 798, 7182, 1, 0, 0, 0, 800, 7214, 1, 0, 0, 0, 802, 7216, 1, 0, 0, 0, 804, 7219, 1, 0, 0, 0, 806, 7227, 1, 0, 0, 0, 808, 7230, 1, 0, 0, 0, 810, 7234, 1, 0, 0, 0, 812, 7249, 1, 0, 0, 0, 814, 7253, 1, 0, 0, 0, 816, 7255, 1, 0, 0, 0, 818, 7266, 1, 0, 0, 0, 820, 7271, 1, 0, 0, 0, 822, 7285, 1, 0, 0, 0, 824, 7293, 1, 0, 0, 0, 826, 7295, 1, 0, 0, 0, 828, 7301, 1, 0, 0, 0, 830, 7306, 1, 0, 0, 0, 832, 7313, 1, 0, 0, 0, 834, 7341, 1, 0, 0, 0, 836, 7343, 1, 0, 0, 0, 838, 7422, 1, 0, 0, 0, 840, 7424, 1, 0, 0, 0, 842, 7426, 1, 0, 0, 0, 844, 7450, 1, 0, 0, 0, 846, 7455, 1, 0, 0, 0, 848, 7470, 1, 0, 0, 0, 850, 7482, 1, 0, 0, 0, 852, 7484, 1, 0, 0, 0, 854, 7492, 1, 0, 0, 0, 856, 7494, 1, 0, 0, 0, 858, 7499, 1, 0, 0, 0, 860, 7504, 1, 0, 0, 0, 862, 7508, 1, 0, 0, 0, 864, 7512, 1, 0, 0, 0, 866, 7516, 1, 0, 0, 0, 868, 7520, 1, 0, 0, 0, 870, 7527, 1, 0, 0, 0, 872, 7529, 1, 0, 0, 0, 874, 7532, 1, 0, 0, 0, 876, 7542, 1, 0, 0, 0, 878, 7560, 1, 0, 0, 0, 880, 7571, 1, 0, 0, 0, 882, 7573, 1, 0, 0, 0, 884, 7581, 1, 0, 0, 0, 886, 7586, 1, 0, 0, 0, 888, 7591, 1, 0, 0, 0, 890, 7593, 1, 0, 0, 0, 892, 7604, 1, 0, 0, 0, 894, 7610, 1, 0, 0, 0, 896, 7639, 1, 0, 0, 0, 898, 7646, 1, 0, 0, 0, 900, 7658, 1, 0, 0, 0, 902, 7660, 1, 0, 0, 0, 904, 7668, 1, 0, 0, 0, 906, 7692, 1, 0, 0, 0, 908, 7694, 1, 0, 0, 0, 910, 7696, 1, 0, 0, 0, 912, 7704, 1, 0, 0, 0, 914, 7720, 1, 0, 0, 0, 916, 7731, 1, 0, 0, 0, 918, 7736, 1, 0, 0, 0, 920, 7738, 1, 0, 0, 0, 922, 7769, 1, 0, 0, 0, 924, 7788, 1, 0, 0, 0, 926, 7801, 1, 0, 0, 0, 928, 7808, 1, 0, 0, 0, 930, 7819, 1, 0, 0, 0, 932, 7821, 1, 0, 0, 0, 934, 7832, 1, 0, 0, 0, 936, 7846, 1, 0, 0, 0, 938, 7850, 1, 0, 0, 0, 940, 7856, 1, 0, 0, 0, 942, 7858, 1, 0, 0, 0, 944, 7867, 1, 0, 0, 0, 946, 7885, 1, 0, 0, 0, 948, 7887, 1, 0, 0, 0, 950, 7890, 1, 0, 0, 0, 952, 7898, 1, 0, 0, 0, 954, 7906, 1, 0, 0, 0, 956, 7915, 1, 0, 0, 0, 958, 7923, 1, 0, 0, 0, 960, 7927, 1, 0, 0, 0, 962, 7937, 1, 0, 0, 0, 964, 7960, 1, 0, 0, 0, 966, 7962, 1, 0, 0, 0, 968, 7972, 1, 0, 0, 0, 970, 8003, 1, 0, 0, 0, 972, 8005, 1, 0, 0, 0, 974, 8011, 1, 0, 0, 0, 976, 8019, 1, 0, 0, 0, 978, 8031, 1, 0, 0, 0, 980, 8035, 1, 0, 0, 0, 982, 8045, 1, 0, 0, 0, 984, 8049, 1, 0, 0, 0, 986, 8065, 1, 0, 0, 0, 988, 8069, 1, 0, 0, 0, 990, 8074, 1, 0, 0, 0, 992, 8076, 1, 0, 0, 0, 994, 8086, 1, 0, 0, 0, 996, 8090, 1, 0, 0, 0, 998, 8092, 1, 0, 0, 0, 1000, 8096, 1, 0, 0, 0, 1002, 8104, 1, 0, 0, 0, 1004, 8120, 1, 0, 0, 0, 1006, 8124, 1, 0, 0, 0, 1008, 8149, 1, 0, 0, 0, 1010, 8151, 1, 0, 0, 0, 1012, 8160, 1, 0, 0, 0, 1014, 8162, 1, 0, 0, 0, 1016, 8169, 1, 0, 0, 0, 1018, 8173, 1, 0, 0, 0, 1020, 8175, 1, 0, 0, 0, 1022, 8177, 1, 0, 0, 0, 1024, 8183, 1, 0, 0, 0, 1026, 8185, 1, 0, 0, 0, 1028, 8198, 1, 0, 0, 0, 1030, 8200, 1, 0, 0, 0, 1032, 8203, 1, 0, 0, 0, 1034, 8208, 1, 0, 0, 0, 1036, 8213, 1, 0, 0, 0, 1038, 8222, 1, 0, 0, 0, 1040, 8228, 1, 0, 0, 0, 1042, 8232, 1, 0, 0, 0, 1044, 8235, 1, 0, 0, 0, 1046, 8239, 1, 0, 0, 0, 1048, 8243, 1, 0, 0, 0, 1050, 8258, 1, 0, 0, 0, 1052, 8260, 1, 0, 0, 0, 1054, 8277, 1, 0, 0, 0, 1056, 8288, 1, 0, 0, 0, 1058, 8290, 1, 0, 0, 0, 1060, 8346, 1, 0, 0, 0, 1062, 8370, 1, 0, 0, 0, 1064, 8381, 1, 0, 0, 0, 1066, 8384, 1, 0, 0, 0, 1068, 8406, 1, 0, 0, 0, 1070, 8408, 1, 0, 0, 0, 1072, 8419, 1, 0, 0, 0, 1074, 8433, 1, 0, 0, 0, 1076, 8435, 1, 0, 0, 0, 1078, 8443, 1, 0, 0, 0, 1080, 8450, 1, 0, 0, 0, 1082, 8463, 1, 0, 0, 0, 1084, 8475, 1, 0, 0, 0, 1086, 8477, 1, 0, 0, 0, 1088, 8480, 1, 0, 0, 0, 1090, 8494, 1, 0, 0, 0, 1092, 8499, 1, 0, 0, 0, 1094, 8504, 1, 0, 0, 0, 1096, 8514, 1, 0, 0, 0, 1098, 8518, 1, 0, 0, 0, 1100, 8520, 1, 0, 0, 0, 1102, 8528, 1, 0, 0, 0, 1104, 8532, 1, 0, 0, 0, 1106, 8553, 1, 0, 0, 0, 1108, 8561, 1, 0, 0, 0, 1110, 8571, 1, 0, 0, 0, 1112, 8583, 1, 0, 0, 0, 1114, 8585, 1, 0, 0, 0, 1116, 8599, 1, 0, 0, 0, 1118, 8619, 1, 0, 0, 0, 1120, 8628, 1, 0, 0, 0, 1122, 8644, 1, 0, 0, 0, 1124, 8650, 1, 0, 0, 0, 1126, 8656, 1, 0, 0, 0, 1128, 8668, 1, 0, 0, 0, 1130, 8686, 1, 0, 0, 0, 1132, 8693, 1, 0, 0, 0, 1134, 8697, 1, 0, 0, 0, 1136, 8701, 1, 0, 0, 0, 1138, 8703, 1, 0, 0, 0, 1140, 8709, 1, 0, 0, 0, 1142, 8712, 1, 0, 0, 0, 1144, 8719, 1, 0, 0, 0, 1146, 8732, 1, 0, 0, 0, 1148, 8736, 1, 0, 0, 0, 1150, 8738, 1, 0, 0, 0, 1152, 8747, 1, 0, 0, 0, 1154, 8756, 1, 0, 0, 0, 1156, 8784, 1, 0, 0, 0, 1158, 8786, 1, 0, 0, 0, 1160, 8796, 1, 0, 0, 0, 1162, 8798, 1, 0, 0, 0, 1164, 8800, 1, 0, 0, 0, 1166, 8804, 1, 0, 0, 0, 1168, 8812, 1, 0, 0, 0, 1170, 8820, 1, 0, 0, 0, 1172, 8828, 1, 0, 0, 0, 1174, 8842, 1, 0, 0, 0, 1176, 8851, 1, 0, 0, 0, 1178, 8855, 1, 0, 0, 0, 1180, 8859, 1, 0, 0, 0, 1182, 8885, 1, 0, 0, 0, 1184, 8899, 1, 0, 0, 0, 1186, 8914, 1, 0, 0, 0, 1188, 8924, 1, 0, 0, 0, 1190, 8928, 1, 0, 0, 0, 1192, 8936, 1, 0, 0, 0, 1194, 8944, 1, 0, 0, 0, 1196, 8950, 1, 0, 0, 0, 1198, 8954, 1, 0, 0, 0, 1200, 8961, 1, 0, 0, 0, 1202, 8966, 1, 0, 0, 0, 1204, 8981, 1, 0, 0, 0, 1206, 9061, 1, 0, 0, 0, 1208, 9063, 1, 0, 0, 0, 1210, 9065, 1, 0, 0, 0, 1212, 9095, 1, 0, 0, 0, 1214, 9099, 1, 0, 0, 0, 1216, 9278, 1, 0, 0, 0, 1218, 9285, 1, 0, 0, 0, 1220, 9298, 1, 0, 0, 0, 1222, 9300, 1, 0, 0, 0, 1224, 9305, 1, 0, 0, 0, 1226, 9313, 1, 0, 0, 0, 1228, 9318, 1, 0, 0, 0, 1230, 9325, 1, 0, 0, 0, 1232, 9342, 1, 0, 0, 0, 1234, 9344, 1, 0, 0, 0, 1236, 9354, 1, 0, 0, 0, 1238, 9363, 1, 0, 0, 0, 1240, 9368, 1, 0, 0, 0, 1242, 9370, 1, 0, 0, 0, 1244, 9378, 1, 0, 0, 0, 1246, 9388, 1, 0, 0, 0, 1248, 9390, 1, 0, 0, 0, 1250, 9399, 1, 0, 0, 0, 1252, 9405, 1, 0, 0, 0, 1254, 9420, 1, 0, 0, 0, 1256, 9428, 1, 0, 0, 0, 1258, 9437, 1, 0, 0, 0, 1260, 9449, 1, 0, 0, 0, 1262, 9463, 1, 0, 0, 0, 1264, 9465, 1, 0, 0, 0, 1266, 9472, 1, 0, 0, 0, 1268, 9478, 1, 0, 0, 0, 1270, 9482, 1, 0, 0, 0, 1272, 9484, 1, 0, 0, 0, 1274, 9492, 1, 0, 0, 0, 1276, 9500, 1, 0, 0, 0, 1278, 9514, 1, 0, 0, 0, 1280, 9516, 1, 0, 0, 0, 1282, 9524, 1, 0, 0, 0, 1284, 9537, 1, 0, 0, 0, 1286, 9539, 1, 0, 0, 0, 1288, 9547, 1, 0, 0, 0, 1290, 9554, 1, 0, 0, 0, 1292, 9567, 1, 0, 0, 0, 1294, 9577, 1, 0, 0, 0, 1296, 9579, 1, 0, 0, 0, 1298, 9581, 1, 0, 0, 0, 1300, 9595, 1, 0, 0, 0, 1302, 9624, 1, 0, 0, 0, 1304, 9633, 1, 0, 0, 0, 1306, 9640, 1, 0, 0, 0, 1308, 9642, 1, 0, 0, 0, 1310, 9649, 1, 0, 0, 0, 1312, 9653, 1, 0, 0, 0, 1314, 9661, 1, 0, 0, 0, 1316, 9665, 1, 0, 0, 0, 1318, 9667, 1, 0, 0, 0, 1320, 9686, 1, 0, 0, 0, 1322, 9690, 1, 0, 0, 0, 1324, 9693, 1, 0, 0, 0, 1326, 9700, 1, 0, 0, 0, 1328, 9705, 1, 0, 0, 0, 1330, 9707, 1, 0, 0, 0, 1332, 9723, 1, 0, 0, 0, 1334, 9725, 1, 0, 0, 0, 1336, 9733, 1, 0, 0, 0, 1338, 9737, 1, 0, 0, 0, 1340, 9745, 1, 0, 0, 0, 1342, 9747, 1, 0, 0, 0, 1344, 9749, 1, 0, 0, 0, 1346, 9758, 1, 0, 0, 0, 1348, 9792, 1, 0, 0, 0, 1350, 9794, 1, 0, 0, 0, 1352, 9796, 1, 0, 0, 0, 1354, 9798, 1, 0, 0, 0, 1356, 9800, 1, 0, 0, 0, 1358, 9802, 1, 0, 0, 0, 1360, 9816, 1, 0, 0, 0, 1362, 9821, 1, 0, 0, 0, 1364, 9828, 1, 0, 0, 0, 1366, 9830, 1, 0, 0, 0, 1368, 9835, 1, 0, 0, 0, 1370, 9837, 1, 0, 0, 0, 1372, 9851, 1, 0, 0, 0, 1374, 9857, 1, 0, 0, 0, 1376, 9863, 1, 0, 0, 0, 1378, 9869, 1, 0, 0, 0, 1380, 9877, 1, 0, 0, 0, 1382, 9886, 1, 0, 0, 0, 1384, 9888, 1, 0, 0, 0, 1386, 9890, 1, 0, 0, 0, 1388, 9944, 1, 0, 0, 0, 1390, 9946, 1, 0, 0, 0, 1392, 9948, 1, 0, 0, 0, 1394, 9950, 1, 0, 0, 0, 1396, 9952, 1, 0, 0, 0, 1398, 9959, 1, 0, 0, 0, 1400, 9982, 1, 0, 0, 0, 1402, 9984, 1, 0, 0, 0, 1404, 9990, 1, 0, 0, 0, 1406, 9994, 1, 0, 0, 0, 1408, 9996, 1, 0, 0, 0, 1410, 10003, 1, 0, 0, 0, 1412, 10010, 1, 0, 0, 0, 1414, 10013, 1, 0, 0, 0, 1416, 10017, 1, 0, 0, 0, 1418, 10024, 1, 0, 0, 0, 1420, 10026, 1, 0, 0, 0, 1422, 10050, 1, 0, 0, 0, 1424, 10052, 1, 0, 0, 0, 1426, 10059, 1, 0, 0, 0, 1428, 10061, 1, 0, 0, 0, 1430, 10069, 1, 0, 0, 0, 1432, 10072, 1, 0, 0, 0, 1434, 10076, 1, 0, 0, 0, 1436, 10078, 1, 0, 0, 0, 1438, 10082, 1, 0, 0, 0, 1440, 10084, 1, 0, 0, 0, 1442, 10089, 1, 0, 0, 0, 1444, 10094, 1, 0, 0, 0, 1446, 10100, 1, 0, 0, 0, 1448, 10104, 1, 0, 0, 0, 1450, 10106, 1, 0, 0, 0, 1452, 10111, 1, 0, 0, 0, 1454, 10141, 1, 0, 0, 0, 1456, 10143, 1, 0, 0, 0, 1458, 10161, 1, 0, 0, 0, 1460, 10165, 1, 0, 0, 0, 1462, 10167, 1, 0, 0, 0, 1464, 10172, 1, 0, 0, 0, 1466, 10181, 1, 0, 0, 0, 1468, 10183, 1, 0, 0, 0, 1470, 10191, 1, 0, 0, 0, 1472, 10195, 1, 0, 0, 0, 1474, 10197, 1, 0, 0, 0, 1476, 10201, 1, 0, 0, 0, 1478, 10212, 1, 0, 0, 0, 1480, 10229, 1, 0, 0, 0, 1482, 10235, 1, 0, 0, 0, 1484, 10237, 1, 0, 0, 0, 1486, 10247, 1, 0, 0, 0, 1488, 10250, 1, 0, 0, 0, 1490, 10254, 1, 0, 0, 0, 1492, 10262, 1, 0, 0, 0, 1494, 10264, 1, 0, 0, 0, 1496, 10267, 1, 0, 0, 0, 1498, 10272, 1, 0, 0, 0, 1500, 10277, 1, 0, 0, 0, 1502, 10299, 1, 0, 0, 0, 1504, 10313, 1, 0, 0, 0, 1506, 10317, 1, 0, 0, 0, 1508, 10322, 1, 0, 0, 0, 1510, 10324, 1, 0, 0, 0, 1512, 10326, 1, 0, 0, 0, 1514, 10338, 1, 0, 0, 0, 1516, 10340, 1, 0, 0, 0, 1518, 10345, 1, 0, 0, 0, 1520, 10347, 1, 0, 0, 0, 1522, 10365, 1, 0, 0, 0, 1524, 10393, 1, 0, 0, 0, 1526, 10403, 1, 0, 0, 0, 1528, 10412, 1, 0, 0, 0, 1530, 10417, 1, 0, 0, 0, 1532, 10419, 1, 0, 0, 0, 1534, 10423, 1, 0, 0, 0, 1536, 10431, 1, 0, 0, 0, 1538, 10439, 1, 0, 0, 0, 1540, 10441, 1, 0, 0, 0, 1542, 10448, 1, 0, 0, 0, 1544, 10451, 1, 0, 0, 0, 1546, 10467, 1, 0, 0, 0, 1548, 10469, 1, 0, 0, 0, 1550, 10483, 1, 0, 0, 0, 1552, 10485, 1, 0, 0, 0, 1554, 10512, 1, 0, 0, 0, 1556, 10514, 1, 0, 0, 0, 1558, 10525, 1, 0, 0, 0, 1560, 10531, 1, 0, 0, 0, 1562, 10535, 1, 0, 0, 0, 1564, 10537, 1, 0, 0, 0, 1566, 10545, 1, 0, 0, 0, 1568, 10550, 1, 0, 0, 0, 1570, 10569, 1, 0, 0, 0, 1572, 10571, 1, 0, 0, 0, 1574, 10576, 1, 0, 0, 0, 1576, 10580, 1, 0, 0, 0, 1578, 10583, 1, 0, 0, 0, 1580, 10587, 1, 0, 0, 0, 1582, 10597, 1, 0, 0, 0, 1584, 10611, 1, 0, 0, 0, 1586, 10615, 1, 0, 0, 0, 1588, 10620, 1, 0, 0, 0, 1590, 10623, 1, 0, 0, 0, 1592, 10627, 1, 0, 0, 0, 1594, 10632, 1, 0, 0, 0, 1596, 10643, 1, 0, 0, 0, 1598, 10647, 1, 0, 0, 0, 1600, 10651, 1, 0, 0, 0, 1602, 10655, 1, 0, 0, 0, 1604, 10660, 1, 0, 0, 0, 1606, 10664, 1, 0, 0, 0, 1608, 10666, 1, 0, 0, 0, 1610, 10668, 1, 0, 0, 0, 1612, 10676, 1, 0, 0, 0, 1614, 10678, 1, 0, 0, 0, 1616, 10680, 1, 0, 0, 0, 1618, 10682, 1, 0, 0, 0, 1620, 10684, 1, 0, 0, 0, 1622, 10692, 1, 0, 0, 0, 1624, 1625, 3, 4, 2, 0, 1625, 1626, 5, 0, 0, 1, 1626, 1, 1, 0, 0, 0, 1627, 1628, 3, 1396, 698, 0, 1628, 3, 1, 0, 0, 0, 1629, 1630, 3, 6, 3, 0, 1630, 5, 1, 0, 0, 0, 1631, 1633, 3, 8, 4, 0, 1632, 1634, 5, 7, 0, 0, 1633, 1632, 1, 0, 0, 0, 1633, 1634, 1, 0, 0, 0, 1634, 1636, 1, 0, 0, 0, 1635, 1631, 1, 0, 0, 0, 1636, 1639, 1, 0, 0, 0, 1637, 1635, 1, 0, 0, 0, 1637, 1638, 1, 0, 0, 0, 1638, 7, 1, 0, 0, 0, 1639, 1637, 1, 0, 0, 0, 1640, 1766, 3, 452, 226, 0, 1641, 1766, 3, 826, 413, 0, 1642, 1766, 3, 816, 408, 0, 1643, 1766, 3, 818, 409, 0, 1644, 1766, 3, 578, 289, 0, 1645, 1766, 3, 832, 416, 0, 1646, 1766, 3, 478, 239, 0, 1647, 1766, 3, 322, 161, 0, 1648, 1766, 3, 328, 164, 0, 1649, 1766, 3, 338, 169, 0, 1650, 1766, 3, 364, 182, 0, 1651, 1766, 3, 670, 335, 0, 1652, 1766, 3, 38, 19, 0, 1653, 1766, 3, 728, 364, 0, 1654, 1766, 3, 732, 366, 0, 1655, 1766, 3, 744, 372, 0, 1656, 1766, 3, 734, 367, 0, 1657, 1766, 3, 742, 371, 0, 1658, 1766, 3, 384, 192, 0, 1659, 1766, 3, 280, 140, 0, 1660, 1766, 3, 828, 414, 0, 1661, 1766, 3, 96, 48, 0, 1662, 1766, 3, 720, 360, 0, 1663, 1766, 3, 134, 67, 0, 1664, 1766, 3, 752, 376, 0, 1665, 1766, 3, 32, 16, 0, 1666, 1766, 3, 28, 14, 0, 1667, 1766, 3, 760, 380, 0, 1668, 1766, 3, 262, 131, 0, 1669, 1766, 3, 838, 419, 0, 1670, 1766, 3, 836, 418, 0, 1671, 1766, 3, 380, 190, 0, 1672, 1766, 3, 850, 425, 0, 1673, 1766, 3, 12, 6, 0, 1674, 1766, 3, 92, 46, 0, 1675, 1766, 3, 140, 70, 0, 1676, 1766, 3, 844, 422, 0, 1677, 1766, 3, 534, 267, 0, 1678, 1766, 3, 86, 43, 0, 1679, 1766, 3, 142, 71, 0, 1680, 1766, 3, 400, 200, 0, 1681, 1766, 3, 264, 132, 0, 1682, 1766, 3, 456, 228, 0, 1683, 1766, 3, 696, 348, 0, 1684, 1766, 3, 842, 421, 0, 1685, 1766, 3, 830, 415, 0, 1686, 1766, 3, 316, 158, 0, 1687, 1766, 3, 330, 165, 0, 1688, 1766, 3, 356, 178, 0, 1689, 1766, 3, 366, 183, 0, 1690, 1766, 3, 616, 308, 0, 1691, 1766, 3, 36, 18, 0, 1692, 1766, 3, 270, 135, 0, 1693, 1766, 3, 482, 241, 0, 1694, 1766, 3, 496, 248, 0, 1695, 1766, 3, 746, 373, 0, 1696, 1766, 3, 498, 249, 0, 1697, 1766, 3, 382, 191, 0, 1698, 1766, 3, 296, 148, 0, 1699, 1766, 3, 42, 21, 0, 1700, 1766, 3, 278, 139, 0, 1701, 1766, 3, 172, 86, 0, 1702, 1766, 3, 754, 377, 0, 1703, 1766, 3, 260, 130, 0, 1704, 1766, 3, 310, 155, 0, 1705, 1766, 3, 704, 352, 0, 1706, 1766, 3, 404, 202, 0, 1707, 1766, 3, 444, 222, 0, 1708, 1766, 3, 14, 7, 0, 1709, 1766, 3, 26, 13, 0, 1710, 1766, 3, 374, 187, 0, 1711, 1766, 3, 804, 402, 0, 1712, 1766, 3, 900, 450, 0, 1713, 1766, 3, 952, 476, 0, 1714, 1766, 3, 458, 229, 0, 1715, 1766, 3, 928, 464, 0, 1716, 1766, 3, 94, 47, 0, 1717, 1766, 3, 690, 345, 0, 1718, 1766, 3, 700, 350, 0, 1719, 1766, 3, 504, 252, 0, 1720, 1766, 3, 506, 253, 0, 1721, 1766, 3, 508, 254, 0, 1722, 1766, 3, 512, 256, 0, 1723, 1766, 3, 762, 381, 0, 1724, 1766, 3, 314, 157, 0, 1725, 1766, 3, 708, 354, 0, 1726, 1766, 3, 34, 17, 0, 1727, 1766, 3, 378, 189, 0, 1728, 1766, 3, 820, 410, 0, 1729, 1766, 3, 896, 448, 0, 1730, 1766, 3, 878, 439, 0, 1731, 1766, 3, 544, 272, 0, 1732, 1766, 3, 552, 276, 0, 1733, 1766, 3, 570, 285, 0, 1734, 1766, 3, 368, 184, 0, 1735, 1766, 3, 588, 294, 0, 1736, 1766, 3, 902, 451, 0, 1737, 1766, 3, 920, 460, 0, 1738, 1766, 3, 782, 391, 0, 1739, 1766, 3, 276, 138, 0, 1740, 1766, 3, 802, 401, 0, 1741, 1766, 3, 932, 466, 0, 1742, 1766, 3, 778, 389, 0, 1743, 1766, 3, 890, 445, 0, 1744, 1766, 3, 510, 255, 0, 1745, 1766, 3, 710, 355, 0, 1746, 1766, 3, 678, 339, 0, 1747, 1766, 3, 676, 338, 0, 1748, 1766, 3, 680, 340, 0, 1749, 1766, 3, 722, 361, 0, 1750, 1766, 3, 554, 277, 0, 1751, 1766, 3, 572, 286, 0, 1752, 1766, 3, 764, 382, 0, 1753, 1766, 3, 538, 269, 0, 1754, 1766, 3, 960, 480, 0, 1755, 1766, 3, 786, 393, 0, 1756, 1766, 3, 530, 265, 0, 1757, 1766, 3, 784, 392, 0, 1758, 1766, 3, 942, 471, 0, 1759, 1766, 3, 848, 424, 0, 1760, 1766, 3, 74, 37, 0, 1761, 1766, 3, 50, 25, 0, 1762, 1766, 3, 84, 42, 0, 1763, 1766, 3, 798, 399, 0, 1764, 1766, 3, 10, 5, 0, 1765, 1640, 1, 0, 0, 0, 1765, 1641, 1, 0, 0, 0, 1765, 1642, 1, 0, 0, 0, 1765, 1643, 1, 0, 0, 0, 1765, 1644, 1, 0, 0, 0, 1765, 1645, 1, 0, 0, 0, 1765, 1646, 1, 0, 0, 0, 1765, 1647, 1, 0, 0, 0, 1765, 1648, 1, 0, 0, 0, 1765, 1649, 1, 0, 0, 0, 1765, 1650, 1, 0, 0, 0, 1765, 1651, 1, 0, 0, 0, 1765, 1652, 1, 0, 0, 0, 1765, 1653, 1, 0, 0, 0, 1765, 1654, 1, 0, 0, 0, 1765, 1655, 1, 0, 0, 0, 1765, 1656, 1, 0, 0, 0, 1765, 1657, 1, 0, 0, 0, 1765, 1658, 1, 0, 0, 0, 1765, 1659, 1, 0, 0, 0, 1765, 1660, 1, 0, 0, 0, 1765, 1661, 1, 0, 0, 0, 1765, 1662, 1, 0, 0, 0, 1765, 1663, 1, 0, 0, 0, 1765, 1664, 1, 0, 0, 0, 1765, 1665, 1, 0, 0, 0, 1765, 1666, 1, 0, 0, 0, 1765, 1667, 1, 0, 0, 0, 1765, 1668, 1, 0, 0, 0, 1765, 1669, 1, 0, 0, 0, 1765, 1670, 1, 0, 0, 0, 1765, 1671, 1, 0, 0, 0, 1765, 1672, 1, 0, 0, 0, 1765, 1673, 1, 0, 0, 0, 1765, 1674, 1, 0, 0, 0, 1765, 1675, 1, 0, 0, 0, 1765, 1676, 1, 0, 0, 0, 1765, 1677, 1, 0, 0, 0, 1765, 1678, 1, 0, 0, 0, 1765, 1679, 1, 0, 0, 0, 1765, 1680, 1, 0, 0, 0, 1765, 1681, 1, 0, 0, 0, 1765, 1682, 1, 0, 0, 0, 1765, 1683, 1, 0, 0, 0, 1765, 1684, 1, 0, 0, 0, 1765, 1685, 1, 0, 0, 0, 1765, 1686, 1, 0, 0, 0, 1765, 1687, 1, 0, 0, 0, 1765, 1688, 1, 0, 0, 0, 1765, 1689, 1, 0, 0, 0, 1765, 1690, 1, 0, 0, 0, 1765, 1691, 1, 0, 0, 0, 1765, 1692, 1, 0, 0, 0, 1765, 1693, 1, 0, 0, 0, 1765, 1694, 1, 0, 0, 0, 1765, 1695, 1, 0, 0, 0, 1765, 1696, 1, 0, 0, 0, 1765, 1697, 1, 0, 0, 0, 1765, 1698, 1, 0, 0, 0, 1765, 1699, 1, 0, 0, 0, 1765, 1700, 1, 0, 0, 0, 1765, 1701, 1, 0, 0, 0, 1765, 1702, 1, 0, 0, 0, 1765, 1703, 1, 0, 0, 0, 1765, 1704, 1, 0, 0, 0, 1765, 1705, 1, 0, 0, 0, 1765, 1706, 1, 0, 0, 0, 1765, 1707, 1, 0, 0, 0, 1765, 1708, 1, 0, 0, 0, 1765, 1709, 1, 0, 0, 0, 1765, 1710, 1, 0, 0, 0, 1765, 1711, 1, 0, 0, 0, 1765, 1712, 1, 0, 0, 0, 1765, 1713, 1, 0, 0, 0, 1765, 1714, 1, 0, 0, 0, 1765, 1715, 1, 0, 0, 0, 1765, 1716, 1, 0, 0, 0, 1765, 1717, 1, 0, 0, 0, 1765, 1718, 1, 0, 0, 0, 1765, 1719, 1, 0, 0, 0, 1765, 1720, 1, 0, 0, 0, 1765, 1721, 1, 0, 0, 0, 1765, 1722, 1, 0, 0, 0, 1765, 1723, 1, 0, 0, 0, 1765, 1724, 1, 0, 0, 0, 1765, 1725, 1, 0, 0, 0, 1765, 1726, 1, 0, 0, 0, 1765, 1727, 1, 0, 0, 0, 1765, 1728, 1, 0, 0, 0, 1765, 1729, 1, 0, 0, 0, 1765, 1730, 1, 0, 0, 0, 1765, 1731, 1, 0, 0, 0, 1765, 1732, 1, 0, 0, 0, 1765, 1733, 1, 0, 0, 0, 1765, 1734, 1, 0, 0, 0, 1765, 1735, 1, 0, 0, 0, 1765, 1736, 1, 0, 0, 0, 1765, 1737, 1, 0, 0, 0, 1765, 1738, 1, 0, 0, 0, 1765, 1739, 1, 0, 0, 0, 1765, 1740, 1, 0, 0, 0, 1765, 1741, 1, 0, 0, 0, 1765, 1742, 1, 0, 0, 0, 1765, 1743, 1, 0, 0, 0, 1765, 1744, 1, 0, 0, 0, 1765, 1745, 1, 0, 0, 0, 1765, 1746, 1, 0, 0, 0, 1765, 1747, 1, 0, 0, 0, 1765, 1748, 1, 0, 0, 0, 1765, 1749, 1, 0, 0, 0, 1765, 1750, 1, 0, 0, 0, 1765, 1751, 1, 0, 0, 0, 1765, 1752, 1, 0, 0, 0, 1765, 1753, 1, 0, 0, 0, 1765, 1754, 1, 0, 0, 0, 1765, 1755, 1, 0, 0, 0, 1765, 1756, 1, 0, 0, 0, 1765, 1757, 1, 0, 0, 0, 1765, 1758, 1, 0, 0, 0, 1765, 1759, 1, 0, 0, 0, 1765, 1760, 1, 0, 0, 0, 1765, 1761, 1, 0, 0, 0, 1765, 1762, 1, 0, 0, 0, 1765, 1763, 1, 0, 0, 0, 1765, 1764, 1, 0, 0, 0, 1766, 9, 1, 0, 0, 0, 1767, 1769, 5, 668, 0, 0, 1768, 1770, 5, 669, 0, 0, 1769, 1768, 1, 0, 0, 0, 1769, 1770, 1, 0, 0, 0, 1770, 11, 1, 0, 0, 0, 1771, 1772, 5, 433, 0, 0, 1772, 1773, 3, 1210, 605, 0, 1773, 13, 1, 0, 0, 0, 1774, 1775, 5, 46, 0, 0, 1775, 1776, 5, 311, 0, 0, 1776, 1777, 3, 1366, 683, 0, 1777, 1778, 3, 16, 8, 0, 1778, 1779, 3, 18, 9, 0, 1779, 15, 1, 0, 0, 0, 1780, 1783, 5, 105, 0, 0, 1781, 1783, 1, 0, 0, 0, 1782, 1780, 1, 0, 0, 0, 1782, 1781, 1, 0, 0, 0, 1783, 17, 1, 0, 0, 0, 1784, 1786, 3, 24, 12, 0, 1785, 1784, 1, 0, 0, 0, 1786, 1789, 1, 0, 0, 0, 1787, 1785, 1, 0, 0, 0, 1787, 1788, 1, 0, 0, 0, 1788, 19, 1, 0, 0, 0, 1789, 1787, 1, 0, 0, 0, 1790, 1792, 3, 22, 11, 0, 1791, 1790, 1, 0, 0, 0, 1792, 1795, 1, 0, 0, 0, 1793, 1791, 1, 0, 0, 0, 1793, 1794, 1, 0, 0, 0, 1794, 21, 1, 0, 0, 0, 1795, 1793, 1, 0, 0, 0, 1796, 1799, 5, 280, 0, 0, 1797, 1800, 3, 1358, 679, 0, 1798, 1800, 5, 78, 0, 0, 1799, 1797, 1, 0, 0, 0, 1799, 1798, 1, 0, 0, 0, 1800, 1815, 1, 0, 0, 0, 1801, 1802, 7, 0, 0, 0, 1802, 1803, 5, 280, 0, 0, 1803, 1815, 3, 1358, 679, 0, 1804, 1815, 5, 228, 0, 0, 1805, 1806, 5, 164, 0, 0, 1806, 1807, 5, 74, 0, 0, 1807, 1815, 3, 1364, 682, 0, 1808, 1809, 5, 364, 0, 0, 1809, 1810, 5, 361, 0, 0, 1810, 1815, 3, 1358, 679, 0, 1811, 1812, 5, 99, 0, 0, 1812, 1815, 3, 1370, 685, 0, 1813, 1815, 3, 1382, 691, 0, 1814, 1796, 1, 0, 0, 0, 1814, 1801, 1, 0, 0, 0, 1814, 1804, 1, 0, 0, 0, 1814, 1805, 1, 0, 0, 0, 1814, 1808, 1, 0, 0, 0, 1814, 1811, 1, 0, 0, 0, 1814, 1813, 1, 0, 0, 0, 1815, 23, 1, 0, 0, 0, 1816, 1827, 3, 22, 11, 0, 1817, 1818, 5, 341, 0, 0, 1818, 1827, 3, 1356, 678, 0, 1819, 1820, 5, 134, 0, 0, 1820, 1827, 3, 1370, 685, 0, 1821, 1822, 5, 311, 0, 0, 1822, 1827, 3, 1370, 685, 0, 1823, 1824, 5, 68, 0, 0, 1824, 1825, 7, 1, 0, 0, 1825, 1827, 3, 1370, 685, 0, 1826, 1816, 1, 0, 0, 0, 1826, 1817, 1, 0, 0, 0, 1826, 1819, 1, 0, 0, 0, 1826, 1821, 1, 0, 0, 0, 1826, 1823, 1, 0, 0, 0, 1827, 25, 1, 0, 0, 0, 1828, 1829, 5, 46, 0, 0, 1829, 1830, 5, 99, 0, 0, 1830, 1831, 3, 1366, 683, 0, 1831, 1832, 3, 16, 8, 0, 1832, 1833, 3, 18, 9, 0, 1833, 27, 1, 0, 0, 0, 1834, 1835, 5, 138, 0, 0, 1835, 1836, 7, 2, 0, 0, 1836, 1837, 3, 1368, 684, 0, 1837, 1838, 3, 16, 8, 0, 1838, 1839, 3, 20, 10, 0, 1839, 29, 1, 0, 0, 0, 1840, 1845, 1, 0, 0, 0, 1841, 1842, 5, 68, 0, 0, 1842, 1843, 5, 175, 0, 0, 1843, 1845, 3, 1340, 670, 0, 1844, 1840, 1, 0, 0, 0, 1844, 1841, 1, 0, 0, 0, 1845, 31, 1, 0, 0, 0, 1846, 1847, 5, 138, 0, 0, 1847, 1849, 7, 2, 0, 0, 1848, 1850, 5, 30, 0, 0, 1849, 1848, 1, 0, 0, 0, 1849, 1850, 1, 0, 0, 0, 1850, 1851, 1, 0, 0, 0, 1851, 1852, 3, 1368, 684, 0, 1852, 1853, 3, 30, 15, 0, 1853, 1854, 3, 80, 40, 0, 1854, 33, 1, 0, 0, 0, 1855, 1856, 5, 191, 0, 0, 1856, 1859, 7, 3, 0, 0, 1857, 1858, 5, 220, 0, 0, 1858, 1860, 5, 389, 0, 0, 1859, 1857, 1, 0, 0, 0, 1859, 1860, 1, 0, 0, 0, 1860, 1861, 1, 0, 0, 0, 1861, 1862, 3, 1370, 685, 0, 1862, 35, 1, 0, 0, 0, 1863, 1864, 5, 46, 0, 0, 1864, 1865, 5, 66, 0, 0, 1865, 1866, 3, 1366, 683, 0, 1866, 1867, 3, 16, 8, 0, 1867, 1868, 3, 18, 9, 0, 1868, 37, 1, 0, 0, 0, 1869, 1870, 5, 138, 0, 0, 1870, 1871, 5, 66, 0, 0, 1871, 1872, 3, 1368, 684, 0, 1872, 1873, 3, 40, 20, 0, 1873, 1874, 5, 99, 0, 0, 1874, 1875, 3, 1370, 685, 0, 1875, 39, 1, 0, 0, 0, 1876, 1877, 7, 4, 0, 0, 1877, 41, 1, 0, 0, 0, 1878, 1879, 5, 46, 0, 0, 1879, 1883, 5, 316, 0, 0, 1880, 1881, 5, 220, 0, 0, 1881, 1882, 5, 77, 0, 0, 1882, 1884, 5, 389, 0, 0, 1883, 1880, 1, 0, 0, 0, 1883, 1884, 1, 0, 0, 0, 1884, 1890, 1, 0, 0, 0, 1885, 1886, 3, 44, 22, 0, 1886, 1887, 5, 106, 0, 0, 1887, 1888, 3, 1368, 684, 0, 1888, 1891, 1, 0, 0, 0, 1889, 1891, 3, 1372, 686, 0, 1890, 1885, 1, 0, 0, 0, 1890, 1889, 1, 0, 0, 0, 1891, 1892, 1, 0, 0, 0, 1892, 1893, 3, 46, 23, 0, 1893, 43, 1, 0, 0, 0, 1894, 1897, 3, 1372, 686, 0, 1895, 1897, 1, 0, 0, 0, 1896, 1894, 1, 0, 0, 0, 1896, 1895, 1, 0, 0, 0, 1897, 45, 1, 0, 0, 0, 1898, 1900, 3, 48, 24, 0, 1899, 1898, 1, 0, 0, 0, 1900, 1903, 1, 0, 0, 0, 1901, 1899, 1, 0, 0, 0, 1901, 1902, 1, 0, 0, 0, 1902, 47, 1, 0, 0, 0, 1903, 1901, 1, 0, 0, 0, 1904, 1911, 3, 172, 86, 0, 1905, 1911, 3, 588, 294, 0, 1906, 1911, 3, 278, 139, 0, 1907, 1911, 3, 404, 202, 0, 1908, 1911, 3, 552, 276, 0, 1909, 1911, 3, 798, 399, 0, 1910, 1904, 1, 0, 0, 0, 1910, 1905, 1, 0, 0, 0, 1910, 1906, 1, 0, 0, 0, 1910, 1907, 1, 0, 0, 0, 1910, 1908, 1, 0, 0, 0, 1910, 1909, 1, 0, 0, 0, 1911, 49, 1, 0, 0, 0, 1912, 1914, 5, 326, 0, 0, 1913, 1915, 7, 5, 0, 0, 1914, 1913, 1, 0, 0, 0, 1914, 1915, 1, 0, 0, 0, 1915, 1916, 1, 0, 0, 0, 1916, 1917, 3, 52, 26, 0, 1917, 51, 1, 0, 0, 0, 1918, 1919, 5, 349, 0, 0, 1919, 1927, 3, 792, 396, 0, 1920, 1921, 5, 325, 0, 0, 1921, 1922, 5, 154, 0, 0, 1922, 1923, 5, 36, 0, 0, 1923, 1924, 5, 349, 0, 0, 1924, 1927, 3, 792, 396, 0, 1925, 1927, 3, 56, 28, 0, 1926, 1918, 1, 0, 0, 0, 1926, 1920, 1, 0, 0, 0, 1926, 1925, 1, 0, 0, 0, 1927, 53, 1, 0, 0, 0, 1928, 1929, 3, 58, 29, 0, 1929, 1930, 7, 6, 0, 0, 1930, 1931, 3, 60, 30, 0, 1931, 55, 1, 0, 0, 0, 1932, 1958, 3, 54, 27, 0, 1933, 1934, 3, 58, 29, 0, 1934, 1935, 5, 64, 0, 0, 1935, 1936, 5, 434, 0, 0, 1936, 1958, 1, 0, 0, 0, 1937, 1938, 5, 411, 0, 0, 1938, 1939, 5, 379, 0, 0, 1939, 1958, 3, 68, 34, 0, 1940, 1941, 5, 152, 0, 0, 1941, 1958, 3, 1358, 679, 0, 1942, 1943, 5, 316, 0, 0, 1943, 1958, 3, 1358, 679, 0, 1944, 1945, 5, 260, 0, 0, 1945, 1958, 3, 70, 35, 0, 1946, 1947, 5, 311, 0, 0, 1947, 1958, 3, 72, 36, 0, 1948, 1949, 5, 325, 0, 0, 1949, 1950, 5, 106, 0, 0, 1950, 1958, 3, 72, 36, 0, 1951, 1952, 5, 376, 0, 0, 1952, 1953, 5, 272, 0, 0, 1953, 1958, 3, 1228, 614, 0, 1954, 1955, 5, 349, 0, 0, 1955, 1956, 5, 330, 0, 0, 1956, 1958, 3, 1358, 679, 0, 1957, 1932, 1, 0, 0, 0, 1957, 1933, 1, 0, 0, 0, 1957, 1937, 1, 0, 0, 0, 1957, 1940, 1, 0, 0, 0, 1957, 1942, 1, 0, 0, 0, 1957, 1944, 1, 0, 0, 0, 1957, 1946, 1, 0, 0, 0, 1957, 1948, 1, 0, 0, 0, 1957, 1951, 1, 0, 0, 0, 1957, 1954, 1, 0, 0, 0, 1958, 57, 1, 0, 0, 0, 1959, 1964, 3, 1372, 686, 0, 1960, 1961, 5, 11, 0, 0, 1961, 1963, 3, 1372, 686, 0, 1962, 1960, 1, 0, 0, 0, 1963, 1966, 1, 0, 0, 0, 1964, 1962, 1, 0, 0, 0, 1964, 1965, 1, 0, 0, 0, 1965, 59, 1, 0, 0, 0, 1966, 1964, 1, 0, 0, 0, 1967, 1972, 3, 62, 31, 0, 1968, 1969, 5, 6, 0, 0, 1969, 1971, 3, 62, 31, 0, 1970, 1968, 1, 0, 0, 0, 1971, 1974, 1, 0, 0, 0, 1972, 1970, 1, 0, 0, 0, 1972, 1973, 1, 0, 0, 0, 1973, 61, 1, 0, 0, 0, 1974, 1972, 1, 0, 0, 0, 1975, 1978, 3, 66, 33, 0, 1976, 1978, 3, 292, 146, 0, 1977, 1975, 1, 0, 0, 0, 1977, 1976, 1, 0, 0, 0, 1978, 63, 1, 0, 0, 0, 1979, 1980, 5, 293, 0, 0, 1980, 1985, 7, 7, 0, 0, 1981, 1982, 5, 303, 0, 0, 1982, 1985, 5, 293, 0, 0, 1983, 1985, 5, 323, 0, 0, 1984, 1979, 1, 0, 0, 0, 1984, 1981, 1, 0, 0, 0, 1984, 1983, 1, 0, 0, 0, 1985, 65, 1, 0, 0, 0, 1986, 1991, 5, 96, 0, 0, 1987, 1991, 5, 60, 0, 0, 1988, 1991, 5, 80, 0, 0, 1989, 1991, 3, 72, 36, 0, 1990, 1986, 1, 0, 0, 0, 1990, 1987, 1, 0, 0, 0, 1990, 1988, 1, 0, 0, 0, 1990, 1989, 1, 0, 0, 0, 1991, 67, 1, 0, 0, 0, 1992, 2008, 3, 1358, 679, 0, 1993, 2008, 3, 1382, 691, 0, 1994, 1995, 3, 1152, 576, 0, 1995, 1996, 3, 1358, 679, 0, 1996, 1997, 3, 1156, 578, 0, 1997, 2008, 1, 0, 0, 0, 1998, 1999, 3, 1152, 576, 0, 1999, 2000, 5, 2, 0, 0, 2000, 2001, 3, 1356, 678, 0, 2001, 2002, 5, 3, 0, 0, 2002, 2003, 3, 1358, 679, 0, 2003, 2008, 1, 0, 0, 0, 2004, 2008, 3, 292, 146, 0, 2005, 2008, 5, 53, 0, 0, 2006, 2008, 5, 245, 0, 0, 2007, 1992, 1, 0, 0, 0, 2007, 1993, 1, 0, 0, 0, 2007, 1994, 1, 0, 0, 0, 2007, 1998, 1, 0, 0, 0, 2007, 2004, 1, 0, 0, 0, 2007, 2005, 1, 0, 0, 0, 2007, 2006, 1, 0, 0, 0, 2008, 69, 1, 0, 0, 0, 2009, 2013, 3, 1358, 679, 0, 2010, 2013, 5, 53, 0, 0, 2011, 2013, 1, 0, 0, 0, 2012, 2009, 1, 0, 0, 0, 2012, 2010, 1, 0, 0, 0, 2012, 2011, 1, 0, 0, 0, 2013, 71, 1, 0, 0, 0, 2014, 2017, 3, 1378, 689, 0, 2015, 2017, 3, 1358, 679, 0, 2016, 2014, 1, 0, 0, 0, 2016, 2015, 1, 0, 0, 0, 2017, 73, 1, 0, 0, 0, 2018, 2019, 5, 306, 0, 0, 2019, 2020, 3, 76, 38, 0, 2020, 75, 1, 0, 0, 0, 2021, 2030, 3, 78, 39, 0, 2022, 2023, 5, 411, 0, 0, 2023, 2030, 5, 379, 0, 0, 2024, 2025, 5, 349, 0, 0, 2025, 2026, 5, 235, 0, 0, 2026, 2030, 5, 242, 0, 0, 2027, 2028, 5, 325, 0, 0, 2028, 2030, 5, 106, 0, 0, 2029, 2021, 1, 0, 0, 0, 2029, 2022, 1, 0, 0, 0, 2029, 2024, 1, 0, 0, 0, 2029, 2027, 1, 0, 0, 0, 2030, 77, 1, 0, 0, 0, 2031, 2034, 3, 58, 29, 0, 2032, 2034, 5, 30, 0, 0, 2033, 2031, 1, 0, 0, 0, 2033, 2032, 1, 0, 0, 0, 2034, 79, 1, 0, 0, 0, 2035, 2036, 5, 326, 0, 0, 2036, 2039, 3, 52, 26, 0, 2037, 2039, 3, 74, 37, 0, 2038, 2035, 1, 0, 0, 0, 2038, 2037, 1, 0, 0, 0, 2039, 81, 1, 0, 0, 0, 2040, 2041, 5, 326, 0, 0, 2041, 2044, 3, 56, 28, 0, 2042, 2044, 3, 74, 37, 0, 2043, 2040, 1, 0, 0, 0, 2043, 2042, 1, 0, 0, 0, 2044, 83, 1, 0, 0, 0, 2045, 2055, 5, 328, 0, 0, 2046, 2056, 3, 58, 29, 0, 2047, 2048, 5, 411, 0, 0, 2048, 2056, 5, 379, 0, 0, 2049, 2050, 5, 349, 0, 0, 2050, 2051, 5, 235, 0, 0, 2051, 2056, 5, 242, 0, 0, 2052, 2053, 5, 325, 0, 0, 2053, 2056, 5, 106, 0, 0, 2054, 2056, 5, 30, 0, 0, 2055, 2046, 1, 0, 0, 0, 2055, 2047, 1, 0, 0, 0, 2055, 2049, 1, 0, 0, 0, 2055, 2052, 1, 0, 0, 0, 2055, 2054, 1, 0, 0, 0, 2056, 85, 1, 0, 0, 0, 2057, 2058, 5, 326, 0, 0, 2058, 2059, 5, 165, 0, 0, 2059, 2060, 3, 88, 44, 0, 2060, 2061, 3, 90, 45, 0, 2061, 87, 1, 0, 0, 0, 2062, 2065, 5, 30, 0, 0, 2063, 2065, 3, 1334, 667, 0, 2064, 2062, 1, 0, 0, 0, 2064, 2063, 1, 0, 0, 0, 2065, 89, 1, 0, 0, 0, 2066, 2067, 7, 8, 0, 0, 2067, 91, 1, 0, 0, 0, 2068, 2069, 5, 155, 0, 0, 2069, 93, 1, 0, 0, 0, 2070, 2071, 5, 187, 0, 0, 2071, 2072, 7, 9, 0, 0, 2072, 95, 1, 0, 0, 0, 2073, 2074, 5, 138, 0, 0, 2074, 2077, 5, 92, 0, 0, 2075, 2076, 5, 220, 0, 0, 2076, 2078, 5, 389, 0, 0, 2077, 2075, 1, 0, 0, 0, 2077, 2078, 1, 0, 0, 0, 2078, 2079, 1, 0, 0, 0, 2079, 2082, 3, 1074, 537, 0, 2080, 2083, 3, 98, 49, 0, 2081, 2083, 3, 100, 50, 0, 2082, 2080, 1, 0, 0, 0, 2082, 2081, 1, 0, 0, 0, 2083, 2183, 1, 0, 0, 0, 2084, 2085, 5, 138, 0, 0, 2085, 2086, 5, 92, 0, 0, 2086, 2087, 5, 30, 0, 0, 2087, 2088, 5, 68, 0, 0, 2088, 2089, 5, 344, 0, 0, 2089, 2093, 3, 1340, 670, 0, 2090, 2091, 5, 274, 0, 0, 2091, 2092, 5, 147, 0, 0, 2092, 2094, 3, 1370, 685, 0, 2093, 2090, 1, 0, 0, 0, 2093, 2094, 1, 0, 0, 0, 2094, 2095, 1, 0, 0, 0, 2095, 2096, 5, 326, 0, 0, 2096, 2097, 5, 344, 0, 0, 2097, 2098, 3, 1340, 670, 0, 2098, 2099, 3, 938, 469, 0, 2099, 2183, 1, 0, 0, 0, 2100, 2101, 5, 138, 0, 0, 2101, 2104, 5, 226, 0, 0, 2102, 2103, 5, 220, 0, 0, 2103, 2105, 5, 389, 0, 0, 2104, 2102, 1, 0, 0, 0, 2104, 2105, 1, 0, 0, 0, 2105, 2106, 1, 0, 0, 0, 2106, 2109, 3, 1336, 668, 0, 2107, 2110, 3, 98, 49, 0, 2108, 2110, 3, 102, 51, 0, 2109, 2107, 1, 0, 0, 0, 2109, 2108, 1, 0, 0, 0, 2110, 2183, 1, 0, 0, 0, 2111, 2112, 5, 138, 0, 0, 2112, 2113, 5, 226, 0, 0, 2113, 2114, 5, 30, 0, 0, 2114, 2115, 5, 68, 0, 0, 2115, 2116, 5, 344, 0, 0, 2116, 2120, 3, 1340, 670, 0, 2117, 2118, 5, 274, 0, 0, 2118, 2119, 5, 147, 0, 0, 2119, 2121, 3, 1370, 685, 0, 2120, 2117, 1, 0, 0, 0, 2120, 2121, 1, 0, 0, 0, 2121, 2122, 1, 0, 0, 0, 2122, 2123, 5, 326, 0, 0, 2123, 2124, 5, 344, 0, 0, 2124, 2125, 3, 1340, 670, 0, 2125, 2126, 3, 938, 469, 0, 2126, 2183, 1, 0, 0, 0, 2127, 2128, 5, 138, 0, 0, 2128, 2131, 5, 321, 0, 0, 2129, 2130, 5, 220, 0, 0, 2130, 2132, 5, 389, 0, 0, 2131, 2129, 1, 0, 0, 0, 2131, 2132, 1, 0, 0, 0, 2132, 2133, 1, 0, 0, 0, 2133, 2134, 3, 1336, 668, 0, 2134, 2135, 3, 98, 49, 0, 2135, 2183, 1, 0, 0, 0, 2136, 2137, 5, 138, 0, 0, 2137, 2140, 5, 369, 0, 0, 2138, 2139, 5, 220, 0, 0, 2139, 2141, 5, 389, 0, 0, 2140, 2138, 1, 0, 0, 0, 2140, 2141, 1, 0, 0, 0, 2141, 2142, 1, 0, 0, 0, 2142, 2143, 3, 1336, 668, 0, 2143, 2144, 3, 98, 49, 0, 2144, 2183, 1, 0, 0, 0, 2145, 2146, 5, 138, 0, 0, 2146, 2147, 5, 251, 0, 0, 2147, 2150, 5, 369, 0, 0, 2148, 2149, 5, 220, 0, 0, 2149, 2151, 5, 389, 0, 0, 2150, 2148, 1, 0, 0, 0, 2150, 2151, 1, 0, 0, 0, 2151, 2152, 1, 0, 0, 0, 2152, 2153, 3, 1336, 668, 0, 2153, 2154, 3, 98, 49, 0, 2154, 2183, 1, 0, 0, 0, 2155, 2156, 5, 138, 0, 0, 2156, 2157, 5, 251, 0, 0, 2157, 2158, 5, 369, 0, 0, 2158, 2159, 5, 30, 0, 0, 2159, 2160, 5, 68, 0, 0, 2160, 2161, 5, 344, 0, 0, 2161, 2165, 3, 1340, 670, 0, 2162, 2163, 5, 274, 0, 0, 2163, 2164, 5, 147, 0, 0, 2164, 2166, 3, 1370, 685, 0, 2165, 2162, 1, 0, 0, 0, 2165, 2166, 1, 0, 0, 0, 2166, 2167, 1, 0, 0, 0, 2167, 2168, 5, 326, 0, 0, 2168, 2169, 5, 344, 0, 0, 2169, 2170, 3, 1340, 670, 0, 2170, 2171, 3, 938, 469, 0, 2171, 2183, 1, 0, 0, 0, 2172, 2173, 5, 138, 0, 0, 2173, 2174, 5, 63, 0, 0, 2174, 2177, 5, 92, 0, 0, 2175, 2176, 5, 220, 0, 0, 2176, 2178, 5, 389, 0, 0, 2177, 2175, 1, 0, 0, 0, 2177, 2178, 1, 0, 0, 0, 2178, 2179, 1, 0, 0, 0, 2179, 2180, 3, 1074, 537, 0, 2180, 2181, 3, 98, 49, 0, 2181, 2183, 1, 0, 0, 0, 2182, 2073, 1, 0, 0, 0, 2182, 2084, 1, 0, 0, 0, 2182, 2100, 1, 0, 0, 0, 2182, 2111, 1, 0, 0, 0, 2182, 2127, 1, 0, 0, 0, 2182, 2136, 1, 0, 0, 0, 2182, 2145, 1, 0, 0, 0, 2182, 2155, 1, 0, 0, 0, 2182, 2172, 1, 0, 0, 0, 2183, 97, 1, 0, 0, 0, 2184, 2189, 3, 104, 52, 0, 2185, 2186, 5, 6, 0, 0, 2186, 2188, 3, 104, 52, 0, 2187, 2185, 1, 0, 0, 0, 2188, 2191, 1, 0, 0, 0, 2189, 2187, 1, 0, 0, 0, 2189, 2190, 1, 0, 0, 0, 2190, 99, 1, 0, 0, 0, 2191, 2189, 1, 0, 0, 0, 2192, 2193, 5, 435, 0, 0, 2193, 2194, 5, 278, 0, 0, 2194, 2195, 3, 1336, 668, 0, 2195, 2196, 3, 128, 64, 0, 2196, 2201, 1, 0, 0, 0, 2197, 2198, 5, 436, 0, 0, 2198, 2199, 5, 278, 0, 0, 2199, 2201, 3, 1336, 668, 0, 2200, 2192, 1, 0, 0, 0, 2200, 2197, 1, 0, 0, 0, 2201, 101, 1, 0, 0, 0, 2202, 2203, 5, 435, 0, 0, 2203, 2204, 5, 278, 0, 0, 2204, 2205, 3, 1336, 668, 0, 2205, 103, 1, 0, 0, 0, 2206, 2207, 5, 133, 0, 0, 2207, 2459, 3, 188, 94, 0, 2208, 2209, 5, 133, 0, 0, 2209, 2210, 5, 220, 0, 0, 2210, 2211, 5, 77, 0, 0, 2211, 2212, 5, 389, 0, 0, 2212, 2459, 3, 188, 94, 0, 2213, 2214, 5, 133, 0, 0, 2214, 2215, 5, 44, 0, 0, 2215, 2459, 3, 188, 94, 0, 2216, 2217, 5, 133, 0, 0, 2217, 2218, 5, 44, 0, 0, 2218, 2219, 5, 220, 0, 0, 2219, 2220, 5, 77, 0, 0, 2220, 2221, 5, 389, 0, 0, 2221, 2459, 3, 188, 94, 0, 2222, 2223, 5, 138, 0, 0, 2223, 2224, 3, 724, 362, 0, 2224, 2225, 3, 1372, 686, 0, 2225, 2226, 3, 106, 53, 0, 2226, 2459, 1, 0, 0, 0, 2227, 2228, 5, 138, 0, 0, 2228, 2229, 3, 724, 362, 0, 2229, 2230, 3, 1372, 686, 0, 2230, 2231, 5, 191, 0, 0, 2231, 2232, 5, 77, 0, 0, 2232, 2233, 5, 78, 0, 0, 2233, 2459, 1, 0, 0, 0, 2234, 2235, 5, 138, 0, 0, 2235, 2236, 3, 724, 362, 0, 2236, 2237, 3, 1372, 686, 0, 2237, 2238, 5, 326, 0, 0, 2238, 2239, 5, 77, 0, 0, 2239, 2240, 5, 78, 0, 0, 2240, 2459, 1, 0, 0, 0, 2241, 2242, 5, 138, 0, 0, 2242, 2243, 3, 724, 362, 0, 2243, 2244, 3, 1372, 686, 0, 2244, 2245, 5, 191, 0, 0, 2245, 2246, 5, 437, 0, 0, 2246, 2459, 1, 0, 0, 0, 2247, 2248, 5, 138, 0, 0, 2248, 2249, 3, 724, 362, 0, 2249, 2250, 3, 1372, 686, 0, 2250, 2251, 5, 191, 0, 0, 2251, 2252, 5, 437, 0, 0, 2252, 2253, 5, 220, 0, 0, 2253, 2254, 5, 389, 0, 0, 2254, 2459, 1, 0, 0, 0, 2255, 2256, 5, 138, 0, 0, 2256, 2257, 3, 724, 362, 0, 2257, 2258, 3, 1372, 686, 0, 2258, 2259, 5, 326, 0, 0, 2259, 2260, 5, 335, 0, 0, 2260, 2261, 3, 1364, 682, 0, 2261, 2459, 1, 0, 0, 0, 2262, 2263, 5, 138, 0, 0, 2263, 2264, 3, 724, 362, 0, 2264, 2265, 3, 1356, 678, 0, 2265, 2266, 5, 326, 0, 0, 2266, 2267, 5, 335, 0, 0, 2267, 2268, 3, 1364, 682, 0, 2268, 2459, 1, 0, 0, 0, 2269, 2270, 5, 138, 0, 0, 2270, 2271, 3, 724, 362, 0, 2271, 2272, 3, 1372, 686, 0, 2272, 2273, 5, 326, 0, 0, 2273, 2274, 3, 116, 58, 0, 2274, 2459, 1, 0, 0, 0, 2275, 2276, 5, 138, 0, 0, 2276, 2277, 3, 724, 362, 0, 2277, 2278, 3, 1372, 686, 0, 2278, 2279, 5, 306, 0, 0, 2279, 2280, 3, 116, 58, 0, 2280, 2459, 1, 0, 0, 0, 2281, 2282, 5, 138, 0, 0, 2282, 2283, 3, 724, 362, 0, 2283, 2284, 3, 1372, 686, 0, 2284, 2285, 5, 326, 0, 0, 2285, 2286, 5, 338, 0, 0, 2286, 2287, 3, 1372, 686, 0, 2287, 2459, 1, 0, 0, 0, 2288, 2289, 5, 138, 0, 0, 2289, 2290, 3, 724, 362, 0, 2290, 2291, 3, 1372, 686, 0, 2291, 2292, 5, 133, 0, 0, 2292, 2293, 5, 438, 0, 0, 2293, 2294, 3, 198, 99, 0, 2294, 2295, 5, 36, 0, 0, 2295, 2296, 5, 219, 0, 0, 2296, 2297, 3, 284, 142, 0, 2297, 2459, 1, 0, 0, 0, 2298, 2299, 5, 138, 0, 0, 2299, 2300, 3, 724, 362, 0, 2300, 2301, 3, 1372, 686, 0, 2301, 2302, 3, 124, 62, 0, 2302, 2459, 1, 0, 0, 0, 2303, 2304, 5, 138, 0, 0, 2304, 2305, 3, 724, 362, 0, 2305, 2306, 3, 1372, 686, 0, 2306, 2307, 5, 191, 0, 0, 2307, 2308, 5, 219, 0, 0, 2308, 2459, 1, 0, 0, 0, 2309, 2310, 5, 138, 0, 0, 2310, 2311, 3, 724, 362, 0, 2311, 2312, 3, 1372, 686, 0, 2312, 2313, 5, 191, 0, 0, 2313, 2314, 5, 219, 0, 0, 2314, 2315, 5, 220, 0, 0, 2315, 2316, 5, 389, 0, 0, 2316, 2459, 1, 0, 0, 0, 2317, 2318, 5, 191, 0, 0, 2318, 2319, 3, 724, 362, 0, 2319, 2320, 5, 220, 0, 0, 2320, 2321, 5, 389, 0, 0, 2321, 2322, 3, 1372, 686, 0, 2322, 2323, 3, 108, 54, 0, 2323, 2459, 1, 0, 0, 0, 2324, 2325, 5, 191, 0, 0, 2325, 2326, 3, 724, 362, 0, 2326, 2327, 3, 1372, 686, 0, 2327, 2328, 3, 108, 54, 0, 2328, 2459, 1, 0, 0, 0, 2329, 2330, 5, 138, 0, 0, 2330, 2331, 3, 724, 362, 0, 2331, 2332, 3, 1372, 686, 0, 2332, 2333, 3, 726, 363, 0, 2333, 2334, 5, 353, 0, 0, 2334, 2335, 3, 1118, 559, 0, 2335, 2336, 3, 110, 55, 0, 2336, 2337, 3, 112, 56, 0, 2337, 2459, 1, 0, 0, 0, 2338, 2339, 5, 138, 0, 0, 2339, 2340, 3, 724, 362, 0, 2340, 2341, 3, 1372, 686, 0, 2341, 2342, 3, 344, 172, 0, 2342, 2459, 1, 0, 0, 0, 2343, 2344, 5, 133, 0, 0, 2344, 2459, 3, 208, 104, 0, 2345, 2346, 5, 138, 0, 0, 2346, 2347, 5, 45, 0, 0, 2347, 2348, 3, 1340, 670, 0, 2348, 2349, 3, 440, 220, 0, 2349, 2459, 1, 0, 0, 0, 2350, 2351, 5, 365, 0, 0, 2351, 2352, 5, 45, 0, 0, 2352, 2459, 3, 1340, 670, 0, 2353, 2354, 5, 191, 0, 0, 2354, 2355, 5, 45, 0, 0, 2355, 2356, 5, 220, 0, 0, 2356, 2357, 5, 389, 0, 0, 2357, 2358, 3, 1340, 670, 0, 2358, 2359, 3, 108, 54, 0, 2359, 2459, 1, 0, 0, 0, 2360, 2361, 5, 191, 0, 0, 2361, 2362, 5, 45, 0, 0, 2362, 2363, 3, 1340, 670, 0, 2363, 2364, 3, 108, 54, 0, 2364, 2459, 1, 0, 0, 0, 2365, 2366, 5, 326, 0, 0, 2366, 2367, 5, 372, 0, 0, 2367, 2459, 5, 270, 0, 0, 2368, 2369, 5, 158, 0, 0, 2369, 2370, 5, 80, 0, 0, 2370, 2459, 3, 1340, 670, 0, 2371, 2372, 5, 326, 0, 0, 2372, 2373, 5, 372, 0, 0, 2373, 2459, 5, 158, 0, 0, 2374, 2375, 5, 326, 0, 0, 2375, 2459, 5, 439, 0, 0, 2376, 2377, 5, 326, 0, 0, 2377, 2459, 5, 360, 0, 0, 2378, 2379, 5, 193, 0, 0, 2379, 2380, 5, 350, 0, 0, 2380, 2459, 3, 1340, 670, 0, 2381, 2382, 5, 193, 0, 0, 2382, 2383, 5, 139, 0, 0, 2383, 2384, 5, 350, 0, 0, 2384, 2459, 3, 1340, 670, 0, 2385, 2386, 5, 193, 0, 0, 2386, 2387, 5, 305, 0, 0, 2387, 2388, 5, 350, 0, 0, 2388, 2459, 3, 1340, 670, 0, 2389, 2390, 5, 193, 0, 0, 2390, 2391, 5, 350, 0, 0, 2391, 2459, 5, 30, 0, 0, 2392, 2393, 5, 193, 0, 0, 2393, 2394, 5, 350, 0, 0, 2394, 2459, 5, 99, 0, 0, 2395, 2396, 5, 186, 0, 0, 2396, 2397, 5, 350, 0, 0, 2397, 2459, 3, 1340, 670, 0, 2398, 2399, 5, 186, 0, 0, 2399, 2400, 5, 350, 0, 0, 2400, 2459, 5, 30, 0, 0, 2401, 2402, 5, 186, 0, 0, 2402, 2403, 5, 350, 0, 0, 2403, 2459, 5, 99, 0, 0, 2404, 2405, 5, 193, 0, 0, 2405, 2406, 5, 314, 0, 0, 2406, 2459, 3, 1340, 670, 0, 2407, 2408, 5, 193, 0, 0, 2408, 2409, 5, 139, 0, 0, 2409, 2410, 5, 314, 0, 0, 2410, 2459, 3, 1340, 670, 0, 2411, 2412, 5, 193, 0, 0, 2412, 2413, 5, 305, 0, 0, 2413, 2414, 5, 314, 0, 0, 2414, 2459, 3, 1340, 670, 0, 2415, 2416, 5, 186, 0, 0, 2416, 2417, 5, 314, 0, 0, 2417, 2459, 3, 1340, 670, 0, 2418, 2419, 5, 228, 0, 0, 2419, 2459, 3, 1336, 668, 0, 2420, 2421, 5, 262, 0, 0, 2421, 2422, 5, 228, 0, 0, 2422, 2459, 3, 1336, 668, 0, 2423, 2424, 5, 268, 0, 0, 2424, 2459, 3, 524, 262, 0, 2425, 2426, 5, 77, 0, 0, 2426, 2459, 5, 268, 0, 0, 2427, 2428, 5, 275, 0, 0, 2428, 2429, 5, 94, 0, 0, 2429, 2459, 3, 1368, 684, 0, 2430, 2431, 5, 326, 0, 0, 2431, 2432, 5, 344, 0, 0, 2432, 2459, 3, 1340, 670, 0, 2433, 2434, 5, 326, 0, 0, 2434, 2459, 3, 116, 58, 0, 2435, 2436, 5, 306, 0, 0, 2436, 2459, 3, 116, 58, 0, 2437, 2438, 5, 305, 0, 0, 2438, 2439, 5, 219, 0, 0, 2439, 2459, 3, 114, 57, 0, 2440, 2441, 5, 193, 0, 0, 2441, 2442, 5, 407, 0, 0, 2442, 2443, 5, 242, 0, 0, 2443, 2459, 5, 320, 0, 0, 2444, 2445, 5, 186, 0, 0, 2445, 2446, 5, 407, 0, 0, 2446, 2447, 5, 242, 0, 0, 2447, 2459, 5, 320, 0, 0, 2448, 2449, 5, 209, 0, 0, 2449, 2450, 5, 407, 0, 0, 2450, 2451, 5, 242, 0, 0, 2451, 2459, 5, 320, 0, 0, 2452, 2453, 5, 262, 0, 0, 2453, 2454, 5, 209, 0, 0, 2454, 2455, 5, 407, 0, 0, 2455, 2456, 5, 242, 0, 0, 2456, 2459, 5, 320, 0, 0, 2457, 2459, 3, 344, 172, 0, 2458, 2206, 1, 0, 0, 0, 2458, 2208, 1, 0, 0, 0, 2458, 2213, 1, 0, 0, 0, 2458, 2216, 1, 0, 0, 0, 2458, 2222, 1, 0, 0, 0, 2458, 2227, 1, 0, 0, 0, 2458, 2234, 1, 0, 0, 0, 2458, 2241, 1, 0, 0, 0, 2458, 2247, 1, 0, 0, 0, 2458, 2255, 1, 0, 0, 0, 2458, 2262, 1, 0, 0, 0, 2458, 2269, 1, 0, 0, 0, 2458, 2275, 1, 0, 0, 0, 2458, 2281, 1, 0, 0, 0, 2458, 2288, 1, 0, 0, 0, 2458, 2298, 1, 0, 0, 0, 2458, 2303, 1, 0, 0, 0, 2458, 2309, 1, 0, 0, 0, 2458, 2317, 1, 0, 0, 0, 2458, 2324, 1, 0, 0, 0, 2458, 2329, 1, 0, 0, 0, 2458, 2338, 1, 0, 0, 0, 2458, 2343, 1, 0, 0, 0, 2458, 2345, 1, 0, 0, 0, 2458, 2350, 1, 0, 0, 0, 2458, 2353, 1, 0, 0, 0, 2458, 2360, 1, 0, 0, 0, 2458, 2365, 1, 0, 0, 0, 2458, 2368, 1, 0, 0, 0, 2458, 2371, 1, 0, 0, 0, 2458, 2374, 1, 0, 0, 0, 2458, 2376, 1, 0, 0, 0, 2458, 2378, 1, 0, 0, 0, 2458, 2381, 1, 0, 0, 0, 2458, 2385, 1, 0, 0, 0, 2458, 2389, 1, 0, 0, 0, 2458, 2392, 1, 0, 0, 0, 2458, 2395, 1, 0, 0, 0, 2458, 2398, 1, 0, 0, 0, 2458, 2401, 1, 0, 0, 0, 2458, 2404, 1, 0, 0, 0, 2458, 2407, 1, 0, 0, 0, 2458, 2411, 1, 0, 0, 0, 2458, 2415, 1, 0, 0, 0, 2458, 2418, 1, 0, 0, 0, 2458, 2420, 1, 0, 0, 0, 2458, 2423, 1, 0, 0, 0, 2458, 2425, 1, 0, 0, 0, 2458, 2427, 1, 0, 0, 0, 2458, 2430, 1, 0, 0, 0, 2458, 2433, 1, 0, 0, 0, 2458, 2435, 1, 0, 0, 0, 2458, 2437, 1, 0, 0, 0, 2458, 2440, 1, 0, 0, 0, 2458, 2444, 1, 0, 0, 0, 2458, 2448, 1, 0, 0, 0, 2458, 2452, 1, 0, 0, 0, 2458, 2457, 1, 0, 0, 0, 2459, 105, 1, 0, 0, 0, 2460, 2461, 5, 326, 0, 0, 2461, 2462, 5, 53, 0, 0, 2462, 2466, 3, 1162, 581, 0, 2463, 2464, 5, 191, 0, 0, 2464, 2466, 5, 53, 0, 0, 2465, 2460, 1, 0, 0, 0, 2465, 2463, 1, 0, 0, 0, 2466, 107, 1, 0, 0, 0, 2467, 2471, 5, 150, 0, 0, 2468, 2471, 5, 308, 0, 0, 2469, 2471, 1, 0, 0, 0, 2470, 2467, 1, 0, 0, 0, 2470, 2468, 1, 0, 0, 0, 2470, 2469, 1, 0, 0, 0, 2471, 109, 1, 0, 0, 0, 2472, 2473, 5, 43, 0, 0, 2473, 2476, 3, 524, 262, 0, 2474, 2476, 1, 0, 0, 0, 2475, 2472, 1, 0, 0, 0, 2475, 2474, 1, 0, 0, 0, 2476, 111, 1, 0, 0, 0, 2477, 2478, 5, 100, 0, 0, 2478, 2481, 3, 1162, 581, 0, 2479, 2481, 1, 0, 0, 0, 2480, 2477, 1, 0, 0, 0, 2480, 2479, 1, 0, 0, 0, 2481, 113, 1, 0, 0, 0, 2482, 2489, 5, 263, 0, 0, 2483, 2489, 5, 113, 0, 0, 2484, 2489, 5, 53, 0, 0, 2485, 2486, 5, 100, 0, 0, 2486, 2487, 5, 226, 0, 0, 2487, 2489, 3, 1340, 670, 0, 2488, 2482, 1, 0, 0, 0, 2488, 2483, 1, 0, 0, 0, 2488, 2484, 1, 0, 0, 0, 2488, 2485, 1, 0, 0, 0, 2489, 115, 1, 0, 0, 0, 2490, 2491, 5, 2, 0, 0, 2491, 2492, 3, 120, 60, 0, 2492, 2493, 5, 3, 0, 0, 2493, 117, 1, 0, 0, 0, 2494, 2495, 5, 105, 0, 0, 2495, 2498, 3, 116, 58, 0, 2496, 2498, 1, 0, 0, 0, 2497, 2494, 1, 0, 0, 0, 2497, 2496, 1, 0, 0, 0, 2498, 119, 1, 0, 0, 0, 2499, 2504, 3, 122, 61, 0, 2500, 2501, 5, 6, 0, 0, 2501, 2503, 3, 122, 61, 0, 2502, 2500, 1, 0, 0, 0, 2503, 2506, 1, 0, 0, 0, 2504, 2502, 1, 0, 0, 0, 2504, 2505, 1, 0, 0, 0, 2505, 121, 1, 0, 0, 0, 2506, 2504, 1, 0, 0, 0, 2507, 2516, 3, 1380, 690, 0, 2508, 2509, 5, 10, 0, 0, 2509, 2517, 3, 466, 233, 0, 2510, 2511, 5, 11, 0, 0, 2511, 2514, 3, 1380, 690, 0, 2512, 2513, 5, 10, 0, 0, 2513, 2515, 3, 466, 233, 0, 2514, 2512, 1, 0, 0, 0, 2514, 2515, 1, 0, 0, 0, 2515, 2517, 1, 0, 0, 0, 2516, 2508, 1, 0, 0, 0, 2516, 2510, 1, 0, 0, 0, 2516, 2517, 1, 0, 0, 0, 2517, 123, 1, 0, 0, 0, 2518, 2520, 3, 126, 63, 0, 2519, 2518, 1, 0, 0, 0, 2520, 2521, 1, 0, 0, 0, 2521, 2519, 1, 0, 0, 0, 2521, 2522, 1, 0, 0, 0, 2522, 125, 1, 0, 0, 0, 2523, 2527, 5, 307, 0, 0, 2524, 2525, 3, 16, 8, 0, 2525, 2526, 3, 292, 146, 0, 2526, 2528, 1, 0, 0, 0, 2527, 2524, 1, 0, 0, 0, 2527, 2528, 1, 0, 0, 0, 2528, 2536, 1, 0, 0, 0, 2529, 2533, 5, 326, 0, 0, 2530, 2534, 3, 288, 144, 0, 2531, 2532, 5, 438, 0, 0, 2532, 2534, 3, 198, 99, 0, 2533, 2530, 1, 0, 0, 0, 2533, 2531, 1, 0, 0, 0, 2534, 2536, 1, 0, 0, 0, 2535, 2523, 1, 0, 0, 0, 2535, 2529, 1, 0, 0, 0, 2536, 127, 1, 0, 0, 0, 2537, 2538, 5, 62, 0, 0, 2538, 2539, 5, 415, 0, 0, 2539, 2540, 5, 105, 0, 0, 2540, 2541, 5, 2, 0, 0, 2541, 2542, 3, 132, 66, 0, 2542, 2543, 5, 3, 0, 0, 2543, 2564, 1, 0, 0, 0, 2544, 2545, 5, 62, 0, 0, 2545, 2546, 5, 415, 0, 0, 2546, 2547, 5, 68, 0, 0, 2547, 2548, 5, 2, 0, 0, 2548, 2549, 3, 1280, 640, 0, 2549, 2550, 5, 3, 0, 0, 2550, 2564, 1, 0, 0, 0, 2551, 2552, 5, 62, 0, 0, 2552, 2553, 5, 415, 0, 0, 2553, 2554, 5, 64, 0, 0, 2554, 2555, 5, 2, 0, 0, 2555, 2556, 3, 1280, 640, 0, 2556, 2557, 5, 3, 0, 0, 2557, 2558, 5, 94, 0, 0, 2558, 2559, 5, 2, 0, 0, 2559, 2560, 3, 1280, 640, 0, 2560, 2561, 5, 3, 0, 0, 2561, 2564, 1, 0, 0, 0, 2562, 2564, 5, 53, 0, 0, 2563, 2537, 1, 0, 0, 0, 2563, 2544, 1, 0, 0, 0, 2563, 2551, 1, 0, 0, 0, 2563, 2562, 1, 0, 0, 0, 2564, 129, 1, 0, 0, 0, 2565, 2566, 3, 1378, 689, 0, 2566, 2567, 3, 1356, 678, 0, 2567, 131, 1, 0, 0, 0, 2568, 2573, 3, 130, 65, 0, 2569, 2570, 5, 6, 0, 0, 2570, 2572, 3, 130, 65, 0, 2571, 2569, 1, 0, 0, 0, 2572, 2575, 1, 0, 0, 0, 2573, 2571, 1, 0, 0, 0, 2573, 2574, 1, 0, 0, 0, 2574, 133, 1, 0, 0, 0, 2575, 2573, 1, 0, 0, 0, 2576, 2577, 5, 138, 0, 0, 2577, 2578, 5, 353, 0, 0, 2578, 2579, 3, 524, 262, 0, 2579, 2580, 3, 136, 68, 0, 2580, 135, 1, 0, 0, 0, 2581, 2586, 3, 138, 69, 0, 2582, 2583, 5, 6, 0, 0, 2583, 2585, 3, 138, 69, 0, 2584, 2582, 1, 0, 0, 0, 2585, 2588, 1, 0, 0, 0, 2586, 2584, 1, 0, 0, 0, 2586, 2587, 1, 0, 0, 0, 2587, 137, 1, 0, 0, 0, 2588, 2586, 1, 0, 0, 0, 2589, 2590, 5, 133, 0, 0, 2590, 2591, 5, 143, 0, 0, 2591, 2592, 3, 1102, 551, 0, 2592, 2593, 3, 108, 54, 0, 2593, 2613, 1, 0, 0, 0, 2594, 2595, 5, 191, 0, 0, 2595, 2598, 5, 143, 0, 0, 2596, 2597, 5, 220, 0, 0, 2597, 2599, 5, 389, 0, 0, 2598, 2596, 1, 0, 0, 0, 2598, 2599, 1, 0, 0, 0, 2599, 2600, 1, 0, 0, 0, 2600, 2601, 3, 1372, 686, 0, 2601, 2602, 3, 108, 54, 0, 2602, 2613, 1, 0, 0, 0, 2603, 2604, 5, 138, 0, 0, 2604, 2605, 5, 143, 0, 0, 2605, 2606, 3, 1372, 686, 0, 2606, 2607, 3, 726, 363, 0, 2607, 2608, 5, 353, 0, 0, 2608, 2609, 3, 1118, 559, 0, 2609, 2610, 3, 110, 55, 0, 2610, 2611, 3, 108, 54, 0, 2611, 2613, 1, 0, 0, 0, 2612, 2589, 1, 0, 0, 0, 2612, 2594, 1, 0, 0, 0, 2612, 2603, 1, 0, 0, 0, 2613, 139, 1, 0, 0, 0, 2614, 2617, 5, 157, 0, 0, 2615, 2618, 3, 954, 477, 0, 2616, 2618, 5, 30, 0, 0, 2617, 2615, 1, 0, 0, 0, 2617, 2616, 1, 0, 0, 0, 2618, 141, 1, 0, 0, 0, 2619, 2620, 5, 169, 0, 0, 2620, 2621, 3, 156, 78, 0, 2621, 2622, 3, 1336, 668, 0, 2622, 2623, 3, 214, 107, 0, 2623, 2624, 3, 144, 72, 0, 2624, 2625, 3, 146, 73, 0, 2625, 2626, 3, 148, 74, 0, 2626, 2627, 3, 158, 79, 0, 2627, 2628, 3, 16, 8, 0, 2628, 2629, 3, 150, 75, 0, 2629, 2630, 3, 1094, 547, 0, 2630, 2642, 1, 0, 0, 0, 2631, 2632, 5, 169, 0, 0, 2632, 2633, 5, 2, 0, 0, 2633, 2634, 3, 894, 447, 0, 2634, 2635, 5, 3, 0, 0, 2635, 2636, 5, 94, 0, 0, 2636, 2637, 3, 146, 73, 0, 2637, 2638, 3, 148, 74, 0, 2638, 2639, 3, 16, 8, 0, 2639, 2640, 3, 150, 75, 0, 2640, 2642, 1, 0, 0, 0, 2641, 2619, 1, 0, 0, 0, 2641, 2631, 1, 0, 0, 0, 2642, 143, 1, 0, 0, 0, 2643, 2644, 7, 10, 0, 0, 2644, 145, 1, 0, 0, 0, 2645, 2648, 5, 290, 0, 0, 2646, 2648, 1, 0, 0, 0, 2647, 2645, 1, 0, 0, 0, 2647, 2646, 1, 0, 0, 0, 2648, 147, 1, 0, 0, 0, 2649, 2653, 3, 1358, 679, 0, 2650, 2653, 5, 336, 0, 0, 2651, 2653, 5, 337, 0, 0, 2652, 2649, 1, 0, 0, 0, 2652, 2650, 1, 0, 0, 0, 2652, 2651, 1, 0, 0, 0, 2653, 149, 1, 0, 0, 0, 2654, 2660, 3, 152, 76, 0, 2655, 2656, 5, 2, 0, 0, 2656, 2657, 3, 162, 81, 0, 2657, 2658, 5, 3, 0, 0, 2658, 2660, 1, 0, 0, 0, 2659, 2654, 1, 0, 0, 0, 2659, 2655, 1, 0, 0, 0, 2660, 151, 1, 0, 0, 0, 2661, 2663, 3, 154, 77, 0, 2662, 2661, 1, 0, 0, 0, 2663, 2666, 1, 0, 0, 0, 2664, 2662, 1, 0, 0, 0, 2664, 2665, 1, 0, 0, 0, 2665, 153, 1, 0, 0, 0, 2666, 2664, 1, 0, 0, 0, 2667, 2703, 5, 107, 0, 0, 2668, 2703, 5, 112, 0, 0, 2669, 2670, 5, 183, 0, 0, 2670, 2671, 3, 834, 417, 0, 2671, 2672, 3, 1358, 679, 0, 2672, 2703, 1, 0, 0, 0, 2673, 2674, 5, 78, 0, 0, 2674, 2675, 3, 834, 417, 0, 2675, 2676, 3, 1358, 679, 0, 2676, 2703, 1, 0, 0, 0, 2677, 2703, 5, 171, 0, 0, 2678, 2703, 5, 216, 0, 0, 2679, 2680, 5, 291, 0, 0, 2680, 2681, 3, 834, 417, 0, 2681, 2682, 3, 1358, 679, 0, 2682, 2703, 1, 0, 0, 0, 2683, 2684, 5, 197, 0, 0, 2684, 2685, 3, 834, 417, 0, 2685, 2686, 3, 1358, 679, 0, 2686, 2703, 1, 0, 0, 0, 2687, 2688, 5, 209, 0, 0, 2688, 2689, 5, 291, 0, 0, 2689, 2703, 3, 216, 108, 0, 2690, 2691, 5, 209, 0, 0, 2691, 2692, 5, 291, 0, 0, 2692, 2703, 5, 9, 0, 0, 2693, 2694, 5, 209, 0, 0, 2694, 2695, 5, 77, 0, 0, 2695, 2696, 5, 78, 0, 0, 2696, 2703, 3, 216, 108, 0, 2697, 2698, 5, 209, 0, 0, 2698, 2699, 5, 78, 0, 0, 2699, 2703, 3, 216, 108, 0, 2700, 2701, 5, 194, 0, 0, 2701, 2703, 3, 1358, 679, 0, 2702, 2667, 1, 0, 0, 0, 2702, 2668, 1, 0, 0, 0, 2702, 2669, 1, 0, 0, 0, 2702, 2673, 1, 0, 0, 0, 2702, 2677, 1, 0, 0, 0, 2702, 2678, 1, 0, 0, 0, 2702, 2679, 1, 0, 0, 0, 2702, 2683, 1, 0, 0, 0, 2702, 2687, 1, 0, 0, 0, 2702, 2690, 1, 0, 0, 0, 2702, 2693, 1, 0, 0, 0, 2702, 2697, 1, 0, 0, 0, 2702, 2700, 1, 0, 0, 0, 2703, 155, 1, 0, 0, 0, 2704, 2707, 5, 107, 0, 0, 2705, 2707, 1, 0, 0, 0, 2706, 2704, 1, 0, 0, 0, 2706, 2705, 1, 0, 0, 0, 2707, 157, 1, 0, 0, 0, 2708, 2709, 3, 160, 80, 0, 2709, 2710, 5, 184, 0, 0, 2710, 2711, 3, 1358, 679, 0, 2711, 2714, 1, 0, 0, 0, 2712, 2714, 1, 0, 0, 0, 2713, 2708, 1, 0, 0, 0, 2713, 2712, 1, 0, 0, 0, 2714, 159, 1, 0, 0, 0, 2715, 2718, 5, 100, 0, 0, 2716, 2718, 1, 0, 0, 0, 2717, 2715, 1, 0, 0, 0, 2717, 2716, 1, 0, 0, 0, 2718, 161, 1, 0, 0, 0, 2719, 2724, 3, 164, 82, 0, 2720, 2721, 5, 6, 0, 0, 2721, 2723, 3, 164, 82, 0, 2722, 2720, 1, 0, 0, 0, 2723, 2726, 1, 0, 0, 0, 2724, 2722, 1, 0, 0, 0, 2724, 2725, 1, 0, 0, 0, 2725, 163, 1, 0, 0, 0, 2726, 2724, 1, 0, 0, 0, 2727, 2728, 3, 1380, 690, 0, 2728, 2729, 3, 166, 83, 0, 2729, 165, 1, 0, 0, 0, 2730, 2739, 3, 66, 33, 0, 2731, 2739, 3, 292, 146, 0, 2732, 2739, 5, 9, 0, 0, 2733, 2734, 5, 2, 0, 0, 2734, 2735, 3, 168, 84, 0, 2735, 2736, 5, 3, 0, 0, 2736, 2739, 1, 0, 0, 0, 2737, 2739, 1, 0, 0, 0, 2738, 2730, 1, 0, 0, 0, 2738, 2731, 1, 0, 0, 0, 2738, 2732, 1, 0, 0, 0, 2738, 2733, 1, 0, 0, 0, 2738, 2737, 1, 0, 0, 0, 2739, 167, 1, 0, 0, 0, 2740, 2745, 3, 170, 85, 0, 2741, 2742, 5, 6, 0, 0, 2742, 2744, 3, 170, 85, 0, 2743, 2741, 1, 0, 0, 0, 2744, 2747, 1, 0, 0, 0, 2745, 2743, 1, 0, 0, 0, 2745, 2746, 1, 0, 0, 0, 2746, 169, 1, 0, 0, 0, 2747, 2745, 1, 0, 0, 0, 2748, 2749, 3, 66, 33, 0, 2749, 171, 1, 0, 0, 0, 2750, 2751, 5, 46, 0, 0, 2751, 2752, 3, 174, 87, 0, 2752, 2756, 5, 92, 0, 0, 2753, 2754, 5, 220, 0, 0, 2754, 2755, 5, 77, 0, 0, 2755, 2757, 5, 389, 0, 0, 2756, 2753, 1, 0, 0, 0, 2756, 2757, 1, 0, 0, 0, 2757, 2758, 1, 0, 0, 0, 2758, 2789, 3, 1336, 668, 0, 2759, 2760, 5, 2, 0, 0, 2760, 2761, 3, 176, 88, 0, 2761, 2762, 5, 3, 0, 0, 2762, 2763, 3, 238, 119, 0, 2763, 2764, 3, 240, 120, 0, 2764, 2765, 3, 248, 124, 0, 2765, 2766, 3, 250, 125, 0, 2766, 2767, 3, 252, 126, 0, 2767, 2768, 3, 254, 127, 0, 2768, 2790, 1, 0, 0, 0, 2769, 2770, 5, 268, 0, 0, 2770, 2771, 3, 524, 262, 0, 2771, 2772, 3, 178, 89, 0, 2772, 2773, 3, 240, 120, 0, 2773, 2774, 3, 248, 124, 0, 2774, 2775, 3, 250, 125, 0, 2775, 2776, 3, 252, 126, 0, 2776, 2777, 3, 254, 127, 0, 2777, 2790, 1, 0, 0, 0, 2778, 2779, 5, 278, 0, 0, 2779, 2780, 5, 268, 0, 0, 2780, 2781, 3, 1336, 668, 0, 2781, 2782, 3, 178, 89, 0, 2782, 2783, 3, 128, 64, 0, 2783, 2784, 3, 240, 120, 0, 2784, 2785, 3, 248, 124, 0, 2785, 2786, 3, 250, 125, 0, 2786, 2787, 3, 252, 126, 0, 2787, 2788, 3, 254, 127, 0, 2788, 2790, 1, 0, 0, 0, 2789, 2759, 1, 0, 0, 0, 2789, 2769, 1, 0, 0, 0, 2789, 2778, 1, 0, 0, 0, 2790, 173, 1, 0, 0, 0, 2791, 2800, 5, 347, 0, 0, 2792, 2800, 5, 345, 0, 0, 2793, 2794, 5, 245, 0, 0, 2794, 2800, 7, 11, 0, 0, 2795, 2796, 5, 213, 0, 0, 2796, 2800, 7, 11, 0, 0, 2797, 2800, 5, 360, 0, 0, 2798, 2800, 1, 0, 0, 0, 2799, 2791, 1, 0, 0, 0, 2799, 2792, 1, 0, 0, 0, 2799, 2793, 1, 0, 0, 0, 2799, 2795, 1, 0, 0, 0, 2799, 2797, 1, 0, 0, 0, 2799, 2798, 1, 0, 0, 0, 2800, 175, 1, 0, 0, 0, 2801, 2804, 3, 180, 90, 0, 2802, 2804, 1, 0, 0, 0, 2803, 2801, 1, 0, 0, 0, 2803, 2802, 1, 0, 0, 0, 2804, 177, 1, 0, 0, 0, 2805, 2806, 5, 2, 0, 0, 2806, 2807, 3, 182, 91, 0, 2807, 2808, 5, 3, 0, 0, 2808, 2811, 1, 0, 0, 0, 2809, 2811, 1, 0, 0, 0, 2810, 2805, 1, 0, 0, 0, 2810, 2809, 1, 0, 0, 0, 2811, 179, 1, 0, 0, 0, 2812, 2817, 3, 184, 92, 0, 2813, 2814, 5, 6, 0, 0, 2814, 2816, 3, 184, 92, 0, 2815, 2813, 1, 0, 0, 0, 2816, 2819, 1, 0, 0, 0, 2817, 2815, 1, 0, 0, 0, 2817, 2818, 1, 0, 0, 0, 2818, 181, 1, 0, 0, 0, 2819, 2817, 1, 0, 0, 0, 2820, 2825, 3, 186, 93, 0, 2821, 2822, 5, 6, 0, 0, 2822, 2824, 3, 186, 93, 0, 2823, 2821, 1, 0, 0, 0, 2824, 2827, 1, 0, 0, 0, 2825, 2823, 1, 0, 0, 0, 2825, 2826, 1, 0, 0, 0, 2826, 183, 1, 0, 0, 0, 2827, 2825, 1, 0, 0, 0, 2828, 2832, 3, 208, 104, 0, 2829, 2832, 3, 202, 101, 0, 2830, 2832, 3, 188, 94, 0, 2831, 2828, 1, 0, 0, 0, 2831, 2829, 1, 0, 0, 0, 2831, 2830, 1, 0, 0, 0, 2832, 185, 1, 0, 0, 0, 2833, 2836, 3, 190, 95, 0, 2834, 2836, 3, 208, 104, 0, 2835, 2833, 1, 0, 0, 0, 2835, 2834, 1, 0, 0, 0, 2836, 187, 1, 0, 0, 0, 2837, 2838, 3, 1372, 686, 0, 2838, 2839, 3, 1118, 559, 0, 2839, 2840, 3, 340, 170, 0, 2840, 2841, 3, 192, 96, 0, 2841, 189, 1, 0, 0, 0, 2842, 2845, 3, 1372, 686, 0, 2843, 2844, 5, 105, 0, 0, 2844, 2846, 5, 273, 0, 0, 2845, 2843, 1, 0, 0, 0, 2845, 2846, 1, 0, 0, 0, 2846, 2847, 1, 0, 0, 0, 2847, 2848, 3, 192, 96, 0, 2848, 191, 1, 0, 0, 0, 2849, 2851, 3, 194, 97, 0, 2850, 2849, 1, 0, 0, 0, 2851, 2854, 1, 0, 0, 0, 2852, 2850, 1, 0, 0, 0, 2852, 2853, 1, 0, 0, 0, 2853, 193, 1, 0, 0, 0, 2854, 2852, 1, 0, 0, 0, 2855, 2856, 5, 45, 0, 0, 2856, 2857, 3, 1340, 670, 0, 2857, 2858, 3, 196, 98, 0, 2858, 2864, 1, 0, 0, 0, 2859, 2864, 3, 196, 98, 0, 2860, 2864, 3, 200, 100, 0, 2861, 2862, 5, 43, 0, 0, 2862, 2864, 3, 524, 262, 0, 2863, 2855, 1, 0, 0, 0, 2863, 2859, 1, 0, 0, 0, 2863, 2860, 1, 0, 0, 0, 2863, 2861, 1, 0, 0, 0, 2864, 195, 1, 0, 0, 0, 2865, 2866, 5, 77, 0, 0, 2866, 2904, 5, 78, 0, 0, 2867, 2904, 5, 78, 0, 0, 2868, 2869, 5, 98, 0, 0, 2869, 2870, 3, 664, 332, 0, 2870, 2871, 3, 256, 128, 0, 2871, 2904, 1, 0, 0, 0, 2872, 2873, 5, 85, 0, 0, 2873, 2874, 5, 236, 0, 0, 2874, 2875, 3, 664, 332, 0, 2875, 2876, 3, 256, 128, 0, 2876, 2904, 1, 0, 0, 0, 2877, 2878, 5, 42, 0, 0, 2878, 2879, 5, 2, 0, 0, 2879, 2880, 3, 1162, 581, 0, 2880, 2881, 5, 3, 0, 0, 2881, 2882, 3, 212, 106, 0, 2882, 2904, 1, 0, 0, 0, 2883, 2884, 5, 53, 0, 0, 2884, 2904, 3, 1204, 602, 0, 2885, 2886, 5, 438, 0, 0, 2886, 2887, 3, 198, 99, 0, 2887, 2895, 5, 36, 0, 0, 2888, 2889, 5, 219, 0, 0, 2889, 2896, 3, 284, 142, 0, 2890, 2891, 5, 2, 0, 0, 2891, 2892, 3, 1162, 581, 0, 2892, 2893, 5, 3, 0, 0, 2893, 2894, 5, 440, 0, 0, 2894, 2896, 1, 0, 0, 0, 2895, 2888, 1, 0, 0, 0, 2895, 2890, 1, 0, 0, 0, 2896, 2904, 1, 0, 0, 0, 2897, 2898, 5, 86, 0, 0, 2898, 2899, 3, 1336, 668, 0, 2899, 2900, 3, 214, 107, 0, 2900, 2901, 3, 222, 111, 0, 2901, 2902, 3, 230, 115, 0, 2902, 2904, 1, 0, 0, 0, 2903, 2865, 1, 0, 0, 0, 2903, 2867, 1, 0, 0, 0, 2903, 2868, 1, 0, 0, 0, 2903, 2872, 1, 0, 0, 0, 2903, 2877, 1, 0, 0, 0, 2903, 2883, 1, 0, 0, 0, 2903, 2885, 1, 0, 0, 0, 2903, 2897, 1, 0, 0, 0, 2904, 197, 1, 0, 0, 0, 2905, 2909, 5, 139, 0, 0, 2906, 2907, 5, 147, 0, 0, 2907, 2909, 5, 53, 0, 0, 2908, 2905, 1, 0, 0, 0, 2908, 2906, 1, 0, 0, 0, 2909, 199, 1, 0, 0, 0, 2910, 2916, 5, 54, 0, 0, 2911, 2912, 5, 77, 0, 0, 2912, 2916, 5, 54, 0, 0, 2913, 2914, 5, 69, 0, 0, 2914, 2916, 7, 8, 0, 0, 2915, 2910, 1, 0, 0, 0, 2915, 2911, 1, 0, 0, 0, 2915, 2913, 1, 0, 0, 0, 2916, 201, 1, 0, 0, 0, 2917, 2918, 5, 120, 0, 0, 2918, 2919, 3, 1336, 668, 0, 2919, 2920, 3, 204, 102, 0, 2920, 203, 1, 0, 0, 0, 2921, 2922, 7, 12, 0, 0, 2922, 2924, 3, 206, 103, 0, 2923, 2921, 1, 0, 0, 0, 2924, 2927, 1, 0, 0, 0, 2925, 2923, 1, 0, 0, 0, 2925, 2926, 1, 0, 0, 0, 2926, 205, 1, 0, 0, 0, 2927, 2925, 1, 0, 0, 0, 2928, 2929, 7, 13, 0, 0, 2929, 207, 1, 0, 0, 0, 2930, 2931, 5, 45, 0, 0, 2931, 2932, 3, 1340, 670, 0, 2932, 2933, 3, 210, 105, 0, 2933, 2936, 1, 0, 0, 0, 2934, 2936, 3, 210, 105, 0, 2935, 2930, 1, 0, 0, 0, 2935, 2934, 1, 0, 0, 0, 2936, 209, 1, 0, 0, 0, 2937, 2938, 5, 42, 0, 0, 2938, 2939, 5, 2, 0, 0, 2939, 2940, 3, 1162, 581, 0, 2940, 2941, 5, 3, 0, 0, 2941, 2942, 3, 440, 220, 0, 2942, 2996, 1, 0, 0, 0, 2943, 2955, 5, 98, 0, 0, 2944, 2945, 5, 2, 0, 0, 2945, 2946, 3, 216, 108, 0, 2946, 2947, 5, 3, 0, 0, 2947, 2948, 3, 220, 110, 0, 2948, 2949, 3, 664, 332, 0, 2949, 2950, 3, 256, 128, 0, 2950, 2951, 3, 440, 220, 0, 2951, 2956, 1, 0, 0, 0, 2952, 2953, 3, 258, 129, 0, 2953, 2954, 3, 440, 220, 0, 2954, 2956, 1, 0, 0, 0, 2955, 2944, 1, 0, 0, 0, 2955, 2952, 1, 0, 0, 0, 2956, 2996, 1, 0, 0, 0, 2957, 2958, 5, 85, 0, 0, 2958, 2970, 5, 236, 0, 0, 2959, 2960, 5, 2, 0, 0, 2960, 2961, 3, 216, 108, 0, 2961, 2962, 5, 3, 0, 0, 2962, 2963, 3, 220, 110, 0, 2963, 2964, 3, 664, 332, 0, 2964, 2965, 3, 256, 128, 0, 2965, 2966, 3, 440, 220, 0, 2966, 2971, 1, 0, 0, 0, 2967, 2968, 3, 258, 129, 0, 2968, 2969, 3, 440, 220, 0, 2969, 2971, 1, 0, 0, 0, 2970, 2959, 1, 0, 0, 0, 2970, 2967, 1, 0, 0, 0, 2971, 2996, 1, 0, 0, 0, 2972, 2973, 5, 199, 0, 0, 2973, 2974, 3, 596, 298, 0, 2974, 2975, 5, 2, 0, 0, 2975, 2976, 3, 224, 112, 0, 2976, 2977, 5, 3, 0, 0, 2977, 2978, 3, 220, 110, 0, 2978, 2979, 3, 664, 332, 0, 2979, 2980, 3, 256, 128, 0, 2980, 2981, 3, 228, 114, 0, 2981, 2982, 3, 440, 220, 0, 2982, 2996, 1, 0, 0, 0, 2983, 2984, 5, 63, 0, 0, 2984, 2985, 5, 236, 0, 0, 2985, 2986, 5, 2, 0, 0, 2986, 2987, 3, 216, 108, 0, 2987, 2988, 5, 3, 0, 0, 2988, 2989, 5, 86, 0, 0, 2989, 2990, 3, 1336, 668, 0, 2990, 2991, 3, 214, 107, 0, 2991, 2992, 3, 222, 111, 0, 2992, 2993, 3, 230, 115, 0, 2993, 2994, 3, 440, 220, 0, 2994, 2996, 1, 0, 0, 0, 2995, 2937, 1, 0, 0, 0, 2995, 2943, 1, 0, 0, 0, 2995, 2957, 1, 0, 0, 0, 2995, 2972, 1, 0, 0, 0, 2995, 2983, 1, 0, 0, 0, 2996, 211, 1, 0, 0, 0, 2997, 2998, 5, 262, 0, 0, 2998, 3001, 5, 228, 0, 0, 2999, 3001, 1, 0, 0, 0, 3000, 2997, 1, 0, 0, 0, 3000, 2999, 1, 0, 0, 0, 3001, 213, 1, 0, 0, 0, 3002, 3003, 5, 2, 0, 0, 3003, 3004, 3, 216, 108, 0, 3004, 3005, 5, 3, 0, 0, 3005, 3008, 1, 0, 0, 0, 3006, 3008, 1, 0, 0, 0, 3007, 3002, 1, 0, 0, 0, 3007, 3006, 1, 0, 0, 0, 3008, 215, 1, 0, 0, 0, 3009, 3014, 3, 218, 109, 0, 3010, 3011, 5, 6, 0, 0, 3011, 3013, 3, 218, 109, 0, 3012, 3010, 1, 0, 0, 0, 3013, 3016, 1, 0, 0, 0, 3014, 3012, 1, 0, 0, 0, 3014, 3015, 1, 0, 0, 0, 3015, 217, 1, 0, 0, 0, 3016, 3014, 1, 0, 0, 0, 3017, 3018, 3, 1372, 686, 0, 3018, 219, 1, 0, 0, 0, 3019, 3020, 5, 441, 0, 0, 3020, 3021, 5, 2, 0, 0, 3021, 3022, 3, 216, 108, 0, 3022, 3023, 5, 3, 0, 0, 3023, 3026, 1, 0, 0, 0, 3024, 3026, 1, 0, 0, 0, 3025, 3019, 1, 0, 0, 0, 3025, 3024, 1, 0, 0, 0, 3026, 221, 1, 0, 0, 0, 3027, 3028, 5, 249, 0, 0, 3028, 3031, 7, 14, 0, 0, 3029, 3031, 1, 0, 0, 0, 3030, 3027, 1, 0, 0, 0, 3030, 3029, 1, 0, 0, 0, 3031, 223, 1, 0, 0, 0, 3032, 3037, 3, 226, 113, 0, 3033, 3034, 5, 6, 0, 0, 3034, 3036, 3, 226, 113, 0, 3035, 3033, 1, 0, 0, 0, 3036, 3039, 1, 0, 0, 0, 3037, 3035, 1, 0, 0, 0, 3037, 3038, 1, 0, 0, 0, 3038, 225, 1, 0, 0, 0, 3039, 3037, 1, 0, 0, 0, 3040, 3041, 3, 602, 301, 0, 3041, 3048, 5, 105, 0, 0, 3042, 3049, 3, 684, 342, 0, 3043, 3044, 5, 271, 0, 0, 3044, 3045, 5, 2, 0, 0, 3045, 3046, 3, 684, 342, 0, 3046, 3047, 5, 3, 0, 0, 3047, 3049, 1, 0, 0, 0, 3048, 3042, 1, 0, 0, 0, 3048, 3043, 1, 0, 0, 0, 3049, 227, 1, 0, 0, 0, 3050, 3051, 5, 103, 0, 0, 3051, 3052, 5, 2, 0, 0, 3052, 3053, 3, 1162, 581, 0, 3053, 3054, 5, 3, 0, 0, 3054, 3057, 1, 0, 0, 0, 3055, 3057, 1, 0, 0, 0, 3056, 3050, 1, 0, 0, 0, 3056, 3055, 1, 0, 0, 0, 3057, 229, 1, 0, 0, 0, 3058, 3068, 3, 232, 116, 0, 3059, 3068, 3, 234, 117, 0, 3060, 3061, 3, 232, 116, 0, 3061, 3062, 3, 234, 117, 0, 3062, 3068, 1, 0, 0, 0, 3063, 3064, 3, 234, 117, 0, 3064, 3065, 3, 232, 116, 0, 3065, 3068, 1, 0, 0, 0, 3066, 3068, 1, 0, 0, 0, 3067, 3058, 1, 0, 0, 0, 3067, 3059, 1, 0, 0, 0, 3067, 3060, 1, 0, 0, 0, 3067, 3063, 1, 0, 0, 0, 3067, 3066, 1, 0, 0, 0, 3068, 231, 1, 0, 0, 0, 3069, 3070, 5, 80, 0, 0, 3070, 3071, 5, 362, 0, 0, 3071, 3072, 3, 236, 118, 0, 3072, 233, 1, 0, 0, 0, 3073, 3074, 5, 80, 0, 0, 3074, 3075, 5, 182, 0, 0, 3075, 3076, 3, 236, 118, 0, 3076, 235, 1, 0, 0, 0, 3077, 3078, 5, 262, 0, 0, 3078, 3084, 5, 132, 0, 0, 3079, 3084, 5, 308, 0, 0, 3080, 3084, 5, 150, 0, 0, 3081, 3082, 5, 326, 0, 0, 3082, 3084, 7, 15, 0, 0, 3083, 3077, 1, 0, 0, 0, 3083, 3079, 1, 0, 0, 0, 3083, 3080, 1, 0, 0, 0, 3083, 3081, 1, 0, 0, 0, 3084, 237, 1, 0, 0, 0, 3085, 3086, 5, 229, 0, 0, 3086, 3087, 5, 2, 0, 0, 3087, 3088, 3, 1334, 667, 0, 3088, 3089, 5, 3, 0, 0, 3089, 3092, 1, 0, 0, 0, 3090, 3092, 1, 0, 0, 0, 3091, 3085, 1, 0, 0, 0, 3091, 3090, 1, 0, 0, 0, 3092, 239, 1, 0, 0, 0, 3093, 3096, 3, 242, 121, 0, 3094, 3096, 1, 0, 0, 0, 3095, 3093, 1, 0, 0, 0, 3095, 3094, 1, 0, 0, 0, 3096, 241, 1, 0, 0, 0, 3097, 3098, 5, 278, 0, 0, 3098, 3099, 5, 147, 0, 0, 3099, 3100, 3, 1372, 686, 0, 3100, 3101, 5, 2, 0, 0, 3101, 3102, 3, 244, 122, 0, 3102, 3103, 5, 3, 0, 0, 3103, 243, 1, 0, 0, 0, 3104, 3109, 3, 246, 123, 0, 3105, 3106, 5, 6, 0, 0, 3106, 3108, 3, 246, 123, 0, 3107, 3105, 1, 0, 0, 0, 3108, 3111, 1, 0, 0, 0, 3109, 3107, 1, 0, 0, 0, 3109, 3110, 1, 0, 0, 0, 3110, 245, 1, 0, 0, 0, 3111, 3109, 1, 0, 0, 0, 3112, 3113, 3, 1372, 686, 0, 3113, 3114, 3, 608, 304, 0, 3114, 3115, 3, 610, 305, 0, 3115, 3127, 1, 0, 0, 0, 3116, 3117, 3, 1214, 607, 0, 3117, 3118, 3, 608, 304, 0, 3118, 3119, 3, 610, 305, 0, 3119, 3127, 1, 0, 0, 0, 3120, 3121, 5, 2, 0, 0, 3121, 3122, 3, 1162, 581, 0, 3122, 3123, 5, 3, 0, 0, 3123, 3124, 3, 608, 304, 0, 3124, 3125, 3, 610, 305, 0, 3125, 3127, 1, 0, 0, 0, 3126, 3112, 1, 0, 0, 0, 3126, 3116, 1, 0, 0, 0, 3126, 3120, 1, 0, 0, 0, 3127, 247, 1, 0, 0, 0, 3128, 3129, 5, 100, 0, 0, 3129, 3132, 3, 1340, 670, 0, 3130, 3132, 1, 0, 0, 0, 3131, 3128, 1, 0, 0, 0, 3131, 3130, 1, 0, 0, 0, 3132, 249, 1, 0, 0, 0, 3133, 3134, 5, 105, 0, 0, 3134, 3139, 3, 116, 58, 0, 3135, 3136, 5, 372, 0, 0, 3136, 3139, 5, 270, 0, 0, 3137, 3139, 1, 0, 0, 0, 3138, 3133, 1, 0, 0, 0, 3138, 3135, 1, 0, 0, 0, 3138, 3137, 1, 0, 0, 0, 3139, 251, 1, 0, 0, 0, 3140, 3141, 5, 80, 0, 0, 3141, 3147, 5, 161, 0, 0, 3142, 3148, 5, 191, 0, 0, 3143, 3144, 5, 182, 0, 0, 3144, 3148, 5, 313, 0, 0, 3145, 3146, 5, 285, 0, 0, 3146, 3148, 5, 313, 0, 0, 3147, 3142, 1, 0, 0, 0, 3147, 3143, 1, 0, 0, 0, 3147, 3145, 1, 0, 0, 0, 3148, 3151, 1, 0, 0, 0, 3149, 3151, 1, 0, 0, 0, 3150, 3140, 1, 0, 0, 0, 3150, 3149, 1, 0, 0, 0, 3151, 253, 1, 0, 0, 0, 3152, 3153, 5, 344, 0, 0, 3153, 3156, 3, 1340, 670, 0, 3154, 3156, 1, 0, 0, 0, 3155, 3152, 1, 0, 0, 0, 3155, 3154, 1, 0, 0, 0, 3156, 255, 1, 0, 0, 0, 3157, 3158, 5, 100, 0, 0, 3158, 3159, 5, 226, 0, 0, 3159, 3160, 5, 344, 0, 0, 3160, 3163, 3, 1340, 670, 0, 3161, 3163, 1, 0, 0, 0, 3162, 3157, 1, 0, 0, 0, 3162, 3161, 1, 0, 0, 0, 3163, 257, 1, 0, 0, 0, 3164, 3165, 5, 100, 0, 0, 3165, 3166, 5, 226, 0, 0, 3166, 3167, 3, 1340, 670, 0, 3167, 259, 1, 0, 0, 0, 3168, 3169, 5, 46, 0, 0, 3169, 3173, 5, 335, 0, 0, 3170, 3171, 5, 220, 0, 0, 3171, 3172, 5, 77, 0, 0, 3172, 3174, 5, 389, 0, 0, 3173, 3170, 1, 0, 0, 0, 3173, 3174, 1, 0, 0, 0, 3174, 3175, 1, 0, 0, 0, 3175, 3176, 3, 524, 262, 0, 3176, 3177, 3, 870, 435, 0, 3177, 3178, 5, 80, 0, 0, 3178, 3179, 3, 1280, 640, 0, 3179, 3180, 5, 64, 0, 0, 3180, 3181, 3, 1056, 528, 0, 3181, 261, 1, 0, 0, 0, 3182, 3183, 5, 138, 0, 0, 3183, 3186, 5, 335, 0, 0, 3184, 3185, 5, 220, 0, 0, 3185, 3187, 5, 389, 0, 0, 3186, 3184, 1, 0, 0, 0, 3186, 3187, 1, 0, 0, 0, 3187, 3188, 1, 0, 0, 0, 3188, 3189, 3, 524, 262, 0, 3189, 3190, 5, 326, 0, 0, 3190, 3191, 5, 335, 0, 0, 3191, 3192, 3, 1364, 682, 0, 3192, 263, 1, 0, 0, 0, 3193, 3194, 5, 46, 0, 0, 3194, 3195, 3, 174, 87, 0, 3195, 3199, 5, 92, 0, 0, 3196, 3197, 5, 220, 0, 0, 3197, 3198, 5, 77, 0, 0, 3198, 3200, 5, 389, 0, 0, 3199, 3196, 1, 0, 0, 0, 3199, 3200, 1, 0, 0, 0, 3200, 3201, 1, 0, 0, 0, 3201, 3202, 3, 266, 133, 0, 3202, 3203, 5, 36, 0, 0, 3203, 3204, 3, 960, 480, 0, 3204, 3205, 3, 268, 134, 0, 3205, 265, 1, 0, 0, 0, 3206, 3207, 3, 1336, 668, 0, 3207, 3208, 3, 214, 107, 0, 3208, 3209, 3, 248, 124, 0, 3209, 3210, 3, 250, 125, 0, 3210, 3211, 3, 252, 126, 0, 3211, 3212, 3, 254, 127, 0, 3212, 267, 1, 0, 0, 0, 3213, 3217, 5, 105, 0, 0, 3214, 3218, 5, 174, 0, 0, 3215, 3216, 5, 262, 0, 0, 3216, 3218, 5, 174, 0, 0, 3217, 3214, 1, 0, 0, 0, 3217, 3215, 1, 0, 0, 0, 3218, 3221, 1, 0, 0, 0, 3219, 3221, 1, 0, 0, 0, 3220, 3213, 1, 0, 0, 0, 3220, 3219, 1, 0, 0, 0, 3221, 269, 1, 0, 0, 0, 3222, 3223, 5, 46, 0, 0, 3223, 3224, 3, 274, 137, 0, 3224, 3225, 5, 251, 0, 0, 3225, 3229, 5, 369, 0, 0, 3226, 3227, 5, 220, 0, 0, 3227, 3228, 5, 77, 0, 0, 3228, 3230, 5, 389, 0, 0, 3229, 3226, 1, 0, 0, 0, 3229, 3230, 1, 0, 0, 0, 3230, 3231, 1, 0, 0, 0, 3231, 3232, 3, 272, 136, 0, 3232, 3233, 5, 36, 0, 0, 3233, 3234, 3, 960, 480, 0, 3234, 3235, 3, 268, 134, 0, 3235, 271, 1, 0, 0, 0, 3236, 3237, 3, 1336, 668, 0, 3237, 3238, 3, 214, 107, 0, 3238, 3239, 3, 248, 124, 0, 3239, 3240, 3, 118, 59, 0, 3240, 3241, 3, 254, 127, 0, 3241, 273, 1, 0, 0, 0, 3242, 3245, 5, 360, 0, 0, 3243, 3245, 1, 0, 0, 0, 3244, 3242, 1, 0, 0, 0, 3244, 3243, 1, 0, 0, 0, 3245, 275, 1, 0, 0, 0, 3246, 3247, 5, 298, 0, 0, 3247, 3248, 5, 251, 0, 0, 3248, 3249, 5, 369, 0, 0, 3249, 3250, 3, 592, 296, 0, 3250, 3251, 3, 1336, 668, 0, 3251, 3252, 3, 268, 134, 0, 3252, 277, 1, 0, 0, 0, 3253, 3254, 5, 46, 0, 0, 3254, 3255, 3, 174, 87, 0, 3255, 3259, 5, 321, 0, 0, 3256, 3257, 5, 220, 0, 0, 3257, 3258, 5, 77, 0, 0, 3258, 3260, 5, 389, 0, 0, 3259, 3256, 1, 0, 0, 0, 3259, 3260, 1, 0, 0, 0, 3260, 3261, 1, 0, 0, 0, 3261, 3262, 3, 1336, 668, 0, 3262, 3263, 3, 282, 141, 0, 3263, 279, 1, 0, 0, 0, 3264, 3265, 5, 138, 0, 0, 3265, 3268, 5, 321, 0, 0, 3266, 3267, 5, 220, 0, 0, 3267, 3269, 5, 389, 0, 0, 3268, 3266, 1, 0, 0, 0, 3268, 3269, 1, 0, 0, 0, 3269, 3270, 1, 0, 0, 0, 3270, 3271, 3, 1336, 668, 0, 3271, 3272, 3, 286, 143, 0, 3272, 281, 1, 0, 0, 0, 3273, 3276, 3, 286, 143, 0, 3274, 3276, 1, 0, 0, 0, 3275, 3273, 1, 0, 0, 0, 3275, 3274, 1, 0, 0, 0, 3276, 283, 1, 0, 0, 0, 3277, 3278, 5, 2, 0, 0, 3278, 3279, 3, 286, 143, 0, 3279, 3280, 5, 3, 0, 0, 3280, 3283, 1, 0, 0, 0, 3281, 3283, 1, 0, 0, 0, 3282, 3277, 1, 0, 0, 0, 3282, 3281, 1, 0, 0, 0, 3283, 285, 1, 0, 0, 0, 3284, 3286, 3, 288, 144, 0, 3285, 3284, 1, 0, 0, 0, 3286, 3287, 1, 0, 0, 0, 3287, 3285, 1, 0, 0, 0, 3287, 3288, 1, 0, 0, 0, 3288, 287, 1, 0, 0, 0, 3289, 3290, 5, 36, 0, 0, 3290, 3320, 3, 1122, 561, 0, 3291, 3292, 5, 148, 0, 0, 3292, 3320, 3, 292, 146, 0, 3293, 3320, 5, 173, 0, 0, 3294, 3295, 5, 225, 0, 0, 3295, 3296, 3, 290, 145, 0, 3296, 3297, 3, 292, 146, 0, 3297, 3320, 1, 0, 0, 0, 3298, 3299, 5, 252, 0, 0, 3299, 3320, 3, 292, 146, 0, 3300, 3301, 5, 255, 0, 0, 3301, 3320, 3, 292, 146, 0, 3302, 3303, 5, 262, 0, 0, 3303, 3320, 7, 16, 0, 0, 3304, 3305, 5, 274, 0, 0, 3305, 3306, 5, 147, 0, 0, 3306, 3320, 3, 524, 262, 0, 3307, 3308, 5, 321, 0, 0, 3308, 3309, 5, 259, 0, 0, 3309, 3320, 3, 524, 262, 0, 3310, 3311, 5, 333, 0, 0, 3311, 3312, 3, 16, 8, 0, 3312, 3313, 3, 292, 146, 0, 3313, 3320, 1, 0, 0, 0, 3314, 3315, 5, 307, 0, 0, 3315, 3317, 3, 16, 8, 0, 3316, 3318, 3, 292, 146, 0, 3317, 3316, 1, 0, 0, 0, 3317, 3318, 1, 0, 0, 0, 3318, 3320, 1, 0, 0, 0, 3319, 3289, 1, 0, 0, 0, 3319, 3291, 1, 0, 0, 0, 3319, 3293, 1, 0, 0, 0, 3319, 3294, 1, 0, 0, 0, 3319, 3298, 1, 0, 0, 0, 3319, 3300, 1, 0, 0, 0, 3319, 3302, 1, 0, 0, 0, 3319, 3304, 1, 0, 0, 0, 3319, 3307, 1, 0, 0, 0, 3319, 3310, 1, 0, 0, 0, 3319, 3314, 1, 0, 0, 0, 3320, 289, 1, 0, 0, 0, 3321, 3324, 5, 147, 0, 0, 3322, 3324, 1, 0, 0, 0, 3323, 3321, 1, 0, 0, 0, 3323, 3322, 1, 0, 0, 0, 3324, 291, 1, 0, 0, 0, 3325, 3332, 3, 1354, 677, 0, 3326, 3327, 5, 12, 0, 0, 3327, 3332, 3, 1354, 677, 0, 3328, 3329, 5, 13, 0, 0, 3329, 3332, 3, 1354, 677, 0, 3330, 3332, 3, 1364, 682, 0, 3331, 3325, 1, 0, 0, 0, 3331, 3326, 1, 0, 0, 0, 3331, 3328, 1, 0, 0, 0, 3331, 3330, 1, 0, 0, 0, 3332, 293, 1, 0, 0, 0, 3333, 3338, 3, 292, 146, 0, 3334, 3335, 5, 6, 0, 0, 3335, 3337, 3, 292, 146, 0, 3336, 3334, 1, 0, 0, 0, 3337, 3340, 1, 0, 0, 0, 3338, 3336, 1, 0, 0, 0, 3338, 3339, 1, 0, 0, 0, 3339, 295, 1, 0, 0, 0, 3340, 3338, 1, 0, 0, 0, 3341, 3342, 5, 46, 0, 0, 3342, 3343, 3, 618, 309, 0, 3343, 3344, 3, 298, 149, 0, 3344, 3345, 3, 308, 154, 0, 3345, 3346, 5, 238, 0, 0, 3346, 3352, 3, 1340, 670, 0, 3347, 3348, 5, 215, 0, 0, 3348, 3349, 3, 300, 150, 0, 3349, 3350, 3, 302, 151, 0, 3350, 3351, 3, 306, 153, 0, 3351, 3353, 1, 0, 0, 0, 3352, 3347, 1, 0, 0, 0, 3352, 3353, 1, 0, 0, 0, 3353, 297, 1, 0, 0, 0, 3354, 3357, 5, 352, 0, 0, 3355, 3357, 1, 0, 0, 0, 3356, 3354, 1, 0, 0, 0, 3356, 3355, 1, 0, 0, 0, 3357, 299, 1, 0, 0, 0, 3358, 3360, 3, 1340, 670, 0, 3359, 3361, 3, 526, 263, 0, 3360, 3359, 1, 0, 0, 0, 3360, 3361, 1, 0, 0, 0, 3361, 301, 1, 0, 0, 0, 3362, 3363, 5, 230, 0, 0, 3363, 3366, 3, 300, 150, 0, 3364, 3366, 1, 0, 0, 0, 3365, 3362, 1, 0, 0, 0, 3365, 3364, 1, 0, 0, 0, 3366, 303, 1, 0, 0, 0, 3367, 3368, 5, 366, 0, 0, 3368, 3372, 3, 300, 150, 0, 3369, 3370, 5, 262, 0, 0, 3370, 3372, 5, 366, 0, 0, 3371, 3367, 1, 0, 0, 0, 3371, 3369, 1, 0, 0, 0, 3372, 305, 1, 0, 0, 0, 3373, 3376, 3, 304, 152, 0, 3374, 3376, 1, 0, 0, 0, 3375, 3373, 1, 0, 0, 0, 3375, 3374, 1, 0, 0, 0, 3376, 307, 1, 0, 0, 0, 3377, 3380, 5, 288, 0, 0, 3378, 3380, 1, 0, 0, 0, 3379, 3377, 1, 0, 0, 0, 3379, 3378, 1, 0, 0, 0, 3380, 309, 1, 0, 0, 0, 3381, 3382, 5, 46, 0, 0, 3382, 3383, 5, 344, 0, 0, 3383, 3384, 3, 1340, 670, 0, 3384, 3385, 3, 312, 156, 0, 3385, 3386, 5, 246, 0, 0, 3386, 3387, 3, 1358, 679, 0, 3387, 3388, 3, 118, 59, 0, 3388, 311, 1, 0, 0, 0, 3389, 3390, 5, 275, 0, 0, 3390, 3393, 3, 1368, 684, 0, 3391, 3393, 1, 0, 0, 0, 3392, 3389, 1, 0, 0, 0, 3392, 3391, 1, 0, 0, 0, 3393, 313, 1, 0, 0, 0, 3394, 3395, 5, 191, 0, 0, 3395, 3398, 5, 344, 0, 0, 3396, 3397, 5, 220, 0, 0, 3397, 3399, 5, 389, 0, 0, 3398, 3396, 1, 0, 0, 0, 3398, 3399, 1, 0, 0, 0, 3399, 3400, 1, 0, 0, 0, 3400, 3401, 3, 1340, 670, 0, 3401, 315, 1, 0, 0, 0, 3402, 3403, 5, 46, 0, 0, 3403, 3407, 5, 204, 0, 0, 3404, 3405, 5, 220, 0, 0, 3405, 3406, 5, 77, 0, 0, 3406, 3408, 5, 389, 0, 0, 3407, 3404, 1, 0, 0, 0, 3407, 3408, 1, 0, 0, 0, 3408, 3409, 1, 0, 0, 0, 3409, 3410, 3, 1340, 670, 0, 3410, 3411, 3, 16, 8, 0, 3411, 3412, 3, 318, 159, 0, 3412, 317, 1, 0, 0, 0, 3413, 3415, 3, 320, 160, 0, 3414, 3413, 1, 0, 0, 0, 3415, 3418, 1, 0, 0, 0, 3416, 3414, 1, 0, 0, 0, 3416, 3417, 1, 0, 0, 0, 3417, 319, 1, 0, 0, 0, 3418, 3416, 1, 0, 0, 0, 3419, 3420, 5, 316, 0, 0, 3420, 3427, 3, 1340, 670, 0, 3421, 3422, 5, 368, 0, 0, 3422, 3427, 3, 72, 36, 0, 3423, 3424, 5, 64, 0, 0, 3424, 3427, 3, 72, 36, 0, 3425, 3427, 5, 150, 0, 0, 3426, 3419, 1, 0, 0, 0, 3426, 3421, 1, 0, 0, 0, 3426, 3423, 1, 0, 0, 0, 3426, 3425, 1, 0, 0, 0, 3427, 321, 1, 0, 0, 0, 3428, 3429, 5, 138, 0, 0, 3429, 3430, 5, 204, 0, 0, 3430, 3431, 3, 1340, 670, 0, 3431, 3432, 5, 362, 0, 0, 3432, 3433, 3, 324, 162, 0, 3433, 323, 1, 0, 0, 0, 3434, 3436, 3, 326, 163, 0, 3435, 3434, 1, 0, 0, 0, 3436, 3439, 1, 0, 0, 0, 3437, 3435, 1, 0, 0, 0, 3437, 3438, 1, 0, 0, 0, 3438, 325, 1, 0, 0, 0, 3439, 3437, 1, 0, 0, 0, 3440, 3441, 5, 94, 0, 0, 3441, 3442, 3, 72, 36, 0, 3442, 327, 1, 0, 0, 0, 3443, 3444, 5, 138, 0, 0, 3444, 3445, 5, 204, 0, 0, 3445, 3446, 3, 1340, 670, 0, 3446, 3447, 3, 40, 20, 0, 3447, 3448, 3, 516, 258, 0, 3448, 3449, 3, 1340, 670, 0, 3449, 3548, 1, 0, 0, 0, 3450, 3451, 5, 138, 0, 0, 3451, 3452, 5, 204, 0, 0, 3452, 3453, 3, 1340, 670, 0, 3453, 3454, 3, 40, 20, 0, 3454, 3455, 3, 514, 257, 0, 3455, 3456, 3, 524, 262, 0, 3456, 3548, 1, 0, 0, 0, 3457, 3458, 5, 138, 0, 0, 3458, 3459, 5, 204, 0, 0, 3459, 3460, 3, 1340, 670, 0, 3460, 3461, 3, 40, 20, 0, 3461, 3462, 5, 136, 0, 0, 3462, 3463, 3, 650, 325, 0, 3463, 3548, 1, 0, 0, 0, 3464, 3465, 5, 138, 0, 0, 3465, 3466, 5, 204, 0, 0, 3466, 3467, 3, 1340, 670, 0, 3467, 3468, 3, 40, 20, 0, 3468, 3469, 5, 41, 0, 0, 3469, 3470, 5, 2, 0, 0, 3470, 3471, 3, 1118, 559, 0, 3471, 3472, 5, 36, 0, 0, 3472, 3473, 3, 1118, 559, 0, 3473, 3474, 5, 3, 0, 0, 3474, 3548, 1, 0, 0, 0, 3475, 3476, 5, 138, 0, 0, 3476, 3477, 5, 204, 0, 0, 3477, 3478, 3, 1340, 670, 0, 3478, 3479, 3, 40, 20, 0, 3479, 3480, 5, 189, 0, 0, 3480, 3481, 3, 1118, 559, 0, 3481, 3548, 1, 0, 0, 0, 3482, 3483, 5, 138, 0, 0, 3483, 3484, 5, 204, 0, 0, 3484, 3485, 3, 1340, 670, 0, 3485, 3486, 3, 40, 20, 0, 3486, 3487, 5, 211, 0, 0, 3487, 3488, 3, 626, 313, 0, 3488, 3548, 1, 0, 0, 0, 3489, 3490, 5, 138, 0, 0, 3490, 3491, 5, 204, 0, 0, 3491, 3492, 3, 1340, 670, 0, 3492, 3493, 3, 40, 20, 0, 3493, 3494, 5, 271, 0, 0, 3494, 3495, 3, 688, 344, 0, 3495, 3548, 1, 0, 0, 0, 3496, 3497, 5, 138, 0, 0, 3497, 3498, 5, 204, 0, 0, 3498, 3499, 3, 1340, 670, 0, 3499, 3500, 3, 40, 20, 0, 3500, 3501, 5, 271, 0, 0, 3501, 3502, 5, 156, 0, 0, 3502, 3503, 3, 524, 262, 0, 3503, 3504, 5, 100, 0, 0, 3504, 3505, 3, 1340, 670, 0, 3505, 3548, 1, 0, 0, 0, 3506, 3507, 5, 138, 0, 0, 3507, 3508, 5, 204, 0, 0, 3508, 3509, 3, 1340, 670, 0, 3509, 3510, 3, 40, 20, 0, 3510, 3511, 5, 271, 0, 0, 3511, 3512, 5, 206, 0, 0, 3512, 3513, 3, 524, 262, 0, 3513, 3514, 5, 100, 0, 0, 3514, 3515, 3, 1340, 670, 0, 3515, 3548, 1, 0, 0, 0, 3516, 3517, 5, 138, 0, 0, 3517, 3518, 5, 204, 0, 0, 3518, 3519, 3, 1340, 670, 0, 3519, 3520, 3, 40, 20, 0, 3520, 3521, 5, 289, 0, 0, 3521, 3522, 3, 626, 313, 0, 3522, 3548, 1, 0, 0, 0, 3523, 3524, 5, 138, 0, 0, 3524, 3525, 5, 204, 0, 0, 3525, 3526, 3, 1340, 670, 0, 3526, 3527, 3, 40, 20, 0, 3527, 3528, 5, 442, 0, 0, 3528, 3529, 3, 626, 313, 0, 3529, 3548, 1, 0, 0, 0, 3530, 3531, 5, 138, 0, 0, 3531, 3532, 5, 204, 0, 0, 3532, 3533, 3, 1340, 670, 0, 3533, 3534, 3, 40, 20, 0, 3534, 3535, 5, 443, 0, 0, 3535, 3536, 5, 62, 0, 0, 3536, 3537, 3, 1118, 559, 0, 3537, 3538, 5, 238, 0, 0, 3538, 3539, 3, 1340, 670, 0, 3539, 3548, 1, 0, 0, 0, 3540, 3541, 5, 138, 0, 0, 3541, 3542, 5, 204, 0, 0, 3542, 3543, 3, 1340, 670, 0, 3543, 3544, 3, 40, 20, 0, 3544, 3545, 5, 353, 0, 0, 3545, 3546, 3, 1118, 559, 0, 3546, 3548, 1, 0, 0, 0, 3547, 3443, 1, 0, 0, 0, 3547, 3450, 1, 0, 0, 0, 3547, 3457, 1, 0, 0, 0, 3547, 3464, 1, 0, 0, 0, 3547, 3475, 1, 0, 0, 0, 3547, 3482, 1, 0, 0, 0, 3547, 3489, 1, 0, 0, 0, 3547, 3496, 1, 0, 0, 0, 3547, 3506, 1, 0, 0, 0, 3547, 3516, 1, 0, 0, 0, 3547, 3523, 1, 0, 0, 0, 3547, 3530, 1, 0, 0, 0, 3547, 3540, 1, 0, 0, 0, 3548, 329, 1, 0, 0, 0, 3549, 3550, 5, 46, 0, 0, 3550, 3551, 5, 63, 0, 0, 3551, 3552, 5, 174, 0, 0, 3552, 3553, 5, 374, 0, 0, 3553, 3554, 3, 1340, 670, 0, 3554, 3555, 3, 336, 168, 0, 3555, 3556, 3, 340, 170, 0, 3556, 331, 1, 0, 0, 0, 3557, 3558, 5, 215, 0, 0, 3558, 3566, 3, 300, 150, 0, 3559, 3560, 5, 262, 0, 0, 3560, 3566, 5, 215, 0, 0, 3561, 3562, 5, 366, 0, 0, 3562, 3566, 3, 300, 150, 0, 3563, 3564, 5, 262, 0, 0, 3564, 3566, 5, 366, 0, 0, 3565, 3557, 1, 0, 0, 0, 3565, 3559, 1, 0, 0, 0, 3565, 3561, 1, 0, 0, 0, 3565, 3563, 1, 0, 0, 0, 3566, 333, 1, 0, 0, 0, 3567, 3569, 3, 332, 166, 0, 3568, 3567, 1, 0, 0, 0, 3569, 3570, 1, 0, 0, 0, 3570, 3568, 1, 0, 0, 0, 3570, 3571, 1, 0, 0, 0, 3571, 335, 1, 0, 0, 0, 3572, 3575, 3, 334, 167, 0, 3573, 3575, 1, 0, 0, 0, 3574, 3572, 1, 0, 0, 0, 3574, 3573, 1, 0, 0, 0, 3575, 337, 1, 0, 0, 0, 3576, 3577, 5, 138, 0, 0, 3577, 3578, 5, 63, 0, 0, 3578, 3579, 5, 174, 0, 0, 3579, 3580, 5, 374, 0, 0, 3580, 3581, 3, 1340, 670, 0, 3581, 3582, 3, 336, 168, 0, 3582, 3583, 3, 344, 172, 0, 3583, 3592, 1, 0, 0, 0, 3584, 3585, 5, 138, 0, 0, 3585, 3586, 5, 63, 0, 0, 3586, 3587, 5, 174, 0, 0, 3587, 3588, 5, 374, 0, 0, 3588, 3589, 3, 1340, 670, 0, 3589, 3590, 3, 334, 167, 0, 3590, 3592, 1, 0, 0, 0, 3591, 3576, 1, 0, 0, 0, 3591, 3584, 1, 0, 0, 0, 3592, 339, 1, 0, 0, 0, 3593, 3594, 5, 273, 0, 0, 3594, 3595, 5, 2, 0, 0, 3595, 3596, 3, 342, 171, 0, 3596, 3597, 5, 3, 0, 0, 3597, 3600, 1, 0, 0, 0, 3598, 3600, 1, 0, 0, 0, 3599, 3593, 1, 0, 0, 0, 3599, 3598, 1, 0, 0, 0, 3600, 341, 1, 0, 0, 0, 3601, 3606, 3, 350, 175, 0, 3602, 3603, 5, 6, 0, 0, 3603, 3605, 3, 350, 175, 0, 3604, 3602, 1, 0, 0, 0, 3605, 3608, 1, 0, 0, 0, 3606, 3604, 1, 0, 0, 0, 3606, 3607, 1, 0, 0, 0, 3607, 343, 1, 0, 0, 0, 3608, 3606, 1, 0, 0, 0, 3609, 3610, 5, 273, 0, 0, 3610, 3611, 5, 2, 0, 0, 3611, 3612, 3, 346, 173, 0, 3612, 3613, 5, 3, 0, 0, 3613, 345, 1, 0, 0, 0, 3614, 3619, 3, 348, 174, 0, 3615, 3616, 5, 6, 0, 0, 3616, 3618, 3, 348, 174, 0, 3617, 3615, 1, 0, 0, 0, 3618, 3621, 1, 0, 0, 0, 3619, 3617, 1, 0, 0, 0, 3619, 3620, 1, 0, 0, 0, 3620, 347, 1, 0, 0, 0, 3621, 3619, 1, 0, 0, 0, 3622, 3630, 3, 350, 175, 0, 3623, 3624, 5, 326, 0, 0, 3624, 3630, 3, 350, 175, 0, 3625, 3626, 5, 133, 0, 0, 3626, 3630, 3, 350, 175, 0, 3627, 3628, 5, 191, 0, 0, 3628, 3630, 3, 352, 176, 0, 3629, 3622, 1, 0, 0, 0, 3629, 3623, 1, 0, 0, 0, 3629, 3625, 1, 0, 0, 0, 3629, 3627, 1, 0, 0, 0, 3630, 349, 1, 0, 0, 0, 3631, 3632, 3, 352, 176, 0, 3632, 3633, 3, 354, 177, 0, 3633, 351, 1, 0, 0, 0, 3634, 3635, 3, 1380, 690, 0, 3635, 353, 1, 0, 0, 0, 3636, 3637, 3, 1358, 679, 0, 3637, 355, 1, 0, 0, 0, 3638, 3639, 5, 46, 0, 0, 3639, 3640, 5, 324, 0, 0, 3640, 3641, 3, 1340, 670, 0, 3641, 3642, 3, 358, 179, 0, 3642, 3643, 3, 362, 181, 0, 3643, 3644, 5, 63, 0, 0, 3644, 3645, 5, 174, 0, 0, 3645, 3646, 5, 374, 0, 0, 3646, 3647, 3, 1340, 670, 0, 3647, 3648, 3, 340, 170, 0, 3648, 3664, 1, 0, 0, 0, 3649, 3650, 5, 46, 0, 0, 3650, 3651, 5, 324, 0, 0, 3651, 3652, 5, 220, 0, 0, 3652, 3653, 5, 77, 0, 0, 3653, 3654, 5, 389, 0, 0, 3654, 3655, 3, 1340, 670, 0, 3655, 3656, 3, 358, 179, 0, 3656, 3657, 3, 362, 181, 0, 3657, 3658, 5, 63, 0, 0, 3658, 3659, 5, 174, 0, 0, 3659, 3660, 5, 374, 0, 0, 3660, 3661, 3, 1340, 670, 0, 3661, 3662, 3, 340, 170, 0, 3662, 3664, 1, 0, 0, 0, 3663, 3638, 1, 0, 0, 0, 3663, 3649, 1, 0, 0, 0, 3664, 357, 1, 0, 0, 0, 3665, 3666, 5, 353, 0, 0, 3666, 3669, 3, 1358, 679, 0, 3667, 3669, 1, 0, 0, 0, 3668, 3665, 1, 0, 0, 0, 3668, 3667, 1, 0, 0, 0, 3669, 359, 1, 0, 0, 0, 3670, 3673, 5, 368, 0, 0, 3671, 3674, 3, 1358, 679, 0, 3672, 3674, 5, 78, 0, 0, 3673, 3671, 1, 0, 0, 0, 3673, 3672, 1, 0, 0, 0, 3674, 361, 1, 0, 0, 0, 3675, 3678, 3, 360, 180, 0, 3676, 3678, 1, 0, 0, 0, 3677, 3675, 1, 0, 0, 0, 3677, 3676, 1, 0, 0, 0, 3678, 363, 1, 0, 0, 0, 3679, 3680, 5, 138, 0, 0, 3680, 3681, 5, 324, 0, 0, 3681, 3687, 3, 1340, 670, 0, 3682, 3688, 3, 344, 172, 0, 3683, 3685, 3, 360, 180, 0, 3684, 3686, 3, 344, 172, 0, 3685, 3684, 1, 0, 0, 0, 3685, 3686, 1, 0, 0, 0, 3686, 3688, 1, 0, 0, 0, 3687, 3682, 1, 0, 0, 0, 3687, 3683, 1, 0, 0, 0, 3688, 365, 1, 0, 0, 0, 3689, 3690, 5, 46, 0, 0, 3690, 3691, 5, 63, 0, 0, 3691, 3692, 5, 92, 0, 0, 3692, 3693, 3, 1336, 668, 0, 3693, 3694, 5, 2, 0, 0, 3694, 3695, 3, 176, 88, 0, 3695, 3696, 5, 3, 0, 0, 3696, 3697, 3, 238, 119, 0, 3697, 3698, 5, 324, 0, 0, 3698, 3699, 3, 1340, 670, 0, 3699, 3700, 3, 340, 170, 0, 3700, 3746, 1, 0, 0, 0, 3701, 3702, 5, 46, 0, 0, 3702, 3703, 5, 63, 0, 0, 3703, 3704, 5, 92, 0, 0, 3704, 3705, 5, 220, 0, 0, 3705, 3706, 5, 77, 0, 0, 3706, 3707, 5, 389, 0, 0, 3707, 3708, 3, 1336, 668, 0, 3708, 3709, 5, 2, 0, 0, 3709, 3710, 3, 176, 88, 0, 3710, 3711, 5, 3, 0, 0, 3711, 3712, 3, 238, 119, 0, 3712, 3713, 5, 324, 0, 0, 3713, 3714, 3, 1340, 670, 0, 3714, 3715, 3, 340, 170, 0, 3715, 3746, 1, 0, 0, 0, 3716, 3717, 5, 46, 0, 0, 3717, 3718, 5, 63, 0, 0, 3718, 3719, 5, 92, 0, 0, 3719, 3720, 3, 1336, 668, 0, 3720, 3721, 5, 278, 0, 0, 3721, 3722, 5, 268, 0, 0, 3722, 3723, 3, 1336, 668, 0, 3723, 3724, 3, 178, 89, 0, 3724, 3725, 3, 128, 64, 0, 3725, 3726, 5, 324, 0, 0, 3726, 3727, 3, 1340, 670, 0, 3727, 3728, 3, 340, 170, 0, 3728, 3746, 1, 0, 0, 0, 3729, 3730, 5, 46, 0, 0, 3730, 3731, 5, 63, 0, 0, 3731, 3732, 5, 92, 0, 0, 3732, 3733, 5, 220, 0, 0, 3733, 3734, 5, 77, 0, 0, 3734, 3735, 5, 389, 0, 0, 3735, 3736, 3, 1336, 668, 0, 3736, 3737, 5, 278, 0, 0, 3737, 3738, 5, 268, 0, 0, 3738, 3739, 3, 1336, 668, 0, 3739, 3740, 3, 178, 89, 0, 3740, 3741, 3, 128, 64, 0, 3741, 3742, 5, 324, 0, 0, 3742, 3743, 3, 1340, 670, 0, 3743, 3744, 3, 340, 170, 0, 3744, 3746, 1, 0, 0, 0, 3745, 3689, 1, 0, 0, 0, 3745, 3701, 1, 0, 0, 0, 3745, 3716, 1, 0, 0, 0, 3745, 3729, 1, 0, 0, 0, 3746, 367, 1, 0, 0, 0, 3747, 3748, 5, 444, 0, 0, 3748, 3749, 5, 63, 0, 0, 3749, 3750, 5, 316, 0, 0, 3750, 3751, 3, 1340, 670, 0, 3751, 3752, 3, 372, 186, 0, 3752, 3753, 5, 64, 0, 0, 3753, 3754, 5, 324, 0, 0, 3754, 3755, 3, 1340, 670, 0, 3755, 3756, 5, 71, 0, 0, 3756, 3757, 3, 1340, 670, 0, 3757, 3758, 3, 340, 170, 0, 3758, 369, 1, 0, 0, 0, 3759, 3760, 5, 74, 0, 0, 3760, 3763, 5, 94, 0, 0, 3761, 3763, 5, 59, 0, 0, 3762, 3759, 1, 0, 0, 0, 3762, 3761, 1, 0, 0, 0, 3763, 371, 1, 0, 0, 0, 3764, 3765, 3, 370, 185, 0, 3765, 3766, 5, 2, 0, 0, 3766, 3767, 3, 1076, 538, 0, 3767, 3768, 5, 3, 0, 0, 3768, 3771, 1, 0, 0, 0, 3769, 3771, 1, 0, 0, 0, 3770, 3764, 1, 0, 0, 0, 3770, 3769, 1, 0, 0, 0, 3771, 373, 1, 0, 0, 0, 3772, 3773, 5, 46, 0, 0, 3773, 3774, 5, 99, 0, 0, 3774, 3775, 5, 248, 0, 0, 3775, 3776, 5, 62, 0, 0, 3776, 3777, 3, 376, 188, 0, 3777, 3778, 5, 324, 0, 0, 3778, 3779, 3, 1340, 670, 0, 3779, 3780, 3, 340, 170, 0, 3780, 3794, 1, 0, 0, 0, 3781, 3782, 5, 46, 0, 0, 3782, 3783, 5, 99, 0, 0, 3783, 3784, 5, 248, 0, 0, 3784, 3785, 5, 220, 0, 0, 3785, 3786, 5, 77, 0, 0, 3786, 3787, 5, 389, 0, 0, 3787, 3788, 5, 62, 0, 0, 3788, 3789, 3, 376, 188, 0, 3789, 3790, 5, 324, 0, 0, 3790, 3791, 3, 1340, 670, 0, 3791, 3792, 3, 340, 170, 0, 3792, 3794, 1, 0, 0, 0, 3793, 3772, 1, 0, 0, 0, 3793, 3781, 1, 0, 0, 0, 3794, 375, 1, 0, 0, 0, 3795, 3798, 3, 1368, 684, 0, 3796, 3798, 5, 99, 0, 0, 3797, 3795, 1, 0, 0, 0, 3797, 3796, 1, 0, 0, 0, 3798, 377, 1, 0, 0, 0, 3799, 3800, 5, 191, 0, 0, 3800, 3801, 5, 99, 0, 0, 3801, 3802, 5, 248, 0, 0, 3802, 3803, 5, 62, 0, 0, 3803, 3804, 3, 376, 188, 0, 3804, 3805, 5, 324, 0, 0, 3805, 3806, 3, 1340, 670, 0, 3806, 3818, 1, 0, 0, 0, 3807, 3808, 5, 191, 0, 0, 3808, 3809, 5, 99, 0, 0, 3809, 3810, 5, 248, 0, 0, 3810, 3811, 5, 220, 0, 0, 3811, 3812, 5, 389, 0, 0, 3812, 3813, 5, 62, 0, 0, 3813, 3814, 3, 376, 188, 0, 3814, 3815, 5, 324, 0, 0, 3815, 3816, 3, 1340, 670, 0, 3816, 3818, 1, 0, 0, 0, 3817, 3799, 1, 0, 0, 0, 3817, 3807, 1, 0, 0, 0, 3818, 379, 1, 0, 0, 0, 3819, 3820, 5, 138, 0, 0, 3820, 3821, 5, 99, 0, 0, 3821, 3822, 5, 248, 0, 0, 3822, 3823, 5, 62, 0, 0, 3823, 3824, 3, 376, 188, 0, 3824, 3825, 5, 324, 0, 0, 3825, 3826, 3, 1340, 670, 0, 3826, 3827, 3, 344, 172, 0, 3827, 381, 1, 0, 0, 0, 3828, 3829, 5, 46, 0, 0, 3829, 3830, 5, 445, 0, 0, 3830, 3831, 3, 1340, 670, 0, 3831, 3832, 5, 80, 0, 0, 3832, 3833, 3, 1336, 668, 0, 3833, 3834, 3, 394, 197, 0, 3834, 3835, 3, 396, 198, 0, 3835, 3836, 3, 390, 195, 0, 3836, 3837, 3, 386, 193, 0, 3837, 3838, 3, 388, 194, 0, 3838, 383, 1, 0, 0, 0, 3839, 3840, 5, 138, 0, 0, 3840, 3841, 5, 445, 0, 0, 3841, 3842, 3, 1340, 670, 0, 3842, 3843, 5, 80, 0, 0, 3843, 3844, 3, 1336, 668, 0, 3844, 3845, 3, 392, 196, 0, 3845, 3846, 3, 386, 193, 0, 3846, 3847, 3, 388, 194, 0, 3847, 385, 1, 0, 0, 0, 3848, 3849, 5, 100, 0, 0, 3849, 3850, 5, 2, 0, 0, 3850, 3851, 3, 1162, 581, 0, 3851, 3852, 5, 3, 0, 0, 3852, 3855, 1, 0, 0, 0, 3853, 3855, 1, 0, 0, 0, 3854, 3848, 1, 0, 0, 0, 3854, 3853, 1, 0, 0, 0, 3855, 387, 1, 0, 0, 0, 3856, 3857, 5, 105, 0, 0, 3857, 3858, 5, 42, 0, 0, 3858, 3859, 5, 2, 0, 0, 3859, 3860, 3, 1162, 581, 0, 3860, 3861, 5, 3, 0, 0, 3861, 3864, 1, 0, 0, 0, 3862, 3864, 1, 0, 0, 0, 3863, 3856, 1, 0, 0, 0, 3863, 3862, 1, 0, 0, 0, 3864, 389, 1, 0, 0, 0, 3865, 3866, 5, 94, 0, 0, 3866, 3869, 3, 1370, 685, 0, 3867, 3869, 1, 0, 0, 0, 3868, 3865, 1, 0, 0, 0, 3868, 3867, 1, 0, 0, 0, 3869, 391, 1, 0, 0, 0, 3870, 3871, 5, 94, 0, 0, 3871, 3874, 3, 1370, 685, 0, 3872, 3874, 1, 0, 0, 0, 3873, 3870, 1, 0, 0, 0, 3873, 3872, 1, 0, 0, 0, 3874, 393, 1, 0, 0, 0, 3875, 3876, 5, 36, 0, 0, 3876, 3879, 3, 1382, 691, 0, 3877, 3879, 1, 0, 0, 0, 3878, 3875, 1, 0, 0, 0, 3878, 3877, 1, 0, 0, 0, 3879, 395, 1, 0, 0, 0, 3880, 3881, 5, 62, 0, 0, 3881, 3884, 3, 398, 199, 0, 3882, 3884, 1, 0, 0, 0, 3883, 3880, 1, 0, 0, 0, 3883, 3882, 1, 0, 0, 0, 3884, 397, 1, 0, 0, 0, 3885, 3886, 7, 17, 0, 0, 3886, 399, 1, 0, 0, 0, 3887, 3888, 5, 46, 0, 0, 3888, 3889, 5, 131, 0, 0, 3889, 3890, 5, 446, 0, 0, 3890, 3891, 3, 1340, 670, 0, 3891, 3892, 5, 353, 0, 0, 3892, 3893, 3, 402, 201, 0, 3893, 3894, 5, 215, 0, 0, 3894, 3895, 3, 300, 150, 0, 3895, 401, 1, 0, 0, 0, 3896, 3897, 7, 18, 0, 0, 3897, 403, 1, 0, 0, 0, 3898, 3899, 5, 46, 0, 0, 3899, 3900, 5, 350, 0, 0, 3900, 3901, 3, 1340, 670, 0, 3901, 3902, 3, 406, 203, 0, 3902, 3903, 3, 408, 204, 0, 3903, 3904, 5, 80, 0, 0, 3904, 3905, 3, 1336, 668, 0, 3905, 3906, 3, 412, 206, 0, 3906, 3907, 3, 424, 212, 0, 3907, 3908, 3, 430, 215, 0, 3908, 3909, 5, 202, 0, 0, 3909, 3910, 3, 432, 216, 0, 3910, 3911, 3, 1346, 673, 0, 3911, 3912, 5, 2, 0, 0, 3912, 3913, 3, 434, 217, 0, 3913, 3914, 5, 3, 0, 0, 3914, 3937, 1, 0, 0, 0, 3915, 3916, 5, 46, 0, 0, 3916, 3917, 5, 45, 0, 0, 3917, 3918, 5, 350, 0, 0, 3918, 3919, 3, 1340, 670, 0, 3919, 3920, 5, 135, 0, 0, 3920, 3921, 3, 408, 204, 0, 3921, 3922, 5, 80, 0, 0, 3922, 3923, 3, 1336, 668, 0, 3923, 3924, 3, 438, 219, 0, 3924, 3925, 3, 440, 220, 0, 3925, 3926, 5, 62, 0, 0, 3926, 3927, 5, 192, 0, 0, 3927, 3928, 5, 407, 0, 0, 3928, 3929, 3, 430, 215, 0, 3929, 3930, 5, 202, 0, 0, 3930, 3931, 3, 432, 216, 0, 3931, 3932, 3, 1346, 673, 0, 3932, 3933, 5, 2, 0, 0, 3933, 3934, 3, 434, 217, 0, 3934, 3935, 5, 3, 0, 0, 3935, 3937, 1, 0, 0, 0, 3936, 3898, 1, 0, 0, 0, 3936, 3915, 1, 0, 0, 0, 3937, 405, 1, 0, 0, 0, 3938, 3943, 5, 145, 0, 0, 3939, 3943, 5, 135, 0, 0, 3940, 3941, 5, 233, 0, 0, 3941, 3943, 5, 268, 0, 0, 3942, 3938, 1, 0, 0, 0, 3942, 3939, 1, 0, 0, 0, 3942, 3940, 1, 0, 0, 0, 3943, 407, 1, 0, 0, 0, 3944, 3949, 3, 410, 205, 0, 3945, 3946, 5, 82, 0, 0, 3946, 3948, 3, 410, 205, 0, 3947, 3945, 1, 0, 0, 0, 3948, 3951, 1, 0, 0, 0, 3949, 3947, 1, 0, 0, 0, 3949, 3950, 1, 0, 0, 0, 3950, 409, 1, 0, 0, 0, 3951, 3949, 1, 0, 0, 0, 3952, 3960, 5, 232, 0, 0, 3953, 3960, 5, 182, 0, 0, 3954, 3960, 5, 362, 0, 0, 3955, 3956, 5, 362, 0, 0, 3956, 3957, 5, 268, 0, 0, 3957, 3960, 3, 216, 108, 0, 3958, 3960, 5, 351, 0, 0, 3959, 3952, 1, 0, 0, 0, 3959, 3953, 1, 0, 0, 0, 3959, 3954, 1, 0, 0, 0, 3959, 3955, 1, 0, 0, 0, 3959, 3958, 1, 0, 0, 0, 3960, 411, 1, 0, 0, 0, 3961, 3962, 5, 447, 0, 0, 3962, 3965, 3, 414, 207, 0, 3963, 3965, 1, 0, 0, 0, 3964, 3961, 1, 0, 0, 0, 3964, 3963, 1, 0, 0, 0, 3965, 413, 1, 0, 0, 0, 3966, 3968, 3, 416, 208, 0, 3967, 3966, 1, 0, 0, 0, 3968, 3969, 1, 0, 0, 0, 3969, 3967, 1, 0, 0, 0, 3969, 3970, 1, 0, 0, 0, 3970, 415, 1, 0, 0, 0, 3971, 3972, 3, 418, 209, 0, 3972, 3973, 3, 420, 210, 0, 3973, 3974, 3, 834, 417, 0, 3974, 3975, 3, 422, 211, 0, 3975, 417, 1, 0, 0, 0, 3976, 3977, 7, 19, 0, 0, 3977, 419, 1, 0, 0, 0, 3978, 3979, 7, 20, 0, 0, 3979, 421, 1, 0, 0, 0, 3980, 3981, 3, 1372, 686, 0, 3981, 423, 1, 0, 0, 0, 3982, 3983, 5, 62, 0, 0, 3983, 3984, 3, 426, 213, 0, 3984, 3985, 3, 428, 214, 0, 3985, 3988, 1, 0, 0, 0, 3986, 3988, 1, 0, 0, 0, 3987, 3982, 1, 0, 0, 0, 3987, 3986, 1, 0, 0, 0, 3988, 425, 1, 0, 0, 0, 3989, 3992, 5, 192, 0, 0, 3990, 3992, 1, 0, 0, 0, 3991, 3989, 1, 0, 0, 0, 3991, 3990, 1, 0, 0, 0, 3992, 427, 1, 0, 0, 0, 3993, 3994, 7, 21, 0, 0, 3994, 429, 1, 0, 0, 0, 3995, 3996, 5, 102, 0, 0, 3996, 3997, 5, 2, 0, 0, 3997, 3998, 3, 1162, 581, 0, 3998, 3999, 5, 3, 0, 0, 3999, 4002, 1, 0, 0, 0, 4000, 4002, 1, 0, 0, 0, 4001, 3995, 1, 0, 0, 0, 4001, 4000, 1, 0, 0, 0, 4002, 431, 1, 0, 0, 0, 4003, 4004, 7, 22, 0, 0, 4004, 433, 1, 0, 0, 0, 4005, 4008, 3, 436, 218, 0, 4006, 4008, 1, 0, 0, 0, 4007, 4005, 1, 0, 0, 0, 4007, 4006, 1, 0, 0, 0, 4008, 4013, 1, 0, 0, 0, 4009, 4010, 5, 6, 0, 0, 4010, 4012, 3, 436, 218, 0, 4011, 4009, 1, 0, 0, 0, 4012, 4015, 1, 0, 0, 0, 4013, 4011, 1, 0, 0, 0, 4013, 4014, 1, 0, 0, 0, 4014, 435, 1, 0, 0, 0, 4015, 4013, 1, 0, 0, 0, 4016, 4021, 3, 1356, 678, 0, 4017, 4021, 3, 1354, 677, 0, 4018, 4021, 3, 1358, 679, 0, 4019, 4021, 3, 1380, 690, 0, 4020, 4016, 1, 0, 0, 0, 4020, 4017, 1, 0, 0, 0, 4020, 4018, 1, 0, 0, 0, 4020, 4019, 1, 0, 0, 0, 4021, 437, 1, 0, 0, 0, 4022, 4023, 5, 64, 0, 0, 4023, 4026, 3, 1336, 668, 0, 4024, 4026, 1, 0, 0, 0, 4025, 4022, 1, 0, 0, 0, 4025, 4024, 1, 0, 0, 0, 4026, 439, 1, 0, 0, 0, 4027, 4029, 3, 442, 221, 0, 4028, 4027, 1, 0, 0, 0, 4029, 4032, 1, 0, 0, 0, 4030, 4028, 1, 0, 0, 0, 4030, 4031, 1, 0, 0, 0, 4031, 441, 1, 0, 0, 0, 4032, 4030, 1, 0, 0, 0, 4033, 4034, 5, 77, 0, 0, 4034, 4045, 5, 54, 0, 0, 4035, 4045, 5, 54, 0, 0, 4036, 4037, 5, 69, 0, 0, 4037, 4045, 5, 221, 0, 0, 4038, 4039, 5, 69, 0, 0, 4039, 4045, 5, 180, 0, 0, 4040, 4041, 5, 77, 0, 0, 4041, 4045, 5, 364, 0, 0, 4042, 4043, 5, 262, 0, 0, 4043, 4045, 5, 228, 0, 0, 4044, 4033, 1, 0, 0, 0, 4044, 4035, 1, 0, 0, 0, 4044, 4036, 1, 0, 0, 0, 4044, 4038, 1, 0, 0, 0, 4044, 4040, 1, 0, 0, 0, 4044, 4042, 1, 0, 0, 0, 4045, 443, 1, 0, 0, 0, 4046, 4047, 5, 46, 0, 0, 4047, 4048, 5, 198, 0, 0, 4048, 4049, 5, 350, 0, 0, 4049, 4050, 3, 1340, 670, 0, 4050, 4051, 5, 80, 0, 0, 4051, 4052, 3, 1380, 690, 0, 4052, 4053, 5, 202, 0, 0, 4053, 4054, 3, 432, 216, 0, 4054, 4055, 3, 1346, 673, 0, 4055, 4056, 5, 2, 0, 0, 4056, 4057, 5, 3, 0, 0, 4057, 4073, 1, 0, 0, 0, 4058, 4059, 5, 46, 0, 0, 4059, 4060, 5, 198, 0, 0, 4060, 4061, 5, 350, 0, 0, 4061, 4062, 3, 1340, 670, 0, 4062, 4063, 5, 80, 0, 0, 4063, 4064, 3, 1380, 690, 0, 4064, 4065, 5, 102, 0, 0, 4065, 4066, 3, 446, 223, 0, 4066, 4067, 5, 202, 0, 0, 4067, 4068, 3, 432, 216, 0, 4068, 4069, 3, 1346, 673, 0, 4069, 4070, 5, 2, 0, 0, 4070, 4071, 5, 3, 0, 0, 4071, 4073, 1, 0, 0, 0, 4072, 4046, 1, 0, 0, 0, 4072, 4058, 1, 0, 0, 0, 4073, 445, 1, 0, 0, 0, 4074, 4079, 3, 448, 224, 0, 4075, 4076, 5, 33, 0, 0, 4076, 4078, 3, 448, 224, 0, 4077, 4075, 1, 0, 0, 0, 4078, 4081, 1, 0, 0, 0, 4079, 4077, 1, 0, 0, 0, 4079, 4080, 1, 0, 0, 0, 4080, 447, 1, 0, 0, 0, 4081, 4079, 1, 0, 0, 0, 4082, 4083, 3, 1372, 686, 0, 4083, 4084, 5, 68, 0, 0, 4084, 4085, 5, 2, 0, 0, 4085, 4086, 3, 450, 225, 0, 4086, 4087, 5, 3, 0, 0, 4087, 449, 1, 0, 0, 0, 4088, 4093, 3, 1358, 679, 0, 4089, 4090, 5, 6, 0, 0, 4090, 4092, 3, 1358, 679, 0, 4091, 4089, 1, 0, 0, 0, 4092, 4095, 1, 0, 0, 0, 4093, 4091, 1, 0, 0, 0, 4093, 4094, 1, 0, 0, 0, 4094, 451, 1, 0, 0, 0, 4095, 4093, 1, 0, 0, 0, 4096, 4097, 5, 138, 0, 0, 4097, 4098, 5, 198, 0, 0, 4098, 4099, 5, 350, 0, 0, 4099, 4100, 3, 1340, 670, 0, 4100, 4101, 3, 454, 227, 0, 4101, 453, 1, 0, 0, 0, 4102, 4109, 5, 193, 0, 0, 4103, 4104, 5, 193, 0, 0, 4104, 4109, 5, 305, 0, 0, 4105, 4106, 5, 193, 0, 0, 4106, 4109, 5, 139, 0, 0, 4107, 4109, 5, 186, 0, 0, 4108, 4102, 1, 0, 0, 0, 4108, 4103, 1, 0, 0, 0, 4108, 4105, 1, 0, 0, 0, 4108, 4107, 1, 0, 0, 0, 4109, 455, 1, 0, 0, 0, 4110, 4111, 5, 46, 0, 0, 4111, 4112, 5, 140, 0, 0, 4112, 4113, 3, 524, 262, 0, 4113, 4114, 5, 42, 0, 0, 4114, 4115, 5, 2, 0, 0, 4115, 4116, 3, 1162, 581, 0, 4116, 4117, 5, 3, 0, 0, 4117, 4118, 3, 440, 220, 0, 4118, 457, 1, 0, 0, 0, 4119, 4120, 5, 46, 0, 0, 4120, 4121, 3, 618, 309, 0, 4121, 4122, 5, 136, 0, 0, 4122, 4123, 3, 1346, 673, 0, 4123, 4124, 3, 646, 323, 0, 4124, 4125, 3, 460, 230, 0, 4125, 4226, 1, 0, 0, 0, 4126, 4127, 5, 46, 0, 0, 4127, 4128, 3, 618, 309, 0, 4128, 4129, 5, 136, 0, 0, 4129, 4130, 3, 1346, 673, 0, 4130, 4131, 3, 468, 234, 0, 4131, 4226, 1, 0, 0, 0, 4132, 4133, 5, 46, 0, 0, 4133, 4134, 5, 271, 0, 0, 4134, 4135, 3, 684, 342, 0, 4135, 4136, 3, 460, 230, 0, 4136, 4226, 1, 0, 0, 0, 4137, 4138, 5, 46, 0, 0, 4138, 4139, 5, 353, 0, 0, 4139, 4140, 3, 524, 262, 0, 4140, 4141, 3, 460, 230, 0, 4141, 4226, 1, 0, 0, 0, 4142, 4143, 5, 46, 0, 0, 4143, 4144, 5, 353, 0, 0, 4144, 4226, 3, 524, 262, 0, 4145, 4146, 5, 46, 0, 0, 4146, 4147, 5, 353, 0, 0, 4147, 4148, 3, 524, 262, 0, 4148, 4149, 5, 36, 0, 0, 4149, 4150, 5, 2, 0, 0, 4150, 4151, 3, 1098, 549, 0, 4151, 4152, 5, 3, 0, 0, 4152, 4226, 1, 0, 0, 0, 4153, 4154, 5, 46, 0, 0, 4154, 4155, 5, 353, 0, 0, 4155, 4156, 3, 524, 262, 0, 4156, 4157, 5, 36, 0, 0, 4157, 4158, 5, 196, 0, 0, 4158, 4159, 5, 2, 0, 0, 4159, 4160, 3, 474, 237, 0, 4160, 4161, 5, 3, 0, 0, 4161, 4226, 1, 0, 0, 0, 4162, 4163, 5, 46, 0, 0, 4163, 4164, 5, 353, 0, 0, 4164, 4165, 3, 524, 262, 0, 4165, 4166, 5, 36, 0, 0, 4166, 4167, 5, 292, 0, 0, 4167, 4168, 3, 460, 230, 0, 4168, 4226, 1, 0, 0, 0, 4169, 4170, 5, 46, 0, 0, 4170, 4171, 5, 348, 0, 0, 4171, 4172, 5, 318, 0, 0, 4172, 4173, 5, 276, 0, 0, 4173, 4174, 3, 524, 262, 0, 4174, 4175, 3, 460, 230, 0, 4175, 4226, 1, 0, 0, 0, 4176, 4177, 5, 46, 0, 0, 4177, 4178, 5, 348, 0, 0, 4178, 4179, 5, 318, 0, 0, 4179, 4180, 5, 185, 0, 0, 4180, 4181, 3, 524, 262, 0, 4181, 4182, 3, 460, 230, 0, 4182, 4226, 1, 0, 0, 0, 4183, 4184, 5, 46, 0, 0, 4184, 4185, 5, 348, 0, 0, 4185, 4186, 5, 318, 0, 0, 4186, 4187, 5, 346, 0, 0, 4187, 4188, 3, 524, 262, 0, 4188, 4189, 3, 460, 230, 0, 4189, 4226, 1, 0, 0, 0, 4190, 4191, 5, 46, 0, 0, 4191, 4192, 5, 348, 0, 0, 4192, 4193, 5, 318, 0, 0, 4193, 4194, 5, 163, 0, 0, 4194, 4195, 3, 524, 262, 0, 4195, 4196, 3, 460, 230, 0, 4196, 4226, 1, 0, 0, 0, 4197, 4198, 5, 46, 0, 0, 4198, 4199, 5, 108, 0, 0, 4199, 4200, 3, 524, 262, 0, 4200, 4201, 3, 460, 230, 0, 4201, 4226, 1, 0, 0, 0, 4202, 4203, 5, 46, 0, 0, 4203, 4204, 5, 108, 0, 0, 4204, 4205, 5, 220, 0, 0, 4205, 4206, 5, 77, 0, 0, 4206, 4207, 5, 389, 0, 0, 4207, 4208, 3, 524, 262, 0, 4208, 4209, 3, 460, 230, 0, 4209, 4226, 1, 0, 0, 0, 4210, 4211, 5, 46, 0, 0, 4211, 4212, 5, 108, 0, 0, 4212, 4213, 3, 524, 262, 0, 4213, 4214, 5, 64, 0, 0, 4214, 4215, 3, 524, 262, 0, 4215, 4226, 1, 0, 0, 0, 4216, 4217, 5, 46, 0, 0, 4217, 4218, 5, 108, 0, 0, 4218, 4219, 5, 220, 0, 0, 4219, 4220, 5, 77, 0, 0, 4220, 4221, 5, 389, 0, 0, 4221, 4222, 3, 524, 262, 0, 4222, 4223, 5, 64, 0, 0, 4223, 4224, 3, 524, 262, 0, 4224, 4226, 1, 0, 0, 0, 4225, 4119, 1, 0, 0, 0, 4225, 4126, 1, 0, 0, 0, 4225, 4132, 1, 0, 0, 0, 4225, 4137, 1, 0, 0, 0, 4225, 4142, 1, 0, 0, 0, 4225, 4145, 1, 0, 0, 0, 4225, 4153, 1, 0, 0, 0, 4225, 4162, 1, 0, 0, 0, 4225, 4169, 1, 0, 0, 0, 4225, 4176, 1, 0, 0, 0, 4225, 4183, 1, 0, 0, 0, 4225, 4190, 1, 0, 0, 0, 4225, 4197, 1, 0, 0, 0, 4225, 4202, 1, 0, 0, 0, 4225, 4210, 1, 0, 0, 0, 4225, 4216, 1, 0, 0, 0, 4226, 459, 1, 0, 0, 0, 4227, 4228, 5, 2, 0, 0, 4228, 4229, 3, 462, 231, 0, 4229, 4230, 5, 3, 0, 0, 4230, 461, 1, 0, 0, 0, 4231, 4236, 3, 464, 232, 0, 4232, 4233, 5, 6, 0, 0, 4233, 4235, 3, 464, 232, 0, 4234, 4232, 1, 0, 0, 0, 4235, 4238, 1, 0, 0, 0, 4236, 4234, 1, 0, 0, 0, 4236, 4237, 1, 0, 0, 0, 4237, 463, 1, 0, 0, 0, 4238, 4236, 1, 0, 0, 0, 4239, 4242, 3, 1380, 690, 0, 4240, 4241, 5, 10, 0, 0, 4241, 4243, 3, 466, 233, 0, 4242, 4240, 1, 0, 0, 0, 4242, 4243, 1, 0, 0, 0, 4243, 465, 1, 0, 0, 0, 4244, 4251, 3, 640, 320, 0, 4245, 4251, 3, 1392, 696, 0, 4246, 4251, 3, 1276, 638, 0, 4247, 4251, 3, 292, 146, 0, 4248, 4251, 3, 1358, 679, 0, 4249, 4251, 5, 400, 0, 0, 4250, 4244, 1, 0, 0, 0, 4250, 4245, 1, 0, 0, 0, 4250, 4246, 1, 0, 0, 0, 4250, 4247, 1, 0, 0, 0, 4250, 4248, 1, 0, 0, 0, 4250, 4249, 1, 0, 0, 0, 4251, 467, 1, 0, 0, 0, 4252, 4253, 5, 2, 0, 0, 4253, 4254, 3, 470, 235, 0, 4254, 4255, 5, 3, 0, 0, 4255, 469, 1, 0, 0, 0, 4256, 4261, 3, 472, 236, 0, 4257, 4258, 5, 6, 0, 0, 4258, 4260, 3, 472, 236, 0, 4259, 4257, 1, 0, 0, 0, 4260, 4263, 1, 0, 0, 0, 4261, 4259, 1, 0, 0, 0, 4261, 4262, 1, 0, 0, 0, 4262, 471, 1, 0, 0, 0, 4263, 4261, 1, 0, 0, 0, 4264, 4265, 3, 1382, 691, 0, 4265, 4266, 5, 10, 0, 0, 4266, 4267, 3, 466, 233, 0, 4267, 473, 1, 0, 0, 0, 4268, 4271, 3, 476, 238, 0, 4269, 4271, 1, 0, 0, 0, 4270, 4268, 1, 0, 0, 0, 4270, 4269, 1, 0, 0, 0, 4271, 475, 1, 0, 0, 0, 4272, 4277, 3, 1358, 679, 0, 4273, 4274, 5, 6, 0, 0, 4274, 4276, 3, 1358, 679, 0, 4275, 4273, 1, 0, 0, 0, 4276, 4279, 1, 0, 0, 0, 4277, 4275, 1, 0, 0, 0, 4277, 4278, 1, 0, 0, 0, 4278, 477, 1, 0, 0, 0, 4279, 4277, 1, 0, 0, 0, 4280, 4281, 5, 138, 0, 0, 4281, 4282, 5, 353, 0, 0, 4282, 4283, 3, 524, 262, 0, 4283, 4284, 5, 133, 0, 0, 4284, 4285, 5, 450, 0, 0, 4285, 4286, 3, 480, 240, 0, 4286, 4287, 3, 1358, 679, 0, 4287, 4318, 1, 0, 0, 0, 4288, 4289, 5, 138, 0, 0, 4289, 4290, 5, 353, 0, 0, 4290, 4291, 3, 524, 262, 0, 4291, 4292, 5, 133, 0, 0, 4292, 4293, 5, 450, 0, 0, 4293, 4294, 3, 480, 240, 0, 4294, 4295, 3, 1358, 679, 0, 4295, 4296, 5, 145, 0, 0, 4296, 4297, 3, 1358, 679, 0, 4297, 4318, 1, 0, 0, 0, 4298, 4299, 5, 138, 0, 0, 4299, 4300, 5, 353, 0, 0, 4300, 4301, 3, 524, 262, 0, 4301, 4302, 5, 133, 0, 0, 4302, 4303, 5, 450, 0, 0, 4303, 4304, 3, 480, 240, 0, 4304, 4305, 3, 1358, 679, 0, 4305, 4306, 5, 135, 0, 0, 4306, 4307, 3, 1358, 679, 0, 4307, 4318, 1, 0, 0, 0, 4308, 4309, 5, 138, 0, 0, 4309, 4310, 5, 353, 0, 0, 4310, 4311, 3, 524, 262, 0, 4311, 4312, 5, 302, 0, 0, 4312, 4313, 5, 450, 0, 0, 4313, 4314, 3, 1358, 679, 0, 4314, 4315, 5, 94, 0, 0, 4315, 4316, 3, 1358, 679, 0, 4316, 4318, 1, 0, 0, 0, 4317, 4280, 1, 0, 0, 0, 4317, 4288, 1, 0, 0, 0, 4317, 4298, 1, 0, 0, 0, 4317, 4308, 1, 0, 0, 0, 4318, 479, 1, 0, 0, 0, 4319, 4320, 5, 220, 0, 0, 4320, 4321, 5, 77, 0, 0, 4321, 4324, 5, 389, 0, 0, 4322, 4324, 1, 0, 0, 0, 4323, 4319, 1, 0, 0, 0, 4323, 4322, 1, 0, 0, 0, 4324, 481, 1, 0, 0, 0, 4325, 4326, 5, 46, 0, 0, 4326, 4327, 5, 271, 0, 0, 4327, 4328, 5, 156, 0, 0, 4328, 4329, 3, 524, 262, 0, 4329, 4330, 3, 488, 244, 0, 4330, 4331, 5, 62, 0, 0, 4331, 4332, 5, 353, 0, 0, 4332, 4333, 3, 1118, 559, 0, 4333, 4334, 5, 100, 0, 0, 4334, 4335, 3, 1340, 670, 0, 4335, 4336, 3, 490, 245, 0, 4336, 4337, 5, 36, 0, 0, 4337, 4338, 3, 484, 242, 0, 4338, 483, 1, 0, 0, 0, 4339, 4344, 3, 486, 243, 0, 4340, 4341, 5, 6, 0, 0, 4341, 4343, 3, 486, 243, 0, 4342, 4340, 1, 0, 0, 0, 4343, 4346, 1, 0, 0, 0, 4344, 4342, 1, 0, 0, 0, 4344, 4345, 1, 0, 0, 0, 4345, 485, 1, 0, 0, 0, 4346, 4344, 1, 0, 0, 0, 4347, 4348, 5, 271, 0, 0, 4348, 4349, 3, 1356, 678, 0, 4349, 4350, 3, 684, 342, 0, 4350, 4351, 3, 492, 246, 0, 4351, 4352, 3, 494, 247, 0, 4352, 4373, 1, 0, 0, 0, 4353, 4354, 5, 271, 0, 0, 4354, 4355, 3, 1356, 678, 0, 4355, 4356, 3, 688, 344, 0, 4356, 4357, 3, 492, 246, 0, 4357, 4358, 3, 494, 247, 0, 4358, 4373, 1, 0, 0, 0, 4359, 4360, 5, 211, 0, 0, 4360, 4361, 3, 1356, 678, 0, 4361, 4362, 3, 626, 313, 0, 4362, 4373, 1, 0, 0, 0, 4363, 4364, 5, 211, 0, 0, 4364, 4365, 3, 1356, 678, 0, 4365, 4366, 5, 2, 0, 0, 4366, 4367, 3, 1286, 643, 0, 4367, 4368, 5, 3, 0, 0, 4368, 4369, 3, 626, 313, 0, 4369, 4373, 1, 0, 0, 0, 4370, 4371, 5, 338, 0, 0, 4371, 4373, 3, 1118, 559, 0, 4372, 4347, 1, 0, 0, 0, 4372, 4353, 1, 0, 0, 0, 4372, 4359, 1, 0, 0, 0, 4372, 4363, 1, 0, 0, 0, 4372, 4370, 1, 0, 0, 0, 4373, 487, 1, 0, 0, 0, 4374, 4377, 5, 53, 0, 0, 4375, 4377, 1, 0, 0, 0, 4376, 4374, 1, 0, 0, 0, 4376, 4375, 1, 0, 0, 0, 4377, 489, 1, 0, 0, 0, 4378, 4379, 5, 206, 0, 0, 4379, 4382, 3, 524, 262, 0, 4380, 4382, 1, 0, 0, 0, 4381, 4378, 1, 0, 0, 0, 4381, 4380, 1, 0, 0, 0, 4382, 491, 1, 0, 0, 0, 4383, 4384, 5, 62, 0, 0, 4384, 4391, 5, 318, 0, 0, 4385, 4386, 5, 62, 0, 0, 4386, 4387, 5, 83, 0, 0, 4387, 4388, 5, 147, 0, 0, 4388, 4391, 3, 524, 262, 0, 4389, 4391, 1, 0, 0, 0, 4390, 4383, 1, 0, 0, 0, 4390, 4385, 1, 0, 0, 0, 4390, 4389, 1, 0, 0, 0, 4391, 493, 1, 0, 0, 0, 4392, 4395, 5, 295, 0, 0, 4393, 4395, 1, 0, 0, 0, 4394, 4392, 1, 0, 0, 0, 4394, 4393, 1, 0, 0, 0, 4395, 495, 1, 0, 0, 0, 4396, 4397, 5, 46, 0, 0, 4397, 4398, 5, 271, 0, 0, 4398, 4399, 5, 206, 0, 0, 4399, 4400, 3, 524, 262, 0, 4400, 4401, 5, 100, 0, 0, 4401, 4402, 3, 1340, 670, 0, 4402, 497, 1, 0, 0, 0, 4403, 4404, 5, 138, 0, 0, 4404, 4405, 5, 271, 0, 0, 4405, 4406, 5, 206, 0, 0, 4406, 4407, 3, 524, 262, 0, 4407, 4408, 5, 100, 0, 0, 4408, 4409, 3, 1340, 670, 0, 4409, 4410, 5, 133, 0, 0, 4410, 4411, 3, 484, 242, 0, 4411, 4422, 1, 0, 0, 0, 4412, 4413, 5, 138, 0, 0, 4413, 4414, 5, 271, 0, 0, 4414, 4415, 5, 206, 0, 0, 4415, 4416, 3, 524, 262, 0, 4416, 4417, 5, 100, 0, 0, 4417, 4418, 3, 1340, 670, 0, 4418, 4419, 5, 191, 0, 0, 4419, 4420, 3, 500, 250, 0, 4420, 4422, 1, 0, 0, 0, 4421, 4403, 1, 0, 0, 0, 4421, 4412, 1, 0, 0, 0, 4422, 499, 1, 0, 0, 0, 4423, 4428, 3, 502, 251, 0, 4424, 4425, 5, 6, 0, 0, 4425, 4427, 3, 502, 251, 0, 4426, 4424, 1, 0, 0, 0, 4427, 4430, 1, 0, 0, 0, 4428, 4426, 1, 0, 0, 0, 4428, 4429, 1, 0, 0, 0, 4429, 501, 1, 0, 0, 0, 4430, 4428, 1, 0, 0, 0, 4431, 4432, 5, 271, 0, 0, 4432, 4433, 3, 1356, 678, 0, 4433, 4434, 5, 2, 0, 0, 4434, 4435, 3, 1286, 643, 0, 4435, 4436, 5, 3, 0, 0, 4436, 4444, 1, 0, 0, 0, 4437, 4438, 5, 211, 0, 0, 4438, 4439, 3, 1356, 678, 0, 4439, 4440, 5, 2, 0, 0, 4440, 4441, 3, 1286, 643, 0, 4441, 4442, 5, 3, 0, 0, 4442, 4444, 1, 0, 0, 0, 4443, 4431, 1, 0, 0, 0, 4443, 4437, 1, 0, 0, 0, 4444, 503, 1, 0, 0, 0, 4445, 4446, 5, 191, 0, 0, 4446, 4447, 5, 271, 0, 0, 4447, 4448, 5, 156, 0, 0, 4448, 4449, 3, 524, 262, 0, 4449, 4450, 5, 100, 0, 0, 4450, 4451, 3, 1340, 670, 0, 4451, 4452, 3, 108, 54, 0, 4452, 4464, 1, 0, 0, 0, 4453, 4454, 5, 191, 0, 0, 4454, 4455, 5, 271, 0, 0, 4455, 4456, 5, 156, 0, 0, 4456, 4457, 5, 220, 0, 0, 4457, 4458, 5, 389, 0, 0, 4458, 4459, 3, 524, 262, 0, 4459, 4460, 5, 100, 0, 0, 4460, 4461, 3, 1340, 670, 0, 4461, 4462, 3, 108, 54, 0, 4462, 4464, 1, 0, 0, 0, 4463, 4445, 1, 0, 0, 0, 4463, 4453, 1, 0, 0, 0, 4464, 505, 1, 0, 0, 0, 4465, 4466, 5, 191, 0, 0, 4466, 4467, 5, 271, 0, 0, 4467, 4468, 5, 206, 0, 0, 4468, 4469, 3, 524, 262, 0, 4469, 4470, 5, 100, 0, 0, 4470, 4471, 3, 1340, 670, 0, 4471, 4472, 3, 108, 54, 0, 4472, 4484, 1, 0, 0, 0, 4473, 4474, 5, 191, 0, 0, 4474, 4475, 5, 271, 0, 0, 4475, 4476, 5, 206, 0, 0, 4476, 4477, 5, 220, 0, 0, 4477, 4478, 5, 389, 0, 0, 4478, 4479, 3, 524, 262, 0, 4479, 4480, 5, 100, 0, 0, 4480, 4481, 3, 1340, 670, 0, 4481, 4482, 3, 108, 54, 0, 4482, 4484, 1, 0, 0, 0, 4483, 4465, 1, 0, 0, 0, 4483, 4473, 1, 0, 0, 0, 4484, 507, 1, 0, 0, 0, 4485, 4486, 5, 191, 0, 0, 4486, 4487, 5, 274, 0, 0, 4487, 4488, 5, 147, 0, 0, 4488, 4489, 3, 1370, 685, 0, 4489, 4490, 3, 108, 54, 0, 4490, 509, 1, 0, 0, 0, 4491, 4492, 5, 294, 0, 0, 4492, 4493, 5, 274, 0, 0, 4493, 4494, 5, 147, 0, 0, 4494, 4495, 3, 1370, 685, 0, 4495, 4496, 5, 94, 0, 0, 4496, 4497, 3, 1368, 684, 0, 4497, 511, 1, 0, 0, 0, 4498, 4499, 5, 191, 0, 0, 4499, 4500, 3, 514, 257, 0, 4500, 4501, 5, 220, 0, 0, 4501, 4502, 5, 389, 0, 0, 4502, 4503, 3, 522, 261, 0, 4503, 4504, 3, 108, 54, 0, 4504, 4577, 1, 0, 0, 0, 4505, 4506, 5, 191, 0, 0, 4506, 4507, 3, 514, 257, 0, 4507, 4508, 3, 522, 261, 0, 4508, 4509, 3, 108, 54, 0, 4509, 4577, 1, 0, 0, 0, 4510, 4511, 5, 191, 0, 0, 4511, 4512, 3, 518, 259, 0, 4512, 4513, 5, 220, 0, 0, 4513, 4514, 5, 389, 0, 0, 4514, 4515, 3, 1338, 669, 0, 4515, 4516, 3, 108, 54, 0, 4516, 4577, 1, 0, 0, 0, 4517, 4518, 5, 191, 0, 0, 4518, 4519, 3, 518, 259, 0, 4519, 4520, 3, 1338, 669, 0, 4520, 4521, 3, 108, 54, 0, 4521, 4577, 1, 0, 0, 0, 4522, 4523, 5, 191, 0, 0, 4523, 4524, 3, 520, 260, 0, 4524, 4525, 3, 1340, 670, 0, 4525, 4526, 5, 80, 0, 0, 4526, 4527, 3, 524, 262, 0, 4527, 4528, 3, 108, 54, 0, 4528, 4577, 1, 0, 0, 0, 4529, 4530, 5, 191, 0, 0, 4530, 4531, 3, 520, 260, 0, 4531, 4532, 5, 220, 0, 0, 4532, 4533, 5, 389, 0, 0, 4533, 4534, 3, 1340, 670, 0, 4534, 4535, 5, 80, 0, 0, 4535, 4536, 3, 524, 262, 0, 4536, 4537, 3, 108, 54, 0, 4537, 4577, 1, 0, 0, 0, 4538, 4539, 5, 191, 0, 0, 4539, 4540, 5, 353, 0, 0, 4540, 4541, 3, 528, 264, 0, 4541, 4542, 3, 108, 54, 0, 4542, 4577, 1, 0, 0, 0, 4543, 4544, 5, 191, 0, 0, 4544, 4545, 5, 353, 0, 0, 4545, 4546, 5, 220, 0, 0, 4546, 4547, 5, 389, 0, 0, 4547, 4548, 3, 528, 264, 0, 4548, 4549, 3, 108, 54, 0, 4549, 4577, 1, 0, 0, 0, 4550, 4551, 5, 191, 0, 0, 4551, 4552, 5, 189, 0, 0, 4552, 4553, 3, 528, 264, 0, 4553, 4554, 3, 108, 54, 0, 4554, 4577, 1, 0, 0, 0, 4555, 4556, 5, 191, 0, 0, 4556, 4557, 5, 189, 0, 0, 4557, 4558, 5, 220, 0, 0, 4558, 4559, 5, 389, 0, 0, 4559, 4560, 3, 528, 264, 0, 4560, 4561, 3, 108, 54, 0, 4561, 4577, 1, 0, 0, 0, 4562, 4563, 5, 191, 0, 0, 4563, 4564, 5, 226, 0, 0, 4564, 4565, 5, 109, 0, 0, 4565, 4566, 3, 522, 261, 0, 4566, 4567, 3, 108, 54, 0, 4567, 4577, 1, 0, 0, 0, 4568, 4569, 5, 191, 0, 0, 4569, 4570, 5, 226, 0, 0, 4570, 4571, 5, 109, 0, 0, 4571, 4572, 5, 220, 0, 0, 4572, 4573, 5, 389, 0, 0, 4573, 4574, 3, 522, 261, 0, 4574, 4575, 3, 108, 54, 0, 4575, 4577, 1, 0, 0, 0, 4576, 4498, 1, 0, 0, 0, 4576, 4505, 1, 0, 0, 0, 4576, 4510, 1, 0, 0, 0, 4576, 4517, 1, 0, 0, 0, 4576, 4522, 1, 0, 0, 0, 4576, 4529, 1, 0, 0, 0, 4576, 4538, 1, 0, 0, 0, 4576, 4543, 1, 0, 0, 0, 4576, 4550, 1, 0, 0, 0, 4576, 4555, 1, 0, 0, 0, 4576, 4562, 1, 0, 0, 0, 4576, 4568, 1, 0, 0, 0, 4577, 513, 1, 0, 0, 0, 4578, 4602, 5, 92, 0, 0, 4579, 4602, 5, 321, 0, 0, 4580, 4602, 5, 369, 0, 0, 4581, 4582, 5, 251, 0, 0, 4582, 4602, 5, 369, 0, 0, 4583, 4602, 5, 226, 0, 0, 4584, 4585, 5, 63, 0, 0, 4585, 4602, 5, 92, 0, 0, 4586, 4602, 5, 108, 0, 0, 4587, 4602, 5, 168, 0, 0, 4588, 4602, 5, 335, 0, 0, 4589, 4590, 5, 348, 0, 0, 4590, 4591, 5, 318, 0, 0, 4591, 4602, 5, 276, 0, 0, 4592, 4593, 5, 348, 0, 0, 4593, 4594, 5, 318, 0, 0, 4594, 4602, 5, 185, 0, 0, 4595, 4596, 5, 348, 0, 0, 4596, 4597, 5, 318, 0, 0, 4597, 4602, 5, 346, 0, 0, 4598, 4599, 5, 348, 0, 0, 4599, 4600, 5, 318, 0, 0, 4600, 4602, 5, 163, 0, 0, 4601, 4578, 1, 0, 0, 0, 4601, 4579, 1, 0, 0, 0, 4601, 4580, 1, 0, 0, 0, 4601, 4581, 1, 0, 0, 0, 4601, 4583, 1, 0, 0, 0, 4601, 4584, 1, 0, 0, 0, 4601, 4586, 1, 0, 0, 0, 4601, 4587, 1, 0, 0, 0, 4601, 4588, 1, 0, 0, 0, 4601, 4589, 1, 0, 0, 0, 4601, 4592, 1, 0, 0, 0, 4601, 4595, 1, 0, 0, 0, 4601, 4598, 1, 0, 0, 0, 4602, 515, 1, 0, 0, 0, 4603, 4609, 3, 518, 259, 0, 4604, 4609, 5, 175, 0, 0, 4605, 4609, 5, 311, 0, 0, 4606, 4609, 5, 451, 0, 0, 4607, 4609, 5, 344, 0, 0, 4608, 4603, 1, 0, 0, 0, 4608, 4604, 1, 0, 0, 0, 4608, 4605, 1, 0, 0, 0, 4608, 4606, 1, 0, 0, 0, 4608, 4607, 1, 0, 0, 0, 4609, 517, 1, 0, 0, 0, 4610, 4611, 5, 131, 0, 0, 4611, 4625, 5, 446, 0, 0, 4612, 4613, 5, 198, 0, 0, 4613, 4625, 5, 350, 0, 0, 4614, 4625, 5, 204, 0, 0, 4615, 4616, 5, 63, 0, 0, 4616, 4617, 5, 174, 0, 0, 4617, 4625, 5, 374, 0, 0, 4618, 4619, 3, 308, 154, 0, 4619, 4620, 5, 238, 0, 0, 4620, 4625, 1, 0, 0, 0, 4621, 4625, 5, 452, 0, 0, 4622, 4625, 5, 316, 0, 0, 4623, 4625, 5, 324, 0, 0, 4624, 4610, 1, 0, 0, 0, 4624, 4612, 1, 0, 0, 0, 4624, 4614, 1, 0, 0, 0, 4624, 4615, 1, 0, 0, 0, 4624, 4618, 1, 0, 0, 0, 4624, 4621, 1, 0, 0, 0, 4624, 4622, 1, 0, 0, 0, 4624, 4623, 1, 0, 0, 0, 4625, 519, 1, 0, 0, 0, 4626, 4627, 7, 23, 0, 0, 4627, 521, 1, 0, 0, 0, 4628, 4633, 3, 524, 262, 0, 4629, 4630, 5, 6, 0, 0, 4630, 4632, 3, 524, 262, 0, 4631, 4629, 1, 0, 0, 0, 4632, 4635, 1, 0, 0, 0, 4633, 4631, 1, 0, 0, 0, 4633, 4634, 1, 0, 0, 0, 4634, 523, 1, 0, 0, 0, 4635, 4633, 1, 0, 0, 0, 4636, 4638, 3, 1372, 686, 0, 4637, 4639, 3, 526, 263, 0, 4638, 4637, 1, 0, 0, 0, 4638, 4639, 1, 0, 0, 0, 4639, 525, 1, 0, 0, 0, 4640, 4641, 5, 11, 0, 0, 4641, 4643, 3, 1342, 671, 0, 4642, 4640, 1, 0, 0, 0, 4643, 4644, 1, 0, 0, 0, 4644, 4642, 1, 0, 0, 0, 4644, 4645, 1, 0, 0, 0, 4645, 527, 1, 0, 0, 0, 4646, 4651, 3, 1118, 559, 0, 4647, 4648, 5, 6, 0, 0, 4648, 4650, 3, 1118, 559, 0, 4649, 4647, 1, 0, 0, 0, 4650, 4653, 1, 0, 0, 0, 4651, 4649, 1, 0, 0, 0, 4651, 4652, 1, 0, 0, 0, 4652, 529, 1, 0, 0, 0, 4653, 4651, 1, 0, 0, 0, 4654, 4655, 5, 351, 0, 0, 4655, 4656, 3, 988, 494, 0, 4656, 4657, 3, 1076, 538, 0, 4657, 4658, 3, 532, 266, 0, 4658, 4659, 3, 108, 54, 0, 4659, 531, 1, 0, 0, 0, 4660, 4661, 5, 167, 0, 0, 4661, 4666, 5, 219, 0, 0, 4662, 4663, 5, 307, 0, 0, 4663, 4666, 5, 219, 0, 0, 4664, 4666, 1, 0, 0, 0, 4665, 4660, 1, 0, 0, 0, 4665, 4662, 1, 0, 0, 0, 4665, 4664, 1, 0, 0, 0, 4666, 533, 1, 0, 0, 0, 4667, 4668, 5, 159, 0, 0, 4668, 4669, 5, 80, 0, 0, 4669, 4670, 3, 514, 257, 0, 4670, 4671, 3, 524, 262, 0, 4671, 4672, 5, 116, 0, 0, 4672, 4673, 3, 536, 268, 0, 4673, 4815, 1, 0, 0, 0, 4674, 4675, 5, 159, 0, 0, 4675, 4676, 5, 80, 0, 0, 4676, 4677, 5, 44, 0, 0, 4677, 4678, 3, 524, 262, 0, 4678, 4679, 5, 116, 0, 0, 4679, 4680, 3, 536, 268, 0, 4680, 4815, 1, 0, 0, 0, 4681, 4682, 5, 159, 0, 0, 4682, 4683, 5, 80, 0, 0, 4683, 4684, 3, 516, 258, 0, 4684, 4685, 3, 1340, 670, 0, 4685, 4686, 5, 116, 0, 0, 4686, 4687, 3, 536, 268, 0, 4687, 4815, 1, 0, 0, 0, 4688, 4689, 5, 159, 0, 0, 4689, 4690, 5, 80, 0, 0, 4690, 4691, 5, 353, 0, 0, 4691, 4692, 3, 1118, 559, 0, 4692, 4693, 5, 116, 0, 0, 4693, 4694, 3, 536, 268, 0, 4694, 4815, 1, 0, 0, 0, 4695, 4696, 5, 159, 0, 0, 4696, 4697, 5, 80, 0, 0, 4697, 4698, 5, 189, 0, 0, 4698, 4699, 3, 1118, 559, 0, 4699, 4700, 5, 116, 0, 0, 4700, 4701, 3, 536, 268, 0, 4701, 4815, 1, 0, 0, 0, 4702, 4703, 5, 159, 0, 0, 4703, 4704, 5, 80, 0, 0, 4704, 4705, 5, 136, 0, 0, 4705, 4706, 3, 650, 325, 0, 4706, 4707, 5, 116, 0, 0, 4707, 4708, 3, 536, 268, 0, 4708, 4815, 1, 0, 0, 0, 4709, 4710, 5, 159, 0, 0, 4710, 4711, 5, 80, 0, 0, 4711, 4712, 5, 211, 0, 0, 4712, 4713, 3, 626, 313, 0, 4713, 4714, 5, 116, 0, 0, 4714, 4715, 3, 536, 268, 0, 4715, 4815, 1, 0, 0, 0, 4716, 4717, 5, 159, 0, 0, 4717, 4718, 5, 80, 0, 0, 4718, 4719, 5, 271, 0, 0, 4719, 4720, 3, 688, 344, 0, 4720, 4721, 5, 116, 0, 0, 4721, 4722, 3, 536, 268, 0, 4722, 4815, 1, 0, 0, 0, 4723, 4724, 5, 159, 0, 0, 4724, 4725, 5, 80, 0, 0, 4725, 4726, 5, 45, 0, 0, 4726, 4727, 3, 1340, 670, 0, 4727, 4728, 5, 80, 0, 0, 4728, 4729, 3, 524, 262, 0, 4729, 4730, 5, 116, 0, 0, 4730, 4731, 3, 536, 268, 0, 4731, 4815, 1, 0, 0, 0, 4732, 4733, 5, 159, 0, 0, 4733, 4734, 5, 80, 0, 0, 4734, 4735, 5, 45, 0, 0, 4735, 4736, 3, 1340, 670, 0, 4736, 4737, 5, 80, 0, 0, 4737, 4738, 5, 189, 0, 0, 4738, 4739, 3, 524, 262, 0, 4739, 4740, 5, 116, 0, 0, 4740, 4741, 3, 536, 268, 0, 4741, 4815, 1, 0, 0, 0, 4742, 4743, 5, 159, 0, 0, 4743, 4744, 5, 80, 0, 0, 4744, 4745, 3, 520, 260, 0, 4745, 4746, 3, 1340, 670, 0, 4746, 4747, 5, 80, 0, 0, 4747, 4748, 3, 524, 262, 0, 4748, 4749, 5, 116, 0, 0, 4749, 4750, 3, 536, 268, 0, 4750, 4815, 1, 0, 0, 0, 4751, 4752, 5, 159, 0, 0, 4752, 4753, 5, 80, 0, 0, 4753, 4754, 5, 289, 0, 0, 4754, 4755, 3, 626, 313, 0, 4755, 4756, 5, 116, 0, 0, 4756, 4757, 3, 536, 268, 0, 4757, 4815, 1, 0, 0, 0, 4758, 4759, 5, 159, 0, 0, 4759, 4760, 5, 80, 0, 0, 4760, 4761, 5, 442, 0, 0, 4761, 4762, 3, 626, 313, 0, 4762, 4763, 5, 116, 0, 0, 4763, 4764, 3, 536, 268, 0, 4764, 4815, 1, 0, 0, 0, 4765, 4766, 5, 159, 0, 0, 4766, 4767, 5, 80, 0, 0, 4767, 4768, 5, 443, 0, 0, 4768, 4769, 5, 62, 0, 0, 4769, 4770, 3, 1118, 559, 0, 4770, 4771, 5, 238, 0, 0, 4771, 4772, 3, 1340, 670, 0, 4772, 4773, 5, 116, 0, 0, 4773, 4774, 3, 536, 268, 0, 4774, 4815, 1, 0, 0, 0, 4775, 4776, 5, 159, 0, 0, 4776, 4777, 5, 80, 0, 0, 4777, 4778, 5, 271, 0, 0, 4778, 4779, 5, 156, 0, 0, 4779, 4780, 3, 524, 262, 0, 4780, 4781, 5, 100, 0, 0, 4781, 4782, 3, 1340, 670, 0, 4782, 4783, 5, 116, 0, 0, 4783, 4784, 3, 536, 268, 0, 4784, 4815, 1, 0, 0, 0, 4785, 4786, 5, 159, 0, 0, 4786, 4787, 5, 80, 0, 0, 4787, 4788, 5, 271, 0, 0, 4788, 4789, 5, 206, 0, 0, 4789, 4790, 3, 524, 262, 0, 4790, 4791, 5, 100, 0, 0, 4791, 4792, 3, 1340, 670, 0, 4792, 4793, 5, 116, 0, 0, 4793, 4794, 3, 536, 268, 0, 4794, 4815, 1, 0, 0, 0, 4795, 4796, 5, 159, 0, 0, 4796, 4797, 5, 80, 0, 0, 4797, 4798, 5, 239, 0, 0, 4798, 4799, 5, 267, 0, 0, 4799, 4800, 3, 292, 146, 0, 4800, 4801, 5, 116, 0, 0, 4801, 4802, 3, 536, 268, 0, 4802, 4815, 1, 0, 0, 0, 4803, 4804, 5, 159, 0, 0, 4804, 4805, 5, 80, 0, 0, 4805, 4806, 5, 41, 0, 0, 4806, 4807, 5, 2, 0, 0, 4807, 4808, 3, 1118, 559, 0, 4808, 4809, 5, 36, 0, 0, 4809, 4810, 3, 1118, 559, 0, 4810, 4811, 5, 3, 0, 0, 4811, 4812, 5, 116, 0, 0, 4812, 4813, 3, 536, 268, 0, 4813, 4815, 1, 0, 0, 0, 4814, 4667, 1, 0, 0, 0, 4814, 4674, 1, 0, 0, 0, 4814, 4681, 1, 0, 0, 0, 4814, 4688, 1, 0, 0, 0, 4814, 4695, 1, 0, 0, 0, 4814, 4702, 1, 0, 0, 0, 4814, 4709, 1, 0, 0, 0, 4814, 4716, 1, 0, 0, 0, 4814, 4723, 1, 0, 0, 0, 4814, 4732, 1, 0, 0, 0, 4814, 4742, 1, 0, 0, 0, 4814, 4751, 1, 0, 0, 0, 4814, 4758, 1, 0, 0, 0, 4814, 4765, 1, 0, 0, 0, 4814, 4775, 1, 0, 0, 0, 4814, 4785, 1, 0, 0, 0, 4814, 4795, 1, 0, 0, 0, 4814, 4803, 1, 0, 0, 0, 4815, 535, 1, 0, 0, 0, 4816, 4819, 3, 1358, 679, 0, 4817, 4819, 5, 78, 0, 0, 4818, 4816, 1, 0, 0, 0, 4818, 4817, 1, 0, 0, 0, 4819, 537, 1, 0, 0, 0, 4820, 4821, 5, 320, 0, 0, 4821, 4822, 5, 237, 0, 0, 4822, 4823, 3, 540, 270, 0, 4823, 4824, 5, 80, 0, 0, 4824, 4825, 3, 514, 257, 0, 4825, 4826, 3, 524, 262, 0, 4826, 4827, 5, 116, 0, 0, 4827, 4828, 3, 542, 271, 0, 4828, 4912, 1, 0, 0, 0, 4829, 4830, 5, 320, 0, 0, 4830, 4831, 5, 237, 0, 0, 4831, 4832, 3, 540, 270, 0, 4832, 4833, 5, 80, 0, 0, 4833, 4834, 5, 44, 0, 0, 4834, 4835, 3, 524, 262, 0, 4835, 4836, 5, 116, 0, 0, 4836, 4837, 3, 542, 271, 0, 4837, 4912, 1, 0, 0, 0, 4838, 4839, 5, 320, 0, 0, 4839, 4840, 5, 237, 0, 0, 4840, 4841, 3, 540, 270, 0, 4841, 4842, 5, 80, 0, 0, 4842, 4843, 3, 516, 258, 0, 4843, 4844, 3, 1340, 670, 0, 4844, 4845, 5, 116, 0, 0, 4845, 4846, 3, 542, 271, 0, 4846, 4912, 1, 0, 0, 0, 4847, 4848, 5, 320, 0, 0, 4848, 4849, 5, 237, 0, 0, 4849, 4850, 3, 540, 270, 0, 4850, 4851, 5, 80, 0, 0, 4851, 4852, 5, 353, 0, 0, 4852, 4853, 3, 1118, 559, 0, 4853, 4854, 5, 116, 0, 0, 4854, 4855, 3, 542, 271, 0, 4855, 4912, 1, 0, 0, 0, 4856, 4857, 5, 320, 0, 0, 4857, 4858, 5, 237, 0, 0, 4858, 4859, 3, 540, 270, 0, 4859, 4860, 5, 80, 0, 0, 4860, 4861, 5, 189, 0, 0, 4861, 4862, 3, 1118, 559, 0, 4862, 4863, 5, 116, 0, 0, 4863, 4864, 3, 542, 271, 0, 4864, 4912, 1, 0, 0, 0, 4865, 4866, 5, 320, 0, 0, 4866, 4867, 5, 237, 0, 0, 4867, 4868, 3, 540, 270, 0, 4868, 4869, 5, 80, 0, 0, 4869, 4870, 5, 136, 0, 0, 4870, 4871, 3, 650, 325, 0, 4871, 4872, 5, 116, 0, 0, 4872, 4873, 3, 542, 271, 0, 4873, 4912, 1, 0, 0, 0, 4874, 4875, 5, 320, 0, 0, 4875, 4876, 5, 237, 0, 0, 4876, 4877, 3, 540, 270, 0, 4877, 4878, 5, 80, 0, 0, 4878, 4879, 5, 211, 0, 0, 4879, 4880, 3, 626, 313, 0, 4880, 4881, 5, 116, 0, 0, 4881, 4882, 3, 542, 271, 0, 4882, 4912, 1, 0, 0, 0, 4883, 4884, 5, 320, 0, 0, 4884, 4885, 5, 237, 0, 0, 4885, 4886, 3, 540, 270, 0, 4886, 4887, 5, 80, 0, 0, 4887, 4888, 5, 239, 0, 0, 4888, 4889, 5, 267, 0, 0, 4889, 4890, 3, 292, 146, 0, 4890, 4891, 5, 116, 0, 0, 4891, 4892, 3, 542, 271, 0, 4892, 4912, 1, 0, 0, 0, 4893, 4894, 5, 320, 0, 0, 4894, 4895, 5, 237, 0, 0, 4895, 4896, 3, 540, 270, 0, 4896, 4897, 5, 80, 0, 0, 4897, 4898, 5, 289, 0, 0, 4898, 4899, 3, 626, 313, 0, 4899, 4900, 5, 116, 0, 0, 4900, 4901, 3, 542, 271, 0, 4901, 4912, 1, 0, 0, 0, 4902, 4903, 5, 320, 0, 0, 4903, 4904, 5, 237, 0, 0, 4904, 4905, 3, 540, 270, 0, 4905, 4906, 5, 80, 0, 0, 4906, 4907, 5, 442, 0, 0, 4907, 4908, 3, 626, 313, 0, 4908, 4909, 5, 116, 0, 0, 4909, 4910, 3, 542, 271, 0, 4910, 4912, 1, 0, 0, 0, 4911, 4820, 1, 0, 0, 0, 4911, 4829, 1, 0, 0, 0, 4911, 4838, 1, 0, 0, 0, 4911, 4847, 1, 0, 0, 0, 4911, 4856, 1, 0, 0, 0, 4911, 4865, 1, 0, 0, 0, 4911, 4874, 1, 0, 0, 0, 4911, 4883, 1, 0, 0, 0, 4911, 4893, 1, 0, 0, 0, 4911, 4902, 1, 0, 0, 0, 4912, 539, 1, 0, 0, 0, 4913, 4914, 5, 62, 0, 0, 4914, 4917, 3, 72, 36, 0, 4915, 4917, 1, 0, 0, 0, 4916, 4913, 1, 0, 0, 0, 4916, 4915, 1, 0, 0, 0, 4917, 541, 1, 0, 0, 0, 4918, 4921, 3, 1358, 679, 0, 4919, 4921, 5, 78, 0, 0, 4920, 4918, 1, 0, 0, 0, 4920, 4919, 1, 0, 0, 0, 4921, 543, 1, 0, 0, 0, 4922, 4923, 5, 61, 0, 0, 4923, 4927, 3, 546, 273, 0, 4924, 4925, 5, 258, 0, 0, 4925, 4927, 3, 546, 273, 0, 4926, 4922, 1, 0, 0, 0, 4926, 4924, 1, 0, 0, 0, 4927, 545, 1, 0, 0, 0, 4928, 4995, 3, 954, 477, 0, 4929, 4930, 3, 548, 274, 0, 4930, 4931, 3, 954, 477, 0, 4931, 4995, 1, 0, 0, 0, 4932, 4933, 5, 261, 0, 0, 4933, 4934, 3, 550, 275, 0, 4934, 4935, 3, 954, 477, 0, 4935, 4995, 1, 0, 0, 0, 4936, 4937, 5, 286, 0, 0, 4937, 4938, 3, 550, 275, 0, 4938, 4939, 3, 954, 477, 0, 4939, 4995, 1, 0, 0, 0, 4940, 4941, 5, 207, 0, 0, 4941, 4942, 3, 550, 275, 0, 4942, 4943, 3, 954, 477, 0, 4943, 4995, 1, 0, 0, 0, 4944, 4945, 5, 240, 0, 0, 4945, 4946, 3, 550, 275, 0, 4946, 4947, 3, 954, 477, 0, 4947, 4995, 1, 0, 0, 0, 4948, 4949, 5, 130, 0, 0, 4949, 4950, 3, 1364, 682, 0, 4950, 4951, 3, 550, 275, 0, 4951, 4952, 3, 954, 477, 0, 4952, 4995, 1, 0, 0, 0, 4953, 4954, 5, 300, 0, 0, 4954, 4955, 3, 1364, 682, 0, 4955, 4956, 3, 550, 275, 0, 4956, 4957, 3, 954, 477, 0, 4957, 4995, 1, 0, 0, 0, 4958, 4959, 3, 1364, 682, 0, 4959, 4960, 3, 550, 275, 0, 4960, 4961, 3, 954, 477, 0, 4961, 4995, 1, 0, 0, 0, 4962, 4963, 5, 30, 0, 0, 4963, 4964, 3, 550, 275, 0, 4964, 4965, 3, 954, 477, 0, 4965, 4995, 1, 0, 0, 0, 4966, 4967, 5, 210, 0, 0, 4967, 4968, 3, 550, 275, 0, 4968, 4969, 3, 954, 477, 0, 4969, 4995, 1, 0, 0, 0, 4970, 4971, 5, 210, 0, 0, 4971, 4972, 3, 1364, 682, 0, 4972, 4973, 3, 550, 275, 0, 4973, 4974, 3, 954, 477, 0, 4974, 4995, 1, 0, 0, 0, 4975, 4976, 5, 210, 0, 0, 4976, 4977, 5, 30, 0, 0, 4977, 4978, 3, 550, 275, 0, 4978, 4979, 3, 954, 477, 0, 4979, 4995, 1, 0, 0, 0, 4980, 4981, 5, 144, 0, 0, 4981, 4982, 3, 550, 275, 0, 4982, 4983, 3, 954, 477, 0, 4983, 4995, 1, 0, 0, 0, 4984, 4985, 5, 144, 0, 0, 4985, 4986, 3, 1364, 682, 0, 4986, 4987, 3, 550, 275, 0, 4987, 4988, 3, 954, 477, 0, 4988, 4995, 1, 0, 0, 0, 4989, 4990, 5, 144, 0, 0, 4990, 4991, 5, 30, 0, 0, 4991, 4992, 3, 550, 275, 0, 4992, 4993, 3, 954, 477, 0, 4993, 4995, 1, 0, 0, 0, 4994, 4928, 1, 0, 0, 0, 4994, 4929, 1, 0, 0, 0, 4994, 4932, 1, 0, 0, 0, 4994, 4936, 1, 0, 0, 0, 4994, 4940, 1, 0, 0, 0, 4994, 4944, 1, 0, 0, 0, 4994, 4948, 1, 0, 0, 0, 4994, 4953, 1, 0, 0, 0, 4994, 4958, 1, 0, 0, 0, 4994, 4962, 1, 0, 0, 0, 4994, 4966, 1, 0, 0, 0, 4994, 4970, 1, 0, 0, 0, 4994, 4975, 1, 0, 0, 0, 4994, 4980, 1, 0, 0, 0, 4994, 4984, 1, 0, 0, 0, 4994, 4989, 1, 0, 0, 0, 4995, 547, 1, 0, 0, 0, 4996, 4997, 7, 24, 0, 0, 4997, 549, 1, 0, 0, 0, 4998, 5001, 3, 548, 274, 0, 4999, 5001, 1, 0, 0, 0, 5000, 4998, 1, 0, 0, 0, 5000, 4999, 1, 0, 0, 0, 5001, 551, 1, 0, 0, 0, 5002, 5003, 5, 65, 0, 0, 5003, 5004, 3, 556, 278, 0, 5004, 5005, 5, 80, 0, 0, 5005, 5006, 3, 562, 281, 0, 5006, 5007, 5, 94, 0, 0, 5007, 5008, 3, 564, 282, 0, 5008, 5009, 3, 568, 284, 0, 5009, 553, 1, 0, 0, 0, 5010, 5011, 5, 310, 0, 0, 5011, 5012, 3, 556, 278, 0, 5012, 5013, 5, 80, 0, 0, 5013, 5014, 3, 562, 281, 0, 5014, 5015, 5, 64, 0, 0, 5015, 5016, 3, 564, 282, 0, 5016, 5017, 3, 108, 54, 0, 5017, 5030, 1, 0, 0, 0, 5018, 5019, 5, 310, 0, 0, 5019, 5020, 5, 65, 0, 0, 5020, 5021, 5, 272, 0, 0, 5021, 5022, 5, 62, 0, 0, 5022, 5023, 3, 556, 278, 0, 5023, 5024, 5, 80, 0, 0, 5024, 5025, 3, 562, 281, 0, 5025, 5026, 5, 64, 0, 0, 5026, 5027, 3, 564, 282, 0, 5027, 5028, 3, 108, 54, 0, 5028, 5030, 1, 0, 0, 0, 5029, 5010, 1, 0, 0, 0, 5029, 5018, 1, 0, 0, 0, 5030, 555, 1, 0, 0, 0, 5031, 5047, 3, 558, 279, 0, 5032, 5047, 5, 30, 0, 0, 5033, 5034, 5, 30, 0, 0, 5034, 5047, 5, 287, 0, 0, 5035, 5036, 5, 30, 0, 0, 5036, 5037, 5, 2, 0, 0, 5037, 5038, 3, 216, 108, 0, 5038, 5039, 5, 3, 0, 0, 5039, 5047, 1, 0, 0, 0, 5040, 5041, 5, 30, 0, 0, 5041, 5042, 5, 287, 0, 0, 5042, 5043, 5, 2, 0, 0, 5043, 5044, 3, 216, 108, 0, 5044, 5045, 5, 3, 0, 0, 5045, 5047, 1, 0, 0, 0, 5046, 5031, 1, 0, 0, 0, 5046, 5032, 1, 0, 0, 0, 5046, 5033, 1, 0, 0, 0, 5046, 5035, 1, 0, 0, 0, 5046, 5040, 1, 0, 0, 0, 5047, 557, 1, 0, 0, 0, 5048, 5053, 3, 560, 280, 0, 5049, 5050, 5, 6, 0, 0, 5050, 5052, 3, 560, 280, 0, 5051, 5049, 1, 0, 0, 0, 5052, 5055, 1, 0, 0, 0, 5053, 5051, 1, 0, 0, 0, 5053, 5054, 1, 0, 0, 0, 5054, 559, 1, 0, 0, 0, 5055, 5053, 1, 0, 0, 0, 5056, 5057, 5, 88, 0, 0, 5057, 5066, 3, 214, 107, 0, 5058, 5059, 5, 86, 0, 0, 5059, 5066, 3, 214, 107, 0, 5060, 5061, 5, 46, 0, 0, 5061, 5066, 3, 214, 107, 0, 5062, 5063, 3, 1372, 686, 0, 5063, 5064, 3, 214, 107, 0, 5064, 5066, 1, 0, 0, 0, 5065, 5056, 1, 0, 0, 0, 5065, 5058, 1, 0, 0, 0, 5065, 5060, 1, 0, 0, 0, 5065, 5062, 1, 0, 0, 0, 5066, 561, 1, 0, 0, 0, 5067, 5126, 3, 1334, 667, 0, 5068, 5069, 5, 92, 0, 0, 5069, 5126, 3, 1334, 667, 0, 5070, 5071, 5, 321, 0, 0, 5071, 5126, 3, 1334, 667, 0, 5072, 5073, 5, 63, 0, 0, 5073, 5074, 5, 174, 0, 0, 5074, 5075, 5, 374, 0, 0, 5075, 5126, 3, 1338, 669, 0, 5076, 5077, 5, 63, 0, 0, 5077, 5078, 5, 324, 0, 0, 5078, 5126, 3, 1338, 669, 0, 5079, 5080, 5, 211, 0, 0, 5080, 5126, 3, 624, 312, 0, 5081, 5082, 5, 289, 0, 0, 5082, 5126, 3, 624, 312, 0, 5083, 5084, 5, 442, 0, 0, 5084, 5126, 3, 624, 312, 0, 5085, 5086, 5, 175, 0, 0, 5086, 5126, 3, 1338, 669, 0, 5087, 5088, 5, 189, 0, 0, 5088, 5126, 3, 522, 261, 0, 5089, 5090, 5, 238, 0, 0, 5090, 5126, 3, 1338, 669, 0, 5091, 5092, 5, 239, 0, 0, 5092, 5093, 5, 267, 0, 0, 5093, 5126, 3, 294, 147, 0, 5094, 5095, 5, 316, 0, 0, 5095, 5126, 3, 1338, 669, 0, 5096, 5097, 5, 344, 0, 0, 5097, 5126, 3, 1338, 669, 0, 5098, 5099, 5, 353, 0, 0, 5099, 5126, 3, 522, 261, 0, 5100, 5101, 5, 30, 0, 0, 5101, 5102, 5, 343, 0, 0, 5102, 5103, 5, 68, 0, 0, 5103, 5104, 5, 316, 0, 0, 5104, 5126, 3, 1338, 669, 0, 5105, 5106, 5, 30, 0, 0, 5106, 5107, 5, 322, 0, 0, 5107, 5108, 5, 68, 0, 0, 5108, 5109, 5, 316, 0, 0, 5109, 5126, 3, 1338, 669, 0, 5110, 5111, 5, 30, 0, 0, 5111, 5112, 5, 212, 0, 0, 5112, 5113, 5, 68, 0, 0, 5113, 5114, 5, 316, 0, 0, 5114, 5126, 3, 1338, 669, 0, 5115, 5116, 5, 30, 0, 0, 5116, 5117, 5, 457, 0, 0, 5117, 5118, 5, 68, 0, 0, 5118, 5119, 5, 316, 0, 0, 5119, 5126, 3, 1338, 669, 0, 5120, 5121, 5, 30, 0, 0, 5121, 5122, 5, 455, 0, 0, 5122, 5123, 5, 68, 0, 0, 5123, 5124, 5, 316, 0, 0, 5124, 5126, 3, 1338, 669, 0, 5125, 5067, 1, 0, 0, 0, 5125, 5068, 1, 0, 0, 0, 5125, 5070, 1, 0, 0, 0, 5125, 5072, 1, 0, 0, 0, 5125, 5076, 1, 0, 0, 0, 5125, 5079, 1, 0, 0, 0, 5125, 5081, 1, 0, 0, 0, 5125, 5083, 1, 0, 0, 0, 5125, 5085, 1, 0, 0, 0, 5125, 5087, 1, 0, 0, 0, 5125, 5089, 1, 0, 0, 0, 5125, 5091, 1, 0, 0, 0, 5125, 5094, 1, 0, 0, 0, 5125, 5096, 1, 0, 0, 0, 5125, 5098, 1, 0, 0, 0, 5125, 5100, 1, 0, 0, 0, 5125, 5105, 1, 0, 0, 0, 5125, 5110, 1, 0, 0, 0, 5125, 5115, 1, 0, 0, 0, 5125, 5120, 1, 0, 0, 0, 5126, 563, 1, 0, 0, 0, 5127, 5132, 3, 566, 283, 0, 5128, 5129, 5, 6, 0, 0, 5129, 5131, 3, 566, 283, 0, 5130, 5128, 1, 0, 0, 0, 5131, 5134, 1, 0, 0, 0, 5132, 5130, 1, 0, 0, 0, 5132, 5133, 1, 0, 0, 0, 5133, 565, 1, 0, 0, 0, 5134, 5132, 1, 0, 0, 0, 5135, 5139, 3, 1368, 684, 0, 5136, 5137, 5, 66, 0, 0, 5137, 5139, 3, 1368, 684, 0, 5138, 5135, 1, 0, 0, 0, 5138, 5136, 1, 0, 0, 0, 5139, 567, 1, 0, 0, 0, 5140, 5141, 5, 105, 0, 0, 5141, 5142, 5, 65, 0, 0, 5142, 5145, 5, 272, 0, 0, 5143, 5145, 1, 0, 0, 0, 5144, 5140, 1, 0, 0, 0, 5144, 5143, 1, 0, 0, 0, 5145, 569, 1, 0, 0, 0, 5146, 5147, 5, 65, 0, 0, 5147, 5148, 3, 558, 279, 0, 5148, 5149, 5, 94, 0, 0, 5149, 5150, 3, 1370, 685, 0, 5150, 5151, 3, 574, 287, 0, 5151, 5152, 3, 576, 288, 0, 5152, 571, 1, 0, 0, 0, 5153, 5154, 5, 310, 0, 0, 5154, 5155, 3, 558, 279, 0, 5155, 5156, 5, 64, 0, 0, 5156, 5157, 3, 1370, 685, 0, 5157, 5158, 3, 576, 288, 0, 5158, 5159, 3, 108, 54, 0, 5159, 5171, 1, 0, 0, 0, 5160, 5161, 5, 310, 0, 0, 5161, 5162, 5, 134, 0, 0, 5162, 5163, 5, 272, 0, 0, 5163, 5164, 5, 62, 0, 0, 5164, 5165, 3, 558, 279, 0, 5165, 5166, 5, 64, 0, 0, 5166, 5167, 3, 1370, 685, 0, 5167, 5168, 3, 576, 288, 0, 5168, 5169, 3, 108, 54, 0, 5169, 5171, 1, 0, 0, 0, 5170, 5153, 1, 0, 0, 0, 5170, 5160, 1, 0, 0, 0, 5171, 573, 1, 0, 0, 0, 5172, 5173, 5, 105, 0, 0, 5173, 5174, 5, 134, 0, 0, 5174, 5177, 5, 272, 0, 0, 5175, 5177, 1, 0, 0, 0, 5176, 5172, 1, 0, 0, 0, 5176, 5175, 1, 0, 0, 0, 5177, 575, 1, 0, 0, 0, 5178, 5179, 5, 214, 0, 0, 5179, 5180, 5, 147, 0, 0, 5180, 5183, 3, 1368, 684, 0, 5181, 5183, 1, 0, 0, 0, 5182, 5178, 1, 0, 0, 0, 5182, 5181, 1, 0, 0, 0, 5183, 577, 1, 0, 0, 0, 5184, 5185, 5, 138, 0, 0, 5185, 5186, 5, 53, 0, 0, 5186, 5187, 5, 287, 0, 0, 5187, 5188, 3, 580, 290, 0, 5188, 5189, 3, 584, 292, 0, 5189, 579, 1, 0, 0, 0, 5190, 5192, 3, 582, 291, 0, 5191, 5190, 1, 0, 0, 0, 5192, 5195, 1, 0, 0, 0, 5193, 5191, 1, 0, 0, 0, 5193, 5194, 1, 0, 0, 0, 5194, 581, 1, 0, 0, 0, 5195, 5193, 1, 0, 0, 0, 5196, 5197, 5, 68, 0, 0, 5197, 5198, 5, 316, 0, 0, 5198, 5206, 3, 1338, 669, 0, 5199, 5200, 5, 62, 0, 0, 5200, 5201, 5, 311, 0, 0, 5201, 5206, 3, 1370, 685, 0, 5202, 5203, 5, 62, 0, 0, 5203, 5204, 5, 99, 0, 0, 5204, 5206, 3, 1370, 685, 0, 5205, 5196, 1, 0, 0, 0, 5205, 5199, 1, 0, 0, 0, 5205, 5202, 1, 0, 0, 0, 5206, 583, 1, 0, 0, 0, 5207, 5208, 5, 65, 0, 0, 5208, 5209, 3, 556, 278, 0, 5209, 5210, 5, 80, 0, 0, 5210, 5211, 3, 586, 293, 0, 5211, 5212, 5, 94, 0, 0, 5212, 5213, 3, 564, 282, 0, 5213, 5214, 3, 568, 284, 0, 5214, 5235, 1, 0, 0, 0, 5215, 5216, 5, 310, 0, 0, 5216, 5217, 3, 556, 278, 0, 5217, 5218, 5, 80, 0, 0, 5218, 5219, 3, 586, 293, 0, 5219, 5220, 5, 64, 0, 0, 5220, 5221, 3, 564, 282, 0, 5221, 5222, 3, 108, 54, 0, 5222, 5235, 1, 0, 0, 0, 5223, 5224, 5, 310, 0, 0, 5224, 5225, 5, 65, 0, 0, 5225, 5226, 5, 272, 0, 0, 5226, 5227, 5, 62, 0, 0, 5227, 5228, 3, 556, 278, 0, 5228, 5229, 5, 80, 0, 0, 5229, 5230, 3, 586, 293, 0, 5230, 5231, 5, 64, 0, 0, 5231, 5232, 3, 564, 282, 0, 5232, 5233, 3, 108, 54, 0, 5233, 5235, 1, 0, 0, 0, 5234, 5207, 1, 0, 0, 0, 5234, 5215, 1, 0, 0, 0, 5234, 5223, 1, 0, 0, 0, 5235, 585, 1, 0, 0, 0, 5236, 5237, 7, 25, 0, 0, 5237, 587, 1, 0, 0, 0, 5238, 5239, 5, 46, 0, 0, 5239, 5240, 3, 590, 295, 0, 5240, 5241, 5, 226, 0, 0, 5241, 5242, 3, 592, 296, 0, 5242, 5243, 3, 594, 297, 0, 5243, 5244, 5, 80, 0, 0, 5244, 5245, 3, 1074, 537, 0, 5245, 5246, 3, 596, 298, 0, 5246, 5247, 5, 2, 0, 0, 5247, 5248, 3, 598, 299, 0, 5248, 5249, 5, 3, 0, 0, 5249, 5250, 3, 604, 302, 0, 5250, 5251, 3, 118, 59, 0, 5251, 5252, 3, 254, 127, 0, 5252, 5253, 3, 1094, 547, 0, 5253, 5274, 1, 0, 0, 0, 5254, 5255, 5, 46, 0, 0, 5255, 5256, 3, 590, 295, 0, 5256, 5257, 5, 226, 0, 0, 5257, 5258, 3, 592, 296, 0, 5258, 5259, 5, 220, 0, 0, 5259, 5260, 5, 77, 0, 0, 5260, 5261, 5, 389, 0, 0, 5261, 5262, 3, 1340, 670, 0, 5262, 5263, 5, 80, 0, 0, 5263, 5264, 3, 1074, 537, 0, 5264, 5265, 3, 596, 298, 0, 5265, 5266, 5, 2, 0, 0, 5266, 5267, 3, 598, 299, 0, 5267, 5268, 5, 3, 0, 0, 5268, 5269, 3, 604, 302, 0, 5269, 5270, 3, 118, 59, 0, 5270, 5271, 3, 254, 127, 0, 5271, 5272, 3, 1094, 547, 0, 5272, 5274, 1, 0, 0, 0, 5273, 5238, 1, 0, 0, 0, 5273, 5254, 1, 0, 0, 0, 5274, 589, 1, 0, 0, 0, 5275, 5278, 5, 98, 0, 0, 5276, 5278, 1, 0, 0, 0, 5277, 5275, 1, 0, 0, 0, 5277, 5276, 1, 0, 0, 0, 5278, 591, 1, 0, 0, 0, 5279, 5282, 5, 109, 0, 0, 5280, 5282, 1, 0, 0, 0, 5281, 5279, 1, 0, 0, 0, 5281, 5280, 1, 0, 0, 0, 5282, 593, 1, 0, 0, 0, 5283, 5286, 3, 1340, 670, 0, 5284, 5286, 1, 0, 0, 0, 5285, 5283, 1, 0, 0, 0, 5285, 5284, 1, 0, 0, 0, 5286, 595, 1, 0, 0, 0, 5287, 5288, 5, 100, 0, 0, 5288, 5291, 3, 1340, 670, 0, 5289, 5291, 1, 0, 0, 0, 5290, 5287, 1, 0, 0, 0, 5290, 5289, 1, 0, 0, 0, 5291, 597, 1, 0, 0, 0, 5292, 5297, 3, 602, 301, 0, 5293, 5294, 5, 6, 0, 0, 5294, 5296, 3, 602, 301, 0, 5295, 5293, 1, 0, 0, 0, 5296, 5299, 1, 0, 0, 0, 5297, 5295, 1, 0, 0, 0, 5297, 5298, 1, 0, 0, 0, 5298, 599, 1, 0, 0, 0, 5299, 5297, 1, 0, 0, 0, 5300, 5301, 3, 608, 304, 0, 5301, 5302, 3, 610, 305, 0, 5302, 5303, 3, 612, 306, 0, 5303, 5304, 3, 614, 307, 0, 5304, 5312, 1, 0, 0, 0, 5305, 5306, 3, 608, 304, 0, 5306, 5307, 3, 524, 262, 0, 5307, 5308, 3, 116, 58, 0, 5308, 5309, 3, 612, 306, 0, 5309, 5310, 3, 614, 307, 0, 5310, 5312, 1, 0, 0, 0, 5311, 5300, 1, 0, 0, 0, 5311, 5305, 1, 0, 0, 0, 5312, 601, 1, 0, 0, 0, 5313, 5314, 3, 1372, 686, 0, 5314, 5315, 3, 600, 300, 0, 5315, 5325, 1, 0, 0, 0, 5316, 5317, 3, 1214, 607, 0, 5317, 5318, 3, 600, 300, 0, 5318, 5325, 1, 0, 0, 0, 5319, 5320, 5, 2, 0, 0, 5320, 5321, 3, 1162, 581, 0, 5321, 5322, 5, 3, 0, 0, 5322, 5323, 3, 600, 300, 0, 5323, 5325, 1, 0, 0, 0, 5324, 5313, 1, 0, 0, 0, 5324, 5316, 1, 0, 0, 0, 5324, 5319, 1, 0, 0, 0, 5325, 603, 1, 0, 0, 0, 5326, 5327, 5, 441, 0, 0, 5327, 5328, 5, 2, 0, 0, 5328, 5329, 3, 606, 303, 0, 5329, 5330, 5, 3, 0, 0, 5330, 5333, 1, 0, 0, 0, 5331, 5333, 1, 0, 0, 0, 5332, 5326, 1, 0, 0, 0, 5332, 5331, 1, 0, 0, 0, 5333, 605, 1, 0, 0, 0, 5334, 5339, 3, 602, 301, 0, 5335, 5336, 5, 6, 0, 0, 5336, 5338, 3, 602, 301, 0, 5337, 5335, 1, 0, 0, 0, 5338, 5341, 1, 0, 0, 0, 5339, 5337, 1, 0, 0, 0, 5339, 5340, 1, 0, 0, 0, 5340, 607, 1, 0, 0, 0, 5341, 5339, 1, 0, 0, 0, 5342, 5343, 5, 43, 0, 0, 5343, 5346, 3, 524, 262, 0, 5344, 5346, 1, 0, 0, 0, 5345, 5342, 1, 0, 0, 0, 5345, 5344, 1, 0, 0, 0, 5346, 609, 1, 0, 0, 0, 5347, 5350, 3, 524, 262, 0, 5348, 5350, 1, 0, 0, 0, 5349, 5347, 1, 0, 0, 0, 5349, 5348, 1, 0, 0, 0, 5350, 611, 1, 0, 0, 0, 5351, 5355, 5, 37, 0, 0, 5352, 5355, 5, 55, 0, 0, 5353, 5355, 1, 0, 0, 0, 5354, 5351, 1, 0, 0, 0, 5354, 5352, 1, 0, 0, 0, 5354, 5353, 1, 0, 0, 0, 5355, 613, 1, 0, 0, 0, 5356, 5357, 5, 266, 0, 0, 5357, 5362, 5, 207, 0, 0, 5358, 5359, 5, 266, 0, 0, 5359, 5362, 5, 240, 0, 0, 5360, 5362, 1, 0, 0, 0, 5361, 5356, 1, 0, 0, 0, 5361, 5358, 1, 0, 0, 0, 5361, 5360, 1, 0, 0, 0, 5362, 615, 1, 0, 0, 0, 5363, 5364, 5, 46, 0, 0, 5364, 5365, 3, 618, 309, 0, 5365, 5366, 7, 22, 0, 0, 5366, 5367, 3, 1346, 673, 0, 5367, 5377, 3, 628, 314, 0, 5368, 5375, 5, 309, 0, 0, 5369, 5376, 3, 638, 319, 0, 5370, 5371, 5, 92, 0, 0, 5371, 5372, 5, 2, 0, 0, 5372, 5373, 3, 668, 334, 0, 5373, 5374, 5, 3, 0, 0, 5374, 5376, 1, 0, 0, 0, 5375, 5369, 1, 0, 0, 0, 5375, 5370, 1, 0, 0, 0, 5376, 5378, 1, 0, 0, 0, 5377, 5368, 1, 0, 0, 0, 5377, 5378, 1, 0, 0, 0, 5378, 5379, 1, 0, 0, 0, 5379, 5380, 3, 654, 327, 0, 5380, 617, 1, 0, 0, 0, 5381, 5382, 5, 82, 0, 0, 5382, 5385, 5, 304, 0, 0, 5383, 5385, 1, 0, 0, 0, 5384, 5381, 1, 0, 0, 0, 5384, 5383, 1, 0, 0, 0, 5385, 619, 1, 0, 0, 0, 5386, 5388, 5, 2, 0, 0, 5387, 5389, 3, 622, 311, 0, 5388, 5387, 1, 0, 0, 0, 5388, 5389, 1, 0, 0, 0, 5389, 5390, 1, 0, 0, 0, 5390, 5391, 5, 3, 0, 0, 5391, 621, 1, 0, 0, 0, 5392, 5397, 3, 632, 316, 0, 5393, 5394, 5, 6, 0, 0, 5394, 5396, 3, 632, 316, 0, 5395, 5393, 1, 0, 0, 0, 5396, 5399, 1, 0, 0, 0, 5397, 5395, 1, 0, 0, 0, 5397, 5398, 1, 0, 0, 0, 5398, 623, 1, 0, 0, 0, 5399, 5397, 1, 0, 0, 0, 5400, 5405, 3, 626, 313, 0, 5401, 5402, 5, 6, 0, 0, 5402, 5404, 3, 626, 313, 0, 5403, 5401, 1, 0, 0, 0, 5404, 5407, 1, 0, 0, 0, 5405, 5403, 1, 0, 0, 0, 5405, 5406, 1, 0, 0, 0, 5406, 625, 1, 0, 0, 0, 5407, 5405, 1, 0, 0, 0, 5408, 5409, 3, 1346, 673, 0, 5409, 5410, 3, 620, 310, 0, 5410, 5417, 1, 0, 0, 0, 5411, 5417, 3, 1390, 695, 0, 5412, 5414, 3, 1372, 686, 0, 5413, 5415, 3, 1324, 662, 0, 5414, 5413, 1, 0, 0, 0, 5414, 5415, 1, 0, 0, 0, 5415, 5417, 1, 0, 0, 0, 5416, 5408, 1, 0, 0, 0, 5416, 5411, 1, 0, 0, 0, 5416, 5412, 1, 0, 0, 0, 5417, 627, 1, 0, 0, 0, 5418, 5420, 5, 2, 0, 0, 5419, 5421, 3, 630, 315, 0, 5420, 5419, 1, 0, 0, 0, 5420, 5421, 1, 0, 0, 0, 5421, 5422, 1, 0, 0, 0, 5422, 5423, 5, 3, 0, 0, 5423, 629, 1, 0, 0, 0, 5424, 5429, 3, 642, 321, 0, 5425, 5426, 5, 6, 0, 0, 5426, 5428, 3, 642, 321, 0, 5427, 5425, 1, 0, 0, 0, 5428, 5431, 1, 0, 0, 0, 5429, 5427, 1, 0, 0, 0, 5429, 5430, 1, 0, 0, 0, 5430, 631, 1, 0, 0, 0, 5431, 5429, 1, 0, 0, 0, 5432, 5434, 3, 634, 317, 0, 5433, 5435, 3, 636, 318, 0, 5434, 5433, 1, 0, 0, 0, 5434, 5435, 1, 0, 0, 0, 5435, 5436, 1, 0, 0, 0, 5436, 5437, 3, 640, 320, 0, 5437, 5446, 1, 0, 0, 0, 5438, 5440, 3, 636, 318, 0, 5439, 5441, 3, 634, 317, 0, 5440, 5439, 1, 0, 0, 0, 5440, 5441, 1, 0, 0, 0, 5441, 5442, 1, 0, 0, 0, 5442, 5443, 3, 640, 320, 0, 5443, 5446, 1, 0, 0, 0, 5444, 5446, 3, 640, 320, 0, 5445, 5432, 1, 0, 0, 0, 5445, 5438, 1, 0, 0, 0, 5445, 5444, 1, 0, 0, 0, 5446, 633, 1, 0, 0, 0, 5447, 5449, 5, 68, 0, 0, 5448, 5450, 5, 453, 0, 0, 5449, 5448, 1, 0, 0, 0, 5449, 5450, 1, 0, 0, 0, 5450, 5455, 1, 0, 0, 0, 5451, 5455, 5, 453, 0, 0, 5452, 5455, 5, 393, 0, 0, 5453, 5455, 5, 101, 0, 0, 5454, 5447, 1, 0, 0, 0, 5454, 5451, 1, 0, 0, 0, 5454, 5452, 1, 0, 0, 0, 5454, 5453, 1, 0, 0, 0, 5455, 635, 1, 0, 0, 0, 5456, 5461, 3, 1376, 688, 0, 5457, 5461, 3, 1394, 697, 0, 5458, 5461, 5, 119, 0, 0, 5459, 5461, 5, 126, 0, 0, 5460, 5456, 1, 0, 0, 0, 5460, 5457, 1, 0, 0, 0, 5460, 5458, 1, 0, 0, 0, 5460, 5459, 1, 0, 0, 0, 5461, 637, 1, 0, 0, 0, 5462, 5463, 3, 640, 320, 0, 5463, 639, 1, 0, 0, 0, 5464, 5479, 3, 1118, 559, 0, 5465, 5467, 5, 408, 0, 0, 5466, 5465, 1, 0, 0, 0, 5466, 5467, 1, 0, 0, 0, 5467, 5472, 1, 0, 0, 0, 5468, 5473, 3, 1394, 697, 0, 5469, 5473, 3, 1376, 688, 0, 5470, 5473, 5, 119, 0, 0, 5471, 5473, 5, 126, 0, 0, 5472, 5468, 1, 0, 0, 0, 5472, 5469, 1, 0, 0, 0, 5472, 5470, 1, 0, 0, 0, 5472, 5471, 1, 0, 0, 0, 5473, 5474, 1, 0, 0, 0, 5474, 5475, 3, 526, 263, 0, 5475, 5476, 5, 27, 0, 0, 5476, 5477, 5, 353, 0, 0, 5477, 5479, 1, 0, 0, 0, 5478, 5464, 1, 0, 0, 0, 5478, 5466, 1, 0, 0, 0, 5479, 641, 1, 0, 0, 0, 5480, 5483, 3, 632, 316, 0, 5481, 5482, 7, 26, 0, 0, 5482, 5484, 3, 1162, 581, 0, 5483, 5481, 1, 0, 0, 0, 5483, 5484, 1, 0, 0, 0, 5484, 643, 1, 0, 0, 0, 5485, 5486, 3, 632, 316, 0, 5486, 645, 1, 0, 0, 0, 5487, 5498, 5, 2, 0, 0, 5488, 5499, 5, 9, 0, 0, 5489, 5499, 3, 648, 324, 0, 5490, 5491, 5, 83, 0, 0, 5491, 5492, 5, 147, 0, 0, 5492, 5499, 3, 648, 324, 0, 5493, 5494, 3, 648, 324, 0, 5494, 5495, 5, 83, 0, 0, 5495, 5496, 5, 147, 0, 0, 5496, 5497, 3, 648, 324, 0, 5497, 5499, 1, 0, 0, 0, 5498, 5488, 1, 0, 0, 0, 5498, 5489, 1, 0, 0, 0, 5498, 5490, 1, 0, 0, 0, 5498, 5493, 1, 0, 0, 0, 5499, 5500, 1, 0, 0, 0, 5500, 5501, 5, 3, 0, 0, 5501, 647, 1, 0, 0, 0, 5502, 5507, 3, 644, 322, 0, 5503, 5504, 5, 6, 0, 0, 5504, 5506, 3, 644, 322, 0, 5505, 5503, 1, 0, 0, 0, 5506, 5509, 1, 0, 0, 0, 5507, 5505, 1, 0, 0, 0, 5507, 5508, 1, 0, 0, 0, 5508, 649, 1, 0, 0, 0, 5509, 5507, 1, 0, 0, 0, 5510, 5511, 3, 1346, 673, 0, 5511, 5512, 3, 646, 323, 0, 5512, 651, 1, 0, 0, 0, 5513, 5518, 3, 650, 325, 0, 5514, 5515, 5, 6, 0, 0, 5515, 5517, 3, 650, 325, 0, 5516, 5514, 1, 0, 0, 0, 5517, 5520, 1, 0, 0, 0, 5518, 5516, 1, 0, 0, 0, 5518, 5519, 1, 0, 0, 0, 5519, 653, 1, 0, 0, 0, 5520, 5518, 1, 0, 0, 0, 5521, 5523, 3, 658, 329, 0, 5522, 5521, 1, 0, 0, 0, 5523, 5524, 1, 0, 0, 0, 5524, 5522, 1, 0, 0, 0, 5524, 5525, 1, 0, 0, 0, 5525, 5526, 1, 0, 0, 0, 5526, 5527, 6, 327, -1, 0, 5527, 655, 1, 0, 0, 0, 5528, 5529, 5, 149, 0, 0, 5529, 5530, 5, 80, 0, 0, 5530, 5531, 5, 78, 0, 0, 5531, 5564, 5, 458, 0, 0, 5532, 5533, 5, 309, 0, 0, 5533, 5534, 5, 78, 0, 0, 5534, 5535, 5, 80, 0, 0, 5535, 5536, 5, 78, 0, 0, 5536, 5564, 5, 458, 0, 0, 5537, 5564, 5, 339, 0, 0, 5538, 5564, 5, 222, 0, 0, 5539, 5564, 5, 331, 0, 0, 5540, 5564, 5, 370, 0, 0, 5541, 5542, 5, 205, 0, 0, 5542, 5543, 5, 320, 0, 0, 5543, 5564, 5, 181, 0, 0, 5544, 5545, 5, 205, 0, 0, 5545, 5546, 5, 320, 0, 0, 5546, 5564, 5, 234, 0, 0, 5547, 5548, 5, 320, 0, 0, 5548, 5564, 5, 181, 0, 0, 5549, 5550, 5, 320, 0, 0, 5550, 5564, 5, 234, 0, 0, 5551, 5564, 5, 241, 0, 0, 5552, 5553, 5, 77, 0, 0, 5553, 5564, 5, 241, 0, 0, 5554, 5555, 5, 170, 0, 0, 5555, 5564, 3, 292, 146, 0, 5556, 5557, 5, 313, 0, 0, 5557, 5564, 3, 292, 146, 0, 5558, 5559, 5, 459, 0, 0, 5559, 5564, 3, 524, 262, 0, 5560, 5564, 3, 82, 41, 0, 5561, 5562, 5, 460, 0, 0, 5562, 5564, 3, 1372, 686, 0, 5563, 5528, 1, 0, 0, 0, 5563, 5532, 1, 0, 0, 0, 5563, 5537, 1, 0, 0, 0, 5563, 5538, 1, 0, 0, 0, 5563, 5539, 1, 0, 0, 0, 5563, 5540, 1, 0, 0, 0, 5563, 5541, 1, 0, 0, 0, 5563, 5544, 1, 0, 0, 0, 5563, 5547, 1, 0, 0, 0, 5563, 5549, 1, 0, 0, 0, 5563, 5551, 1, 0, 0, 0, 5563, 5552, 1, 0, 0, 0, 5563, 5554, 1, 0, 0, 0, 5563, 5556, 1, 0, 0, 0, 5563, 5558, 1, 0, 0, 0, 5563, 5560, 1, 0, 0, 0, 5563, 5561, 1, 0, 0, 0, 5564, 657, 1, 0, 0, 0, 5565, 5566, 5, 36, 0, 0, 5566, 5574, 3, 660, 330, 0, 5567, 5568, 5, 238, 0, 0, 5568, 5574, 3, 72, 36, 0, 5569, 5570, 5, 443, 0, 0, 5570, 5574, 3, 662, 331, 0, 5571, 5574, 5, 104, 0, 0, 5572, 5574, 3, 656, 328, 0, 5573, 5565, 1, 0, 0, 0, 5573, 5567, 1, 0, 0, 0, 5573, 5569, 1, 0, 0, 0, 5573, 5571, 1, 0, 0, 0, 5573, 5572, 1, 0, 0, 0, 5574, 659, 1, 0, 0, 0, 5575, 5581, 3, 1358, 679, 0, 5576, 5577, 3, 1358, 679, 0, 5577, 5578, 5, 6, 0, 0, 5578, 5579, 3, 1358, 679, 0, 5579, 5581, 1, 0, 0, 0, 5580, 5575, 1, 0, 0, 0, 5580, 5576, 1, 0, 0, 0, 5581, 661, 1, 0, 0, 0, 5582, 5583, 5, 62, 0, 0, 5583, 5584, 5, 353, 0, 0, 5584, 5591, 3, 1118, 559, 0, 5585, 5586, 5, 6, 0, 0, 5586, 5587, 5, 62, 0, 0, 5587, 5588, 5, 353, 0, 0, 5588, 5590, 3, 1118, 559, 0, 5589, 5585, 1, 0, 0, 0, 5590, 5593, 1, 0, 0, 0, 5591, 5589, 1, 0, 0, 0, 5591, 5592, 1, 0, 0, 0, 5592, 663, 1, 0, 0, 0, 5593, 5591, 1, 0, 0, 0, 5594, 5595, 5, 105, 0, 0, 5595, 5598, 3, 460, 230, 0, 5596, 5598, 1, 0, 0, 0, 5597, 5594, 1, 0, 0, 0, 5597, 5596, 1, 0, 0, 0, 5598, 665, 1, 0, 0, 0, 5599, 5600, 3, 636, 318, 0, 5600, 5601, 3, 640, 320, 0, 5601, 667, 1, 0, 0, 0, 5602, 5607, 3, 666, 333, 0, 5603, 5604, 5, 6, 0, 0, 5604, 5606, 3, 666, 333, 0, 5605, 5603, 1, 0, 0, 0, 5606, 5609, 1, 0, 0, 0, 5607, 5605, 1, 0, 0, 0, 5607, 5608, 1, 0, 0, 0, 5608, 669, 1, 0, 0, 0, 5609, 5607, 1, 0, 0, 0, 5610, 5611, 5, 138, 0, 0, 5611, 5612, 7, 27, 0, 0, 5612, 5613, 3, 626, 313, 0, 5613, 5614, 3, 672, 336, 0, 5614, 5615, 3, 674, 337, 0, 5615, 671, 1, 0, 0, 0, 5616, 5618, 3, 656, 328, 0, 5617, 5616, 1, 0, 0, 0, 5618, 5619, 1, 0, 0, 0, 5619, 5617, 1, 0, 0, 0, 5619, 5620, 1, 0, 0, 0, 5620, 673, 1, 0, 0, 0, 5621, 5624, 5, 308, 0, 0, 5622, 5624, 1, 0, 0, 0, 5623, 5621, 1, 0, 0, 0, 5623, 5622, 1, 0, 0, 0, 5624, 675, 1, 0, 0, 0, 5625, 5626, 5, 191, 0, 0, 5626, 5627, 5, 211, 0, 0, 5627, 5628, 3, 624, 312, 0, 5628, 5629, 3, 108, 54, 0, 5629, 5662, 1, 0, 0, 0, 5630, 5631, 5, 191, 0, 0, 5631, 5632, 5, 211, 0, 0, 5632, 5633, 5, 220, 0, 0, 5633, 5634, 5, 389, 0, 0, 5634, 5635, 3, 624, 312, 0, 5635, 5636, 3, 108, 54, 0, 5636, 5662, 1, 0, 0, 0, 5637, 5638, 5, 191, 0, 0, 5638, 5639, 5, 289, 0, 0, 5639, 5640, 3, 624, 312, 0, 5640, 5641, 3, 108, 54, 0, 5641, 5662, 1, 0, 0, 0, 5642, 5643, 5, 191, 0, 0, 5643, 5644, 5, 289, 0, 0, 5644, 5645, 5, 220, 0, 0, 5645, 5646, 5, 389, 0, 0, 5646, 5647, 3, 624, 312, 0, 5647, 5648, 3, 108, 54, 0, 5648, 5662, 1, 0, 0, 0, 5649, 5650, 5, 191, 0, 0, 5650, 5651, 5, 442, 0, 0, 5651, 5652, 3, 624, 312, 0, 5652, 5653, 3, 108, 54, 0, 5653, 5662, 1, 0, 0, 0, 5654, 5655, 5, 191, 0, 0, 5655, 5656, 5, 442, 0, 0, 5656, 5657, 5, 220, 0, 0, 5657, 5658, 5, 389, 0, 0, 5658, 5659, 3, 624, 312, 0, 5659, 5660, 3, 108, 54, 0, 5660, 5662, 1, 0, 0, 0, 5661, 5625, 1, 0, 0, 0, 5661, 5630, 1, 0, 0, 0, 5661, 5637, 1, 0, 0, 0, 5661, 5642, 1, 0, 0, 0, 5661, 5649, 1, 0, 0, 0, 5661, 5654, 1, 0, 0, 0, 5662, 677, 1, 0, 0, 0, 5663, 5664, 5, 191, 0, 0, 5664, 5665, 5, 136, 0, 0, 5665, 5666, 3, 652, 326, 0, 5666, 5667, 3, 108, 54, 0, 5667, 5676, 1, 0, 0, 0, 5668, 5669, 5, 191, 0, 0, 5669, 5670, 5, 136, 0, 0, 5670, 5671, 5, 220, 0, 0, 5671, 5672, 5, 389, 0, 0, 5672, 5673, 3, 652, 326, 0, 5673, 5674, 3, 108, 54, 0, 5674, 5676, 1, 0, 0, 0, 5675, 5663, 1, 0, 0, 0, 5675, 5668, 1, 0, 0, 0, 5676, 679, 1, 0, 0, 0, 5677, 5678, 5, 191, 0, 0, 5678, 5679, 5, 271, 0, 0, 5679, 5680, 3, 686, 343, 0, 5680, 5681, 3, 108, 54, 0, 5681, 5690, 1, 0, 0, 0, 5682, 5683, 5, 191, 0, 0, 5683, 5684, 5, 271, 0, 0, 5684, 5685, 5, 220, 0, 0, 5685, 5686, 5, 389, 0, 0, 5686, 5687, 3, 686, 343, 0, 5687, 5688, 3, 108, 54, 0, 5688, 5690, 1, 0, 0, 0, 5689, 5677, 1, 0, 0, 0, 5689, 5682, 1, 0, 0, 0, 5690, 681, 1, 0, 0, 0, 5691, 5692, 5, 2, 0, 0, 5692, 5693, 3, 1118, 559, 0, 5693, 5694, 5, 3, 0, 0, 5694, 5714, 1, 0, 0, 0, 5695, 5696, 5, 2, 0, 0, 5696, 5697, 3, 1118, 559, 0, 5697, 5698, 5, 6, 0, 0, 5698, 5699, 3, 1118, 559, 0, 5699, 5700, 5, 3, 0, 0, 5700, 5714, 1, 0, 0, 0, 5701, 5702, 5, 2, 0, 0, 5702, 5703, 5, 400, 0, 0, 5703, 5704, 5, 6, 0, 0, 5704, 5705, 3, 1118, 559, 0, 5705, 5706, 5, 3, 0, 0, 5706, 5714, 1, 0, 0, 0, 5707, 5708, 5, 2, 0, 0, 5708, 5709, 3, 1118, 559, 0, 5709, 5710, 5, 6, 0, 0, 5710, 5711, 5, 400, 0, 0, 5711, 5712, 5, 3, 0, 0, 5712, 5714, 1, 0, 0, 0, 5713, 5691, 1, 0, 0, 0, 5713, 5695, 1, 0, 0, 0, 5713, 5701, 1, 0, 0, 0, 5713, 5707, 1, 0, 0, 0, 5714, 683, 1, 0, 0, 0, 5715, 5716, 3, 1372, 686, 0, 5716, 5717, 5, 11, 0, 0, 5717, 5719, 1, 0, 0, 0, 5718, 5715, 1, 0, 0, 0, 5719, 5722, 1, 0, 0, 0, 5720, 5718, 1, 0, 0, 0, 5720, 5721, 1, 0, 0, 0, 5721, 5723, 1, 0, 0, 0, 5722, 5720, 1, 0, 0, 0, 5723, 5724, 3, 1270, 635, 0, 5724, 685, 1, 0, 0, 0, 5725, 5730, 3, 688, 344, 0, 5726, 5727, 5, 6, 0, 0, 5727, 5729, 3, 688, 344, 0, 5728, 5726, 1, 0, 0, 0, 5729, 5732, 1, 0, 0, 0, 5730, 5728, 1, 0, 0, 0, 5730, 5731, 1, 0, 0, 0, 5731, 687, 1, 0, 0, 0, 5732, 5730, 1, 0, 0, 0, 5733, 5734, 3, 684, 342, 0, 5734, 5735, 3, 682, 341, 0, 5735, 689, 1, 0, 0, 0, 5736, 5737, 5, 57, 0, 0, 5737, 5738, 3, 692, 346, 0, 5738, 691, 1, 0, 0, 0, 5739, 5741, 3, 694, 347, 0, 5740, 5739, 1, 0, 0, 0, 5741, 5742, 1, 0, 0, 0, 5742, 5740, 1, 0, 0, 0, 5742, 5743, 1, 0, 0, 0, 5743, 693, 1, 0, 0, 0, 5744, 5748, 3, 1358, 679, 0, 5745, 5746, 5, 238, 0, 0, 5746, 5748, 3, 72, 36, 0, 5747, 5744, 1, 0, 0, 0, 5747, 5745, 1, 0, 0, 0, 5748, 695, 1, 0, 0, 0, 5749, 5750, 5, 46, 0, 0, 5750, 5751, 5, 41, 0, 0, 5751, 5752, 5, 2, 0, 0, 5752, 5753, 3, 1118, 559, 0, 5753, 5754, 5, 36, 0, 0, 5754, 5755, 3, 1118, 559, 0, 5755, 5756, 5, 3, 0, 0, 5756, 5757, 5, 105, 0, 0, 5757, 5758, 5, 211, 0, 0, 5758, 5759, 3, 626, 313, 0, 5759, 5760, 3, 698, 349, 0, 5760, 5784, 1, 0, 0, 0, 5761, 5762, 5, 46, 0, 0, 5762, 5763, 5, 41, 0, 0, 5763, 5764, 5, 2, 0, 0, 5764, 5765, 3, 1118, 559, 0, 5765, 5766, 5, 36, 0, 0, 5766, 5767, 3, 1118, 559, 0, 5767, 5768, 5, 3, 0, 0, 5768, 5769, 5, 372, 0, 0, 5769, 5770, 5, 211, 0, 0, 5770, 5771, 3, 698, 349, 0, 5771, 5784, 1, 0, 0, 0, 5772, 5773, 5, 46, 0, 0, 5773, 5774, 5, 41, 0, 0, 5774, 5775, 5, 2, 0, 0, 5775, 5776, 3, 1118, 559, 0, 5776, 5777, 5, 36, 0, 0, 5777, 5778, 3, 1118, 559, 0, 5778, 5779, 5, 3, 0, 0, 5779, 5780, 5, 105, 0, 0, 5780, 5781, 5, 393, 0, 0, 5781, 5782, 3, 698, 349, 0, 5782, 5784, 1, 0, 0, 0, 5783, 5749, 1, 0, 0, 0, 5783, 5761, 1, 0, 0, 0, 5783, 5772, 1, 0, 0, 0, 5784, 697, 1, 0, 0, 0, 5785, 5786, 5, 36, 0, 0, 5786, 5791, 5, 223, 0, 0, 5787, 5788, 5, 36, 0, 0, 5788, 5791, 5, 141, 0, 0, 5789, 5791, 1, 0, 0, 0, 5790, 5785, 1, 0, 0, 0, 5790, 5787, 1, 0, 0, 0, 5790, 5789, 1, 0, 0, 0, 5791, 699, 1, 0, 0, 0, 5792, 5793, 5, 191, 0, 0, 5793, 5794, 5, 41, 0, 0, 5794, 5795, 3, 702, 351, 0, 5795, 5796, 5, 2, 0, 0, 5796, 5797, 3, 1118, 559, 0, 5797, 5798, 5, 36, 0, 0, 5798, 5799, 3, 1118, 559, 0, 5799, 5800, 5, 3, 0, 0, 5800, 5801, 3, 108, 54, 0, 5801, 701, 1, 0, 0, 0, 5802, 5803, 5, 220, 0, 0, 5803, 5806, 5, 389, 0, 0, 5804, 5806, 1, 0, 0, 0, 5805, 5802, 1, 0, 0, 0, 5805, 5804, 1, 0, 0, 0, 5806, 703, 1, 0, 0, 0, 5807, 5808, 5, 46, 0, 0, 5808, 5809, 3, 618, 309, 0, 5809, 5810, 5, 443, 0, 0, 5810, 5811, 5, 62, 0, 0, 5811, 5812, 3, 1118, 559, 0, 5812, 5813, 5, 238, 0, 0, 5813, 5814, 3, 1340, 670, 0, 5814, 5815, 5, 2, 0, 0, 5815, 5816, 3, 706, 353, 0, 5816, 5817, 5, 3, 0, 0, 5817, 705, 1, 0, 0, 0, 5818, 5819, 5, 64, 0, 0, 5819, 5820, 5, 461, 0, 0, 5820, 5821, 5, 105, 0, 0, 5821, 5822, 5, 211, 0, 0, 5822, 5823, 3, 626, 313, 0, 5823, 5824, 5, 6, 0, 0, 5824, 5825, 5, 94, 0, 0, 5825, 5826, 5, 461, 0, 0, 5826, 5827, 5, 105, 0, 0, 5827, 5828, 5, 211, 0, 0, 5828, 5829, 3, 626, 313, 0, 5829, 5853, 1, 0, 0, 0, 5830, 5831, 5, 94, 0, 0, 5831, 5832, 5, 461, 0, 0, 5832, 5833, 5, 105, 0, 0, 5833, 5834, 5, 211, 0, 0, 5834, 5835, 3, 626, 313, 0, 5835, 5836, 5, 6, 0, 0, 5836, 5837, 5, 64, 0, 0, 5837, 5838, 5, 461, 0, 0, 5838, 5839, 5, 105, 0, 0, 5839, 5840, 5, 211, 0, 0, 5840, 5841, 3, 626, 313, 0, 5841, 5853, 1, 0, 0, 0, 5842, 5843, 5, 64, 0, 0, 5843, 5844, 5, 461, 0, 0, 5844, 5845, 5, 105, 0, 0, 5845, 5846, 5, 211, 0, 0, 5846, 5853, 3, 626, 313, 0, 5847, 5848, 5, 94, 0, 0, 5848, 5849, 5, 461, 0, 0, 5849, 5850, 5, 105, 0, 0, 5850, 5851, 5, 211, 0, 0, 5851, 5853, 3, 626, 313, 0, 5852, 5818, 1, 0, 0, 0, 5852, 5830, 1, 0, 0, 0, 5852, 5842, 1, 0, 0, 0, 5852, 5847, 1, 0, 0, 0, 5853, 707, 1, 0, 0, 0, 5854, 5855, 5, 191, 0, 0, 5855, 5856, 5, 443, 0, 0, 5856, 5857, 3, 702, 351, 0, 5857, 5858, 5, 62, 0, 0, 5858, 5859, 3, 1118, 559, 0, 5859, 5860, 5, 238, 0, 0, 5860, 5861, 3, 1340, 670, 0, 5861, 5862, 3, 108, 54, 0, 5862, 709, 1, 0, 0, 0, 5863, 5864, 5, 299, 0, 0, 5864, 5865, 3, 712, 356, 0, 5865, 5866, 3, 592, 296, 0, 5866, 5867, 3, 1336, 668, 0, 5867, 5890, 1, 0, 0, 0, 5868, 5869, 5, 299, 0, 0, 5869, 5870, 3, 714, 357, 0, 5870, 5871, 3, 592, 296, 0, 5871, 5872, 3, 1340, 670, 0, 5872, 5890, 1, 0, 0, 0, 5873, 5874, 5, 299, 0, 0, 5874, 5875, 5, 2, 0, 0, 5875, 5876, 3, 716, 358, 0, 5876, 5877, 5, 3, 0, 0, 5877, 5878, 3, 712, 356, 0, 5878, 5879, 3, 592, 296, 0, 5879, 5880, 3, 1336, 668, 0, 5880, 5890, 1, 0, 0, 0, 5881, 5882, 5, 299, 0, 0, 5882, 5883, 5, 2, 0, 0, 5883, 5884, 3, 716, 358, 0, 5884, 5885, 5, 3, 0, 0, 5885, 5886, 3, 714, 357, 0, 5886, 5887, 3, 592, 296, 0, 5887, 5888, 3, 1340, 670, 0, 5888, 5890, 1, 0, 0, 0, 5889, 5863, 1, 0, 0, 0, 5889, 5868, 1, 0, 0, 0, 5889, 5873, 1, 0, 0, 0, 5889, 5881, 1, 0, 0, 0, 5890, 711, 1, 0, 0, 0, 5891, 5892, 7, 28, 0, 0, 5892, 713, 1, 0, 0, 0, 5893, 5894, 7, 29, 0, 0, 5894, 715, 1, 0, 0, 0, 5895, 5900, 3, 718, 359, 0, 5896, 5897, 5, 6, 0, 0, 5897, 5899, 3, 718, 359, 0, 5898, 5896, 1, 0, 0, 0, 5899, 5902, 1, 0, 0, 0, 5900, 5898, 1, 0, 0, 0, 5900, 5901, 1, 0, 0, 0, 5901, 717, 1, 0, 0, 0, 5902, 5900, 1, 0, 0, 0, 5903, 5904, 7, 30, 0, 0, 5904, 719, 1, 0, 0, 0, 5905, 5906, 5, 138, 0, 0, 5906, 5907, 5, 344, 0, 0, 5907, 5908, 3, 1340, 670, 0, 5908, 5909, 5, 326, 0, 0, 5909, 5910, 3, 116, 58, 0, 5910, 5918, 1, 0, 0, 0, 5911, 5912, 5, 138, 0, 0, 5912, 5913, 5, 344, 0, 0, 5913, 5914, 3, 1340, 670, 0, 5914, 5915, 5, 306, 0, 0, 5915, 5916, 3, 116, 58, 0, 5916, 5918, 1, 0, 0, 0, 5917, 5905, 1, 0, 0, 0, 5917, 5911, 1, 0, 0, 0, 5918, 721, 1, 0, 0, 0, 5919, 5920, 5, 138, 0, 0, 5920, 5921, 5, 136, 0, 0, 5921, 5922, 3, 650, 325, 0, 5922, 5923, 5, 302, 0, 0, 5923, 5924, 5, 94, 0, 0, 5924, 5925, 3, 1340, 670, 0, 5925, 6388, 1, 0, 0, 0, 5926, 5927, 5, 138, 0, 0, 5927, 5928, 5, 108, 0, 0, 5928, 5929, 3, 524, 262, 0, 5929, 5930, 5, 302, 0, 0, 5930, 5931, 5, 94, 0, 0, 5931, 5932, 3, 1340, 670, 0, 5932, 6388, 1, 0, 0, 0, 5933, 5934, 5, 138, 0, 0, 5934, 5935, 5, 168, 0, 0, 5935, 5936, 3, 524, 262, 0, 5936, 5937, 5, 302, 0, 0, 5937, 5938, 5, 94, 0, 0, 5938, 5939, 3, 1340, 670, 0, 5939, 6388, 1, 0, 0, 0, 5940, 5941, 5, 138, 0, 0, 5941, 5942, 5, 175, 0, 0, 5942, 5943, 3, 1340, 670, 0, 5943, 5944, 5, 302, 0, 0, 5944, 5945, 5, 94, 0, 0, 5945, 5946, 3, 1340, 670, 0, 5946, 6388, 1, 0, 0, 0, 5947, 5948, 5, 138, 0, 0, 5948, 5949, 5, 189, 0, 0, 5949, 5950, 3, 524, 262, 0, 5950, 5951, 5, 302, 0, 0, 5951, 5952, 5, 94, 0, 0, 5952, 5953, 3, 1340, 670, 0, 5953, 6388, 1, 0, 0, 0, 5954, 5955, 5, 138, 0, 0, 5955, 5956, 5, 189, 0, 0, 5956, 5957, 3, 524, 262, 0, 5957, 5958, 5, 302, 0, 0, 5958, 5959, 5, 45, 0, 0, 5959, 5960, 3, 1340, 670, 0, 5960, 5961, 5, 94, 0, 0, 5961, 5962, 3, 1340, 670, 0, 5962, 6388, 1, 0, 0, 0, 5963, 5964, 5, 138, 0, 0, 5964, 5965, 5, 63, 0, 0, 5965, 5966, 5, 174, 0, 0, 5966, 5967, 5, 374, 0, 0, 5967, 5968, 3, 1340, 670, 0, 5968, 5969, 5, 302, 0, 0, 5969, 5970, 5, 94, 0, 0, 5970, 5971, 3, 1340, 670, 0, 5971, 6388, 1, 0, 0, 0, 5972, 5973, 5, 138, 0, 0, 5973, 5974, 5, 211, 0, 0, 5974, 5975, 3, 626, 313, 0, 5975, 5976, 5, 302, 0, 0, 5976, 5977, 5, 94, 0, 0, 5977, 5978, 3, 1340, 670, 0, 5978, 6388, 1, 0, 0, 0, 5979, 5980, 5, 138, 0, 0, 5980, 5981, 5, 66, 0, 0, 5981, 5982, 3, 1366, 683, 0, 5982, 5983, 5, 302, 0, 0, 5983, 5984, 5, 94, 0, 0, 5984, 5985, 3, 1366, 683, 0, 5985, 6388, 1, 0, 0, 0, 5986, 5987, 5, 138, 0, 0, 5987, 5988, 3, 308, 154, 0, 5988, 5989, 5, 238, 0, 0, 5989, 5990, 3, 1340, 670, 0, 5990, 5991, 5, 302, 0, 0, 5991, 5992, 5, 94, 0, 0, 5992, 5993, 3, 1340, 670, 0, 5993, 6388, 1, 0, 0, 0, 5994, 5995, 5, 138, 0, 0, 5995, 5996, 5, 271, 0, 0, 5996, 5997, 5, 156, 0, 0, 5997, 5998, 3, 524, 262, 0, 5998, 5999, 5, 100, 0, 0, 5999, 6000, 3, 1340, 670, 0, 6000, 6001, 5, 302, 0, 0, 6001, 6002, 5, 94, 0, 0, 6002, 6003, 3, 1340, 670, 0, 6003, 6388, 1, 0, 0, 0, 6004, 6005, 5, 138, 0, 0, 6005, 6006, 5, 271, 0, 0, 6006, 6007, 5, 206, 0, 0, 6007, 6008, 3, 524, 262, 0, 6008, 6009, 5, 100, 0, 0, 6009, 6010, 3, 1340, 670, 0, 6010, 6011, 5, 302, 0, 0, 6011, 6012, 5, 94, 0, 0, 6012, 6013, 3, 1340, 670, 0, 6013, 6388, 1, 0, 0, 0, 6014, 6015, 5, 138, 0, 0, 6015, 6016, 5, 445, 0, 0, 6016, 6017, 3, 1340, 670, 0, 6017, 6018, 5, 80, 0, 0, 6018, 6019, 3, 1336, 668, 0, 6019, 6020, 5, 302, 0, 0, 6020, 6021, 5, 94, 0, 0, 6021, 6022, 3, 1340, 670, 0, 6022, 6388, 1, 0, 0, 0, 6023, 6024, 5, 138, 0, 0, 6024, 6025, 5, 445, 0, 0, 6025, 6026, 5, 220, 0, 0, 6026, 6027, 5, 389, 0, 0, 6027, 6028, 3, 1340, 670, 0, 6028, 6029, 5, 80, 0, 0, 6029, 6030, 3, 1336, 668, 0, 6030, 6031, 5, 302, 0, 0, 6031, 6032, 5, 94, 0, 0, 6032, 6033, 3, 1340, 670, 0, 6033, 6388, 1, 0, 0, 0, 6034, 6035, 5, 138, 0, 0, 6035, 6036, 5, 289, 0, 0, 6036, 6037, 3, 626, 313, 0, 6037, 6038, 5, 302, 0, 0, 6038, 6039, 5, 94, 0, 0, 6039, 6040, 3, 1340, 670, 0, 6040, 6388, 1, 0, 0, 0, 6041, 6042, 5, 138, 0, 0, 6042, 6043, 5, 452, 0, 0, 6043, 6044, 3, 1340, 670, 0, 6044, 6045, 5, 302, 0, 0, 6045, 6046, 5, 94, 0, 0, 6046, 6047, 3, 1340, 670, 0, 6047, 6388, 1, 0, 0, 0, 6048, 6049, 5, 138, 0, 0, 6049, 6050, 5, 442, 0, 0, 6050, 6051, 3, 626, 313, 0, 6051, 6052, 5, 302, 0, 0, 6052, 6053, 5, 94, 0, 0, 6053, 6054, 3, 1340, 670, 0, 6054, 6388, 1, 0, 0, 0, 6055, 6056, 5, 138, 0, 0, 6056, 6057, 5, 316, 0, 0, 6057, 6058, 3, 1340, 670, 0, 6058, 6059, 5, 302, 0, 0, 6059, 6060, 5, 94, 0, 0, 6060, 6061, 3, 1340, 670, 0, 6061, 6388, 1, 0, 0, 0, 6062, 6063, 5, 138, 0, 0, 6063, 6064, 5, 324, 0, 0, 6064, 6065, 3, 1340, 670, 0, 6065, 6066, 5, 302, 0, 0, 6066, 6067, 5, 94, 0, 0, 6067, 6068, 3, 1340, 670, 0, 6068, 6388, 1, 0, 0, 0, 6069, 6070, 5, 138, 0, 0, 6070, 6071, 5, 451, 0, 0, 6071, 6072, 3, 1340, 670, 0, 6072, 6073, 5, 302, 0, 0, 6073, 6074, 5, 94, 0, 0, 6074, 6075, 3, 1340, 670, 0, 6075, 6388, 1, 0, 0, 0, 6076, 6077, 5, 138, 0, 0, 6077, 6078, 5, 92, 0, 0, 6078, 6079, 3, 1074, 537, 0, 6079, 6080, 5, 302, 0, 0, 6080, 6081, 5, 94, 0, 0, 6081, 6082, 3, 1340, 670, 0, 6082, 6388, 1, 0, 0, 0, 6083, 6084, 5, 138, 0, 0, 6084, 6085, 5, 92, 0, 0, 6085, 6086, 5, 220, 0, 0, 6086, 6087, 5, 389, 0, 0, 6087, 6088, 3, 1074, 537, 0, 6088, 6089, 5, 302, 0, 0, 6089, 6090, 5, 94, 0, 0, 6090, 6091, 3, 1340, 670, 0, 6091, 6388, 1, 0, 0, 0, 6092, 6093, 5, 138, 0, 0, 6093, 6094, 5, 321, 0, 0, 6094, 6095, 3, 1336, 668, 0, 6095, 6096, 5, 302, 0, 0, 6096, 6097, 5, 94, 0, 0, 6097, 6098, 3, 1340, 670, 0, 6098, 6388, 1, 0, 0, 0, 6099, 6100, 5, 138, 0, 0, 6100, 6101, 5, 321, 0, 0, 6101, 6102, 5, 220, 0, 0, 6102, 6103, 5, 389, 0, 0, 6103, 6104, 3, 1336, 668, 0, 6104, 6105, 5, 302, 0, 0, 6105, 6106, 5, 94, 0, 0, 6106, 6107, 3, 1340, 670, 0, 6107, 6388, 1, 0, 0, 0, 6108, 6109, 5, 138, 0, 0, 6109, 6110, 5, 369, 0, 0, 6110, 6111, 3, 1336, 668, 0, 6111, 6112, 5, 302, 0, 0, 6112, 6113, 5, 94, 0, 0, 6113, 6114, 3, 1340, 670, 0, 6114, 6388, 1, 0, 0, 0, 6115, 6116, 5, 138, 0, 0, 6116, 6117, 5, 369, 0, 0, 6117, 6118, 5, 220, 0, 0, 6118, 6119, 5, 389, 0, 0, 6119, 6120, 3, 1336, 668, 0, 6120, 6121, 5, 302, 0, 0, 6121, 6122, 5, 94, 0, 0, 6122, 6123, 3, 1340, 670, 0, 6123, 6388, 1, 0, 0, 0, 6124, 6125, 5, 138, 0, 0, 6125, 6126, 5, 251, 0, 0, 6126, 6127, 5, 369, 0, 0, 6127, 6128, 3, 1336, 668, 0, 6128, 6129, 5, 302, 0, 0, 6129, 6130, 5, 94, 0, 0, 6130, 6131, 3, 1340, 670, 0, 6131, 6388, 1, 0, 0, 0, 6132, 6133, 5, 138, 0, 0, 6133, 6134, 5, 251, 0, 0, 6134, 6135, 5, 369, 0, 0, 6135, 6136, 5, 220, 0, 0, 6136, 6137, 5, 389, 0, 0, 6137, 6138, 3, 1336, 668, 0, 6138, 6139, 5, 302, 0, 0, 6139, 6140, 5, 94, 0, 0, 6140, 6141, 3, 1340, 670, 0, 6141, 6388, 1, 0, 0, 0, 6142, 6143, 5, 138, 0, 0, 6143, 6144, 5, 226, 0, 0, 6144, 6145, 3, 1336, 668, 0, 6145, 6146, 5, 302, 0, 0, 6146, 6147, 5, 94, 0, 0, 6147, 6148, 3, 1340, 670, 0, 6148, 6388, 1, 0, 0, 0, 6149, 6150, 5, 138, 0, 0, 6150, 6151, 5, 226, 0, 0, 6151, 6152, 5, 220, 0, 0, 6152, 6153, 5, 389, 0, 0, 6153, 6154, 3, 1336, 668, 0, 6154, 6155, 5, 302, 0, 0, 6155, 6156, 5, 94, 0, 0, 6156, 6157, 3, 1340, 670, 0, 6157, 6388, 1, 0, 0, 0, 6158, 6159, 5, 138, 0, 0, 6159, 6160, 5, 63, 0, 0, 6160, 6161, 5, 92, 0, 0, 6161, 6162, 3, 1074, 537, 0, 6162, 6163, 5, 302, 0, 0, 6163, 6164, 5, 94, 0, 0, 6164, 6165, 3, 1340, 670, 0, 6165, 6388, 1, 0, 0, 0, 6166, 6167, 5, 138, 0, 0, 6167, 6168, 5, 63, 0, 0, 6168, 6169, 5, 92, 0, 0, 6169, 6170, 5, 220, 0, 0, 6170, 6171, 5, 389, 0, 0, 6171, 6172, 3, 1074, 537, 0, 6172, 6173, 5, 302, 0, 0, 6173, 6174, 5, 94, 0, 0, 6174, 6175, 3, 1340, 670, 0, 6175, 6388, 1, 0, 0, 0, 6176, 6177, 5, 138, 0, 0, 6177, 6178, 5, 92, 0, 0, 6178, 6179, 3, 1074, 537, 0, 6179, 6180, 5, 302, 0, 0, 6180, 6181, 3, 724, 362, 0, 6181, 6182, 3, 1340, 670, 0, 6182, 6183, 5, 94, 0, 0, 6183, 6184, 3, 1340, 670, 0, 6184, 6388, 1, 0, 0, 0, 6185, 6186, 5, 138, 0, 0, 6186, 6187, 5, 92, 0, 0, 6187, 6188, 5, 220, 0, 0, 6188, 6189, 5, 389, 0, 0, 6189, 6190, 3, 1074, 537, 0, 6190, 6191, 5, 302, 0, 0, 6191, 6192, 3, 724, 362, 0, 6192, 6193, 3, 1340, 670, 0, 6193, 6194, 5, 94, 0, 0, 6194, 6195, 3, 1340, 670, 0, 6195, 6388, 1, 0, 0, 0, 6196, 6197, 5, 138, 0, 0, 6197, 6198, 5, 369, 0, 0, 6198, 6199, 3, 1336, 668, 0, 6199, 6200, 5, 302, 0, 0, 6200, 6201, 3, 724, 362, 0, 6201, 6202, 3, 1340, 670, 0, 6202, 6203, 5, 94, 0, 0, 6203, 6204, 3, 1340, 670, 0, 6204, 6388, 1, 0, 0, 0, 6205, 6206, 5, 138, 0, 0, 6206, 6207, 5, 369, 0, 0, 6207, 6208, 5, 220, 0, 0, 6208, 6209, 5, 389, 0, 0, 6209, 6210, 3, 1336, 668, 0, 6210, 6211, 5, 302, 0, 0, 6211, 6212, 3, 724, 362, 0, 6212, 6213, 3, 1340, 670, 0, 6213, 6214, 5, 94, 0, 0, 6214, 6215, 3, 1340, 670, 0, 6215, 6388, 1, 0, 0, 0, 6216, 6217, 5, 138, 0, 0, 6217, 6218, 5, 251, 0, 0, 6218, 6219, 5, 369, 0, 0, 6219, 6220, 3, 1336, 668, 0, 6220, 6221, 5, 302, 0, 0, 6221, 6222, 3, 724, 362, 0, 6222, 6223, 3, 1340, 670, 0, 6223, 6224, 5, 94, 0, 0, 6224, 6225, 3, 1340, 670, 0, 6225, 6388, 1, 0, 0, 0, 6226, 6227, 5, 138, 0, 0, 6227, 6228, 5, 251, 0, 0, 6228, 6229, 5, 369, 0, 0, 6229, 6230, 5, 220, 0, 0, 6230, 6231, 5, 389, 0, 0, 6231, 6232, 3, 1336, 668, 0, 6232, 6233, 5, 302, 0, 0, 6233, 6234, 3, 724, 362, 0, 6234, 6235, 3, 1340, 670, 0, 6235, 6236, 5, 94, 0, 0, 6236, 6237, 3, 1340, 670, 0, 6237, 6388, 1, 0, 0, 0, 6238, 6239, 5, 138, 0, 0, 6239, 6240, 5, 92, 0, 0, 6240, 6241, 3, 1074, 537, 0, 6241, 6242, 5, 302, 0, 0, 6242, 6243, 5, 45, 0, 0, 6243, 6244, 3, 1340, 670, 0, 6244, 6245, 5, 94, 0, 0, 6245, 6246, 3, 1340, 670, 0, 6246, 6388, 1, 0, 0, 0, 6247, 6248, 5, 138, 0, 0, 6248, 6249, 5, 92, 0, 0, 6249, 6250, 5, 220, 0, 0, 6250, 6251, 5, 389, 0, 0, 6251, 6252, 3, 1074, 537, 0, 6252, 6253, 5, 302, 0, 0, 6253, 6254, 5, 45, 0, 0, 6254, 6255, 3, 1340, 670, 0, 6255, 6256, 5, 94, 0, 0, 6256, 6257, 3, 1340, 670, 0, 6257, 6388, 1, 0, 0, 0, 6258, 6259, 5, 138, 0, 0, 6259, 6260, 5, 63, 0, 0, 6260, 6261, 5, 92, 0, 0, 6261, 6262, 3, 1074, 537, 0, 6262, 6263, 5, 302, 0, 0, 6263, 6264, 3, 724, 362, 0, 6264, 6265, 3, 1340, 670, 0, 6265, 6266, 5, 94, 0, 0, 6266, 6267, 3, 1340, 670, 0, 6267, 6388, 1, 0, 0, 0, 6268, 6269, 5, 138, 0, 0, 6269, 6270, 5, 63, 0, 0, 6270, 6271, 5, 92, 0, 0, 6271, 6272, 5, 220, 0, 0, 6272, 6273, 5, 389, 0, 0, 6273, 6274, 3, 1074, 537, 0, 6274, 6275, 5, 302, 0, 0, 6275, 6276, 3, 724, 362, 0, 6276, 6277, 3, 1340, 670, 0, 6277, 6278, 5, 94, 0, 0, 6278, 6279, 3, 1340, 670, 0, 6279, 6388, 1, 0, 0, 0, 6280, 6281, 5, 138, 0, 0, 6281, 6282, 5, 314, 0, 0, 6282, 6283, 3, 1340, 670, 0, 6283, 6284, 5, 80, 0, 0, 6284, 6285, 3, 1336, 668, 0, 6285, 6286, 5, 302, 0, 0, 6286, 6287, 5, 94, 0, 0, 6287, 6288, 3, 1340, 670, 0, 6288, 6388, 1, 0, 0, 0, 6289, 6290, 5, 138, 0, 0, 6290, 6291, 5, 350, 0, 0, 6291, 6292, 3, 1340, 670, 0, 6292, 6293, 5, 80, 0, 0, 6293, 6294, 3, 1336, 668, 0, 6294, 6295, 5, 302, 0, 0, 6295, 6296, 5, 94, 0, 0, 6296, 6297, 3, 1340, 670, 0, 6297, 6388, 1, 0, 0, 0, 6298, 6299, 5, 138, 0, 0, 6299, 6300, 5, 198, 0, 0, 6300, 6301, 5, 350, 0, 0, 6301, 6302, 3, 1340, 670, 0, 6302, 6303, 5, 302, 0, 0, 6303, 6304, 5, 94, 0, 0, 6304, 6305, 3, 1340, 670, 0, 6305, 6388, 1, 0, 0, 0, 6306, 6307, 5, 138, 0, 0, 6307, 6308, 5, 311, 0, 0, 6308, 6309, 3, 1366, 683, 0, 6309, 6310, 5, 302, 0, 0, 6310, 6311, 5, 94, 0, 0, 6311, 6312, 3, 1366, 683, 0, 6312, 6388, 1, 0, 0, 0, 6313, 6314, 5, 138, 0, 0, 6314, 6315, 5, 99, 0, 0, 6315, 6316, 3, 1366, 683, 0, 6316, 6317, 5, 302, 0, 0, 6317, 6318, 5, 94, 0, 0, 6318, 6319, 3, 1366, 683, 0, 6319, 6388, 1, 0, 0, 0, 6320, 6321, 5, 138, 0, 0, 6321, 6322, 5, 344, 0, 0, 6322, 6323, 3, 1340, 670, 0, 6323, 6324, 5, 302, 0, 0, 6324, 6325, 5, 94, 0, 0, 6325, 6326, 3, 1340, 670, 0, 6326, 6388, 1, 0, 0, 0, 6327, 6328, 5, 138, 0, 0, 6328, 6329, 5, 335, 0, 0, 6329, 6330, 3, 524, 262, 0, 6330, 6331, 5, 302, 0, 0, 6331, 6332, 5, 94, 0, 0, 6332, 6333, 3, 1340, 670, 0, 6333, 6388, 1, 0, 0, 0, 6334, 6335, 5, 138, 0, 0, 6335, 6336, 5, 348, 0, 0, 6336, 6337, 5, 318, 0, 0, 6337, 6338, 5, 276, 0, 0, 6338, 6339, 3, 524, 262, 0, 6339, 6340, 5, 302, 0, 0, 6340, 6341, 5, 94, 0, 0, 6341, 6342, 3, 1340, 670, 0, 6342, 6388, 1, 0, 0, 0, 6343, 6344, 5, 138, 0, 0, 6344, 6345, 5, 348, 0, 0, 6345, 6346, 5, 318, 0, 0, 6346, 6347, 5, 185, 0, 0, 6347, 6348, 3, 524, 262, 0, 6348, 6349, 5, 302, 0, 0, 6349, 6350, 5, 94, 0, 0, 6350, 6351, 3, 1340, 670, 0, 6351, 6388, 1, 0, 0, 0, 6352, 6353, 5, 138, 0, 0, 6353, 6354, 5, 348, 0, 0, 6354, 6355, 5, 318, 0, 0, 6355, 6356, 5, 346, 0, 0, 6356, 6357, 3, 524, 262, 0, 6357, 6358, 5, 302, 0, 0, 6358, 6359, 5, 94, 0, 0, 6359, 6360, 3, 1340, 670, 0, 6360, 6388, 1, 0, 0, 0, 6361, 6362, 5, 138, 0, 0, 6362, 6363, 5, 348, 0, 0, 6363, 6364, 5, 318, 0, 0, 6364, 6365, 5, 163, 0, 0, 6365, 6366, 3, 524, 262, 0, 6366, 6367, 5, 302, 0, 0, 6367, 6368, 5, 94, 0, 0, 6368, 6369, 3, 1340, 670, 0, 6369, 6388, 1, 0, 0, 0, 6370, 6371, 5, 138, 0, 0, 6371, 6372, 5, 353, 0, 0, 6372, 6373, 3, 524, 262, 0, 6373, 6374, 5, 302, 0, 0, 6374, 6375, 5, 94, 0, 0, 6375, 6376, 3, 1340, 670, 0, 6376, 6388, 1, 0, 0, 0, 6377, 6378, 5, 138, 0, 0, 6378, 6379, 5, 353, 0, 0, 6379, 6380, 3, 524, 262, 0, 6380, 6381, 5, 302, 0, 0, 6381, 6382, 5, 143, 0, 0, 6382, 6383, 3, 1340, 670, 0, 6383, 6384, 5, 94, 0, 0, 6384, 6385, 3, 1340, 670, 0, 6385, 6386, 3, 108, 54, 0, 6386, 6388, 1, 0, 0, 0, 6387, 5919, 1, 0, 0, 0, 6387, 5926, 1, 0, 0, 0, 6387, 5933, 1, 0, 0, 0, 6387, 5940, 1, 0, 0, 0, 6387, 5947, 1, 0, 0, 0, 6387, 5954, 1, 0, 0, 0, 6387, 5963, 1, 0, 0, 0, 6387, 5972, 1, 0, 0, 0, 6387, 5979, 1, 0, 0, 0, 6387, 5986, 1, 0, 0, 0, 6387, 5994, 1, 0, 0, 0, 6387, 6004, 1, 0, 0, 0, 6387, 6014, 1, 0, 0, 0, 6387, 6023, 1, 0, 0, 0, 6387, 6034, 1, 0, 0, 0, 6387, 6041, 1, 0, 0, 0, 6387, 6048, 1, 0, 0, 0, 6387, 6055, 1, 0, 0, 0, 6387, 6062, 1, 0, 0, 0, 6387, 6069, 1, 0, 0, 0, 6387, 6076, 1, 0, 0, 0, 6387, 6083, 1, 0, 0, 0, 6387, 6092, 1, 0, 0, 0, 6387, 6099, 1, 0, 0, 0, 6387, 6108, 1, 0, 0, 0, 6387, 6115, 1, 0, 0, 0, 6387, 6124, 1, 0, 0, 0, 6387, 6132, 1, 0, 0, 0, 6387, 6142, 1, 0, 0, 0, 6387, 6149, 1, 0, 0, 0, 6387, 6158, 1, 0, 0, 0, 6387, 6166, 1, 0, 0, 0, 6387, 6176, 1, 0, 0, 0, 6387, 6185, 1, 0, 0, 0, 6387, 6196, 1, 0, 0, 0, 6387, 6205, 1, 0, 0, 0, 6387, 6216, 1, 0, 0, 0, 6387, 6226, 1, 0, 0, 0, 6387, 6238, 1, 0, 0, 0, 6387, 6247, 1, 0, 0, 0, 6387, 6258, 1, 0, 0, 0, 6387, 6268, 1, 0, 0, 0, 6387, 6280, 1, 0, 0, 0, 6387, 6289, 1, 0, 0, 0, 6387, 6298, 1, 0, 0, 0, 6387, 6306, 1, 0, 0, 0, 6387, 6313, 1, 0, 0, 0, 6387, 6320, 1, 0, 0, 0, 6387, 6327, 1, 0, 0, 0, 6387, 6334, 1, 0, 0, 0, 6387, 6343, 1, 0, 0, 0, 6387, 6352, 1, 0, 0, 0, 6387, 6361, 1, 0, 0, 0, 6387, 6370, 1, 0, 0, 0, 6387, 6377, 1, 0, 0, 0, 6388, 723, 1, 0, 0, 0, 6389, 6392, 5, 44, 0, 0, 6390, 6392, 1, 0, 0, 0, 6391, 6389, 1, 0, 0, 0, 6391, 6390, 1, 0, 0, 0, 6392, 725, 1, 0, 0, 0, 6393, 6394, 5, 326, 0, 0, 6394, 6397, 5, 174, 0, 0, 6395, 6397, 1, 0, 0, 0, 6396, 6393, 1, 0, 0, 0, 6396, 6395, 1, 0, 0, 0, 6397, 727, 1, 0, 0, 0, 6398, 6399, 5, 138, 0, 0, 6399, 6400, 5, 211, 0, 0, 6400, 6401, 3, 626, 313, 0, 6401, 6402, 3, 730, 365, 0, 6402, 6403, 5, 462, 0, 0, 6403, 6404, 5, 80, 0, 0, 6404, 6405, 5, 204, 0, 0, 6405, 6406, 3, 1340, 670, 0, 6406, 6456, 1, 0, 0, 0, 6407, 6408, 5, 138, 0, 0, 6408, 6409, 5, 289, 0, 0, 6409, 6410, 3, 626, 313, 0, 6410, 6411, 3, 730, 365, 0, 6411, 6412, 5, 462, 0, 0, 6412, 6413, 5, 80, 0, 0, 6413, 6414, 5, 204, 0, 0, 6414, 6415, 3, 1340, 670, 0, 6415, 6456, 1, 0, 0, 0, 6416, 6417, 5, 138, 0, 0, 6417, 6418, 5, 442, 0, 0, 6418, 6419, 3, 626, 313, 0, 6419, 6420, 3, 730, 365, 0, 6420, 6421, 5, 462, 0, 0, 6421, 6422, 5, 80, 0, 0, 6422, 6423, 5, 204, 0, 0, 6423, 6424, 3, 1340, 670, 0, 6424, 6456, 1, 0, 0, 0, 6425, 6426, 5, 138, 0, 0, 6426, 6427, 5, 350, 0, 0, 6427, 6428, 3, 1340, 670, 0, 6428, 6429, 5, 80, 0, 0, 6429, 6430, 3, 1336, 668, 0, 6430, 6431, 3, 730, 365, 0, 6431, 6432, 5, 462, 0, 0, 6432, 6433, 5, 80, 0, 0, 6433, 6434, 5, 204, 0, 0, 6434, 6435, 3, 1340, 670, 0, 6435, 6456, 1, 0, 0, 0, 6436, 6437, 5, 138, 0, 0, 6437, 6438, 5, 251, 0, 0, 6438, 6439, 5, 369, 0, 0, 6439, 6440, 3, 1336, 668, 0, 6440, 6441, 3, 730, 365, 0, 6441, 6442, 5, 462, 0, 0, 6442, 6443, 5, 80, 0, 0, 6443, 6444, 5, 204, 0, 0, 6444, 6445, 3, 1340, 670, 0, 6445, 6456, 1, 0, 0, 0, 6446, 6447, 5, 138, 0, 0, 6447, 6448, 5, 226, 0, 0, 6448, 6449, 3, 1336, 668, 0, 6449, 6450, 3, 730, 365, 0, 6450, 6451, 5, 462, 0, 0, 6451, 6452, 5, 80, 0, 0, 6452, 6453, 5, 204, 0, 0, 6453, 6454, 3, 1340, 670, 0, 6454, 6456, 1, 0, 0, 0, 6455, 6398, 1, 0, 0, 0, 6455, 6407, 1, 0, 0, 0, 6455, 6416, 1, 0, 0, 0, 6455, 6425, 1, 0, 0, 0, 6455, 6436, 1, 0, 0, 0, 6455, 6446, 1, 0, 0, 0, 6456, 729, 1, 0, 0, 0, 6457, 6460, 5, 262, 0, 0, 6458, 6460, 1, 0, 0, 0, 6459, 6457, 1, 0, 0, 0, 6459, 6458, 1, 0, 0, 0, 6460, 731, 1, 0, 0, 0, 6461, 6462, 5, 138, 0, 0, 6462, 6463, 5, 136, 0, 0, 6463, 6464, 3, 650, 325, 0, 6464, 6465, 5, 326, 0, 0, 6465, 6466, 5, 316, 0, 0, 6466, 6467, 3, 1340, 670, 0, 6467, 6679, 1, 0, 0, 0, 6468, 6469, 5, 138, 0, 0, 6469, 6470, 5, 108, 0, 0, 6470, 6471, 3, 524, 262, 0, 6471, 6472, 5, 326, 0, 0, 6472, 6473, 5, 316, 0, 0, 6473, 6474, 3, 1340, 670, 0, 6474, 6679, 1, 0, 0, 0, 6475, 6476, 5, 138, 0, 0, 6476, 6477, 5, 168, 0, 0, 6477, 6478, 3, 524, 262, 0, 6478, 6479, 5, 326, 0, 0, 6479, 6480, 5, 316, 0, 0, 6480, 6481, 3, 1340, 670, 0, 6481, 6679, 1, 0, 0, 0, 6482, 6483, 5, 138, 0, 0, 6483, 6484, 5, 189, 0, 0, 6484, 6485, 3, 524, 262, 0, 6485, 6486, 5, 326, 0, 0, 6486, 6487, 5, 316, 0, 0, 6487, 6488, 3, 1340, 670, 0, 6488, 6679, 1, 0, 0, 0, 6489, 6490, 5, 138, 0, 0, 6490, 6491, 5, 204, 0, 0, 6491, 6492, 3, 1340, 670, 0, 6492, 6493, 5, 326, 0, 0, 6493, 6494, 5, 316, 0, 0, 6494, 6495, 3, 1340, 670, 0, 6495, 6679, 1, 0, 0, 0, 6496, 6497, 5, 138, 0, 0, 6497, 6498, 5, 211, 0, 0, 6498, 6499, 3, 626, 313, 0, 6499, 6500, 5, 326, 0, 0, 6500, 6501, 5, 316, 0, 0, 6501, 6502, 3, 1340, 670, 0, 6502, 6679, 1, 0, 0, 0, 6503, 6504, 5, 138, 0, 0, 6504, 6505, 5, 271, 0, 0, 6505, 6506, 3, 688, 344, 0, 6506, 6507, 5, 326, 0, 0, 6507, 6508, 5, 316, 0, 0, 6508, 6509, 3, 1340, 670, 0, 6509, 6679, 1, 0, 0, 0, 6510, 6511, 5, 138, 0, 0, 6511, 6512, 5, 271, 0, 0, 6512, 6513, 5, 156, 0, 0, 6513, 6514, 3, 524, 262, 0, 6514, 6515, 5, 100, 0, 0, 6515, 6516, 3, 1340, 670, 0, 6516, 6517, 5, 326, 0, 0, 6517, 6518, 5, 316, 0, 0, 6518, 6519, 3, 1340, 670, 0, 6519, 6679, 1, 0, 0, 0, 6520, 6521, 5, 138, 0, 0, 6521, 6522, 5, 271, 0, 0, 6522, 6523, 5, 206, 0, 0, 6523, 6524, 3, 524, 262, 0, 6524, 6525, 5, 100, 0, 0, 6525, 6526, 3, 1340, 670, 0, 6526, 6527, 5, 326, 0, 0, 6527, 6528, 5, 316, 0, 0, 6528, 6529, 3, 1340, 670, 0, 6529, 6679, 1, 0, 0, 0, 6530, 6531, 5, 138, 0, 0, 6531, 6532, 5, 289, 0, 0, 6532, 6533, 3, 626, 313, 0, 6533, 6534, 5, 326, 0, 0, 6534, 6535, 5, 316, 0, 0, 6535, 6536, 3, 1340, 670, 0, 6536, 6679, 1, 0, 0, 0, 6537, 6538, 5, 138, 0, 0, 6538, 6539, 5, 442, 0, 0, 6539, 6540, 3, 626, 313, 0, 6540, 6541, 5, 326, 0, 0, 6541, 6542, 5, 316, 0, 0, 6542, 6543, 3, 1340, 670, 0, 6543, 6679, 1, 0, 0, 0, 6544, 6545, 5, 138, 0, 0, 6545, 6546, 5, 92, 0, 0, 6546, 6547, 3, 1074, 537, 0, 6547, 6548, 5, 326, 0, 0, 6548, 6549, 5, 316, 0, 0, 6549, 6550, 3, 1340, 670, 0, 6550, 6679, 1, 0, 0, 0, 6551, 6552, 5, 138, 0, 0, 6552, 6553, 5, 92, 0, 0, 6553, 6554, 5, 220, 0, 0, 6554, 6555, 5, 389, 0, 0, 6555, 6556, 3, 1074, 537, 0, 6556, 6557, 5, 326, 0, 0, 6557, 6558, 5, 316, 0, 0, 6558, 6559, 3, 1340, 670, 0, 6559, 6679, 1, 0, 0, 0, 6560, 6561, 5, 138, 0, 0, 6561, 6562, 5, 335, 0, 0, 6562, 6563, 3, 524, 262, 0, 6563, 6564, 5, 326, 0, 0, 6564, 6565, 5, 316, 0, 0, 6565, 6566, 3, 1340, 670, 0, 6566, 6679, 1, 0, 0, 0, 6567, 6568, 5, 138, 0, 0, 6568, 6569, 5, 348, 0, 0, 6569, 6570, 5, 318, 0, 0, 6570, 6571, 5, 276, 0, 0, 6571, 6572, 3, 524, 262, 0, 6572, 6573, 5, 326, 0, 0, 6573, 6574, 5, 316, 0, 0, 6574, 6575, 3, 1340, 670, 0, 6575, 6679, 1, 0, 0, 0, 6576, 6577, 5, 138, 0, 0, 6577, 6578, 5, 348, 0, 0, 6578, 6579, 5, 318, 0, 0, 6579, 6580, 5, 185, 0, 0, 6580, 6581, 3, 524, 262, 0, 6581, 6582, 5, 326, 0, 0, 6582, 6583, 5, 316, 0, 0, 6583, 6584, 3, 1340, 670, 0, 6584, 6679, 1, 0, 0, 0, 6585, 6586, 5, 138, 0, 0, 6586, 6587, 5, 348, 0, 0, 6587, 6588, 5, 318, 0, 0, 6588, 6589, 5, 346, 0, 0, 6589, 6590, 3, 524, 262, 0, 6590, 6591, 5, 326, 0, 0, 6591, 6592, 5, 316, 0, 0, 6592, 6593, 3, 1340, 670, 0, 6593, 6679, 1, 0, 0, 0, 6594, 6595, 5, 138, 0, 0, 6595, 6596, 5, 348, 0, 0, 6596, 6597, 5, 318, 0, 0, 6597, 6598, 5, 163, 0, 0, 6598, 6599, 3, 524, 262, 0, 6599, 6600, 5, 326, 0, 0, 6600, 6601, 5, 316, 0, 0, 6601, 6602, 3, 1340, 670, 0, 6602, 6679, 1, 0, 0, 0, 6603, 6604, 5, 138, 0, 0, 6604, 6605, 5, 321, 0, 0, 6605, 6606, 3, 1336, 668, 0, 6606, 6607, 5, 326, 0, 0, 6607, 6608, 5, 316, 0, 0, 6608, 6609, 3, 1340, 670, 0, 6609, 6679, 1, 0, 0, 0, 6610, 6611, 5, 138, 0, 0, 6611, 6612, 5, 321, 0, 0, 6612, 6613, 5, 220, 0, 0, 6613, 6614, 5, 389, 0, 0, 6614, 6615, 3, 1336, 668, 0, 6615, 6616, 5, 326, 0, 0, 6616, 6617, 5, 316, 0, 0, 6617, 6618, 3, 1340, 670, 0, 6618, 6679, 1, 0, 0, 0, 6619, 6620, 5, 138, 0, 0, 6620, 6621, 5, 369, 0, 0, 6621, 6622, 3, 1336, 668, 0, 6622, 6623, 5, 326, 0, 0, 6623, 6624, 5, 316, 0, 0, 6624, 6625, 3, 1340, 670, 0, 6625, 6679, 1, 0, 0, 0, 6626, 6627, 5, 138, 0, 0, 6627, 6628, 5, 369, 0, 0, 6628, 6629, 5, 220, 0, 0, 6629, 6630, 5, 389, 0, 0, 6630, 6631, 3, 1336, 668, 0, 6631, 6632, 5, 326, 0, 0, 6632, 6633, 5, 316, 0, 0, 6633, 6634, 3, 1340, 670, 0, 6634, 6679, 1, 0, 0, 0, 6635, 6636, 5, 138, 0, 0, 6636, 6637, 5, 251, 0, 0, 6637, 6638, 5, 369, 0, 0, 6638, 6639, 3, 1336, 668, 0, 6639, 6640, 5, 326, 0, 0, 6640, 6641, 5, 316, 0, 0, 6641, 6642, 3, 1340, 670, 0, 6642, 6679, 1, 0, 0, 0, 6643, 6644, 5, 138, 0, 0, 6644, 6645, 5, 251, 0, 0, 6645, 6646, 5, 369, 0, 0, 6646, 6647, 5, 220, 0, 0, 6647, 6648, 5, 389, 0, 0, 6648, 6649, 3, 1336, 668, 0, 6649, 6650, 5, 326, 0, 0, 6650, 6651, 5, 316, 0, 0, 6651, 6652, 3, 1340, 670, 0, 6652, 6679, 1, 0, 0, 0, 6653, 6654, 5, 138, 0, 0, 6654, 6655, 5, 63, 0, 0, 6655, 6656, 5, 92, 0, 0, 6656, 6657, 3, 1074, 537, 0, 6657, 6658, 5, 326, 0, 0, 6658, 6659, 5, 316, 0, 0, 6659, 6660, 3, 1340, 670, 0, 6660, 6679, 1, 0, 0, 0, 6661, 6662, 5, 138, 0, 0, 6662, 6663, 5, 63, 0, 0, 6663, 6664, 5, 92, 0, 0, 6664, 6665, 5, 220, 0, 0, 6665, 6666, 5, 389, 0, 0, 6666, 6667, 3, 1074, 537, 0, 6667, 6668, 5, 326, 0, 0, 6668, 6669, 5, 316, 0, 0, 6669, 6670, 3, 1340, 670, 0, 6670, 6679, 1, 0, 0, 0, 6671, 6672, 5, 138, 0, 0, 6672, 6673, 5, 353, 0, 0, 6673, 6674, 3, 524, 262, 0, 6674, 6675, 5, 326, 0, 0, 6675, 6676, 5, 316, 0, 0, 6676, 6677, 3, 1340, 670, 0, 6677, 6679, 1, 0, 0, 0, 6678, 6461, 1, 0, 0, 0, 6678, 6468, 1, 0, 0, 0, 6678, 6475, 1, 0, 0, 0, 6678, 6482, 1, 0, 0, 0, 6678, 6489, 1, 0, 0, 0, 6678, 6496, 1, 0, 0, 0, 6678, 6503, 1, 0, 0, 0, 6678, 6510, 1, 0, 0, 0, 6678, 6520, 1, 0, 0, 0, 6678, 6530, 1, 0, 0, 0, 6678, 6537, 1, 0, 0, 0, 6678, 6544, 1, 0, 0, 0, 6678, 6551, 1, 0, 0, 0, 6678, 6560, 1, 0, 0, 0, 6678, 6567, 1, 0, 0, 0, 6678, 6576, 1, 0, 0, 0, 6678, 6585, 1, 0, 0, 0, 6678, 6594, 1, 0, 0, 0, 6678, 6603, 1, 0, 0, 0, 6678, 6610, 1, 0, 0, 0, 6678, 6619, 1, 0, 0, 0, 6678, 6626, 1, 0, 0, 0, 6678, 6635, 1, 0, 0, 0, 6678, 6643, 1, 0, 0, 0, 6678, 6653, 1, 0, 0, 0, 6678, 6661, 1, 0, 0, 0, 6678, 6671, 1, 0, 0, 0, 6679, 733, 1, 0, 0, 0, 6680, 6681, 5, 138, 0, 0, 6681, 6682, 5, 271, 0, 0, 6682, 6683, 3, 688, 344, 0, 6683, 6684, 5, 326, 0, 0, 6684, 6685, 5, 2, 0, 0, 6685, 6686, 3, 736, 368, 0, 6686, 6687, 5, 3, 0, 0, 6687, 735, 1, 0, 0, 0, 6688, 6693, 3, 738, 369, 0, 6689, 6690, 5, 6, 0, 0, 6690, 6692, 3, 738, 369, 0, 6691, 6689, 1, 0, 0, 0, 6692, 6695, 1, 0, 0, 0, 6693, 6691, 1, 0, 0, 0, 6693, 6694, 1, 0, 0, 0, 6694, 737, 1, 0, 0, 0, 6695, 6693, 1, 0, 0, 0, 6696, 6697, 3, 1380, 690, 0, 6697, 6698, 5, 10, 0, 0, 6698, 6699, 5, 400, 0, 0, 6699, 6705, 1, 0, 0, 0, 6700, 6701, 3, 1380, 690, 0, 6701, 6702, 5, 10, 0, 0, 6702, 6703, 3, 740, 370, 0, 6703, 6705, 1, 0, 0, 0, 6704, 6696, 1, 0, 0, 0, 6704, 6700, 1, 0, 0, 0, 6705, 739, 1, 0, 0, 0, 6706, 6712, 3, 640, 320, 0, 6707, 6712, 3, 1392, 696, 0, 6708, 6712, 3, 1276, 638, 0, 6709, 6712, 3, 292, 146, 0, 6710, 6712, 3, 1358, 679, 0, 6711, 6706, 1, 0, 0, 0, 6711, 6707, 1, 0, 0, 0, 6711, 6708, 1, 0, 0, 0, 6711, 6709, 1, 0, 0, 0, 6711, 6710, 1, 0, 0, 0, 6712, 741, 1, 0, 0, 0, 6713, 6714, 5, 138, 0, 0, 6714, 6715, 5, 353, 0, 0, 6715, 6716, 3, 524, 262, 0, 6716, 6717, 5, 326, 0, 0, 6717, 6718, 5, 2, 0, 0, 6718, 6719, 3, 736, 368, 0, 6719, 6720, 5, 3, 0, 0, 6720, 743, 1, 0, 0, 0, 6721, 6722, 5, 138, 0, 0, 6722, 6723, 5, 136, 0, 0, 6723, 6724, 3, 650, 325, 0, 6724, 6725, 5, 275, 0, 0, 6725, 6726, 5, 94, 0, 0, 6726, 6727, 3, 1368, 684, 0, 6727, 6905, 1, 0, 0, 0, 6728, 6729, 5, 138, 0, 0, 6729, 6730, 5, 108, 0, 0, 6730, 6731, 3, 524, 262, 0, 6731, 6732, 5, 275, 0, 0, 6732, 6733, 5, 94, 0, 0, 6733, 6734, 3, 1368, 684, 0, 6734, 6905, 1, 0, 0, 0, 6735, 6736, 5, 138, 0, 0, 6736, 6737, 5, 168, 0, 0, 6737, 6738, 3, 524, 262, 0, 6738, 6739, 5, 275, 0, 0, 6739, 6740, 5, 94, 0, 0, 6740, 6741, 3, 1368, 684, 0, 6741, 6905, 1, 0, 0, 0, 6742, 6743, 5, 138, 0, 0, 6743, 6744, 5, 175, 0, 0, 6744, 6745, 3, 1340, 670, 0, 6745, 6746, 5, 275, 0, 0, 6746, 6747, 5, 94, 0, 0, 6747, 6748, 3, 1368, 684, 0, 6748, 6905, 1, 0, 0, 0, 6749, 6750, 5, 138, 0, 0, 6750, 6751, 5, 189, 0, 0, 6751, 6752, 3, 524, 262, 0, 6752, 6753, 5, 275, 0, 0, 6753, 6754, 5, 94, 0, 0, 6754, 6755, 3, 1368, 684, 0, 6755, 6905, 1, 0, 0, 0, 6756, 6757, 5, 138, 0, 0, 6757, 6758, 5, 211, 0, 0, 6758, 6759, 3, 626, 313, 0, 6759, 6760, 5, 275, 0, 0, 6760, 6761, 5, 94, 0, 0, 6761, 6762, 3, 1368, 684, 0, 6762, 6905, 1, 0, 0, 0, 6763, 6764, 5, 138, 0, 0, 6764, 6765, 3, 308, 154, 0, 6765, 6766, 5, 238, 0, 0, 6766, 6767, 3, 1340, 670, 0, 6767, 6768, 5, 275, 0, 0, 6768, 6769, 5, 94, 0, 0, 6769, 6770, 3, 1368, 684, 0, 6770, 6905, 1, 0, 0, 0, 6771, 6772, 5, 138, 0, 0, 6772, 6773, 5, 239, 0, 0, 6773, 6774, 5, 267, 0, 0, 6774, 6775, 3, 292, 146, 0, 6775, 6776, 5, 275, 0, 0, 6776, 6777, 5, 94, 0, 0, 6777, 6778, 3, 1368, 684, 0, 6778, 6905, 1, 0, 0, 0, 6779, 6780, 5, 138, 0, 0, 6780, 6781, 5, 271, 0, 0, 6781, 6782, 3, 688, 344, 0, 6782, 6783, 5, 275, 0, 0, 6783, 6784, 5, 94, 0, 0, 6784, 6785, 3, 1368, 684, 0, 6785, 6905, 1, 0, 0, 0, 6786, 6787, 5, 138, 0, 0, 6787, 6788, 5, 271, 0, 0, 6788, 6789, 5, 156, 0, 0, 6789, 6790, 3, 524, 262, 0, 6790, 6791, 5, 100, 0, 0, 6791, 6792, 3, 1340, 670, 0, 6792, 6793, 5, 275, 0, 0, 6793, 6794, 5, 94, 0, 0, 6794, 6795, 3, 1368, 684, 0, 6795, 6905, 1, 0, 0, 0, 6796, 6797, 5, 138, 0, 0, 6797, 6798, 5, 271, 0, 0, 6798, 6799, 5, 206, 0, 0, 6799, 6800, 3, 524, 262, 0, 6800, 6801, 5, 100, 0, 0, 6801, 6802, 3, 1340, 670, 0, 6802, 6803, 5, 275, 0, 0, 6803, 6804, 5, 94, 0, 0, 6804, 6805, 3, 1368, 684, 0, 6805, 6905, 1, 0, 0, 0, 6806, 6807, 5, 138, 0, 0, 6807, 6808, 5, 289, 0, 0, 6808, 6809, 3, 626, 313, 0, 6809, 6810, 5, 275, 0, 0, 6810, 6811, 5, 94, 0, 0, 6811, 6812, 3, 1368, 684, 0, 6812, 6905, 1, 0, 0, 0, 6813, 6814, 5, 138, 0, 0, 6814, 6815, 5, 442, 0, 0, 6815, 6816, 3, 626, 313, 0, 6816, 6817, 5, 275, 0, 0, 6817, 6818, 5, 94, 0, 0, 6818, 6819, 3, 1368, 684, 0, 6819, 6905, 1, 0, 0, 0, 6820, 6821, 5, 138, 0, 0, 6821, 6822, 5, 316, 0, 0, 6822, 6823, 3, 1340, 670, 0, 6823, 6824, 5, 275, 0, 0, 6824, 6825, 5, 94, 0, 0, 6825, 6826, 3, 1368, 684, 0, 6826, 6905, 1, 0, 0, 0, 6827, 6828, 5, 138, 0, 0, 6828, 6829, 5, 353, 0, 0, 6829, 6830, 3, 524, 262, 0, 6830, 6831, 5, 275, 0, 0, 6831, 6832, 5, 94, 0, 0, 6832, 6833, 3, 1368, 684, 0, 6833, 6905, 1, 0, 0, 0, 6834, 6835, 5, 138, 0, 0, 6835, 6836, 5, 344, 0, 0, 6836, 6837, 3, 1340, 670, 0, 6837, 6838, 5, 275, 0, 0, 6838, 6839, 5, 94, 0, 0, 6839, 6840, 3, 1368, 684, 0, 6840, 6905, 1, 0, 0, 0, 6841, 6842, 5, 138, 0, 0, 6842, 6843, 5, 335, 0, 0, 6843, 6844, 3, 524, 262, 0, 6844, 6845, 5, 275, 0, 0, 6845, 6846, 5, 94, 0, 0, 6846, 6847, 3, 1368, 684, 0, 6847, 6905, 1, 0, 0, 0, 6848, 6849, 5, 138, 0, 0, 6849, 6850, 5, 348, 0, 0, 6850, 6851, 5, 318, 0, 0, 6851, 6852, 5, 185, 0, 0, 6852, 6853, 3, 524, 262, 0, 6853, 6854, 5, 275, 0, 0, 6854, 6855, 5, 94, 0, 0, 6855, 6856, 3, 1368, 684, 0, 6856, 6905, 1, 0, 0, 0, 6857, 6858, 5, 138, 0, 0, 6858, 6859, 5, 348, 0, 0, 6859, 6860, 5, 318, 0, 0, 6860, 6861, 5, 163, 0, 0, 6861, 6862, 3, 524, 262, 0, 6862, 6863, 5, 275, 0, 0, 6863, 6864, 5, 94, 0, 0, 6864, 6865, 3, 1368, 684, 0, 6865, 6905, 1, 0, 0, 0, 6866, 6867, 5, 138, 0, 0, 6867, 6868, 5, 63, 0, 0, 6868, 6869, 5, 174, 0, 0, 6869, 6870, 5, 374, 0, 0, 6870, 6871, 3, 1340, 670, 0, 6871, 6872, 5, 275, 0, 0, 6872, 6873, 5, 94, 0, 0, 6873, 6874, 3, 1368, 684, 0, 6874, 6905, 1, 0, 0, 0, 6875, 6876, 5, 138, 0, 0, 6876, 6877, 5, 324, 0, 0, 6877, 6878, 3, 1340, 670, 0, 6878, 6879, 5, 275, 0, 0, 6879, 6880, 5, 94, 0, 0, 6880, 6881, 3, 1368, 684, 0, 6881, 6905, 1, 0, 0, 0, 6882, 6883, 5, 138, 0, 0, 6883, 6884, 5, 198, 0, 0, 6884, 6885, 5, 350, 0, 0, 6885, 6886, 3, 1340, 670, 0, 6886, 6887, 5, 275, 0, 0, 6887, 6888, 5, 94, 0, 0, 6888, 6889, 3, 1368, 684, 0, 6889, 6905, 1, 0, 0, 0, 6890, 6891, 5, 138, 0, 0, 6891, 6892, 5, 452, 0, 0, 6892, 6893, 3, 1340, 670, 0, 6893, 6894, 5, 275, 0, 0, 6894, 6895, 5, 94, 0, 0, 6895, 6896, 3, 1368, 684, 0, 6896, 6905, 1, 0, 0, 0, 6897, 6898, 5, 138, 0, 0, 6898, 6899, 5, 451, 0, 0, 6899, 6900, 3, 1340, 670, 0, 6900, 6901, 5, 275, 0, 0, 6901, 6902, 5, 94, 0, 0, 6902, 6903, 3, 1368, 684, 0, 6903, 6905, 1, 0, 0, 0, 6904, 6721, 1, 0, 0, 0, 6904, 6728, 1, 0, 0, 0, 6904, 6735, 1, 0, 0, 0, 6904, 6742, 1, 0, 0, 0, 6904, 6749, 1, 0, 0, 0, 6904, 6756, 1, 0, 0, 0, 6904, 6763, 1, 0, 0, 0, 6904, 6771, 1, 0, 0, 0, 6904, 6779, 1, 0, 0, 0, 6904, 6786, 1, 0, 0, 0, 6904, 6796, 1, 0, 0, 0, 6904, 6806, 1, 0, 0, 0, 6904, 6813, 1, 0, 0, 0, 6904, 6820, 1, 0, 0, 0, 6904, 6827, 1, 0, 0, 0, 6904, 6834, 1, 0, 0, 0, 6904, 6841, 1, 0, 0, 0, 6904, 6848, 1, 0, 0, 0, 6904, 6857, 1, 0, 0, 0, 6904, 6866, 1, 0, 0, 0, 6904, 6875, 1, 0, 0, 0, 6904, 6882, 1, 0, 0, 0, 6904, 6890, 1, 0, 0, 0, 6904, 6897, 1, 0, 0, 0, 6905, 745, 1, 0, 0, 0, 6906, 6907, 5, 46, 0, 0, 6907, 6908, 5, 452, 0, 0, 6908, 6909, 3, 1340, 670, 0, 6909, 6910, 3, 748, 374, 0, 6910, 6911, 3, 664, 332, 0, 6911, 747, 1, 0, 0, 0, 6912, 6915, 3, 750, 375, 0, 6913, 6915, 1, 0, 0, 0, 6914, 6912, 1, 0, 0, 0, 6914, 6913, 1, 0, 0, 0, 6915, 749, 1, 0, 0, 0, 6916, 6917, 5, 62, 0, 0, 6917, 6918, 5, 92, 0, 0, 6918, 6923, 3, 1076, 538, 0, 6919, 6920, 5, 62, 0, 0, 6920, 6921, 5, 30, 0, 0, 6921, 6923, 5, 343, 0, 0, 6922, 6916, 1, 0, 0, 0, 6922, 6919, 1, 0, 0, 0, 6923, 751, 1, 0, 0, 0, 6924, 6925, 5, 138, 0, 0, 6925, 6926, 5, 452, 0, 0, 6926, 6927, 3, 1340, 670, 0, 6927, 6928, 5, 326, 0, 0, 6928, 6929, 3, 460, 230, 0, 6929, 6952, 1, 0, 0, 0, 6930, 6931, 5, 138, 0, 0, 6931, 6932, 5, 452, 0, 0, 6932, 6933, 3, 1340, 670, 0, 6933, 6934, 5, 133, 0, 0, 6934, 6935, 5, 92, 0, 0, 6935, 6936, 3, 1076, 538, 0, 6936, 6952, 1, 0, 0, 0, 6937, 6938, 5, 138, 0, 0, 6938, 6939, 5, 452, 0, 0, 6939, 6940, 3, 1340, 670, 0, 6940, 6941, 5, 326, 0, 0, 6941, 6942, 5, 92, 0, 0, 6942, 6943, 3, 1076, 538, 0, 6943, 6952, 1, 0, 0, 0, 6944, 6945, 5, 138, 0, 0, 6945, 6946, 5, 452, 0, 0, 6946, 6947, 3, 1340, 670, 0, 6947, 6948, 5, 191, 0, 0, 6948, 6949, 5, 92, 0, 0, 6949, 6950, 3, 1076, 538, 0, 6950, 6952, 1, 0, 0, 0, 6951, 6924, 1, 0, 0, 0, 6951, 6930, 1, 0, 0, 0, 6951, 6937, 1, 0, 0, 0, 6951, 6944, 1, 0, 0, 0, 6952, 753, 1, 0, 0, 0, 6953, 6954, 5, 46, 0, 0, 6954, 6955, 5, 451, 0, 0, 6955, 6956, 3, 1340, 670, 0, 6956, 6957, 5, 164, 0, 0, 6957, 6958, 3, 1358, 679, 0, 6958, 6959, 5, 452, 0, 0, 6959, 6960, 3, 756, 378, 0, 6960, 6961, 3, 664, 332, 0, 6961, 755, 1, 0, 0, 0, 6962, 6967, 3, 758, 379, 0, 6963, 6964, 5, 6, 0, 0, 6964, 6966, 3, 758, 379, 0, 6965, 6963, 1, 0, 0, 0, 6966, 6969, 1, 0, 0, 0, 6967, 6965, 1, 0, 0, 0, 6967, 6968, 1, 0, 0, 0, 6968, 757, 1, 0, 0, 0, 6969, 6967, 1, 0, 0, 0, 6970, 6971, 3, 1380, 690, 0, 6971, 759, 1, 0, 0, 0, 6972, 6973, 5, 138, 0, 0, 6973, 6974, 5, 451, 0, 0, 6974, 6975, 3, 1340, 670, 0, 6975, 6976, 5, 326, 0, 0, 6976, 6977, 3, 460, 230, 0, 6977, 7010, 1, 0, 0, 0, 6978, 6979, 5, 138, 0, 0, 6979, 6980, 5, 451, 0, 0, 6980, 6981, 3, 1340, 670, 0, 6981, 6982, 5, 164, 0, 0, 6982, 6983, 3, 1358, 679, 0, 6983, 7010, 1, 0, 0, 0, 6984, 6985, 5, 138, 0, 0, 6985, 6986, 5, 451, 0, 0, 6986, 6987, 3, 1340, 670, 0, 6987, 6988, 5, 298, 0, 0, 6988, 6989, 5, 452, 0, 0, 6989, 6990, 3, 664, 332, 0, 6990, 7010, 1, 0, 0, 0, 6991, 6992, 5, 138, 0, 0, 6992, 6993, 5, 451, 0, 0, 6993, 6994, 3, 1340, 670, 0, 6994, 6995, 5, 326, 0, 0, 6995, 6996, 5, 452, 0, 0, 6996, 6997, 3, 756, 378, 0, 6997, 6998, 3, 664, 332, 0, 6998, 7010, 1, 0, 0, 0, 6999, 7000, 5, 138, 0, 0, 7000, 7001, 5, 451, 0, 0, 7001, 7002, 3, 1340, 670, 0, 7002, 7003, 5, 193, 0, 0, 7003, 7010, 1, 0, 0, 0, 7004, 7005, 5, 138, 0, 0, 7005, 7006, 5, 451, 0, 0, 7006, 7007, 3, 1340, 670, 0, 7007, 7008, 5, 186, 0, 0, 7008, 7010, 1, 0, 0, 0, 7009, 6972, 1, 0, 0, 0, 7009, 6978, 1, 0, 0, 0, 7009, 6984, 1, 0, 0, 0, 7009, 6991, 1, 0, 0, 0, 7009, 6999, 1, 0, 0, 0, 7009, 7004, 1, 0, 0, 0, 7010, 761, 1, 0, 0, 0, 7011, 7012, 5, 191, 0, 0, 7012, 7013, 5, 451, 0, 0, 7013, 7014, 3, 1340, 670, 0, 7014, 7015, 3, 108, 54, 0, 7015, 7024, 1, 0, 0, 0, 7016, 7017, 5, 191, 0, 0, 7017, 7018, 5, 451, 0, 0, 7018, 7019, 5, 220, 0, 0, 7019, 7020, 5, 389, 0, 0, 7020, 7021, 3, 1340, 670, 0, 7021, 7022, 3, 108, 54, 0, 7022, 7024, 1, 0, 0, 0, 7023, 7011, 1, 0, 0, 0, 7023, 7016, 1, 0, 0, 0, 7024, 763, 1, 0, 0, 0, 7025, 7026, 5, 46, 0, 0, 7026, 7027, 3, 618, 309, 0, 7027, 7028, 5, 314, 0, 0, 7028, 7029, 3, 1340, 670, 0, 7029, 7030, 5, 36, 0, 0, 7030, 7031, 5, 80, 0, 0, 7031, 7032, 3, 774, 387, 0, 7032, 7033, 5, 94, 0, 0, 7033, 7034, 3, 1336, 668, 0, 7034, 7035, 3, 1094, 547, 0, 7035, 7036, 5, 57, 0, 0, 7036, 7037, 3, 776, 388, 0, 7037, 7038, 3, 766, 383, 0, 7038, 765, 1, 0, 0, 0, 7039, 7046, 5, 263, 0, 0, 7040, 7046, 3, 770, 385, 0, 7041, 7042, 5, 2, 0, 0, 7042, 7043, 3, 768, 384, 0, 7043, 7044, 5, 3, 0, 0, 7044, 7046, 1, 0, 0, 0, 7045, 7039, 1, 0, 0, 0, 7045, 7040, 1, 0, 0, 0, 7045, 7041, 1, 0, 0, 0, 7046, 767, 1, 0, 0, 0, 7047, 7052, 3, 772, 386, 0, 7048, 7049, 5, 7, 0, 0, 7049, 7051, 3, 772, 386, 0, 7050, 7048, 1, 0, 0, 0, 7051, 7054, 1, 0, 0, 0, 7052, 7050, 1, 0, 0, 0, 7052, 7053, 1, 0, 0, 0, 7053, 769, 1, 0, 0, 0, 7054, 7052, 1, 0, 0, 0, 7055, 7061, 3, 960, 480, 0, 7056, 7061, 3, 902, 451, 0, 7057, 7061, 3, 942, 471, 0, 7058, 7061, 3, 928, 464, 0, 7059, 7061, 3, 778, 389, 0, 7060, 7055, 1, 0, 0, 0, 7060, 7056, 1, 0, 0, 0, 7060, 7057, 1, 0, 0, 0, 7060, 7058, 1, 0, 0, 0, 7060, 7059, 1, 0, 0, 0, 7061, 771, 1, 0, 0, 0, 7062, 7065, 3, 770, 385, 0, 7063, 7065, 1, 0, 0, 0, 7064, 7062, 1, 0, 0, 0, 7064, 7063, 1, 0, 0, 0, 7065, 773, 1, 0, 0, 0, 7066, 7067, 7, 31, 0, 0, 7067, 775, 1, 0, 0, 0, 7068, 7072, 5, 233, 0, 0, 7069, 7072, 5, 137, 0, 0, 7070, 7072, 1, 0, 0, 0, 7071, 7068, 1, 0, 0, 0, 7071, 7069, 1, 0, 0, 0, 7071, 7070, 1, 0, 0, 0, 7072, 777, 1, 0, 0, 0, 7073, 7074, 5, 264, 0, 0, 7074, 7075, 3, 1372, 686, 0, 7075, 7076, 3, 780, 390, 0, 7076, 779, 1, 0, 0, 0, 7077, 7078, 5, 6, 0, 0, 7078, 7081, 3, 1358, 679, 0, 7079, 7081, 1, 0, 0, 0, 7080, 7077, 1, 0, 0, 0, 7080, 7079, 1, 0, 0, 0, 7081, 781, 1, 0, 0, 0, 7082, 7083, 5, 243, 0, 0, 7083, 7084, 3, 1372, 686, 0, 7084, 783, 1, 0, 0, 0, 7085, 7086, 5, 359, 0, 0, 7086, 7090, 3, 1372, 686, 0, 7087, 7088, 5, 359, 0, 0, 7088, 7090, 5, 9, 0, 0, 7089, 7085, 1, 0, 0, 0, 7089, 7087, 1, 0, 0, 0, 7090, 785, 1, 0, 0, 0, 7091, 7092, 5, 129, 0, 0, 7092, 7093, 3, 788, 394, 0, 7093, 7094, 3, 796, 398, 0, 7094, 7142, 1, 0, 0, 0, 7095, 7096, 5, 146, 0, 0, 7096, 7097, 3, 788, 394, 0, 7097, 7098, 3, 794, 397, 0, 7098, 7142, 1, 0, 0, 0, 7099, 7100, 5, 333, 0, 0, 7100, 7101, 5, 349, 0, 0, 7101, 7142, 3, 794, 397, 0, 7102, 7103, 5, 161, 0, 0, 7103, 7104, 3, 788, 394, 0, 7104, 7105, 3, 796, 398, 0, 7105, 7142, 1, 0, 0, 0, 7106, 7107, 5, 454, 0, 0, 7107, 7108, 3, 788, 394, 0, 7108, 7109, 3, 796, 398, 0, 7109, 7142, 1, 0, 0, 0, 7110, 7111, 5, 312, 0, 0, 7111, 7112, 3, 788, 394, 0, 7112, 7113, 3, 796, 398, 0, 7113, 7142, 1, 0, 0, 0, 7114, 7115, 5, 315, 0, 0, 7115, 7142, 3, 1372, 686, 0, 7116, 7117, 5, 301, 0, 0, 7117, 7118, 5, 315, 0, 0, 7118, 7142, 3, 1372, 686, 0, 7119, 7120, 5, 301, 0, 0, 7120, 7142, 3, 1372, 686, 0, 7121, 7122, 5, 312, 0, 0, 7122, 7123, 3, 788, 394, 0, 7123, 7124, 5, 94, 0, 0, 7124, 7125, 5, 315, 0, 0, 7125, 7126, 3, 1372, 686, 0, 7126, 7142, 1, 0, 0, 0, 7127, 7128, 5, 312, 0, 0, 7128, 7129, 3, 788, 394, 0, 7129, 7130, 5, 94, 0, 0, 7130, 7131, 3, 1372, 686, 0, 7131, 7142, 1, 0, 0, 0, 7132, 7133, 5, 283, 0, 0, 7133, 7134, 5, 349, 0, 0, 7134, 7142, 3, 1358, 679, 0, 7135, 7136, 5, 161, 0, 0, 7136, 7137, 5, 284, 0, 0, 7137, 7142, 3, 1358, 679, 0, 7138, 7139, 5, 312, 0, 0, 7139, 7140, 5, 284, 0, 0, 7140, 7142, 3, 1358, 679, 0, 7141, 7091, 1, 0, 0, 0, 7141, 7095, 1, 0, 0, 0, 7141, 7099, 1, 0, 0, 0, 7141, 7102, 1, 0, 0, 0, 7141, 7106, 1, 0, 0, 0, 7141, 7110, 1, 0, 0, 0, 7141, 7114, 1, 0, 0, 0, 7141, 7116, 1, 0, 0, 0, 7141, 7119, 1, 0, 0, 0, 7141, 7121, 1, 0, 0, 0, 7141, 7127, 1, 0, 0, 0, 7141, 7132, 1, 0, 0, 0, 7141, 7135, 1, 0, 0, 0, 7141, 7138, 1, 0, 0, 0, 7142, 787, 1, 0, 0, 0, 7143, 7147, 5, 373, 0, 0, 7144, 7147, 5, 349, 0, 0, 7145, 7147, 1, 0, 0, 0, 7146, 7143, 1, 0, 0, 0, 7146, 7144, 1, 0, 0, 0, 7146, 7145, 1, 0, 0, 0, 7147, 789, 1, 0, 0, 0, 7148, 7149, 5, 235, 0, 0, 7149, 7150, 5, 242, 0, 0, 7150, 7159, 3, 64, 32, 0, 7151, 7152, 5, 293, 0, 0, 7152, 7159, 5, 81, 0, 0, 7153, 7154, 5, 293, 0, 0, 7154, 7159, 5, 375, 0, 0, 7155, 7159, 5, 54, 0, 0, 7156, 7157, 5, 77, 0, 0, 7157, 7159, 5, 54, 0, 0, 7158, 7148, 1, 0, 0, 0, 7158, 7151, 1, 0, 0, 0, 7158, 7153, 1, 0, 0, 0, 7158, 7155, 1, 0, 0, 0, 7158, 7156, 1, 0, 0, 0, 7159, 791, 1, 0, 0, 0, 7160, 7167, 3, 790, 395, 0, 7161, 7163, 5, 6, 0, 0, 7162, 7161, 1, 0, 0, 0, 7162, 7163, 1, 0, 0, 0, 7163, 7164, 1, 0, 0, 0, 7164, 7166, 3, 790, 395, 0, 7165, 7162, 1, 0, 0, 0, 7166, 7169, 1, 0, 0, 0, 7167, 7165, 1, 0, 0, 0, 7167, 7168, 1, 0, 0, 0, 7168, 793, 1, 0, 0, 0, 7169, 7167, 1, 0, 0, 0, 7170, 7173, 3, 792, 396, 0, 7171, 7173, 1, 0, 0, 0, 7172, 7170, 1, 0, 0, 0, 7172, 7171, 1, 0, 0, 0, 7173, 795, 1, 0, 0, 0, 7174, 7176, 5, 33, 0, 0, 7175, 7177, 5, 262, 0, 0, 7176, 7175, 1, 0, 0, 0, 7176, 7177, 1, 0, 0, 0, 7177, 7178, 1, 0, 0, 0, 7178, 7181, 5, 153, 0, 0, 7179, 7181, 1, 0, 0, 0, 7180, 7174, 1, 0, 0, 0, 7180, 7179, 1, 0, 0, 0, 7181, 797, 1, 0, 0, 0, 7182, 7185, 5, 46, 0, 0, 7183, 7184, 5, 82, 0, 0, 7184, 7186, 5, 304, 0, 0, 7185, 7183, 1, 0, 0, 0, 7185, 7186, 1, 0, 0, 0, 7186, 7187, 1, 0, 0, 0, 7187, 7201, 3, 174, 87, 0, 7188, 7189, 5, 369, 0, 0, 7189, 7190, 3, 1336, 668, 0, 7190, 7191, 3, 214, 107, 0, 7191, 7192, 3, 118, 59, 0, 7192, 7202, 1, 0, 0, 0, 7193, 7194, 5, 296, 0, 0, 7194, 7195, 5, 369, 0, 0, 7195, 7196, 3, 1336, 668, 0, 7196, 7197, 5, 2, 0, 0, 7197, 7198, 3, 216, 108, 0, 7198, 7199, 5, 3, 0, 0, 7199, 7200, 3, 118, 59, 0, 7200, 7202, 1, 0, 0, 0, 7201, 7188, 1, 0, 0, 0, 7201, 7193, 1, 0, 0, 0, 7202, 7203, 1, 0, 0, 0, 7203, 7204, 5, 36, 0, 0, 7204, 7205, 3, 960, 480, 0, 7205, 7206, 3, 800, 400, 0, 7206, 799, 1, 0, 0, 0, 7207, 7209, 5, 105, 0, 0, 7208, 7210, 7, 32, 0, 0, 7209, 7208, 1, 0, 0, 0, 7209, 7210, 1, 0, 0, 0, 7210, 7211, 1, 0, 0, 0, 7211, 7212, 5, 42, 0, 0, 7212, 7215, 5, 272, 0, 0, 7213, 7215, 1, 0, 0, 0, 7214, 7207, 1, 0, 0, 0, 7214, 7213, 1, 0, 0, 0, 7215, 801, 1, 0, 0, 0, 7216, 7217, 5, 244, 0, 0, 7217, 7218, 3, 1344, 672, 0, 7218, 803, 1, 0, 0, 0, 7219, 7220, 5, 46, 0, 0, 7220, 7221, 5, 175, 0, 0, 7221, 7222, 3, 1340, 670, 0, 7222, 7223, 3, 16, 8, 0, 7223, 7224, 3, 806, 403, 0, 7224, 805, 1, 0, 0, 0, 7225, 7228, 3, 808, 404, 0, 7226, 7228, 1, 0, 0, 0, 7227, 7225, 1, 0, 0, 0, 7227, 7226, 1, 0, 0, 0, 7228, 807, 1, 0, 0, 0, 7229, 7231, 3, 810, 405, 0, 7230, 7229, 1, 0, 0, 0, 7231, 7232, 1, 0, 0, 0, 7232, 7230, 1, 0, 0, 0, 7232, 7233, 1, 0, 0, 0, 7233, 809, 1, 0, 0, 0, 7234, 7235, 3, 812, 406, 0, 7235, 7239, 3, 814, 407, 0, 7236, 7240, 3, 1364, 682, 0, 7237, 7240, 3, 66, 33, 0, 7238, 7240, 5, 53, 0, 0, 7239, 7236, 1, 0, 0, 0, 7239, 7237, 1, 0, 0, 0, 7239, 7238, 1, 0, 0, 0, 7240, 811, 1, 0, 0, 0, 7241, 7250, 3, 1382, 691, 0, 7242, 7243, 5, 164, 0, 0, 7243, 7250, 5, 74, 0, 0, 7244, 7250, 5, 194, 0, 0, 7245, 7250, 5, 246, 0, 0, 7246, 7250, 5, 275, 0, 0, 7247, 7250, 5, 344, 0, 0, 7248, 7250, 5, 346, 0, 0, 7249, 7241, 1, 0, 0, 0, 7249, 7242, 1, 0, 0, 0, 7249, 7244, 1, 0, 0, 0, 7249, 7245, 1, 0, 0, 0, 7249, 7246, 1, 0, 0, 0, 7249, 7247, 1, 0, 0, 0, 7249, 7248, 1, 0, 0, 0, 7250, 813, 1, 0, 0, 0, 7251, 7254, 5, 10, 0, 0, 7252, 7254, 1, 0, 0, 0, 7253, 7251, 1, 0, 0, 0, 7253, 7252, 1, 0, 0, 0, 7254, 815, 1, 0, 0, 0, 7255, 7256, 5, 138, 0, 0, 7256, 7257, 5, 175, 0, 0, 7257, 7264, 3, 1340, 670, 0, 7258, 7259, 5, 105, 0, 0, 7259, 7265, 3, 806, 403, 0, 7260, 7265, 3, 806, 403, 0, 7261, 7262, 5, 326, 0, 0, 7262, 7263, 5, 344, 0, 0, 7263, 7265, 3, 1340, 670, 0, 7264, 7258, 1, 0, 0, 0, 7264, 7260, 1, 0, 0, 0, 7264, 7261, 1, 0, 0, 0, 7265, 817, 1, 0, 0, 0, 7266, 7267, 5, 138, 0, 0, 7267, 7268, 5, 175, 0, 0, 7268, 7269, 3, 1340, 670, 0, 7269, 7270, 3, 80, 40, 0, 7270, 819, 1, 0, 0, 0, 7271, 7272, 5, 191, 0, 0, 7272, 7275, 5, 175, 0, 0, 7273, 7274, 5, 220, 0, 0, 7274, 7276, 5, 389, 0, 0, 7275, 7273, 1, 0, 0, 0, 7275, 7276, 1, 0, 0, 0, 7276, 7277, 1, 0, 0, 0, 7277, 7283, 3, 1340, 670, 0, 7278, 7279, 3, 16, 8, 0, 7279, 7280, 5, 2, 0, 0, 7280, 7281, 3, 822, 411, 0, 7281, 7282, 5, 3, 0, 0, 7282, 7284, 1, 0, 0, 0, 7283, 7278, 1, 0, 0, 0, 7283, 7284, 1, 0, 0, 0, 7284, 821, 1, 0, 0, 0, 7285, 7290, 3, 824, 412, 0, 7286, 7287, 5, 6, 0, 0, 7287, 7289, 3, 824, 412, 0, 7288, 7286, 1, 0, 0, 0, 7289, 7292, 1, 0, 0, 0, 7290, 7288, 1, 0, 0, 0, 7290, 7291, 1, 0, 0, 0, 7291, 823, 1, 0, 0, 0, 7292, 7290, 1, 0, 0, 0, 7293, 7294, 5, 209, 0, 0, 7294, 825, 1, 0, 0, 0, 7295, 7296, 5, 138, 0, 0, 7296, 7297, 5, 108, 0, 0, 7297, 7298, 3, 524, 262, 0, 7298, 7299, 5, 298, 0, 0, 7299, 7300, 5, 368, 0, 0, 7300, 827, 1, 0, 0, 0, 7301, 7302, 5, 138, 0, 0, 7302, 7303, 5, 342, 0, 0, 7303, 7304, 7, 33, 0, 0, 7304, 7305, 3, 54, 27, 0, 7305, 829, 1, 0, 0, 0, 7306, 7307, 5, 46, 0, 0, 7307, 7308, 5, 189, 0, 0, 7308, 7309, 3, 524, 262, 0, 7309, 7310, 3, 834, 417, 0, 7310, 7311, 3, 1118, 559, 0, 7311, 7312, 3, 192, 96, 0, 7312, 831, 1, 0, 0, 0, 7313, 7314, 5, 138, 0, 0, 7314, 7315, 5, 189, 0, 0, 7315, 7337, 3, 524, 262, 0, 7316, 7338, 3, 106, 53, 0, 7317, 7318, 5, 191, 0, 0, 7318, 7319, 5, 77, 0, 0, 7319, 7338, 5, 78, 0, 0, 7320, 7321, 5, 326, 0, 0, 7321, 7322, 5, 77, 0, 0, 7322, 7338, 5, 78, 0, 0, 7323, 7324, 5, 133, 0, 0, 7324, 7338, 3, 208, 104, 0, 7325, 7326, 5, 191, 0, 0, 7326, 7329, 5, 45, 0, 0, 7327, 7328, 5, 220, 0, 0, 7328, 7330, 5, 389, 0, 0, 7329, 7327, 1, 0, 0, 0, 7329, 7330, 1, 0, 0, 0, 7330, 7331, 1, 0, 0, 0, 7331, 7332, 3, 1340, 670, 0, 7332, 7333, 3, 108, 54, 0, 7333, 7338, 1, 0, 0, 0, 7334, 7335, 5, 365, 0, 0, 7335, 7336, 5, 45, 0, 0, 7336, 7338, 3, 1340, 670, 0, 7337, 7316, 1, 0, 0, 0, 7337, 7317, 1, 0, 0, 0, 7337, 7320, 1, 0, 0, 0, 7337, 7323, 1, 0, 0, 0, 7337, 7325, 1, 0, 0, 0, 7337, 7334, 1, 0, 0, 0, 7338, 833, 1, 0, 0, 0, 7339, 7342, 5, 36, 0, 0, 7340, 7342, 1, 0, 0, 0, 7341, 7339, 1, 0, 0, 0, 7341, 7340, 1, 0, 0, 0, 7342, 835, 1, 0, 0, 0, 7343, 7344, 5, 138, 0, 0, 7344, 7345, 5, 348, 0, 0, 7345, 7346, 5, 318, 0, 0, 7346, 7347, 5, 185, 0, 0, 7347, 7348, 3, 524, 262, 0, 7348, 7349, 3, 460, 230, 0, 7349, 837, 1, 0, 0, 0, 7350, 7351, 5, 138, 0, 0, 7351, 7352, 5, 348, 0, 0, 7352, 7353, 5, 318, 0, 0, 7353, 7354, 5, 163, 0, 0, 7354, 7355, 3, 524, 262, 0, 7355, 7356, 5, 133, 0, 0, 7356, 7357, 5, 248, 0, 0, 7357, 7358, 5, 62, 0, 0, 7358, 7359, 3, 1338, 669, 0, 7359, 7360, 3, 840, 420, 0, 7360, 7361, 3, 522, 261, 0, 7361, 7423, 1, 0, 0, 0, 7362, 7363, 5, 138, 0, 0, 7363, 7364, 5, 348, 0, 0, 7364, 7365, 5, 318, 0, 0, 7365, 7366, 5, 163, 0, 0, 7366, 7367, 3, 524, 262, 0, 7367, 7368, 5, 138, 0, 0, 7368, 7369, 5, 248, 0, 0, 7369, 7370, 5, 62, 0, 0, 7370, 7371, 3, 1338, 669, 0, 7371, 7372, 3, 840, 420, 0, 7372, 7373, 3, 522, 261, 0, 7373, 7423, 1, 0, 0, 0, 7374, 7375, 5, 138, 0, 0, 7375, 7376, 5, 348, 0, 0, 7376, 7377, 5, 318, 0, 0, 7377, 7378, 5, 163, 0, 0, 7378, 7379, 3, 524, 262, 0, 7379, 7380, 5, 138, 0, 0, 7380, 7381, 5, 248, 0, 0, 7381, 7382, 5, 304, 0, 0, 7382, 7383, 3, 524, 262, 0, 7383, 7384, 3, 840, 420, 0, 7384, 7385, 3, 524, 262, 0, 7385, 7423, 1, 0, 0, 0, 7386, 7387, 5, 138, 0, 0, 7387, 7388, 5, 348, 0, 0, 7388, 7389, 5, 318, 0, 0, 7389, 7390, 5, 163, 0, 0, 7390, 7391, 3, 524, 262, 0, 7391, 7392, 5, 138, 0, 0, 7392, 7393, 5, 248, 0, 0, 7393, 7394, 5, 62, 0, 0, 7394, 7395, 3, 1338, 669, 0, 7395, 7396, 5, 304, 0, 0, 7396, 7397, 3, 524, 262, 0, 7397, 7398, 3, 840, 420, 0, 7398, 7399, 3, 524, 262, 0, 7399, 7423, 1, 0, 0, 0, 7400, 7401, 5, 138, 0, 0, 7401, 7402, 5, 348, 0, 0, 7402, 7403, 5, 318, 0, 0, 7403, 7404, 5, 163, 0, 0, 7404, 7405, 3, 524, 262, 0, 7405, 7406, 5, 191, 0, 0, 7406, 7407, 5, 248, 0, 0, 7407, 7408, 5, 62, 0, 0, 7408, 7409, 3, 1338, 669, 0, 7409, 7423, 1, 0, 0, 0, 7410, 7411, 5, 138, 0, 0, 7411, 7412, 5, 348, 0, 0, 7412, 7413, 5, 318, 0, 0, 7413, 7414, 5, 163, 0, 0, 7414, 7415, 3, 524, 262, 0, 7415, 7416, 5, 191, 0, 0, 7416, 7417, 5, 248, 0, 0, 7417, 7418, 5, 220, 0, 0, 7418, 7419, 5, 389, 0, 0, 7419, 7420, 5, 62, 0, 0, 7420, 7421, 3, 1338, 669, 0, 7421, 7423, 1, 0, 0, 0, 7422, 7350, 1, 0, 0, 0, 7422, 7362, 1, 0, 0, 0, 7422, 7374, 1, 0, 0, 0, 7422, 7386, 1, 0, 0, 0, 7422, 7400, 1, 0, 0, 0, 7422, 7410, 1, 0, 0, 0, 7423, 839, 1, 0, 0, 0, 7424, 7425, 5, 105, 0, 0, 7425, 841, 1, 0, 0, 0, 7426, 7427, 5, 46, 0, 0, 7427, 7428, 3, 488, 244, 0, 7428, 7429, 5, 168, 0, 0, 7429, 7430, 3, 524, 262, 0, 7430, 7431, 5, 62, 0, 0, 7431, 7432, 3, 1358, 679, 0, 7432, 7433, 5, 94, 0, 0, 7433, 7434, 3, 1358, 679, 0, 7434, 7435, 5, 64, 0, 0, 7435, 7436, 3, 524, 262, 0, 7436, 843, 1, 0, 0, 0, 7437, 7438, 5, 158, 0, 0, 7438, 7439, 3, 864, 432, 0, 7439, 7440, 3, 1336, 668, 0, 7440, 7441, 3, 846, 423, 0, 7441, 7451, 1, 0, 0, 0, 7442, 7443, 5, 158, 0, 0, 7443, 7451, 3, 864, 432, 0, 7444, 7445, 5, 158, 0, 0, 7445, 7446, 3, 864, 432, 0, 7446, 7447, 3, 1340, 670, 0, 7447, 7448, 5, 80, 0, 0, 7448, 7449, 3, 1336, 668, 0, 7449, 7451, 1, 0, 0, 0, 7450, 7437, 1, 0, 0, 0, 7450, 7442, 1, 0, 0, 0, 7450, 7444, 1, 0, 0, 0, 7451, 845, 1, 0, 0, 0, 7452, 7453, 5, 100, 0, 0, 7453, 7456, 3, 1340, 670, 0, 7454, 7456, 1, 0, 0, 0, 7455, 7452, 1, 0, 0, 0, 7455, 7454, 1, 0, 0, 0, 7456, 847, 1, 0, 0, 0, 7457, 7458, 5, 363, 0, 0, 7458, 7459, 3, 866, 433, 0, 7459, 7460, 3, 868, 434, 0, 7460, 7461, 3, 864, 432, 0, 7461, 7462, 3, 862, 431, 0, 7462, 7463, 3, 876, 438, 0, 7463, 7471, 1, 0, 0, 0, 7464, 7465, 5, 363, 0, 0, 7465, 7466, 5, 2, 0, 0, 7466, 7467, 3, 852, 426, 0, 7467, 7468, 5, 3, 0, 0, 7468, 7469, 3, 876, 438, 0, 7469, 7471, 1, 0, 0, 0, 7470, 7457, 1, 0, 0, 0, 7470, 7464, 1, 0, 0, 0, 7471, 849, 1, 0, 0, 0, 7472, 7473, 3, 854, 427, 0, 7473, 7474, 3, 864, 432, 0, 7474, 7475, 3, 876, 438, 0, 7475, 7483, 1, 0, 0, 0, 7476, 7477, 3, 854, 427, 0, 7477, 7478, 5, 2, 0, 0, 7478, 7479, 3, 852, 426, 0, 7479, 7480, 5, 3, 0, 0, 7480, 7481, 3, 876, 438, 0, 7481, 7483, 1, 0, 0, 0, 7482, 7472, 1, 0, 0, 0, 7482, 7476, 1, 0, 0, 0, 7483, 851, 1, 0, 0, 0, 7484, 7489, 3, 856, 428, 0, 7485, 7486, 5, 6, 0, 0, 7486, 7488, 3, 856, 428, 0, 7487, 7485, 1, 0, 0, 0, 7488, 7491, 1, 0, 0, 0, 7489, 7487, 1, 0, 0, 0, 7489, 7490, 1, 0, 0, 0, 7490, 853, 1, 0, 0, 0, 7491, 7489, 1, 0, 0, 0, 7492, 7493, 7, 34, 0, 0, 7493, 855, 1, 0, 0, 0, 7494, 7495, 3, 858, 429, 0, 7495, 7496, 3, 860, 430, 0, 7496, 857, 1, 0, 0, 0, 7497, 7500, 3, 1378, 689, 0, 7498, 7500, 3, 854, 427, 0, 7499, 7497, 1, 0, 0, 0, 7499, 7498, 1, 0, 0, 0, 7500, 859, 1, 0, 0, 0, 7501, 7505, 3, 66, 33, 0, 7502, 7505, 3, 292, 146, 0, 7503, 7505, 1, 0, 0, 0, 7504, 7501, 1, 0, 0, 0, 7504, 7502, 1, 0, 0, 0, 7504, 7503, 1, 0, 0, 0, 7505, 861, 1, 0, 0, 0, 7506, 7509, 3, 854, 427, 0, 7507, 7509, 1, 0, 0, 0, 7508, 7506, 1, 0, 0, 0, 7508, 7507, 1, 0, 0, 0, 7509, 863, 1, 0, 0, 0, 7510, 7513, 5, 128, 0, 0, 7511, 7513, 1, 0, 0, 0, 7512, 7510, 1, 0, 0, 0, 7512, 7511, 1, 0, 0, 0, 7513, 865, 1, 0, 0, 0, 7514, 7517, 5, 113, 0, 0, 7515, 7517, 1, 0, 0, 0, 7516, 7514, 1, 0, 0, 0, 7516, 7515, 1, 0, 0, 0, 7517, 867, 1, 0, 0, 0, 7518, 7521, 5, 112, 0, 0, 7519, 7521, 1, 0, 0, 0, 7520, 7518, 1, 0, 0, 0, 7520, 7519, 1, 0, 0, 0, 7521, 869, 1, 0, 0, 0, 7522, 7523, 5, 2, 0, 0, 7523, 7524, 3, 1338, 669, 0, 7524, 7525, 5, 3, 0, 0, 7525, 7528, 1, 0, 0, 0, 7526, 7528, 1, 0, 0, 0, 7527, 7522, 1, 0, 0, 0, 7527, 7526, 1, 0, 0, 0, 7528, 871, 1, 0, 0, 0, 7529, 7530, 3, 1336, 668, 0, 7530, 7531, 3, 870, 435, 0, 7531, 873, 1, 0, 0, 0, 7532, 7537, 3, 872, 436, 0, 7533, 7534, 5, 6, 0, 0, 7534, 7536, 3, 872, 436, 0, 7535, 7533, 1, 0, 0, 0, 7536, 7539, 1, 0, 0, 0, 7537, 7535, 1, 0, 0, 0, 7537, 7538, 1, 0, 0, 0, 7538, 875, 1, 0, 0, 0, 7539, 7537, 1, 0, 0, 0, 7540, 7543, 3, 874, 437, 0, 7541, 7543, 1, 0, 0, 0, 7542, 7540, 1, 0, 0, 0, 7542, 7541, 1, 0, 0, 0, 7543, 877, 1, 0, 0, 0, 7544, 7545, 5, 203, 0, 0, 7545, 7561, 3, 880, 440, 0, 7546, 7547, 5, 203, 0, 0, 7547, 7548, 3, 854, 427, 0, 7548, 7549, 3, 864, 432, 0, 7549, 7550, 3, 880, 440, 0, 7550, 7561, 1, 0, 0, 0, 7551, 7552, 5, 203, 0, 0, 7552, 7553, 5, 128, 0, 0, 7553, 7561, 3, 880, 440, 0, 7554, 7555, 5, 203, 0, 0, 7555, 7556, 5, 2, 0, 0, 7556, 7557, 3, 882, 441, 0, 7557, 7558, 5, 3, 0, 0, 7558, 7559, 3, 880, 440, 0, 7559, 7561, 1, 0, 0, 0, 7560, 7544, 1, 0, 0, 0, 7560, 7546, 1, 0, 0, 0, 7560, 7551, 1, 0, 0, 0, 7560, 7554, 1, 0, 0, 0, 7561, 879, 1, 0, 0, 0, 7562, 7572, 3, 960, 480, 0, 7563, 7572, 3, 902, 451, 0, 7564, 7572, 3, 942, 471, 0, 7565, 7572, 3, 928, 464, 0, 7566, 7572, 3, 952, 476, 0, 7567, 7572, 3, 264, 132, 0, 7568, 7572, 3, 270, 135, 0, 7569, 7572, 3, 276, 138, 0, 7570, 7572, 3, 896, 448, 0, 7571, 7562, 1, 0, 0, 0, 7571, 7563, 1, 0, 0, 0, 7571, 7564, 1, 0, 0, 0, 7571, 7565, 1, 0, 0, 0, 7571, 7566, 1, 0, 0, 0, 7571, 7567, 1, 0, 0, 0, 7571, 7568, 1, 0, 0, 0, 7571, 7569, 1, 0, 0, 0, 7571, 7570, 1, 0, 0, 0, 7572, 881, 1, 0, 0, 0, 7573, 7578, 3, 884, 442, 0, 7574, 7575, 5, 6, 0, 0, 7575, 7577, 3, 884, 442, 0, 7576, 7574, 1, 0, 0, 0, 7577, 7580, 1, 0, 0, 0, 7578, 7576, 1, 0, 0, 0, 7578, 7579, 1, 0, 0, 0, 7579, 883, 1, 0, 0, 0, 7580, 7578, 1, 0, 0, 0, 7581, 7582, 3, 886, 443, 0, 7582, 7583, 3, 888, 444, 0, 7583, 885, 1, 0, 0, 0, 7584, 7587, 3, 1378, 689, 0, 7585, 7587, 3, 854, 427, 0, 7586, 7584, 1, 0, 0, 0, 7586, 7585, 1, 0, 0, 0, 7587, 887, 1, 0, 0, 0, 7588, 7592, 3, 66, 33, 0, 7589, 7592, 3, 292, 146, 0, 7590, 7592, 1, 0, 0, 0, 7591, 7588, 1, 0, 0, 0, 7591, 7589, 1, 0, 0, 0, 7591, 7590, 1, 0, 0, 0, 7592, 889, 1, 0, 0, 0, 7593, 7594, 5, 283, 0, 0, 7594, 7595, 3, 1340, 670, 0, 7595, 7596, 3, 892, 446, 0, 7596, 7597, 5, 36, 0, 0, 7597, 7598, 3, 894, 447, 0, 7598, 891, 1, 0, 0, 0, 7599, 7600, 5, 2, 0, 0, 7600, 7601, 3, 1286, 643, 0, 7601, 7602, 5, 3, 0, 0, 7602, 7605, 1, 0, 0, 0, 7603, 7605, 1, 0, 0, 0, 7604, 7599, 1, 0, 0, 0, 7604, 7603, 1, 0, 0, 0, 7605, 893, 1, 0, 0, 0, 7606, 7611, 3, 960, 480, 0, 7607, 7611, 3, 902, 451, 0, 7608, 7611, 3, 942, 471, 0, 7609, 7611, 3, 928, 464, 0, 7610, 7606, 1, 0, 0, 0, 7610, 7607, 1, 0, 0, 0, 7610, 7608, 1, 0, 0, 0, 7610, 7609, 1, 0, 0, 0, 7611, 895, 1, 0, 0, 0, 7612, 7613, 5, 202, 0, 0, 7613, 7614, 3, 1340, 670, 0, 7614, 7615, 3, 898, 449, 0, 7615, 7640, 1, 0, 0, 0, 7616, 7617, 5, 46, 0, 0, 7617, 7618, 3, 174, 87, 0, 7618, 7619, 5, 92, 0, 0, 7619, 7620, 3, 266, 133, 0, 7620, 7621, 5, 36, 0, 0, 7621, 7622, 5, 202, 0, 0, 7622, 7623, 3, 1340, 670, 0, 7623, 7624, 3, 898, 449, 0, 7624, 7625, 3, 268, 134, 0, 7625, 7640, 1, 0, 0, 0, 7626, 7627, 5, 46, 0, 0, 7627, 7628, 3, 174, 87, 0, 7628, 7629, 5, 92, 0, 0, 7629, 7630, 5, 220, 0, 0, 7630, 7631, 5, 77, 0, 0, 7631, 7632, 5, 389, 0, 0, 7632, 7633, 3, 266, 133, 0, 7633, 7634, 5, 36, 0, 0, 7634, 7635, 5, 202, 0, 0, 7635, 7636, 3, 1340, 670, 0, 7636, 7637, 3, 898, 449, 0, 7637, 7638, 3, 268, 134, 0, 7638, 7640, 1, 0, 0, 0, 7639, 7612, 1, 0, 0, 0, 7639, 7616, 1, 0, 0, 0, 7639, 7626, 1, 0, 0, 0, 7640, 897, 1, 0, 0, 0, 7641, 7642, 5, 2, 0, 0, 7642, 7643, 3, 1280, 640, 0, 7643, 7644, 5, 3, 0, 0, 7644, 7647, 1, 0, 0, 0, 7645, 7647, 1, 0, 0, 0, 7646, 7641, 1, 0, 0, 0, 7646, 7645, 1, 0, 0, 0, 7647, 899, 1, 0, 0, 0, 7648, 7649, 5, 177, 0, 0, 7649, 7659, 3, 1340, 670, 0, 7650, 7651, 5, 177, 0, 0, 7651, 7652, 5, 283, 0, 0, 7652, 7659, 3, 1340, 670, 0, 7653, 7654, 5, 177, 0, 0, 7654, 7659, 5, 30, 0, 0, 7655, 7656, 5, 177, 0, 0, 7656, 7657, 5, 283, 0, 0, 7657, 7659, 5, 30, 0, 0, 7658, 7648, 1, 0, 0, 0, 7658, 7650, 1, 0, 0, 0, 7658, 7653, 1, 0, 0, 0, 7658, 7655, 1, 0, 0, 0, 7659, 901, 1, 0, 0, 0, 7660, 7661, 3, 980, 490, 0, 7661, 7662, 5, 232, 0, 0, 7662, 7663, 5, 71, 0, 0, 7663, 7664, 3, 904, 452, 0, 7664, 7665, 3, 906, 453, 0, 7665, 7666, 3, 914, 457, 0, 7666, 7667, 3, 918, 459, 0, 7667, 903, 1, 0, 0, 0, 7668, 7671, 3, 1336, 668, 0, 7669, 7670, 5, 36, 0, 0, 7670, 7672, 3, 1372, 686, 0, 7671, 7669, 1, 0, 0, 0, 7671, 7672, 1, 0, 0, 0, 7672, 905, 1, 0, 0, 0, 7673, 7693, 3, 960, 480, 0, 7674, 7675, 5, 463, 0, 0, 7675, 7676, 3, 908, 454, 0, 7676, 7677, 5, 450, 0, 0, 7677, 7678, 3, 960, 480, 0, 7678, 7693, 1, 0, 0, 0, 7679, 7680, 5, 2, 0, 0, 7680, 7681, 3, 910, 455, 0, 7681, 7686, 5, 3, 0, 0, 7682, 7683, 5, 463, 0, 0, 7683, 7684, 3, 908, 454, 0, 7684, 7685, 5, 450, 0, 0, 7685, 7687, 1, 0, 0, 0, 7686, 7682, 1, 0, 0, 0, 7686, 7687, 1, 0, 0, 0, 7687, 7688, 1, 0, 0, 0, 7688, 7689, 3, 960, 480, 0, 7689, 7693, 1, 0, 0, 0, 7690, 7691, 5, 53, 0, 0, 7691, 7693, 5, 415, 0, 0, 7692, 7673, 1, 0, 0, 0, 7692, 7674, 1, 0, 0, 0, 7692, 7679, 1, 0, 0, 0, 7692, 7690, 1, 0, 0, 0, 7693, 907, 1, 0, 0, 0, 7694, 7695, 7, 35, 0, 0, 7695, 909, 1, 0, 0, 0, 7696, 7701, 3, 912, 456, 0, 7697, 7698, 5, 6, 0, 0, 7698, 7700, 3, 912, 456, 0, 7699, 7697, 1, 0, 0, 0, 7700, 7703, 1, 0, 0, 0, 7701, 7699, 1, 0, 0, 0, 7701, 7702, 1, 0, 0, 0, 7702, 911, 1, 0, 0, 0, 7703, 7701, 1, 0, 0, 0, 7704, 7705, 3, 1372, 686, 0, 7705, 7706, 3, 1326, 663, 0, 7706, 913, 1, 0, 0, 0, 7707, 7708, 5, 80, 0, 0, 7708, 7709, 5, 464, 0, 0, 7709, 7710, 3, 916, 458, 0, 7710, 7717, 5, 57, 0, 0, 7711, 7712, 5, 362, 0, 0, 7712, 7713, 5, 326, 0, 0, 7713, 7714, 3, 944, 472, 0, 7714, 7715, 3, 1094, 547, 0, 7715, 7718, 1, 0, 0, 0, 7716, 7718, 5, 263, 0, 0, 7717, 7711, 1, 0, 0, 0, 7717, 7716, 1, 0, 0, 0, 7718, 7721, 1, 0, 0, 0, 7719, 7721, 1, 0, 0, 0, 7720, 7707, 1, 0, 0, 0, 7720, 7719, 1, 0, 0, 0, 7721, 915, 1, 0, 0, 0, 7722, 7723, 5, 2, 0, 0, 7723, 7724, 3, 598, 299, 0, 7724, 7725, 5, 3, 0, 0, 7725, 7726, 3, 1094, 547, 0, 7726, 7732, 1, 0, 0, 0, 7727, 7728, 5, 80, 0, 0, 7728, 7729, 5, 45, 0, 0, 7729, 7732, 3, 1340, 670, 0, 7730, 7732, 1, 0, 0, 0, 7731, 7722, 1, 0, 0, 0, 7731, 7727, 1, 0, 0, 0, 7731, 7730, 1, 0, 0, 0, 7732, 917, 1, 0, 0, 0, 7733, 7734, 5, 87, 0, 0, 7734, 7737, 3, 1330, 665, 0, 7735, 7737, 1, 0, 0, 0, 7736, 7733, 1, 0, 0, 0, 7736, 7735, 1, 0, 0, 0, 7737, 919, 1, 0, 0, 0, 7738, 7740, 5, 253, 0, 0, 7739, 7741, 5, 71, 0, 0, 7740, 7739, 1, 0, 0, 0, 7740, 7741, 1, 0, 0, 0, 7741, 7742, 1, 0, 0, 0, 7742, 7744, 3, 1336, 668, 0, 7743, 7745, 3, 1062, 531, 0, 7744, 7743, 1, 0, 0, 0, 7744, 7745, 1, 0, 0, 0, 7745, 7746, 1, 0, 0, 0, 7746, 7749, 5, 100, 0, 0, 7747, 7750, 3, 962, 481, 0, 7748, 7750, 3, 1336, 668, 0, 7749, 7747, 1, 0, 0, 0, 7749, 7748, 1, 0, 0, 0, 7750, 7752, 1, 0, 0, 0, 7751, 7753, 3, 1062, 531, 0, 7752, 7751, 1, 0, 0, 0, 7752, 7753, 1, 0, 0, 0, 7753, 7754, 1, 0, 0, 0, 7754, 7755, 5, 80, 0, 0, 7755, 7764, 3, 1162, 581, 0, 7756, 7758, 3, 922, 461, 0, 7757, 7759, 3, 924, 462, 0, 7758, 7757, 1, 0, 0, 0, 7758, 7759, 1, 0, 0, 0, 7759, 7765, 1, 0, 0, 0, 7760, 7762, 3, 924, 462, 0, 7761, 7763, 3, 922, 461, 0, 7762, 7761, 1, 0, 0, 0, 7762, 7763, 1, 0, 0, 0, 7763, 7765, 1, 0, 0, 0, 7764, 7756, 1, 0, 0, 0, 7764, 7760, 1, 0, 0, 0, 7765, 7767, 1, 0, 0, 0, 7766, 7768, 3, 926, 463, 0, 7767, 7766, 1, 0, 0, 0, 7767, 7768, 1, 0, 0, 0, 7768, 921, 1, 0, 0, 0, 7769, 7770, 5, 102, 0, 0, 7770, 7771, 5, 77, 0, 0, 7771, 7774, 5, 250, 0, 0, 7772, 7773, 5, 33, 0, 0, 7773, 7775, 3, 1162, 581, 0, 7774, 7772, 1, 0, 0, 0, 7774, 7775, 1, 0, 0, 0, 7775, 7777, 1, 0, 0, 0, 7776, 7778, 5, 93, 0, 0, 7777, 7776, 1, 0, 0, 0, 7777, 7778, 1, 0, 0, 0, 7778, 7779, 1, 0, 0, 0, 7779, 7784, 5, 232, 0, 0, 7780, 7781, 5, 2, 0, 0, 7781, 7782, 3, 910, 455, 0, 7782, 7783, 5, 3, 0, 0, 7783, 7785, 1, 0, 0, 0, 7784, 7780, 1, 0, 0, 0, 7784, 7785, 1, 0, 0, 0, 7785, 7786, 1, 0, 0, 0, 7786, 7787, 3, 1052, 526, 0, 7787, 923, 1, 0, 0, 0, 7788, 7789, 5, 102, 0, 0, 7789, 7792, 5, 250, 0, 0, 7790, 7791, 5, 33, 0, 0, 7791, 7793, 3, 1162, 581, 0, 7792, 7790, 1, 0, 0, 0, 7792, 7793, 1, 0, 0, 0, 7793, 7795, 1, 0, 0, 0, 7794, 7796, 5, 93, 0, 0, 7795, 7794, 1, 0, 0, 0, 7795, 7796, 1, 0, 0, 0, 7796, 7797, 1, 0, 0, 0, 7797, 7798, 5, 362, 0, 0, 7798, 7799, 5, 326, 0, 0, 7799, 7800, 3, 944, 472, 0, 7800, 925, 1, 0, 0, 0, 7801, 7802, 5, 102, 0, 0, 7802, 7804, 5, 250, 0, 0, 7803, 7805, 5, 93, 0, 0, 7804, 7803, 1, 0, 0, 0, 7804, 7805, 1, 0, 0, 0, 7805, 7806, 1, 0, 0, 0, 7806, 7807, 5, 182, 0, 0, 7807, 927, 1, 0, 0, 0, 7808, 7809, 3, 980, 490, 0, 7809, 7810, 5, 182, 0, 0, 7810, 7811, 5, 64, 0, 0, 7811, 7812, 3, 1078, 539, 0, 7812, 7813, 3, 930, 465, 0, 7813, 7814, 3, 1096, 548, 0, 7814, 7815, 3, 918, 459, 0, 7815, 929, 1, 0, 0, 0, 7816, 7817, 5, 100, 0, 0, 7817, 7820, 3, 1056, 528, 0, 7818, 7820, 1, 0, 0, 0, 7819, 7816, 1, 0, 0, 0, 7819, 7818, 1, 0, 0, 0, 7820, 931, 1, 0, 0, 0, 7821, 7822, 5, 247, 0, 0, 7822, 7823, 3, 988, 494, 0, 7823, 7824, 3, 1076, 538, 0, 7824, 7825, 3, 934, 467, 0, 7825, 7826, 3, 938, 469, 0, 7826, 933, 1, 0, 0, 0, 7827, 7828, 5, 68, 0, 0, 7828, 7829, 3, 936, 468, 0, 7829, 7830, 5, 256, 0, 0, 7830, 7833, 1, 0, 0, 0, 7831, 7833, 1, 0, 0, 0, 7832, 7827, 1, 0, 0, 0, 7832, 7831, 1, 0, 0, 0, 7833, 935, 1, 0, 0, 0, 7834, 7835, 5, 131, 0, 0, 7835, 7847, 7, 36, 0, 0, 7836, 7837, 5, 407, 0, 0, 7837, 7847, 7, 36, 0, 0, 7838, 7843, 5, 327, 0, 0, 7839, 7840, 5, 362, 0, 0, 7840, 7844, 5, 201, 0, 0, 7841, 7842, 5, 407, 0, 0, 7842, 7844, 5, 201, 0, 0, 7843, 7839, 1, 0, 0, 0, 7843, 7841, 1, 0, 0, 0, 7843, 7844, 1, 0, 0, 0, 7844, 7847, 1, 0, 0, 0, 7845, 7847, 5, 201, 0, 0, 7846, 7834, 1, 0, 0, 0, 7846, 7836, 1, 0, 0, 0, 7846, 7838, 1, 0, 0, 0, 7846, 7845, 1, 0, 0, 0, 7847, 937, 1, 0, 0, 0, 7848, 7851, 5, 265, 0, 0, 7849, 7851, 1, 0, 0, 0, 7850, 7848, 1, 0, 0, 0, 7850, 7849, 1, 0, 0, 0, 7851, 939, 1, 0, 0, 0, 7852, 7857, 5, 265, 0, 0, 7853, 7854, 5, 465, 0, 0, 7854, 7857, 5, 466, 0, 0, 7855, 7857, 1, 0, 0, 0, 7856, 7852, 1, 0, 0, 0, 7856, 7853, 1, 0, 0, 0, 7856, 7855, 1, 0, 0, 0, 7857, 941, 1, 0, 0, 0, 7858, 7859, 3, 980, 490, 0, 7859, 7860, 5, 362, 0, 0, 7860, 7861, 3, 1078, 539, 0, 7861, 7862, 5, 326, 0, 0, 7862, 7863, 3, 944, 472, 0, 7863, 7864, 3, 1054, 527, 0, 7864, 7865, 3, 1096, 548, 0, 7865, 7866, 3, 918, 459, 0, 7866, 943, 1, 0, 0, 0, 7867, 7872, 3, 946, 473, 0, 7868, 7869, 5, 6, 0, 0, 7869, 7871, 3, 946, 473, 0, 7870, 7868, 1, 0, 0, 0, 7871, 7874, 1, 0, 0, 0, 7872, 7870, 1, 0, 0, 0, 7872, 7873, 1, 0, 0, 0, 7873, 945, 1, 0, 0, 0, 7874, 7872, 1, 0, 0, 0, 7875, 7876, 3, 948, 474, 0, 7876, 7877, 5, 10, 0, 0, 7877, 7878, 3, 1162, 581, 0, 7878, 7886, 1, 0, 0, 0, 7879, 7880, 5, 2, 0, 0, 7880, 7881, 3, 950, 475, 0, 7881, 7882, 5, 3, 0, 0, 7882, 7883, 5, 10, 0, 0, 7883, 7884, 3, 1162, 581, 0, 7884, 7886, 1, 0, 0, 0, 7885, 7875, 1, 0, 0, 0, 7885, 7879, 1, 0, 0, 0, 7886, 947, 1, 0, 0, 0, 7887, 7888, 3, 1372, 686, 0, 7888, 7889, 3, 1326, 663, 0, 7889, 949, 1, 0, 0, 0, 7890, 7895, 3, 948, 474, 0, 7891, 7892, 5, 6, 0, 0, 7892, 7894, 3, 948, 474, 0, 7893, 7891, 1, 0, 0, 0, 7894, 7897, 1, 0, 0, 0, 7895, 7893, 1, 0, 0, 0, 7895, 7896, 1, 0, 0, 0, 7896, 951, 1, 0, 0, 0, 7897, 7895, 1, 0, 0, 0, 7898, 7899, 5, 178, 0, 0, 7899, 7900, 3, 954, 477, 0, 7900, 7901, 3, 956, 478, 0, 7901, 7902, 5, 172, 0, 0, 7902, 7903, 3, 958, 479, 0, 7903, 7904, 5, 62, 0, 0, 7904, 7905, 3, 960, 480, 0, 7905, 953, 1, 0, 0, 0, 7906, 7907, 3, 1340, 670, 0, 7907, 955, 1, 0, 0, 0, 7908, 7909, 5, 262, 0, 0, 7909, 7914, 5, 317, 0, 0, 7910, 7914, 5, 317, 0, 0, 7911, 7914, 5, 107, 0, 0, 7912, 7914, 5, 231, 0, 0, 7913, 7908, 1, 0, 0, 0, 7913, 7910, 1, 0, 0, 0, 7913, 7911, 1, 0, 0, 0, 7913, 7912, 1, 0, 0, 0, 7914, 7917, 1, 0, 0, 0, 7915, 7913, 1, 0, 0, 0, 7915, 7916, 1, 0, 0, 0, 7916, 957, 1, 0, 0, 0, 7917, 7915, 1, 0, 0, 0, 7918, 7924, 1, 0, 0, 0, 7919, 7920, 5, 105, 0, 0, 7920, 7924, 5, 217, 0, 0, 7921, 7922, 5, 372, 0, 0, 7922, 7924, 5, 217, 0, 0, 7923, 7918, 1, 0, 0, 0, 7923, 7919, 1, 0, 0, 0, 7923, 7921, 1, 0, 0, 0, 7924, 959, 1, 0, 0, 0, 7925, 7928, 3, 964, 482, 0, 7926, 7928, 3, 962, 481, 0, 7927, 7925, 1, 0, 0, 0, 7927, 7926, 1, 0, 0, 0, 7928, 961, 1, 0, 0, 0, 7929, 7930, 5, 2, 0, 0, 7930, 7931, 3, 964, 482, 0, 7931, 7932, 5, 3, 0, 0, 7932, 7938, 1, 0, 0, 0, 7933, 7934, 5, 2, 0, 0, 7934, 7935, 3, 962, 481, 0, 7935, 7936, 5, 3, 0, 0, 7936, 7938, 1, 0, 0, 0, 7937, 7929, 1, 0, 0, 0, 7937, 7933, 1, 0, 0, 0, 7938, 963, 1, 0, 0, 0, 7939, 7940, 3, 966, 483, 0, 7940, 7947, 3, 996, 498, 0, 7941, 7942, 3, 1040, 520, 0, 7942, 7943, 3, 1006, 503, 0, 7943, 7948, 1, 0, 0, 0, 7944, 7945, 3, 1004, 502, 0, 7945, 7946, 3, 1042, 521, 0, 7946, 7948, 1, 0, 0, 0, 7947, 7941, 1, 0, 0, 0, 7947, 7944, 1, 0, 0, 0, 7947, 7948, 1, 0, 0, 0, 7948, 7961, 1, 0, 0, 0, 7949, 7950, 3, 972, 486, 0, 7950, 7951, 3, 966, 483, 0, 7951, 7958, 3, 996, 498, 0, 7952, 7953, 3, 1040, 520, 0, 7953, 7954, 3, 1006, 503, 0, 7954, 7959, 1, 0, 0, 0, 7955, 7956, 3, 1004, 502, 0, 7956, 7957, 3, 1042, 521, 0, 7957, 7959, 1, 0, 0, 0, 7958, 7952, 1, 0, 0, 0, 7958, 7955, 1, 0, 0, 0, 7958, 7959, 1, 0, 0, 0, 7959, 7961, 1, 0, 0, 0, 7960, 7939, 1, 0, 0, 0, 7960, 7949, 1, 0, 0, 0, 7961, 965, 1, 0, 0, 0, 7962, 7969, 3, 968, 484, 0, 7963, 7964, 7, 37, 0, 0, 7964, 7965, 3, 990, 495, 0, 7965, 7966, 3, 968, 484, 0, 7966, 7968, 1, 0, 0, 0, 7967, 7963, 1, 0, 0, 0, 7968, 7971, 1, 0, 0, 0, 7969, 7967, 1, 0, 0, 0, 7969, 7970, 1, 0, 0, 0, 7970, 967, 1, 0, 0, 0, 7971, 7969, 1, 0, 0, 0, 7972, 7979, 3, 970, 485, 0, 7973, 7974, 5, 70, 0, 0, 7974, 7975, 3, 990, 495, 0, 7975, 7976, 3, 970, 485, 0, 7976, 7978, 1, 0, 0, 0, 7977, 7973, 1, 0, 0, 0, 7978, 7981, 1, 0, 0, 0, 7979, 7977, 1, 0, 0, 0, 7979, 7980, 1, 0, 0, 0, 7980, 969, 1, 0, 0, 0, 7981, 7979, 1, 0, 0, 0, 7982, 7990, 5, 88, 0, 0, 7983, 7984, 3, 994, 497, 0, 7984, 7985, 3, 982, 491, 0, 7985, 7986, 3, 1328, 664, 0, 7986, 7991, 1, 0, 0, 0, 7987, 7988, 3, 992, 496, 0, 7988, 7989, 3, 1330, 665, 0, 7989, 7991, 1, 0, 0, 0, 7990, 7983, 1, 0, 0, 0, 7990, 7987, 1, 0, 0, 0, 7991, 7992, 1, 0, 0, 0, 7992, 7993, 3, 982, 491, 0, 7993, 7994, 3, 1054, 527, 0, 7994, 7995, 3, 1094, 547, 0, 7995, 7996, 3, 1024, 512, 0, 7996, 7997, 3, 1038, 519, 0, 7997, 7998, 3, 1240, 620, 0, 7998, 8004, 1, 0, 0, 0, 7999, 8004, 3, 1052, 526, 0, 8000, 8001, 5, 92, 0, 0, 8001, 8004, 3, 1074, 537, 0, 8002, 8004, 3, 962, 481, 0, 8003, 7982, 1, 0, 0, 0, 8003, 7999, 1, 0, 0, 0, 8003, 8000, 1, 0, 0, 0, 8003, 8002, 1, 0, 0, 0, 8004, 971, 1, 0, 0, 0, 8005, 8007, 5, 105, 0, 0, 8006, 8008, 5, 296, 0, 0, 8007, 8006, 1, 0, 0, 0, 8007, 8008, 1, 0, 0, 0, 8008, 8009, 1, 0, 0, 0, 8009, 8010, 3, 974, 487, 0, 8010, 973, 1, 0, 0, 0, 8011, 8016, 3, 976, 488, 0, 8012, 8013, 5, 6, 0, 0, 8013, 8015, 3, 976, 488, 0, 8014, 8012, 1, 0, 0, 0, 8015, 8018, 1, 0, 0, 0, 8016, 8014, 1, 0, 0, 0, 8016, 8017, 1, 0, 0, 0, 8017, 975, 1, 0, 0, 0, 8018, 8016, 1, 0, 0, 0, 8019, 8020, 3, 1340, 670, 0, 8020, 8021, 3, 870, 435, 0, 8021, 8022, 5, 36, 0, 0, 8022, 8023, 3, 978, 489, 0, 8023, 8024, 5, 2, 0, 0, 8024, 8025, 3, 894, 447, 0, 8025, 8026, 5, 3, 0, 0, 8026, 977, 1, 0, 0, 0, 8027, 8032, 5, 251, 0, 0, 8028, 8029, 5, 77, 0, 0, 8029, 8032, 5, 251, 0, 0, 8030, 8032, 1, 0, 0, 0, 8031, 8027, 1, 0, 0, 0, 8031, 8028, 1, 0, 0, 0, 8031, 8030, 1, 0, 0, 0, 8032, 979, 1, 0, 0, 0, 8033, 8036, 3, 972, 486, 0, 8034, 8036, 1, 0, 0, 0, 8035, 8033, 1, 0, 0, 0, 8035, 8034, 1, 0, 0, 0, 8036, 981, 1, 0, 0, 0, 8037, 8042, 5, 71, 0, 0, 8038, 8039, 3, 984, 492, 0, 8039, 8040, 3, 986, 493, 0, 8040, 8043, 1, 0, 0, 0, 8041, 8043, 3, 1566, 783, 0, 8042, 8038, 1, 0, 0, 0, 8042, 8041, 1, 0, 0, 0, 8043, 8046, 1, 0, 0, 0, 8044, 8046, 1, 0, 0, 0, 8045, 8037, 1, 0, 0, 0, 8045, 8044, 1, 0, 0, 0, 8046, 983, 1, 0, 0, 0, 8047, 8050, 1, 0, 0, 0, 8048, 8050, 5, 339, 0, 0, 8049, 8047, 1, 0, 0, 0, 8049, 8048, 1, 0, 0, 0, 8050, 985, 1, 0, 0, 0, 8051, 8053, 7, 38, 0, 0, 8052, 8051, 1, 0, 0, 0, 8052, 8053, 1, 0, 0, 0, 8053, 8054, 1, 0, 0, 0, 8054, 8055, 7, 11, 0, 0, 8055, 8056, 3, 988, 494, 0, 8056, 8057, 3, 1336, 668, 0, 8057, 8066, 1, 0, 0, 0, 8058, 8059, 5, 360, 0, 0, 8059, 8060, 3, 988, 494, 0, 8060, 8061, 3, 1336, 668, 0, 8061, 8066, 1, 0, 0, 0, 8062, 8063, 5, 92, 0, 0, 8063, 8066, 3, 1336, 668, 0, 8064, 8066, 3, 1336, 668, 0, 8065, 8052, 1, 0, 0, 0, 8065, 8058, 1, 0, 0, 0, 8065, 8062, 1, 0, 0, 0, 8065, 8064, 1, 0, 0, 0, 8066, 987, 1, 0, 0, 0, 8067, 8070, 5, 92, 0, 0, 8068, 8070, 1, 0, 0, 0, 8069, 8067, 1, 0, 0, 0, 8069, 8068, 1, 0, 0, 0, 8070, 989, 1, 0, 0, 0, 8071, 8075, 5, 30, 0, 0, 8072, 8075, 5, 56, 0, 0, 8073, 8075, 1, 0, 0, 0, 8074, 8071, 1, 0, 0, 0, 8074, 8072, 1, 0, 0, 0, 8074, 8073, 1, 0, 0, 0, 8075, 991, 1, 0, 0, 0, 8076, 8082, 5, 56, 0, 0, 8077, 8078, 5, 80, 0, 0, 8078, 8079, 5, 2, 0, 0, 8079, 8080, 3, 1280, 640, 0, 8080, 8081, 5, 3, 0, 0, 8081, 8083, 1, 0, 0, 0, 8082, 8077, 1, 0, 0, 0, 8082, 8083, 1, 0, 0, 0, 8083, 993, 1, 0, 0, 0, 8084, 8087, 5, 30, 0, 0, 8085, 8087, 1, 0, 0, 0, 8086, 8084, 1, 0, 0, 0, 8086, 8085, 1, 0, 0, 0, 8087, 995, 1, 0, 0, 0, 8088, 8091, 3, 998, 499, 0, 8089, 8091, 1, 0, 0, 0, 8090, 8088, 1, 0, 0, 0, 8090, 8089, 1, 0, 0, 0, 8091, 997, 1, 0, 0, 0, 8092, 8093, 5, 83, 0, 0, 8093, 8094, 5, 147, 0, 0, 8094, 8095, 3, 1000, 500, 0, 8095, 999, 1, 0, 0, 0, 8096, 8101, 3, 1002, 501, 0, 8097, 8098, 5, 6, 0, 0, 8098, 8100, 3, 1002, 501, 0, 8099, 8097, 1, 0, 0, 0, 8100, 8103, 1, 0, 0, 0, 8101, 8099, 1, 0, 0, 0, 8101, 8102, 1, 0, 0, 0, 8102, 1001, 1, 0, 0, 0, 8103, 8101, 1, 0, 0, 0, 8104, 8108, 3, 1162, 581, 0, 8105, 8106, 5, 100, 0, 0, 8106, 8109, 3, 1276, 638, 0, 8107, 8109, 3, 612, 306, 0, 8108, 8105, 1, 0, 0, 0, 8108, 8107, 1, 0, 0, 0, 8109, 8110, 1, 0, 0, 0, 8110, 8111, 3, 614, 307, 0, 8111, 1003, 1, 0, 0, 0, 8112, 8114, 3, 1008, 504, 0, 8113, 8115, 3, 1010, 505, 0, 8114, 8113, 1, 0, 0, 0, 8114, 8115, 1, 0, 0, 0, 8115, 8121, 1, 0, 0, 0, 8116, 8118, 3, 1010, 505, 0, 8117, 8119, 3, 1008, 504, 0, 8118, 8117, 1, 0, 0, 0, 8118, 8119, 1, 0, 0, 0, 8119, 8121, 1, 0, 0, 0, 8120, 8112, 1, 0, 0, 0, 8120, 8116, 1, 0, 0, 0, 8121, 1005, 1, 0, 0, 0, 8122, 8125, 3, 1004, 502, 0, 8123, 8125, 1, 0, 0, 0, 8124, 8122, 1, 0, 0, 0, 8124, 8123, 1, 0, 0, 0, 8125, 1007, 1, 0, 0, 0, 8126, 8127, 5, 74, 0, 0, 8127, 8130, 3, 1012, 506, 0, 8128, 8129, 5, 6, 0, 0, 8129, 8131, 3, 1014, 507, 0, 8130, 8128, 1, 0, 0, 0, 8130, 8131, 1, 0, 0, 0, 8131, 8150, 1, 0, 0, 0, 8132, 8133, 5, 61, 0, 0, 8133, 8147, 3, 1022, 511, 0, 8134, 8135, 3, 1016, 508, 0, 8135, 8139, 3, 1020, 510, 0, 8136, 8140, 5, 81, 0, 0, 8137, 8138, 5, 105, 0, 0, 8138, 8140, 5, 467, 0, 0, 8139, 8136, 1, 0, 0, 0, 8139, 8137, 1, 0, 0, 0, 8140, 8148, 1, 0, 0, 0, 8141, 8145, 3, 1020, 510, 0, 8142, 8146, 5, 81, 0, 0, 8143, 8144, 5, 105, 0, 0, 8144, 8146, 5, 467, 0, 0, 8145, 8142, 1, 0, 0, 0, 8145, 8143, 1, 0, 0, 0, 8146, 8148, 1, 0, 0, 0, 8147, 8134, 1, 0, 0, 0, 8147, 8141, 1, 0, 0, 0, 8148, 8150, 1, 0, 0, 0, 8149, 8126, 1, 0, 0, 0, 8149, 8132, 1, 0, 0, 0, 8150, 1009, 1, 0, 0, 0, 8151, 8156, 5, 79, 0, 0, 8152, 8157, 3, 1014, 507, 0, 8153, 8154, 3, 1016, 508, 0, 8154, 8155, 3, 1020, 510, 0, 8155, 8157, 1, 0, 0, 0, 8156, 8152, 1, 0, 0, 0, 8156, 8153, 1, 0, 0, 0, 8157, 1011, 1, 0, 0, 0, 8158, 8161, 3, 1162, 581, 0, 8159, 8161, 5, 30, 0, 0, 8160, 8158, 1, 0, 0, 0, 8160, 8159, 1, 0, 0, 0, 8161, 1013, 1, 0, 0, 0, 8162, 8163, 3, 1162, 581, 0, 8163, 1015, 1, 0, 0, 0, 8164, 8170, 3, 1206, 603, 0, 8165, 8166, 5, 12, 0, 0, 8166, 8170, 3, 1018, 509, 0, 8167, 8168, 5, 13, 0, 0, 8168, 8170, 3, 1018, 509, 0, 8169, 8164, 1, 0, 0, 0, 8169, 8165, 1, 0, 0, 0, 8169, 8167, 1, 0, 0, 0, 8170, 1017, 1, 0, 0, 0, 8171, 8174, 3, 1356, 678, 0, 8172, 8174, 3, 1354, 677, 0, 8173, 8171, 1, 0, 0, 0, 8173, 8172, 1, 0, 0, 0, 8174, 1019, 1, 0, 0, 0, 8175, 8176, 7, 39, 0, 0, 8176, 1021, 1, 0, 0, 0, 8177, 8178, 7, 40, 0, 0, 8178, 1023, 1, 0, 0, 0, 8179, 8180, 5, 66, 0, 0, 8180, 8181, 5, 147, 0, 0, 8181, 8184, 3, 1026, 513, 0, 8182, 8184, 1, 0, 0, 0, 8183, 8179, 1, 0, 0, 0, 8183, 8182, 1, 0, 0, 0, 8184, 1025, 1, 0, 0, 0, 8185, 8190, 3, 1028, 514, 0, 8186, 8187, 5, 6, 0, 0, 8187, 8189, 3, 1028, 514, 0, 8188, 8186, 1, 0, 0, 0, 8189, 8192, 1, 0, 0, 0, 8190, 8188, 1, 0, 0, 0, 8190, 8191, 1, 0, 0, 0, 8191, 1027, 1, 0, 0, 0, 8192, 8190, 1, 0, 0, 0, 8193, 8199, 3, 1030, 515, 0, 8194, 8199, 3, 1034, 517, 0, 8195, 8199, 3, 1032, 516, 0, 8196, 8199, 3, 1036, 518, 0, 8197, 8199, 3, 1162, 581, 0, 8198, 8193, 1, 0, 0, 0, 8198, 8194, 1, 0, 0, 0, 8198, 8195, 1, 0, 0, 0, 8198, 8196, 1, 0, 0, 0, 8198, 8197, 1, 0, 0, 0, 8199, 1029, 1, 0, 0, 0, 8200, 8201, 5, 2, 0, 0, 8201, 8202, 5, 3, 0, 0, 8202, 1031, 1, 0, 0, 0, 8203, 8204, 5, 468, 0, 0, 8204, 8205, 5, 2, 0, 0, 8205, 8206, 3, 1280, 640, 0, 8206, 8207, 5, 3, 0, 0, 8207, 1033, 1, 0, 0, 0, 8208, 8209, 5, 469, 0, 0, 8209, 8210, 5, 2, 0, 0, 8210, 8211, 3, 1280, 640, 0, 8211, 8212, 5, 3, 0, 0, 8212, 1035, 1, 0, 0, 0, 8213, 8214, 5, 470, 0, 0, 8214, 8215, 5, 471, 0, 0, 8215, 8216, 5, 2, 0, 0, 8216, 8217, 3, 1026, 513, 0, 8217, 8218, 5, 3, 0, 0, 8218, 1037, 1, 0, 0, 0, 8219, 8220, 5, 67, 0, 0, 8220, 8223, 3, 1162, 581, 0, 8221, 8223, 1, 0, 0, 0, 8222, 8219, 1, 0, 0, 0, 8222, 8221, 1, 0, 0, 0, 8223, 1039, 1, 0, 0, 0, 8224, 8229, 3, 1044, 522, 0, 8225, 8226, 5, 62, 0, 0, 8226, 8227, 5, 293, 0, 0, 8227, 8229, 5, 81, 0, 0, 8228, 8224, 1, 0, 0, 0, 8228, 8225, 1, 0, 0, 0, 8229, 1041, 1, 0, 0, 0, 8230, 8233, 3, 1040, 520, 0, 8231, 8233, 1, 0, 0, 0, 8232, 8230, 1, 0, 0, 0, 8232, 8231, 1, 0, 0, 0, 8233, 1043, 1, 0, 0, 0, 8234, 8236, 3, 1046, 523, 0, 8235, 8234, 1, 0, 0, 0, 8236, 8237, 1, 0, 0, 0, 8237, 8235, 1, 0, 0, 0, 8237, 8238, 1, 0, 0, 0, 8238, 1045, 1, 0, 0, 0, 8239, 8240, 3, 1048, 524, 0, 8240, 8241, 3, 1050, 525, 0, 8241, 8242, 3, 940, 470, 0, 8242, 1047, 1, 0, 0, 0, 8243, 8253, 5, 62, 0, 0, 8244, 8245, 5, 262, 0, 0, 8245, 8247, 5, 236, 0, 0, 8246, 8244, 1, 0, 0, 0, 8246, 8247, 1, 0, 0, 0, 8247, 8248, 1, 0, 0, 0, 8248, 8254, 5, 362, 0, 0, 8249, 8251, 5, 236, 0, 0, 8250, 8249, 1, 0, 0, 0, 8250, 8251, 1, 0, 0, 0, 8251, 8252, 1, 0, 0, 0, 8252, 8254, 5, 327, 0, 0, 8253, 8246, 1, 0, 0, 0, 8253, 8250, 1, 0, 0, 0, 8254, 1049, 1, 0, 0, 0, 8255, 8256, 5, 268, 0, 0, 8256, 8259, 3, 1334, 667, 0, 8257, 8259, 1, 0, 0, 0, 8258, 8255, 1, 0, 0, 0, 8258, 8257, 1, 0, 0, 0, 8259, 1051, 1, 0, 0, 0, 8260, 8261, 5, 415, 0, 0, 8261, 8262, 5, 2, 0, 0, 8262, 8263, 3, 1280, 640, 0, 8263, 8271, 5, 3, 0, 0, 8264, 8265, 5, 6, 0, 0, 8265, 8266, 5, 2, 0, 0, 8266, 8267, 3, 1280, 640, 0, 8267, 8268, 5, 3, 0, 0, 8268, 8270, 1, 0, 0, 0, 8269, 8264, 1, 0, 0, 0, 8270, 8273, 1, 0, 0, 0, 8271, 8269, 1, 0, 0, 0, 8271, 8272, 1, 0, 0, 0, 8272, 1053, 1, 0, 0, 0, 8273, 8271, 1, 0, 0, 0, 8274, 8275, 5, 64, 0, 0, 8275, 8278, 3, 1056, 528, 0, 8276, 8278, 1, 0, 0, 0, 8277, 8274, 1, 0, 0, 0, 8277, 8276, 1, 0, 0, 0, 8278, 1055, 1, 0, 0, 0, 8279, 8289, 3, 1058, 529, 0, 8280, 8285, 3, 1060, 530, 0, 8281, 8282, 5, 6, 0, 0, 8282, 8284, 3, 1060, 530, 0, 8283, 8281, 1, 0, 0, 0, 8284, 8287, 1, 0, 0, 0, 8285, 8283, 1, 0, 0, 0, 8285, 8286, 1, 0, 0, 0, 8286, 8289, 1, 0, 0, 0, 8287, 8285, 1, 0, 0, 0, 8288, 8279, 1, 0, 0, 0, 8288, 8280, 1, 0, 0, 0, 8289, 1057, 1, 0, 0, 0, 8290, 8293, 3, 1060, 530, 0, 8291, 8292, 5, 6, 0, 0, 8292, 8294, 3, 1060, 530, 0, 8293, 8291, 1, 0, 0, 0, 8294, 8295, 1, 0, 0, 0, 8295, 8293, 1, 0, 0, 0, 8295, 8296, 1, 0, 0, 0, 8296, 1059, 1, 0, 0, 0, 8297, 8298, 3, 1074, 537, 0, 8298, 8300, 3, 1064, 532, 0, 8299, 8301, 3, 1080, 540, 0, 8300, 8299, 1, 0, 0, 0, 8300, 8301, 1, 0, 0, 0, 8301, 8347, 1, 0, 0, 0, 8302, 8303, 3, 1084, 542, 0, 8303, 8304, 3, 1068, 534, 0, 8304, 8347, 1, 0, 0, 0, 8305, 8306, 3, 1104, 552, 0, 8306, 8307, 3, 1064, 532, 0, 8307, 8347, 1, 0, 0, 0, 8308, 8309, 3, 962, 481, 0, 8309, 8310, 3, 1064, 532, 0, 8310, 8347, 1, 0, 0, 0, 8311, 8321, 5, 72, 0, 0, 8312, 8313, 3, 1104, 552, 0, 8313, 8314, 3, 1064, 532, 0, 8314, 8322, 1, 0, 0, 0, 8315, 8316, 3, 1084, 542, 0, 8316, 8317, 3, 1068, 534, 0, 8317, 8322, 1, 0, 0, 0, 8318, 8319, 3, 962, 481, 0, 8319, 8320, 3, 1064, 532, 0, 8320, 8322, 1, 0, 0, 0, 8321, 8312, 1, 0, 0, 0, 8321, 8315, 1, 0, 0, 0, 8321, 8318, 1, 0, 0, 0, 8322, 8347, 1, 0, 0, 0, 8323, 8324, 5, 2, 0, 0, 8324, 8341, 3, 1060, 530, 0, 8325, 8326, 5, 110, 0, 0, 8326, 8327, 5, 118, 0, 0, 8327, 8342, 3, 1060, 530, 0, 8328, 8330, 5, 121, 0, 0, 8329, 8331, 3, 1070, 535, 0, 8330, 8329, 1, 0, 0, 0, 8330, 8331, 1, 0, 0, 0, 8331, 8332, 1, 0, 0, 0, 8332, 8333, 5, 118, 0, 0, 8333, 8342, 3, 1060, 530, 0, 8334, 8336, 3, 1070, 535, 0, 8335, 8334, 1, 0, 0, 0, 8335, 8336, 1, 0, 0, 0, 8336, 8337, 1, 0, 0, 0, 8337, 8338, 5, 118, 0, 0, 8338, 8339, 3, 1060, 530, 0, 8339, 8340, 3, 1072, 536, 0, 8340, 8342, 1, 0, 0, 0, 8341, 8325, 1, 0, 0, 0, 8341, 8328, 1, 0, 0, 0, 8341, 8335, 1, 0, 0, 0, 8341, 8342, 1, 0, 0, 0, 8342, 8343, 1, 0, 0, 0, 8343, 8344, 5, 3, 0, 0, 8344, 8345, 3, 1064, 532, 0, 8345, 8347, 1, 0, 0, 0, 8346, 8297, 1, 0, 0, 0, 8346, 8302, 1, 0, 0, 0, 8346, 8305, 1, 0, 0, 0, 8346, 8308, 1, 0, 0, 0, 8346, 8311, 1, 0, 0, 0, 8346, 8323, 1, 0, 0, 0, 8347, 8366, 1, 0, 0, 0, 8348, 8349, 5, 110, 0, 0, 8349, 8350, 5, 118, 0, 0, 8350, 8365, 3, 1060, 530, 0, 8351, 8353, 5, 121, 0, 0, 8352, 8354, 3, 1070, 535, 0, 8353, 8352, 1, 0, 0, 0, 8353, 8354, 1, 0, 0, 0, 8354, 8355, 1, 0, 0, 0, 8355, 8356, 5, 118, 0, 0, 8356, 8365, 3, 1060, 530, 0, 8357, 8359, 3, 1070, 535, 0, 8358, 8357, 1, 0, 0, 0, 8358, 8359, 1, 0, 0, 0, 8359, 8360, 1, 0, 0, 0, 8360, 8361, 5, 118, 0, 0, 8361, 8362, 3, 1060, 530, 0, 8362, 8363, 3, 1072, 536, 0, 8363, 8365, 1, 0, 0, 0, 8364, 8348, 1, 0, 0, 0, 8364, 8351, 1, 0, 0, 0, 8364, 8358, 1, 0, 0, 0, 8365, 8368, 1, 0, 0, 0, 8366, 8364, 1, 0, 0, 0, 8366, 8367, 1, 0, 0, 0, 8367, 1061, 1, 0, 0, 0, 8368, 8366, 1, 0, 0, 0, 8369, 8371, 5, 36, 0, 0, 8370, 8369, 1, 0, 0, 0, 8370, 8371, 1, 0, 0, 0, 8371, 8372, 1, 0, 0, 0, 8372, 8377, 3, 1372, 686, 0, 8373, 8374, 5, 2, 0, 0, 8374, 8375, 3, 1338, 669, 0, 8375, 8376, 5, 3, 0, 0, 8376, 8378, 1, 0, 0, 0, 8377, 8373, 1, 0, 0, 0, 8377, 8378, 1, 0, 0, 0, 8378, 1063, 1, 0, 0, 0, 8379, 8382, 3, 1066, 533, 0, 8380, 8382, 1, 0, 0, 0, 8381, 8379, 1, 0, 0, 0, 8381, 8380, 1, 0, 0, 0, 8382, 1065, 1, 0, 0, 0, 8383, 8385, 5, 36, 0, 0, 8384, 8383, 1, 0, 0, 0, 8384, 8385, 1, 0, 0, 0, 8385, 8386, 1, 0, 0, 0, 8386, 8391, 3, 1374, 687, 0, 8387, 8388, 5, 2, 0, 0, 8388, 8389, 3, 1338, 669, 0, 8389, 8390, 5, 3, 0, 0, 8390, 8392, 1, 0, 0, 0, 8391, 8387, 1, 0, 0, 0, 8391, 8392, 1, 0, 0, 0, 8392, 1067, 1, 0, 0, 0, 8393, 8407, 3, 1062, 531, 0, 8394, 8396, 5, 36, 0, 0, 8395, 8397, 3, 1372, 686, 0, 8396, 8395, 1, 0, 0, 0, 8396, 8397, 1, 0, 0, 0, 8397, 8400, 1, 0, 0, 0, 8398, 8400, 3, 1372, 686, 0, 8399, 8394, 1, 0, 0, 0, 8399, 8398, 1, 0, 0, 0, 8400, 8401, 1, 0, 0, 0, 8401, 8402, 5, 2, 0, 0, 8402, 8403, 3, 1100, 550, 0, 8403, 8404, 5, 3, 0, 0, 8404, 8407, 1, 0, 0, 0, 8405, 8407, 1, 0, 0, 0, 8406, 8393, 1, 0, 0, 0, 8406, 8399, 1, 0, 0, 0, 8406, 8405, 1, 0, 0, 0, 8407, 1069, 1, 0, 0, 0, 8408, 8410, 7, 41, 0, 0, 8409, 8411, 5, 123, 0, 0, 8410, 8409, 1, 0, 0, 0, 8410, 8411, 1, 0, 0, 0, 8411, 1071, 1, 0, 0, 0, 8412, 8413, 5, 100, 0, 0, 8413, 8414, 5, 2, 0, 0, 8414, 8415, 3, 1338, 669, 0, 8415, 8416, 5, 3, 0, 0, 8416, 8420, 1, 0, 0, 0, 8417, 8418, 5, 80, 0, 0, 8418, 8420, 3, 1162, 581, 0, 8419, 8412, 1, 0, 0, 0, 8419, 8417, 1, 0, 0, 0, 8420, 1073, 1, 0, 0, 0, 8421, 8423, 3, 1336, 668, 0, 8422, 8424, 5, 9, 0, 0, 8423, 8422, 1, 0, 0, 0, 8423, 8424, 1, 0, 0, 0, 8424, 8434, 1, 0, 0, 0, 8425, 8431, 5, 81, 0, 0, 8426, 8432, 3, 1336, 668, 0, 8427, 8428, 5, 2, 0, 0, 8428, 8429, 3, 1336, 668, 0, 8429, 8430, 5, 3, 0, 0, 8430, 8432, 1, 0, 0, 0, 8431, 8426, 1, 0, 0, 0, 8431, 8427, 1, 0, 0, 0, 8432, 8434, 1, 0, 0, 0, 8433, 8421, 1, 0, 0, 0, 8433, 8425, 1, 0, 0, 0, 8434, 1075, 1, 0, 0, 0, 8435, 8440, 3, 1074, 537, 0, 8436, 8437, 5, 6, 0, 0, 8437, 8439, 3, 1074, 537, 0, 8438, 8436, 1, 0, 0, 0, 8439, 8442, 1, 0, 0, 0, 8440, 8438, 1, 0, 0, 0, 8440, 8441, 1, 0, 0, 0, 8441, 1077, 1, 0, 0, 0, 8442, 8440, 1, 0, 0, 0, 8443, 8448, 3, 1074, 537, 0, 8444, 8446, 5, 36, 0, 0, 8445, 8444, 1, 0, 0, 0, 8445, 8446, 1, 0, 0, 0, 8446, 8447, 1, 0, 0, 0, 8447, 8449, 3, 1372, 686, 0, 8448, 8445, 1, 0, 0, 0, 8448, 8449, 1, 0, 0, 0, 8449, 1079, 1, 0, 0, 0, 8450, 8451, 5, 472, 0, 0, 8451, 8452, 3, 1346, 673, 0, 8452, 8453, 5, 2, 0, 0, 8453, 8454, 3, 1280, 640, 0, 8454, 8455, 5, 3, 0, 0, 8455, 8456, 3, 1082, 541, 0, 8456, 1081, 1, 0, 0, 0, 8457, 8458, 5, 303, 0, 0, 8458, 8459, 5, 2, 0, 0, 8459, 8460, 3, 1162, 581, 0, 8460, 8461, 5, 3, 0, 0, 8461, 8464, 1, 0, 0, 0, 8462, 8464, 1, 0, 0, 0, 8463, 8457, 1, 0, 0, 0, 8463, 8462, 1, 0, 0, 0, 8464, 1083, 1, 0, 0, 0, 8465, 8466, 3, 1214, 607, 0, 8466, 8467, 3, 1092, 546, 0, 8467, 8476, 1, 0, 0, 0, 8468, 8469, 5, 313, 0, 0, 8469, 8470, 5, 64, 0, 0, 8470, 8471, 5, 2, 0, 0, 8471, 8472, 3, 1088, 544, 0, 8472, 8473, 5, 3, 0, 0, 8473, 8474, 3, 1092, 546, 0, 8474, 8476, 1, 0, 0, 0, 8475, 8465, 1, 0, 0, 0, 8475, 8468, 1, 0, 0, 0, 8476, 1085, 1, 0, 0, 0, 8477, 8478, 3, 1214, 607, 0, 8478, 8479, 3, 1090, 545, 0, 8479, 1087, 1, 0, 0, 0, 8480, 8485, 3, 1086, 543, 0, 8481, 8482, 5, 6, 0, 0, 8482, 8484, 3, 1086, 543, 0, 8483, 8481, 1, 0, 0, 0, 8484, 8487, 1, 0, 0, 0, 8485, 8483, 1, 0, 0, 0, 8485, 8486, 1, 0, 0, 0, 8486, 1089, 1, 0, 0, 0, 8487, 8485, 1, 0, 0, 0, 8488, 8489, 5, 36, 0, 0, 8489, 8490, 5, 2, 0, 0, 8490, 8491, 3, 1100, 550, 0, 8491, 8492, 5, 3, 0, 0, 8492, 8495, 1, 0, 0, 0, 8493, 8495, 1, 0, 0, 0, 8494, 8488, 1, 0, 0, 0, 8494, 8493, 1, 0, 0, 0, 8495, 1091, 1, 0, 0, 0, 8496, 8497, 5, 105, 0, 0, 8497, 8500, 5, 473, 0, 0, 8498, 8500, 1, 0, 0, 0, 8499, 8496, 1, 0, 0, 0, 8499, 8498, 1, 0, 0, 0, 8500, 1093, 1, 0, 0, 0, 8501, 8502, 5, 103, 0, 0, 8502, 8505, 3, 1162, 581, 0, 8503, 8505, 1, 0, 0, 0, 8504, 8501, 1, 0, 0, 0, 8504, 8503, 1, 0, 0, 0, 8505, 1095, 1, 0, 0, 0, 8506, 8511, 5, 103, 0, 0, 8507, 8508, 5, 434, 0, 0, 8508, 8509, 5, 268, 0, 0, 8509, 8512, 3, 954, 477, 0, 8510, 8512, 3, 1162, 581, 0, 8511, 8507, 1, 0, 0, 0, 8511, 8510, 1, 0, 0, 0, 8512, 8515, 1, 0, 0, 0, 8513, 8515, 1, 0, 0, 0, 8514, 8506, 1, 0, 0, 0, 8514, 8513, 1, 0, 0, 0, 8515, 1097, 1, 0, 0, 0, 8516, 8519, 3, 1100, 550, 0, 8517, 8519, 1, 0, 0, 0, 8518, 8516, 1, 0, 0, 0, 8518, 8517, 1, 0, 0, 0, 8519, 1099, 1, 0, 0, 0, 8520, 8525, 3, 1102, 551, 0, 8521, 8522, 5, 6, 0, 0, 8522, 8524, 3, 1102, 551, 0, 8523, 8521, 1, 0, 0, 0, 8524, 8527, 1, 0, 0, 0, 8525, 8523, 1, 0, 0, 0, 8525, 8526, 1, 0, 0, 0, 8526, 1101, 1, 0, 0, 0, 8527, 8525, 1, 0, 0, 0, 8528, 8529, 3, 1372, 686, 0, 8529, 8530, 3, 1118, 559, 0, 8530, 8531, 3, 110, 55, 0, 8531, 1103, 1, 0, 0, 0, 8532, 8533, 5, 474, 0, 0, 8533, 8549, 5, 2, 0, 0, 8534, 8535, 3, 1206, 603, 0, 8535, 8536, 3, 1232, 616, 0, 8536, 8537, 5, 475, 0, 0, 8537, 8538, 3, 1106, 553, 0, 8538, 8550, 1, 0, 0, 0, 8539, 8540, 5, 476, 0, 0, 8540, 8541, 5, 2, 0, 0, 8541, 8542, 3, 1114, 557, 0, 8542, 8543, 5, 3, 0, 0, 8543, 8544, 5, 6, 0, 0, 8544, 8545, 3, 1206, 603, 0, 8545, 8546, 3, 1232, 616, 0, 8546, 8547, 5, 475, 0, 0, 8547, 8548, 3, 1106, 553, 0, 8548, 8550, 1, 0, 0, 0, 8549, 8534, 1, 0, 0, 0, 8549, 8539, 1, 0, 0, 0, 8550, 8551, 1, 0, 0, 0, 8551, 8552, 5, 3, 0, 0, 8552, 1105, 1, 0, 0, 0, 8553, 8558, 3, 1108, 554, 0, 8554, 8555, 5, 6, 0, 0, 8555, 8557, 3, 1108, 554, 0, 8556, 8554, 1, 0, 0, 0, 8557, 8560, 1, 0, 0, 0, 8558, 8556, 1, 0, 0, 0, 8558, 8559, 1, 0, 0, 0, 8559, 1107, 1, 0, 0, 0, 8560, 8558, 1, 0, 0, 0, 8561, 8568, 3, 1372, 686, 0, 8562, 8564, 3, 1118, 559, 0, 8563, 8565, 3, 1110, 555, 0, 8564, 8563, 1, 0, 0, 0, 8564, 8565, 1, 0, 0, 0, 8565, 8569, 1, 0, 0, 0, 8566, 8567, 5, 62, 0, 0, 8567, 8569, 5, 473, 0, 0, 8568, 8562, 1, 0, 0, 0, 8568, 8566, 1, 0, 0, 0, 8569, 1109, 1, 0, 0, 0, 8570, 8572, 3, 1112, 556, 0, 8571, 8570, 1, 0, 0, 0, 8572, 8573, 1, 0, 0, 0, 8573, 8571, 1, 0, 0, 0, 8573, 8574, 1, 0, 0, 0, 8574, 1111, 1, 0, 0, 0, 8575, 8576, 5, 53, 0, 0, 8576, 8584, 3, 1162, 581, 0, 8577, 8578, 3, 1382, 691, 0, 8578, 8579, 3, 1162, 581, 0, 8579, 8584, 1, 0, 0, 0, 8580, 8581, 5, 77, 0, 0, 8581, 8584, 5, 78, 0, 0, 8582, 8584, 5, 78, 0, 0, 8583, 8575, 1, 0, 0, 0, 8583, 8577, 1, 0, 0, 0, 8583, 8580, 1, 0, 0, 0, 8583, 8582, 1, 0, 0, 0, 8584, 1113, 1, 0, 0, 0, 8585, 8590, 3, 1116, 558, 0, 8586, 8587, 5, 6, 0, 0, 8587, 8589, 3, 1116, 558, 0, 8588, 8586, 1, 0, 0, 0, 8589, 8592, 1, 0, 0, 0, 8590, 8588, 1, 0, 0, 0, 8590, 8591, 1, 0, 0, 0, 8591, 1115, 1, 0, 0, 0, 8592, 8590, 1, 0, 0, 0, 8593, 8594, 3, 1204, 602, 0, 8594, 8595, 5, 36, 0, 0, 8595, 8596, 3, 1380, 690, 0, 8596, 8600, 1, 0, 0, 0, 8597, 8598, 5, 53, 0, 0, 8598, 8600, 3, 1204, 602, 0, 8599, 8593, 1, 0, 0, 0, 8599, 8597, 1, 0, 0, 0, 8600, 1117, 1, 0, 0, 0, 8601, 8603, 5, 408, 0, 0, 8602, 8601, 1, 0, 0, 0, 8602, 8603, 1, 0, 0, 0, 8603, 8604, 1, 0, 0, 0, 8604, 8613, 3, 1122, 561, 0, 8605, 8614, 3, 1120, 560, 0, 8606, 8611, 5, 35, 0, 0, 8607, 8608, 5, 4, 0, 0, 8608, 8609, 3, 1356, 678, 0, 8609, 8610, 5, 5, 0, 0, 8610, 8612, 1, 0, 0, 0, 8611, 8607, 1, 0, 0, 0, 8611, 8612, 1, 0, 0, 0, 8612, 8614, 1, 0, 0, 0, 8613, 8605, 1, 0, 0, 0, 8613, 8606, 1, 0, 0, 0, 8614, 8620, 1, 0, 0, 0, 8615, 8616, 3, 1336, 668, 0, 8616, 8617, 5, 27, 0, 0, 8617, 8618, 7, 42, 0, 0, 8618, 8620, 1, 0, 0, 0, 8619, 8602, 1, 0, 0, 0, 8619, 8615, 1, 0, 0, 0, 8620, 1119, 1, 0, 0, 0, 8621, 8623, 5, 4, 0, 0, 8622, 8624, 3, 1356, 678, 0, 8623, 8622, 1, 0, 0, 0, 8623, 8624, 1, 0, 0, 0, 8624, 8625, 1, 0, 0, 0, 8625, 8627, 5, 5, 0, 0, 8626, 8621, 1, 0, 0, 0, 8627, 8630, 1, 0, 0, 0, 8628, 8626, 1, 0, 0, 0, 8628, 8629, 1, 0, 0, 0, 8629, 1121, 1, 0, 0, 0, 8630, 8628, 1, 0, 0, 0, 8631, 8645, 3, 1126, 563, 0, 8632, 8645, 3, 1130, 565, 0, 8633, 8645, 3, 1134, 567, 0, 8634, 8645, 3, 1142, 571, 0, 8635, 8645, 3, 1150, 575, 0, 8636, 8642, 3, 1152, 576, 0, 8637, 8643, 3, 1156, 578, 0, 8638, 8639, 5, 2, 0, 0, 8639, 8640, 3, 1356, 678, 0, 8640, 8641, 5, 3, 0, 0, 8641, 8643, 1, 0, 0, 0, 8642, 8637, 1, 0, 0, 0, 8642, 8638, 1, 0, 0, 0, 8643, 8645, 1, 0, 0, 0, 8644, 8631, 1, 0, 0, 0, 8644, 8632, 1, 0, 0, 0, 8644, 8633, 1, 0, 0, 0, 8644, 8634, 1, 0, 0, 0, 8644, 8635, 1, 0, 0, 0, 8644, 8636, 1, 0, 0, 0, 8645, 1123, 1, 0, 0, 0, 8646, 8651, 3, 1130, 565, 0, 8647, 8651, 3, 1136, 568, 0, 8648, 8651, 3, 1144, 572, 0, 8649, 8651, 3, 1150, 575, 0, 8650, 8646, 1, 0, 0, 0, 8650, 8647, 1, 0, 0, 0, 8650, 8648, 1, 0, 0, 0, 8650, 8649, 1, 0, 0, 0, 8651, 1125, 1, 0, 0, 0, 8652, 8657, 3, 1394, 697, 0, 8653, 8657, 3, 1376, 688, 0, 8654, 8657, 5, 119, 0, 0, 8655, 8657, 5, 126, 0, 0, 8656, 8652, 1, 0, 0, 0, 8656, 8653, 1, 0, 0, 0, 8656, 8654, 1, 0, 0, 0, 8656, 8655, 1, 0, 0, 0, 8657, 8659, 1, 0, 0, 0, 8658, 8660, 3, 526, 263, 0, 8659, 8658, 1, 0, 0, 0, 8659, 8660, 1, 0, 0, 0, 8660, 8661, 1, 0, 0, 0, 8661, 8662, 3, 1128, 564, 0, 8662, 1127, 1, 0, 0, 0, 8663, 8664, 5, 2, 0, 0, 8664, 8665, 3, 1280, 640, 0, 8665, 8666, 5, 3, 0, 0, 8666, 8669, 1, 0, 0, 0, 8667, 8669, 1, 0, 0, 0, 8668, 8663, 1, 0, 0, 0, 8668, 8667, 1, 0, 0, 0, 8669, 1129, 1, 0, 0, 0, 8670, 8687, 5, 394, 0, 0, 8671, 8687, 5, 395, 0, 0, 8672, 8687, 5, 409, 0, 0, 8673, 8687, 5, 381, 0, 0, 8674, 8687, 5, 406, 0, 0, 8675, 8676, 5, 391, 0, 0, 8676, 8687, 3, 1132, 566, 0, 8677, 8678, 5, 190, 0, 0, 8678, 8687, 5, 405, 0, 0, 8679, 8680, 5, 388, 0, 0, 8680, 8687, 3, 1128, 564, 0, 8681, 8682, 5, 387, 0, 0, 8682, 8687, 3, 1128, 564, 0, 8683, 8684, 5, 402, 0, 0, 8684, 8687, 3, 1128, 564, 0, 8685, 8687, 5, 383, 0, 0, 8686, 8670, 1, 0, 0, 0, 8686, 8671, 1, 0, 0, 0, 8686, 8672, 1, 0, 0, 0, 8686, 8673, 1, 0, 0, 0, 8686, 8674, 1, 0, 0, 0, 8686, 8675, 1, 0, 0, 0, 8686, 8677, 1, 0, 0, 0, 8686, 8679, 1, 0, 0, 0, 8686, 8681, 1, 0, 0, 0, 8686, 8683, 1, 0, 0, 0, 8686, 8685, 1, 0, 0, 0, 8687, 1131, 1, 0, 0, 0, 8688, 8689, 5, 2, 0, 0, 8689, 8690, 3, 1356, 678, 0, 8690, 8691, 5, 3, 0, 0, 8691, 8694, 1, 0, 0, 0, 8692, 8694, 1, 0, 0, 0, 8693, 8688, 1, 0, 0, 0, 8693, 8692, 1, 0, 0, 0, 8694, 1133, 1, 0, 0, 0, 8695, 8698, 3, 1138, 569, 0, 8696, 8698, 3, 1140, 570, 0, 8697, 8695, 1, 0, 0, 0, 8697, 8696, 1, 0, 0, 0, 8698, 1135, 1, 0, 0, 0, 8699, 8702, 3, 1138, 569, 0, 8700, 8702, 3, 1140, 570, 0, 8701, 8699, 1, 0, 0, 0, 8701, 8700, 1, 0, 0, 0, 8702, 1137, 1, 0, 0, 0, 8703, 8704, 5, 382, 0, 0, 8704, 8705, 3, 1148, 574, 0, 8705, 8706, 5, 2, 0, 0, 8706, 8707, 3, 1280, 640, 0, 8707, 8708, 5, 3, 0, 0, 8708, 1139, 1, 0, 0, 0, 8709, 8710, 5, 382, 0, 0, 8710, 8711, 3, 1148, 574, 0, 8711, 1141, 1, 0, 0, 0, 8712, 8717, 3, 1146, 573, 0, 8713, 8714, 5, 2, 0, 0, 8714, 8715, 3, 1356, 678, 0, 8715, 8716, 5, 3, 0, 0, 8716, 8718, 1, 0, 0, 0, 8717, 8713, 1, 0, 0, 0, 8717, 8718, 1, 0, 0, 0, 8718, 1143, 1, 0, 0, 0, 8719, 8724, 3, 1146, 573, 0, 8720, 8721, 5, 2, 0, 0, 8721, 8722, 3, 1356, 678, 0, 8722, 8723, 5, 3, 0, 0, 8723, 8725, 1, 0, 0, 0, 8724, 8720, 1, 0, 0, 0, 8724, 8725, 1, 0, 0, 0, 8725, 1145, 1, 0, 0, 0, 8726, 8727, 7, 43, 0, 0, 8727, 8733, 3, 1148, 574, 0, 8728, 8733, 5, 416, 0, 0, 8729, 8730, 5, 398, 0, 0, 8730, 8731, 7, 44, 0, 0, 8731, 8733, 3, 1148, 574, 0, 8732, 8726, 1, 0, 0, 0, 8732, 8728, 1, 0, 0, 0, 8732, 8729, 1, 0, 0, 0, 8733, 1147, 1, 0, 0, 0, 8734, 8737, 5, 367, 0, 0, 8735, 8737, 1, 0, 0, 0, 8736, 8734, 1, 0, 0, 0, 8736, 8735, 1, 0, 0, 0, 8737, 1149, 1, 0, 0, 0, 8738, 8743, 7, 45, 0, 0, 8739, 8740, 5, 2, 0, 0, 8740, 8741, 3, 1356, 678, 0, 8741, 8742, 5, 3, 0, 0, 8742, 8744, 1, 0, 0, 0, 8743, 8739, 1, 0, 0, 0, 8743, 8744, 1, 0, 0, 0, 8744, 8745, 1, 0, 0, 0, 8745, 8746, 3, 1154, 577, 0, 8746, 1151, 1, 0, 0, 0, 8747, 8748, 5, 396, 0, 0, 8748, 1153, 1, 0, 0, 0, 8749, 8750, 5, 105, 0, 0, 8750, 8751, 5, 411, 0, 0, 8751, 8757, 5, 379, 0, 0, 8752, 8753, 5, 372, 0, 0, 8753, 8754, 5, 411, 0, 0, 8754, 8757, 5, 379, 0, 0, 8755, 8757, 1, 0, 0, 0, 8756, 8749, 1, 0, 0, 0, 8756, 8752, 1, 0, 0, 0, 8756, 8755, 1, 0, 0, 0, 8757, 1155, 1, 0, 0, 0, 8758, 8785, 5, 377, 0, 0, 8759, 8785, 5, 257, 0, 0, 8760, 8785, 5, 176, 0, 0, 8761, 8785, 5, 218, 0, 0, 8762, 8785, 5, 254, 0, 0, 8763, 8785, 3, 1158, 579, 0, 8764, 8765, 5, 377, 0, 0, 8765, 8766, 5, 94, 0, 0, 8766, 8785, 5, 257, 0, 0, 8767, 8768, 5, 176, 0, 0, 8768, 8772, 5, 94, 0, 0, 8769, 8773, 5, 218, 0, 0, 8770, 8773, 5, 254, 0, 0, 8771, 8773, 3, 1158, 579, 0, 8772, 8769, 1, 0, 0, 0, 8772, 8770, 1, 0, 0, 0, 8772, 8771, 1, 0, 0, 0, 8773, 8785, 1, 0, 0, 0, 8774, 8775, 5, 218, 0, 0, 8775, 8778, 5, 94, 0, 0, 8776, 8779, 5, 254, 0, 0, 8777, 8779, 3, 1158, 579, 0, 8778, 8776, 1, 0, 0, 0, 8778, 8777, 1, 0, 0, 0, 8779, 8785, 1, 0, 0, 0, 8780, 8781, 5, 254, 0, 0, 8781, 8782, 5, 94, 0, 0, 8782, 8785, 3, 1158, 579, 0, 8783, 8785, 1, 0, 0, 0, 8784, 8758, 1, 0, 0, 0, 8784, 8759, 1, 0, 0, 0, 8784, 8760, 1, 0, 0, 0, 8784, 8761, 1, 0, 0, 0, 8784, 8762, 1, 0, 0, 0, 8784, 8763, 1, 0, 0, 0, 8784, 8764, 1, 0, 0, 0, 8784, 8767, 1, 0, 0, 0, 8784, 8774, 1, 0, 0, 0, 8784, 8780, 1, 0, 0, 0, 8784, 8783, 1, 0, 0, 0, 8785, 1157, 1, 0, 0, 0, 8786, 8791, 5, 319, 0, 0, 8787, 8788, 5, 2, 0, 0, 8788, 8789, 3, 1356, 678, 0, 8789, 8790, 5, 3, 0, 0, 8790, 8792, 1, 0, 0, 0, 8791, 8787, 1, 0, 0, 0, 8791, 8792, 1, 0, 0, 0, 8792, 1159, 1, 0, 0, 0, 8793, 8794, 5, 197, 0, 0, 8794, 8797, 3, 1162, 581, 0, 8795, 8797, 1, 0, 0, 0, 8796, 8793, 1, 0, 0, 0, 8796, 8795, 1, 0, 0, 0, 8797, 1161, 1, 0, 0, 0, 8798, 8799, 3, 1164, 582, 0, 8799, 1163, 1, 0, 0, 0, 8800, 8802, 3, 1166, 583, 0, 8801, 8803, 3, 1274, 637, 0, 8802, 8801, 1, 0, 0, 0, 8802, 8803, 1, 0, 0, 0, 8803, 1165, 1, 0, 0, 0, 8804, 8809, 3, 1168, 584, 0, 8805, 8806, 7, 46, 0, 0, 8806, 8808, 3, 1168, 584, 0, 8807, 8805, 1, 0, 0, 0, 8808, 8811, 1, 0, 0, 0, 8809, 8807, 1, 0, 0, 0, 8809, 8810, 1, 0, 0, 0, 8810, 1167, 1, 0, 0, 0, 8811, 8809, 1, 0, 0, 0, 8812, 8817, 3, 1170, 585, 0, 8813, 8814, 5, 82, 0, 0, 8814, 8816, 3, 1170, 585, 0, 8815, 8813, 1, 0, 0, 0, 8816, 8819, 1, 0, 0, 0, 8817, 8815, 1, 0, 0, 0, 8817, 8818, 1, 0, 0, 0, 8818, 1169, 1, 0, 0, 0, 8819, 8817, 1, 0, 0, 0, 8820, 8825, 3, 1172, 586, 0, 8821, 8822, 5, 33, 0, 0, 8822, 8824, 3, 1172, 586, 0, 8823, 8821, 1, 0, 0, 0, 8824, 8827, 1, 0, 0, 0, 8825, 8823, 1, 0, 0, 0, 8825, 8826, 1, 0, 0, 0, 8826, 1171, 1, 0, 0, 0, 8827, 8825, 1, 0, 0, 0, 8828, 8840, 3, 1174, 587, 0, 8829, 8831, 5, 77, 0, 0, 8830, 8829, 1, 0, 0, 0, 8830, 8831, 1, 0, 0, 0, 8831, 8832, 1, 0, 0, 0, 8832, 8834, 5, 380, 0, 0, 8833, 8835, 5, 91, 0, 0, 8834, 8833, 1, 0, 0, 0, 8834, 8835, 1, 0, 0, 0, 8835, 8836, 1, 0, 0, 0, 8836, 8837, 3, 1174, 587, 0, 8837, 8838, 5, 33, 0, 0, 8838, 8839, 3, 1174, 587, 0, 8839, 8841, 1, 0, 0, 0, 8840, 8830, 1, 0, 0, 0, 8840, 8841, 1, 0, 0, 0, 8841, 1173, 1, 0, 0, 0, 8842, 8848, 3, 1176, 588, 0, 8843, 8845, 5, 77, 0, 0, 8844, 8843, 1, 0, 0, 0, 8844, 8845, 1, 0, 0, 0, 8845, 8846, 1, 0, 0, 0, 8846, 8847, 5, 68, 0, 0, 8847, 8849, 3, 1306, 653, 0, 8848, 8844, 1, 0, 0, 0, 8848, 8849, 1, 0, 0, 0, 8849, 1175, 1, 0, 0, 0, 8850, 8852, 5, 77, 0, 0, 8851, 8850, 1, 0, 0, 0, 8851, 8852, 1, 0, 0, 0, 8852, 8853, 1, 0, 0, 0, 8853, 8854, 3, 1178, 589, 0, 8854, 1177, 1, 0, 0, 0, 8855, 8857, 3, 1180, 590, 0, 8856, 8858, 7, 47, 0, 0, 8857, 8856, 1, 0, 0, 0, 8857, 8858, 1, 0, 0, 0, 8858, 1179, 1, 0, 0, 0, 8859, 8883, 3, 1182, 591, 0, 8860, 8862, 5, 116, 0, 0, 8861, 8863, 5, 77, 0, 0, 8862, 8861, 1, 0, 0, 0, 8862, 8863, 1, 0, 0, 0, 8863, 8881, 1, 0, 0, 0, 8864, 8882, 5, 78, 0, 0, 8865, 8882, 5, 96, 0, 0, 8866, 8882, 5, 60, 0, 0, 8867, 8882, 5, 358, 0, 0, 8868, 8869, 5, 56, 0, 0, 8869, 8870, 5, 64, 0, 0, 8870, 8882, 3, 1162, 581, 0, 8871, 8872, 5, 268, 0, 0, 8872, 8873, 5, 2, 0, 0, 8873, 8874, 3, 1286, 643, 0, 8874, 8875, 5, 3, 0, 0, 8875, 8882, 1, 0, 0, 0, 8876, 8882, 5, 188, 0, 0, 8877, 8879, 3, 1296, 648, 0, 8878, 8877, 1, 0, 0, 0, 8878, 8879, 1, 0, 0, 0, 8879, 8880, 1, 0, 0, 0, 8880, 8882, 5, 478, 0, 0, 8881, 8864, 1, 0, 0, 0, 8881, 8865, 1, 0, 0, 0, 8881, 8866, 1, 0, 0, 0, 8881, 8867, 1, 0, 0, 0, 8881, 8868, 1, 0, 0, 0, 8881, 8871, 1, 0, 0, 0, 8881, 8876, 1, 0, 0, 0, 8881, 8878, 1, 0, 0, 0, 8882, 8884, 1, 0, 0, 0, 8883, 8860, 1, 0, 0, 0, 8883, 8884, 1, 0, 0, 0, 8884, 1181, 1, 0, 0, 0, 8885, 8897, 3, 1184, 592, 0, 8886, 8887, 7, 48, 0, 0, 8887, 8898, 3, 1184, 592, 0, 8888, 8889, 3, 1278, 639, 0, 8889, 8895, 3, 1268, 634, 0, 8890, 8896, 3, 962, 481, 0, 8891, 8892, 5, 2, 0, 0, 8892, 8893, 3, 1162, 581, 0, 8893, 8894, 5, 3, 0, 0, 8894, 8896, 1, 0, 0, 0, 8895, 8890, 1, 0, 0, 0, 8895, 8891, 1, 0, 0, 0, 8896, 8898, 1, 0, 0, 0, 8897, 8886, 1, 0, 0, 0, 8897, 8888, 1, 0, 0, 0, 8897, 8898, 1, 0, 0, 0, 8898, 1183, 1, 0, 0, 0, 8899, 8912, 3, 1186, 593, 0, 8900, 8902, 5, 77, 0, 0, 8901, 8900, 1, 0, 0, 0, 8901, 8902, 1, 0, 0, 0, 8902, 8907, 1, 0, 0, 0, 8903, 8908, 5, 120, 0, 0, 8904, 8908, 5, 114, 0, 0, 8905, 8906, 5, 127, 0, 0, 8906, 8908, 5, 94, 0, 0, 8907, 8903, 1, 0, 0, 0, 8907, 8904, 1, 0, 0, 0, 8907, 8905, 1, 0, 0, 0, 8908, 8909, 1, 0, 0, 0, 8909, 8910, 3, 1186, 593, 0, 8910, 8911, 3, 1160, 580, 0, 8911, 8913, 1, 0, 0, 0, 8912, 8901, 1, 0, 0, 0, 8912, 8913, 1, 0, 0, 0, 8913, 1185, 1, 0, 0, 0, 8914, 8920, 3, 1188, 594, 0, 8915, 8916, 3, 1274, 637, 0, 8916, 8917, 3, 1188, 594, 0, 8917, 8919, 1, 0, 0, 0, 8918, 8915, 1, 0, 0, 0, 8919, 8922, 1, 0, 0, 0, 8920, 8918, 1, 0, 0, 0, 8920, 8921, 1, 0, 0, 0, 8921, 1187, 1, 0, 0, 0, 8922, 8920, 1, 0, 0, 0, 8923, 8925, 3, 1274, 637, 0, 8924, 8923, 1, 0, 0, 0, 8924, 8925, 1, 0, 0, 0, 8925, 8926, 1, 0, 0, 0, 8926, 8927, 3, 1190, 595, 0, 8927, 1189, 1, 0, 0, 0, 8928, 8933, 3, 1192, 596, 0, 8929, 8930, 7, 49, 0, 0, 8930, 8932, 3, 1192, 596, 0, 8931, 8929, 1, 0, 0, 0, 8932, 8935, 1, 0, 0, 0, 8933, 8931, 1, 0, 0, 0, 8933, 8934, 1, 0, 0, 0, 8934, 1191, 1, 0, 0, 0, 8935, 8933, 1, 0, 0, 0, 8936, 8941, 3, 1194, 597, 0, 8937, 8938, 7, 50, 0, 0, 8938, 8940, 3, 1194, 597, 0, 8939, 8937, 1, 0, 0, 0, 8940, 8943, 1, 0, 0, 0, 8941, 8939, 1, 0, 0, 0, 8941, 8942, 1, 0, 0, 0, 8942, 1193, 1, 0, 0, 0, 8943, 8941, 1, 0, 0, 0, 8944, 8947, 3, 1196, 598, 0, 8945, 8946, 5, 15, 0, 0, 8946, 8948, 3, 1162, 581, 0, 8947, 8945, 1, 0, 0, 0, 8947, 8948, 1, 0, 0, 0, 8948, 1195, 1, 0, 0, 0, 8949, 8951, 7, 49, 0, 0, 8950, 8949, 1, 0, 0, 0, 8950, 8951, 1, 0, 0, 0, 8951, 8952, 1, 0, 0, 0, 8952, 8953, 3, 1198, 599, 0, 8953, 1197, 1, 0, 0, 0, 8954, 8959, 3, 1200, 600, 0, 8955, 8956, 5, 142, 0, 0, 8956, 8957, 5, 411, 0, 0, 8957, 8958, 5, 379, 0, 0, 8958, 8960, 3, 1162, 581, 0, 8959, 8955, 1, 0, 0, 0, 8959, 8960, 1, 0, 0, 0, 8960, 1199, 1, 0, 0, 0, 8961, 8964, 3, 1202, 601, 0, 8962, 8963, 5, 43, 0, 0, 8963, 8965, 3, 524, 262, 0, 8964, 8962, 1, 0, 0, 0, 8964, 8965, 1, 0, 0, 0, 8965, 1201, 1, 0, 0, 0, 8966, 8971, 3, 1206, 603, 0, 8967, 8968, 5, 26, 0, 0, 8968, 8970, 3, 1118, 559, 0, 8969, 8967, 1, 0, 0, 0, 8970, 8973, 1, 0, 0, 0, 8971, 8969, 1, 0, 0, 0, 8971, 8972, 1, 0, 0, 0, 8972, 1203, 1, 0, 0, 0, 8973, 8971, 1, 0, 0, 0, 8974, 8975, 6, 602, -1, 0, 8975, 8982, 3, 1206, 603, 0, 8976, 8977, 7, 49, 0, 0, 8977, 8982, 3, 1204, 602, 9, 8978, 8979, 3, 1274, 637, 0, 8979, 8980, 3, 1204, 602, 3, 8980, 8982, 1, 0, 0, 0, 8981, 8974, 1, 0, 0, 0, 8981, 8976, 1, 0, 0, 0, 8981, 8978, 1, 0, 0, 0, 8982, 9022, 1, 0, 0, 0, 8983, 8984, 10, 8, 0, 0, 8984, 8985, 5, 15, 0, 0, 8985, 9021, 3, 1204, 602, 9, 8986, 8987, 10, 7, 0, 0, 8987, 8988, 7, 50, 0, 0, 8988, 9021, 3, 1204, 602, 8, 8989, 8990, 10, 6, 0, 0, 8990, 8991, 7, 49, 0, 0, 8991, 9021, 3, 1204, 602, 7, 8992, 8993, 10, 5, 0, 0, 8993, 8994, 3, 1274, 637, 0, 8994, 8995, 3, 1204, 602, 6, 8995, 9021, 1, 0, 0, 0, 8996, 8997, 10, 4, 0, 0, 8997, 8998, 7, 48, 0, 0, 8998, 9021, 3, 1204, 602, 5, 8999, 9000, 10, 10, 0, 0, 9000, 9001, 5, 26, 0, 0, 9001, 9021, 3, 1118, 559, 0, 9002, 9003, 10, 2, 0, 0, 9003, 9021, 3, 1274, 637, 0, 9004, 9005, 10, 1, 0, 0, 9005, 9007, 5, 116, 0, 0, 9006, 9008, 5, 77, 0, 0, 9007, 9006, 1, 0, 0, 0, 9007, 9008, 1, 0, 0, 0, 9008, 9018, 1, 0, 0, 0, 9009, 9010, 5, 56, 0, 0, 9010, 9011, 5, 64, 0, 0, 9011, 9019, 3, 1204, 602, 0, 9012, 9013, 5, 268, 0, 0, 9013, 9014, 5, 2, 0, 0, 9014, 9015, 3, 1286, 643, 0, 9015, 9016, 5, 3, 0, 0, 9016, 9019, 1, 0, 0, 0, 9017, 9019, 5, 188, 0, 0, 9018, 9009, 1, 0, 0, 0, 9018, 9012, 1, 0, 0, 0, 9018, 9017, 1, 0, 0, 0, 9019, 9021, 1, 0, 0, 0, 9020, 8983, 1, 0, 0, 0, 9020, 8986, 1, 0, 0, 0, 9020, 8989, 1, 0, 0, 0, 9020, 8992, 1, 0, 0, 0, 9020, 8996, 1, 0, 0, 0, 9020, 8999, 1, 0, 0, 0, 9020, 9002, 1, 0, 0, 0, 9020, 9004, 1, 0, 0, 0, 9021, 9024, 1, 0, 0, 0, 9022, 9020, 1, 0, 0, 0, 9022, 9023, 1, 0, 0, 0, 9023, 1205, 1, 0, 0, 0, 9024, 9022, 1, 0, 0, 0, 9025, 9026, 5, 389, 0, 0, 9026, 9062, 3, 962, 481, 0, 9027, 9030, 5, 35, 0, 0, 9028, 9031, 3, 962, 481, 0, 9029, 9031, 3, 1288, 644, 0, 9030, 9028, 1, 0, 0, 0, 9030, 9029, 1, 0, 0, 0, 9031, 9062, 1, 0, 0, 0, 9032, 9033, 5, 28, 0, 0, 9033, 9062, 3, 1326, 663, 0, 9034, 9035, 5, 470, 0, 0, 9035, 9036, 5, 2, 0, 0, 9036, 9037, 3, 1280, 640, 0, 9037, 9038, 5, 3, 0, 0, 9038, 9062, 1, 0, 0, 0, 9039, 9040, 5, 98, 0, 0, 9040, 9062, 3, 962, 481, 0, 9041, 9062, 3, 1318, 659, 0, 9042, 9062, 3, 1348, 674, 0, 9043, 9062, 3, 1208, 604, 0, 9044, 9045, 5, 2, 0, 0, 9045, 9046, 3, 1162, 581, 0, 9046, 9047, 5, 3, 0, 0, 9047, 9048, 3, 1326, 663, 0, 9048, 9062, 1, 0, 0, 0, 9049, 9062, 3, 1308, 654, 0, 9050, 9062, 3, 1212, 606, 0, 9051, 9053, 3, 962, 481, 0, 9052, 9054, 3, 1324, 662, 0, 9053, 9052, 1, 0, 0, 0, 9053, 9054, 1, 0, 0, 0, 9054, 9062, 1, 0, 0, 0, 9055, 9062, 3, 1264, 632, 0, 9056, 9062, 3, 1266, 633, 0, 9057, 9058, 3, 1262, 631, 0, 9058, 9059, 5, 125, 0, 0, 9059, 9060, 3, 1262, 631, 0, 9060, 9062, 1, 0, 0, 0, 9061, 9025, 1, 0, 0, 0, 9061, 9027, 1, 0, 0, 0, 9061, 9032, 1, 0, 0, 0, 9061, 9034, 1, 0, 0, 0, 9061, 9039, 1, 0, 0, 0, 9061, 9041, 1, 0, 0, 0, 9061, 9042, 1, 0, 0, 0, 9061, 9043, 1, 0, 0, 0, 9061, 9044, 1, 0, 0, 0, 9061, 9049, 1, 0, 0, 0, 9061, 9050, 1, 0, 0, 0, 9061, 9051, 1, 0, 0, 0, 9061, 9055, 1, 0, 0, 0, 9061, 9056, 1, 0, 0, 0, 9061, 9057, 1, 0, 0, 0, 9062, 1207, 1, 0, 0, 0, 9063, 9064, 5, 661, 0, 0, 9064, 1209, 1, 0, 0, 0, 9065, 9066, 3, 1346, 673, 0, 9066, 9085, 5, 2, 0, 0, 9067, 9071, 3, 1282, 641, 0, 9068, 9069, 5, 6, 0, 0, 9069, 9070, 5, 101, 0, 0, 9070, 9072, 3, 1284, 642, 0, 9071, 9068, 1, 0, 0, 0, 9071, 9072, 1, 0, 0, 0, 9072, 9073, 1, 0, 0, 0, 9073, 9074, 3, 996, 498, 0, 9074, 9086, 1, 0, 0, 0, 9075, 9076, 5, 101, 0, 0, 9076, 9077, 3, 1284, 642, 0, 9077, 9078, 3, 996, 498, 0, 9078, 9086, 1, 0, 0, 0, 9079, 9080, 7, 51, 0, 0, 9080, 9081, 3, 1282, 641, 0, 9081, 9082, 3, 996, 498, 0, 9082, 9086, 1, 0, 0, 0, 9083, 9086, 5, 9, 0, 0, 9084, 9086, 1, 0, 0, 0, 9085, 9067, 1, 0, 0, 0, 9085, 9075, 1, 0, 0, 0, 9085, 9079, 1, 0, 0, 0, 9085, 9083, 1, 0, 0, 0, 9085, 9084, 1, 0, 0, 0, 9086, 9087, 1, 0, 0, 0, 9087, 9088, 5, 3, 0, 0, 9088, 1211, 1, 0, 0, 0, 9089, 9090, 3, 1210, 605, 0, 9090, 9091, 3, 1236, 618, 0, 9091, 9092, 3, 1238, 619, 0, 9092, 9093, 3, 1246, 623, 0, 9093, 9096, 1, 0, 0, 0, 9094, 9096, 3, 1216, 608, 0, 9095, 9089, 1, 0, 0, 0, 9095, 9094, 1, 0, 0, 0, 9096, 1213, 1, 0, 0, 0, 9097, 9100, 3, 1210, 605, 0, 9098, 9100, 3, 1216, 608, 0, 9099, 9097, 1, 0, 0, 0, 9099, 9098, 1, 0, 0, 0, 9100, 1215, 1, 0, 0, 0, 9101, 9102, 5, 108, 0, 0, 9102, 9103, 5, 62, 0, 0, 9103, 9104, 5, 2, 0, 0, 9104, 9105, 3, 1162, 581, 0, 9105, 9106, 5, 3, 0, 0, 9106, 9279, 1, 0, 0, 0, 9107, 9279, 5, 48, 0, 0, 9108, 9113, 5, 50, 0, 0, 9109, 9110, 5, 2, 0, 0, 9110, 9111, 3, 1356, 678, 0, 9111, 9112, 5, 3, 0, 0, 9112, 9114, 1, 0, 0, 0, 9113, 9109, 1, 0, 0, 0, 9113, 9114, 1, 0, 0, 0, 9114, 9279, 1, 0, 0, 0, 9115, 9120, 5, 51, 0, 0, 9116, 9117, 5, 2, 0, 0, 9117, 9118, 3, 1356, 678, 0, 9118, 9119, 5, 3, 0, 0, 9119, 9121, 1, 0, 0, 0, 9120, 9116, 1, 0, 0, 0, 9120, 9121, 1, 0, 0, 0, 9121, 9279, 1, 0, 0, 0, 9122, 9127, 5, 75, 0, 0, 9123, 9124, 5, 2, 0, 0, 9124, 9125, 3, 1356, 678, 0, 9125, 9126, 5, 3, 0, 0, 9126, 9128, 1, 0, 0, 0, 9127, 9123, 1, 0, 0, 0, 9127, 9128, 1, 0, 0, 0, 9128, 9279, 1, 0, 0, 0, 9129, 9134, 5, 76, 0, 0, 9130, 9131, 5, 2, 0, 0, 9131, 9132, 3, 1356, 678, 0, 9132, 9133, 5, 3, 0, 0, 9133, 9135, 1, 0, 0, 0, 9134, 9130, 1, 0, 0, 0, 9134, 9135, 1, 0, 0, 0, 9135, 9279, 1, 0, 0, 0, 9136, 9279, 5, 49, 0, 0, 9137, 9279, 5, 52, 0, 0, 9138, 9279, 5, 89, 0, 0, 9139, 9279, 5, 99, 0, 0, 9140, 9279, 5, 47, 0, 0, 9141, 9279, 5, 111, 0, 0, 9142, 9143, 5, 41, 0, 0, 9143, 9144, 5, 2, 0, 0, 9144, 9145, 3, 1162, 581, 0, 9145, 9146, 5, 36, 0, 0, 9146, 9147, 3, 1118, 559, 0, 9147, 9148, 5, 3, 0, 0, 9148, 9279, 1, 0, 0, 0, 9149, 9150, 5, 390, 0, 0, 9150, 9151, 5, 2, 0, 0, 9151, 9152, 3, 1292, 646, 0, 9152, 9153, 5, 3, 0, 0, 9153, 9279, 1, 0, 0, 0, 9154, 9155, 5, 489, 0, 0, 9155, 9156, 5, 2, 0, 0, 9156, 9159, 3, 1162, 581, 0, 9157, 9158, 5, 6, 0, 0, 9158, 9160, 3, 1296, 648, 0, 9159, 9157, 1, 0, 0, 0, 9159, 9160, 1, 0, 0, 0, 9160, 9161, 1, 0, 0, 0, 9161, 9162, 5, 3, 0, 0, 9162, 9279, 1, 0, 0, 0, 9163, 9164, 5, 403, 0, 0, 9164, 9165, 5, 2, 0, 0, 9165, 9166, 3, 1298, 649, 0, 9166, 9167, 5, 3, 0, 0, 9167, 9279, 1, 0, 0, 0, 9168, 9169, 5, 404, 0, 0, 9169, 9170, 5, 2, 0, 0, 9170, 9171, 3, 1300, 650, 0, 9171, 9172, 5, 3, 0, 0, 9172, 9279, 1, 0, 0, 0, 9173, 9174, 5, 410, 0, 0, 9174, 9175, 5, 2, 0, 0, 9175, 9176, 3, 1302, 651, 0, 9176, 9177, 5, 3, 0, 0, 9177, 9279, 1, 0, 0, 0, 9178, 9179, 5, 413, 0, 0, 9179, 9180, 5, 2, 0, 0, 9180, 9181, 3, 1162, 581, 0, 9181, 9182, 5, 36, 0, 0, 9182, 9183, 3, 1118, 559, 0, 9183, 9184, 5, 3, 0, 0, 9184, 9279, 1, 0, 0, 0, 9185, 9186, 5, 414, 0, 0, 9186, 9188, 5, 2, 0, 0, 9187, 9189, 7, 52, 0, 0, 9188, 9187, 1, 0, 0, 0, 9188, 9189, 1, 0, 0, 0, 9189, 9190, 1, 0, 0, 0, 9190, 9191, 3, 1304, 652, 0, 9191, 9192, 5, 3, 0, 0, 9192, 9279, 1, 0, 0, 0, 9193, 9194, 5, 401, 0, 0, 9194, 9195, 5, 2, 0, 0, 9195, 9196, 3, 1162, 581, 0, 9196, 9197, 5, 6, 0, 0, 9197, 9198, 3, 1162, 581, 0, 9198, 9199, 5, 3, 0, 0, 9199, 9279, 1, 0, 0, 0, 9200, 9201, 5, 386, 0, 0, 9201, 9202, 5, 2, 0, 0, 9202, 9203, 3, 1280, 640, 0, 9203, 9204, 5, 3, 0, 0, 9204, 9279, 1, 0, 0, 0, 9205, 9206, 5, 392, 0, 0, 9206, 9207, 5, 2, 0, 0, 9207, 9208, 3, 1280, 640, 0, 9208, 9209, 5, 3, 0, 0, 9209, 9279, 1, 0, 0, 0, 9210, 9211, 5, 397, 0, 0, 9211, 9212, 5, 2, 0, 0, 9212, 9213, 3, 1280, 640, 0, 9213, 9214, 5, 3, 0, 0, 9214, 9279, 1, 0, 0, 0, 9215, 9216, 5, 425, 0, 0, 9216, 9217, 5, 2, 0, 0, 9217, 9218, 3, 1280, 640, 0, 9218, 9219, 5, 3, 0, 0, 9219, 9279, 1, 0, 0, 0, 9220, 9221, 5, 426, 0, 0, 9221, 9222, 5, 2, 0, 0, 9222, 9223, 5, 259, 0, 0, 9223, 9229, 3, 1380, 690, 0, 9224, 9227, 5, 6, 0, 0, 9225, 9228, 3, 1222, 611, 0, 9226, 9228, 3, 1280, 640, 0, 9227, 9225, 1, 0, 0, 0, 9227, 9226, 1, 0, 0, 0, 9228, 9230, 1, 0, 0, 0, 9229, 9224, 1, 0, 0, 0, 9229, 9230, 1, 0, 0, 0, 9230, 9231, 1, 0, 0, 0, 9231, 9232, 5, 3, 0, 0, 9232, 9279, 1, 0, 0, 0, 9233, 9234, 5, 427, 0, 0, 9234, 9235, 5, 2, 0, 0, 9235, 9236, 3, 1206, 603, 0, 9236, 9237, 3, 1232, 616, 0, 9237, 9238, 5, 3, 0, 0, 9238, 9279, 1, 0, 0, 0, 9239, 9240, 5, 428, 0, 0, 9240, 9241, 5, 2, 0, 0, 9241, 9242, 3, 1224, 612, 0, 9242, 9243, 5, 3, 0, 0, 9243, 9279, 1, 0, 0, 0, 9244, 9245, 5, 429, 0, 0, 9245, 9246, 5, 2, 0, 0, 9246, 9247, 3, 1228, 614, 0, 9247, 9248, 3, 1162, 581, 0, 9248, 9249, 3, 1230, 615, 0, 9249, 9250, 5, 3, 0, 0, 9250, 9279, 1, 0, 0, 0, 9251, 9252, 5, 430, 0, 0, 9252, 9253, 5, 2, 0, 0, 9253, 9254, 5, 259, 0, 0, 9254, 9257, 3, 1380, 690, 0, 9255, 9256, 5, 6, 0, 0, 9256, 9258, 3, 1162, 581, 0, 9257, 9255, 1, 0, 0, 0, 9257, 9258, 1, 0, 0, 0, 9258, 9259, 1, 0, 0, 0, 9259, 9260, 5, 3, 0, 0, 9260, 9279, 1, 0, 0, 0, 9261, 9262, 5, 431, 0, 0, 9262, 9263, 5, 2, 0, 0, 9263, 9264, 5, 376, 0, 0, 9264, 9265, 3, 1162, 581, 0, 9265, 9266, 5, 6, 0, 0, 9266, 9267, 3, 1218, 609, 0, 9267, 9268, 3, 1220, 610, 0, 9268, 9269, 5, 3, 0, 0, 9269, 9279, 1, 0, 0, 0, 9270, 9271, 5, 432, 0, 0, 9271, 9272, 5, 2, 0, 0, 9272, 9273, 3, 1228, 614, 0, 9273, 9274, 3, 1162, 581, 0, 9274, 9275, 5, 36, 0, 0, 9275, 9276, 3, 1122, 561, 0, 9276, 9277, 5, 3, 0, 0, 9277, 9279, 1, 0, 0, 0, 9278, 9101, 1, 0, 0, 0, 9278, 9107, 1, 0, 0, 0, 9278, 9108, 1, 0, 0, 0, 9278, 9115, 1, 0, 0, 0, 9278, 9122, 1, 0, 0, 0, 9278, 9129, 1, 0, 0, 0, 9278, 9136, 1, 0, 0, 0, 9278, 9137, 1, 0, 0, 0, 9278, 9138, 1, 0, 0, 0, 9278, 9139, 1, 0, 0, 0, 9278, 9140, 1, 0, 0, 0, 9278, 9141, 1, 0, 0, 0, 9278, 9142, 1, 0, 0, 0, 9278, 9149, 1, 0, 0, 0, 9278, 9154, 1, 0, 0, 0, 9278, 9163, 1, 0, 0, 0, 9278, 9168, 1, 0, 0, 0, 9278, 9173, 1, 0, 0, 0, 9278, 9178, 1, 0, 0, 0, 9278, 9185, 1, 0, 0, 0, 9278, 9193, 1, 0, 0, 0, 9278, 9200, 1, 0, 0, 0, 9278, 9205, 1, 0, 0, 0, 9278, 9210, 1, 0, 0, 0, 9278, 9215, 1, 0, 0, 0, 9278, 9220, 1, 0, 0, 0, 9278, 9233, 1, 0, 0, 0, 9278, 9239, 1, 0, 0, 0, 9278, 9244, 1, 0, 0, 0, 9278, 9251, 1, 0, 0, 0, 9278, 9261, 1, 0, 0, 0, 9278, 9270, 1, 0, 0, 0, 9279, 1217, 1, 0, 0, 0, 9280, 9281, 5, 368, 0, 0, 9281, 9286, 3, 1162, 581, 0, 9282, 9283, 5, 368, 0, 0, 9283, 9284, 5, 262, 0, 0, 9284, 9286, 5, 450, 0, 0, 9285, 9280, 1, 0, 0, 0, 9285, 9282, 1, 0, 0, 0, 9286, 1219, 1, 0, 0, 0, 9287, 9288, 5, 6, 0, 0, 9288, 9289, 5, 332, 0, 0, 9289, 9299, 5, 378, 0, 0, 9290, 9291, 5, 6, 0, 0, 9291, 9292, 5, 332, 0, 0, 9292, 9299, 5, 262, 0, 0, 9293, 9294, 5, 6, 0, 0, 9294, 9295, 5, 332, 0, 0, 9295, 9296, 5, 262, 0, 0, 9296, 9299, 5, 450, 0, 0, 9297, 9299, 1, 0, 0, 0, 9298, 9287, 1, 0, 0, 0, 9298, 9290, 1, 0, 0, 0, 9298, 9293, 1, 0, 0, 0, 9298, 9297, 1, 0, 0, 0, 9299, 1221, 1, 0, 0, 0, 9300, 9301, 5, 417, 0, 0, 9301, 9302, 5, 2, 0, 0, 9302, 9303, 3, 1224, 612, 0, 9303, 9304, 5, 3, 0, 0, 9304, 1223, 1, 0, 0, 0, 9305, 9310, 3, 1226, 613, 0, 9306, 9307, 5, 6, 0, 0, 9307, 9309, 3, 1226, 613, 0, 9308, 9306, 1, 0, 0, 0, 9309, 9312, 1, 0, 0, 0, 9310, 9308, 1, 0, 0, 0, 9310, 9311, 1, 0, 0, 0, 9311, 1225, 1, 0, 0, 0, 9312, 9310, 1, 0, 0, 0, 9313, 9316, 3, 1162, 581, 0, 9314, 9315, 5, 36, 0, 0, 9315, 9317, 3, 1380, 690, 0, 9316, 9314, 1, 0, 0, 0, 9316, 9317, 1, 0, 0, 0, 9317, 1227, 1, 0, 0, 0, 9318, 9319, 7, 53, 0, 0, 9319, 1229, 1, 0, 0, 0, 9320, 9321, 5, 285, 0, 0, 9321, 9326, 5, 371, 0, 0, 9322, 9323, 5, 340, 0, 0, 9323, 9326, 5, 371, 0, 0, 9324, 9326, 1, 0, 0, 0, 9325, 9320, 1, 0, 0, 0, 9325, 9322, 1, 0, 0, 0, 9325, 9324, 1, 0, 0, 0, 9326, 1231, 1, 0, 0, 0, 9327, 9328, 5, 279, 0, 0, 9328, 9343, 3, 1206, 603, 0, 9329, 9330, 5, 279, 0, 0, 9330, 9331, 3, 1206, 603, 0, 9331, 9332, 3, 1234, 617, 0, 9332, 9343, 1, 0, 0, 0, 9333, 9334, 5, 279, 0, 0, 9334, 9335, 3, 1234, 617, 0, 9335, 9336, 3, 1206, 603, 0, 9336, 9343, 1, 0, 0, 0, 9337, 9338, 5, 279, 0, 0, 9338, 9339, 3, 1234, 617, 0, 9339, 9340, 3, 1206, 603, 0, 9340, 9341, 3, 1234, 617, 0, 9341, 9343, 1, 0, 0, 0, 9342, 9327, 1, 0, 0, 0, 9342, 9329, 1, 0, 0, 0, 9342, 9333, 1, 0, 0, 0, 9342, 9337, 1, 0, 0, 0, 9343, 1233, 1, 0, 0, 0, 9344, 9345, 5, 147, 0, 0, 9345, 9346, 7, 54, 0, 0, 9346, 1235, 1, 0, 0, 0, 9347, 9348, 5, 479, 0, 0, 9348, 9349, 5, 66, 0, 0, 9349, 9350, 5, 2, 0, 0, 9350, 9351, 3, 998, 499, 0, 9351, 9352, 5, 3, 0, 0, 9352, 9355, 1, 0, 0, 0, 9353, 9355, 1, 0, 0, 0, 9354, 9347, 1, 0, 0, 0, 9354, 9353, 1, 0, 0, 0, 9355, 1237, 1, 0, 0, 0, 9356, 9357, 5, 480, 0, 0, 9357, 9358, 5, 2, 0, 0, 9358, 9359, 5, 103, 0, 0, 9359, 9360, 3, 1162, 581, 0, 9360, 9361, 5, 3, 0, 0, 9361, 9364, 1, 0, 0, 0, 9362, 9364, 1, 0, 0, 0, 9363, 9356, 1, 0, 0, 0, 9363, 9362, 1, 0, 0, 0, 9364, 1239, 1, 0, 0, 0, 9365, 9366, 5, 104, 0, 0, 9366, 9369, 3, 1242, 621, 0, 9367, 9369, 1, 0, 0, 0, 9368, 9365, 1, 0, 0, 0, 9368, 9367, 1, 0, 0, 0, 9369, 1241, 1, 0, 0, 0, 9370, 9375, 3, 1244, 622, 0, 9371, 9372, 5, 6, 0, 0, 9372, 9374, 3, 1244, 622, 0, 9373, 9371, 1, 0, 0, 0, 9374, 9377, 1, 0, 0, 0, 9375, 9373, 1, 0, 0, 0, 9375, 9376, 1, 0, 0, 0, 9376, 1243, 1, 0, 0, 0, 9377, 9375, 1, 0, 0, 0, 9378, 9379, 3, 1372, 686, 0, 9379, 9380, 5, 36, 0, 0, 9380, 9381, 3, 1248, 624, 0, 9381, 1245, 1, 0, 0, 0, 9382, 9385, 5, 124, 0, 0, 9383, 9386, 3, 1248, 624, 0, 9384, 9386, 3, 1372, 686, 0, 9385, 9383, 1, 0, 0, 0, 9385, 9384, 1, 0, 0, 0, 9386, 9389, 1, 0, 0, 0, 9387, 9389, 1, 0, 0, 0, 9388, 9382, 1, 0, 0, 0, 9388, 9387, 1, 0, 0, 0, 9389, 1247, 1, 0, 0, 0, 9390, 9391, 5, 2, 0, 0, 9391, 9392, 3, 1250, 625, 0, 9392, 9393, 3, 1252, 626, 0, 9393, 9394, 3, 996, 498, 0, 9394, 9395, 3, 1254, 627, 0, 9395, 9396, 5, 3, 0, 0, 9396, 1249, 1, 0, 0, 0, 9397, 9400, 3, 1372, 686, 0, 9398, 9400, 1, 0, 0, 0, 9399, 9397, 1, 0, 0, 0, 9399, 9398, 1, 0, 0, 0, 9400, 1251, 1, 0, 0, 0, 9401, 9402, 5, 278, 0, 0, 9402, 9403, 5, 147, 0, 0, 9403, 9406, 3, 1280, 640, 0, 9404, 9406, 1, 0, 0, 0, 9405, 9401, 1, 0, 0, 0, 9405, 9404, 1, 0, 0, 0, 9406, 1253, 1, 0, 0, 0, 9407, 9408, 5, 292, 0, 0, 9408, 9409, 3, 1256, 628, 0, 9409, 9410, 3, 1260, 630, 0, 9410, 9421, 1, 0, 0, 0, 9411, 9412, 5, 313, 0, 0, 9412, 9413, 3, 1256, 628, 0, 9413, 9414, 3, 1260, 630, 0, 9414, 9421, 1, 0, 0, 0, 9415, 9416, 5, 481, 0, 0, 9416, 9417, 3, 1256, 628, 0, 9417, 9418, 3, 1260, 630, 0, 9418, 9421, 1, 0, 0, 0, 9419, 9421, 1, 0, 0, 0, 9420, 9407, 1, 0, 0, 0, 9420, 9411, 1, 0, 0, 0, 9420, 9415, 1, 0, 0, 0, 9420, 9419, 1, 0, 0, 0, 9421, 1255, 1, 0, 0, 0, 9422, 9429, 3, 1258, 629, 0, 9423, 9424, 5, 380, 0, 0, 9424, 9425, 3, 1258, 629, 0, 9425, 9426, 5, 33, 0, 0, 9426, 9427, 3, 1258, 629, 0, 9427, 9429, 1, 0, 0, 0, 9428, 9422, 1, 0, 0, 0, 9428, 9423, 1, 0, 0, 0, 9429, 1257, 1, 0, 0, 0, 9430, 9431, 5, 355, 0, 0, 9431, 9438, 7, 55, 0, 0, 9432, 9433, 5, 434, 0, 0, 9433, 9438, 5, 407, 0, 0, 9434, 9435, 3, 1162, 581, 0, 9435, 9436, 7, 55, 0, 0, 9436, 9438, 1, 0, 0, 0, 9437, 9430, 1, 0, 0, 0, 9437, 9432, 1, 0, 0, 0, 9437, 9434, 1, 0, 0, 0, 9438, 1259, 1, 0, 0, 0, 9439, 9446, 5, 199, 0, 0, 9440, 9441, 5, 434, 0, 0, 9441, 9447, 5, 407, 0, 0, 9442, 9447, 5, 66, 0, 0, 9443, 9447, 5, 467, 0, 0, 9444, 9445, 5, 262, 0, 0, 9445, 9447, 5, 482, 0, 0, 9446, 9440, 1, 0, 0, 0, 9446, 9442, 1, 0, 0, 0, 9446, 9443, 1, 0, 0, 0, 9446, 9444, 1, 0, 0, 0, 9447, 9450, 1, 0, 0, 0, 9448, 9450, 1, 0, 0, 0, 9449, 9439, 1, 0, 0, 0, 9449, 9448, 1, 0, 0, 0, 9450, 1261, 1, 0, 0, 0, 9451, 9452, 5, 407, 0, 0, 9452, 9454, 5, 2, 0, 0, 9453, 9455, 3, 1280, 640, 0, 9454, 9453, 1, 0, 0, 0, 9454, 9455, 1, 0, 0, 0, 9455, 9456, 1, 0, 0, 0, 9456, 9464, 5, 3, 0, 0, 9457, 9458, 5, 2, 0, 0, 9458, 9459, 3, 1280, 640, 0, 9459, 9460, 5, 6, 0, 0, 9460, 9461, 3, 1162, 581, 0, 9461, 9462, 5, 3, 0, 0, 9462, 9464, 1, 0, 0, 0, 9463, 9451, 1, 0, 0, 0, 9463, 9457, 1, 0, 0, 0, 9464, 1263, 1, 0, 0, 0, 9465, 9466, 5, 407, 0, 0, 9466, 9468, 5, 2, 0, 0, 9467, 9469, 3, 1280, 640, 0, 9468, 9467, 1, 0, 0, 0, 9468, 9469, 1, 0, 0, 0, 9469, 9470, 1, 0, 0, 0, 9470, 9471, 5, 3, 0, 0, 9471, 1265, 1, 0, 0, 0, 9472, 9473, 5, 2, 0, 0, 9473, 9474, 3, 1280, 640, 0, 9474, 9475, 5, 6, 0, 0, 9475, 9476, 3, 1162, 581, 0, 9476, 9477, 5, 3, 0, 0, 9477, 1267, 1, 0, 0, 0, 9478, 9479, 7, 56, 0, 0, 9479, 1269, 1, 0, 0, 0, 9480, 9483, 5, 29, 0, 0, 9481, 9483, 3, 1272, 636, 0, 9482, 9480, 1, 0, 0, 0, 9482, 9481, 1, 0, 0, 0, 9483, 1271, 1, 0, 0, 0, 9484, 9485, 7, 57, 0, 0, 9485, 1273, 1, 0, 0, 0, 9486, 9493, 5, 29, 0, 0, 9487, 9488, 5, 271, 0, 0, 9488, 9489, 5, 2, 0, 0, 9489, 9490, 3, 684, 342, 0, 9490, 9491, 5, 3, 0, 0, 9491, 9493, 1, 0, 0, 0, 9492, 9486, 1, 0, 0, 0, 9492, 9487, 1, 0, 0, 0, 9493, 1275, 1, 0, 0, 0, 9494, 9501, 3, 1270, 635, 0, 9495, 9496, 5, 271, 0, 0, 9496, 9497, 5, 2, 0, 0, 9497, 9498, 3, 684, 342, 0, 9498, 9499, 5, 3, 0, 0, 9499, 9501, 1, 0, 0, 0, 9500, 9494, 1, 0, 0, 0, 9500, 9495, 1, 0, 0, 0, 9501, 1277, 1, 0, 0, 0, 9502, 9515, 3, 1270, 635, 0, 9503, 9504, 5, 271, 0, 0, 9504, 9505, 5, 2, 0, 0, 9505, 9506, 3, 684, 342, 0, 9506, 9507, 5, 3, 0, 0, 9507, 9515, 1, 0, 0, 0, 9508, 9515, 5, 120, 0, 0, 9509, 9510, 5, 77, 0, 0, 9510, 9515, 5, 120, 0, 0, 9511, 9515, 5, 114, 0, 0, 9512, 9513, 5, 77, 0, 0, 9513, 9515, 5, 114, 0, 0, 9514, 9502, 1, 0, 0, 0, 9514, 9503, 1, 0, 0, 0, 9514, 9508, 1, 0, 0, 0, 9514, 9509, 1, 0, 0, 0, 9514, 9511, 1, 0, 0, 0, 9514, 9512, 1, 0, 0, 0, 9515, 1279, 1, 0, 0, 0, 9516, 9521, 3, 1162, 581, 0, 9517, 9518, 5, 6, 0, 0, 9518, 9520, 3, 1162, 581, 0, 9519, 9517, 1, 0, 0, 0, 9520, 9523, 1, 0, 0, 0, 9521, 9519, 1, 0, 0, 0, 9521, 9522, 1, 0, 0, 0, 9522, 1281, 1, 0, 0, 0, 9523, 9521, 1, 0, 0, 0, 9524, 9529, 3, 1284, 642, 0, 9525, 9526, 5, 6, 0, 0, 9526, 9528, 3, 1284, 642, 0, 9527, 9525, 1, 0, 0, 0, 9528, 9531, 1, 0, 0, 0, 9529, 9527, 1, 0, 0, 0, 9529, 9530, 1, 0, 0, 0, 9530, 1283, 1, 0, 0, 0, 9531, 9529, 1, 0, 0, 0, 9532, 9538, 3, 1162, 581, 0, 9533, 9534, 3, 636, 318, 0, 9534, 9535, 7, 58, 0, 0, 9535, 9536, 3, 1162, 581, 0, 9536, 9538, 1, 0, 0, 0, 9537, 9532, 1, 0, 0, 0, 9537, 9533, 1, 0, 0, 0, 9538, 1285, 1, 0, 0, 0, 9539, 9544, 3, 1118, 559, 0, 9540, 9541, 5, 6, 0, 0, 9541, 9543, 3, 1118, 559, 0, 9542, 9540, 1, 0, 0, 0, 9543, 9546, 1, 0, 0, 0, 9544, 9542, 1, 0, 0, 0, 9544, 9545, 1, 0, 0, 0, 9545, 1287, 1, 0, 0, 0, 9546, 9544, 1, 0, 0, 0, 9547, 9550, 5, 4, 0, 0, 9548, 9551, 3, 1280, 640, 0, 9549, 9551, 3, 1290, 645, 0, 9550, 9548, 1, 0, 0, 0, 9550, 9549, 1, 0, 0, 0, 9550, 9551, 1, 0, 0, 0, 9551, 9552, 1, 0, 0, 0, 9552, 9553, 5, 5, 0, 0, 9553, 1289, 1, 0, 0, 0, 9554, 9559, 3, 1288, 644, 0, 9555, 9556, 5, 6, 0, 0, 9556, 9558, 3, 1288, 644, 0, 9557, 9555, 1, 0, 0, 0, 9558, 9561, 1, 0, 0, 0, 9559, 9557, 1, 0, 0, 0, 9559, 9560, 1, 0, 0, 0, 9560, 1291, 1, 0, 0, 0, 9561, 9559, 1, 0, 0, 0, 9562, 9563, 3, 1294, 647, 0, 9563, 9564, 5, 64, 0, 0, 9564, 9565, 3, 1162, 581, 0, 9565, 9568, 1, 0, 0, 0, 9566, 9568, 1, 0, 0, 0, 9567, 9562, 1, 0, 0, 0, 9567, 9566, 1, 0, 0, 0, 9568, 1293, 1, 0, 0, 0, 9569, 9578, 3, 1382, 691, 0, 9570, 9578, 5, 377, 0, 0, 9571, 9578, 5, 257, 0, 0, 9572, 9578, 5, 176, 0, 0, 9573, 9578, 5, 218, 0, 0, 9574, 9578, 5, 254, 0, 0, 9575, 9578, 5, 319, 0, 0, 9576, 9578, 3, 1358, 679, 0, 9577, 9569, 1, 0, 0, 0, 9577, 9570, 1, 0, 0, 0, 9577, 9571, 1, 0, 0, 0, 9577, 9572, 1, 0, 0, 0, 9577, 9573, 1, 0, 0, 0, 9577, 9574, 1, 0, 0, 0, 9577, 9575, 1, 0, 0, 0, 9577, 9576, 1, 0, 0, 0, 9578, 1295, 1, 0, 0, 0, 9579, 9580, 7, 59, 0, 0, 9580, 1297, 1, 0, 0, 0, 9581, 9582, 3, 1162, 581, 0, 9582, 9583, 5, 84, 0, 0, 9583, 9584, 3, 1162, 581, 0, 9584, 9585, 5, 64, 0, 0, 9585, 9588, 3, 1162, 581, 0, 9586, 9587, 5, 62, 0, 0, 9587, 9589, 3, 1162, 581, 0, 9588, 9586, 1, 0, 0, 0, 9588, 9589, 1, 0, 0, 0, 9589, 1299, 1, 0, 0, 0, 9590, 9591, 3, 1204, 602, 0, 9591, 9592, 5, 68, 0, 0, 9592, 9593, 3, 1204, 602, 0, 9593, 9596, 1, 0, 0, 0, 9594, 9596, 1, 0, 0, 0, 9595, 9590, 1, 0, 0, 0, 9595, 9594, 1, 0, 0, 0, 9596, 1301, 1, 0, 0, 0, 9597, 9598, 3, 1162, 581, 0, 9598, 9599, 5, 64, 0, 0, 9599, 9600, 3, 1162, 581, 0, 9600, 9601, 5, 62, 0, 0, 9601, 9602, 3, 1162, 581, 0, 9602, 9625, 1, 0, 0, 0, 9603, 9604, 3, 1162, 581, 0, 9604, 9605, 5, 62, 0, 0, 9605, 9606, 3, 1162, 581, 0, 9606, 9607, 5, 64, 0, 0, 9607, 9608, 3, 1162, 581, 0, 9608, 9625, 1, 0, 0, 0, 9609, 9610, 3, 1162, 581, 0, 9610, 9611, 5, 64, 0, 0, 9611, 9612, 3, 1162, 581, 0, 9612, 9625, 1, 0, 0, 0, 9613, 9614, 3, 1162, 581, 0, 9614, 9615, 5, 62, 0, 0, 9615, 9616, 3, 1162, 581, 0, 9616, 9625, 1, 0, 0, 0, 9617, 9618, 3, 1162, 581, 0, 9618, 9619, 5, 127, 0, 0, 9619, 9620, 3, 1162, 581, 0, 9620, 9621, 5, 197, 0, 0, 9621, 9622, 3, 1162, 581, 0, 9622, 9625, 1, 0, 0, 0, 9623, 9625, 3, 1280, 640, 0, 9624, 9597, 1, 0, 0, 0, 9624, 9603, 1, 0, 0, 0, 9624, 9609, 1, 0, 0, 0, 9624, 9613, 1, 0, 0, 0, 9624, 9617, 1, 0, 0, 0, 9624, 9623, 1, 0, 0, 0, 9625, 1303, 1, 0, 0, 0, 9626, 9627, 3, 1162, 581, 0, 9627, 9628, 5, 64, 0, 0, 9628, 9629, 3, 1280, 640, 0, 9629, 9634, 1, 0, 0, 0, 9630, 9631, 5, 64, 0, 0, 9631, 9634, 3, 1280, 640, 0, 9632, 9634, 3, 1280, 640, 0, 9633, 9626, 1, 0, 0, 0, 9633, 9630, 1, 0, 0, 0, 9633, 9632, 1, 0, 0, 0, 9634, 1305, 1, 0, 0, 0, 9635, 9641, 3, 962, 481, 0, 9636, 9637, 5, 2, 0, 0, 9637, 9638, 3, 1280, 640, 0, 9638, 9639, 5, 3, 0, 0, 9639, 9641, 1, 0, 0, 0, 9640, 9635, 1, 0, 0, 0, 9640, 9636, 1, 0, 0, 0, 9641, 1307, 1, 0, 0, 0, 9642, 9643, 5, 40, 0, 0, 9643, 9644, 3, 1316, 658, 0, 9644, 9645, 3, 1310, 655, 0, 9645, 9646, 3, 1314, 657, 0, 9646, 9647, 5, 454, 0, 0, 9647, 1309, 1, 0, 0, 0, 9648, 9650, 3, 1312, 656, 0, 9649, 9648, 1, 0, 0, 0, 9650, 9651, 1, 0, 0, 0, 9651, 9649, 1, 0, 0, 0, 9651, 9652, 1, 0, 0, 0, 9652, 1311, 1, 0, 0, 0, 9653, 9654, 5, 102, 0, 0, 9654, 9655, 3, 1162, 581, 0, 9655, 9656, 5, 93, 0, 0, 9656, 9657, 3, 1162, 581, 0, 9657, 1313, 1, 0, 0, 0, 9658, 9659, 5, 58, 0, 0, 9659, 9662, 3, 1162, 581, 0, 9660, 9662, 1, 0, 0, 0, 9661, 9658, 1, 0, 0, 0, 9661, 9660, 1, 0, 0, 0, 9662, 1315, 1, 0, 0, 0, 9663, 9666, 3, 1162, 581, 0, 9664, 9666, 1, 0, 0, 0, 9665, 9663, 1, 0, 0, 0, 9665, 9664, 1, 0, 0, 0, 9666, 1317, 1, 0, 0, 0, 9667, 9669, 3, 1372, 686, 0, 9668, 9670, 3, 1324, 662, 0, 9669, 9668, 1, 0, 0, 0, 9669, 9670, 1, 0, 0, 0, 9670, 1319, 1, 0, 0, 0, 9671, 9674, 5, 11, 0, 0, 9672, 9675, 3, 1342, 671, 0, 9673, 9675, 5, 9, 0, 0, 9674, 9672, 1, 0, 0, 0, 9674, 9673, 1, 0, 0, 0, 9675, 9687, 1, 0, 0, 0, 9676, 9682, 5, 4, 0, 0, 9677, 9683, 3, 1162, 581, 0, 9678, 9679, 3, 1322, 661, 0, 9679, 9680, 5, 8, 0, 0, 9680, 9681, 3, 1322, 661, 0, 9681, 9683, 1, 0, 0, 0, 9682, 9677, 1, 0, 0, 0, 9682, 9678, 1, 0, 0, 0, 9683, 9684, 1, 0, 0, 0, 9684, 9685, 5, 5, 0, 0, 9685, 9687, 1, 0, 0, 0, 9686, 9671, 1, 0, 0, 0, 9686, 9676, 1, 0, 0, 0, 9687, 1321, 1, 0, 0, 0, 9688, 9691, 3, 1162, 581, 0, 9689, 9691, 1, 0, 0, 0, 9690, 9688, 1, 0, 0, 0, 9690, 9689, 1, 0, 0, 0, 9691, 1323, 1, 0, 0, 0, 9692, 9694, 3, 1320, 660, 0, 9693, 9692, 1, 0, 0, 0, 9694, 9695, 1, 0, 0, 0, 9695, 9693, 1, 0, 0, 0, 9695, 9696, 1, 0, 0, 0, 9696, 1325, 1, 0, 0, 0, 9697, 9699, 3, 1320, 660, 0, 9698, 9697, 1, 0, 0, 0, 9699, 9702, 1, 0, 0, 0, 9700, 9698, 1, 0, 0, 0, 9700, 9701, 1, 0, 0, 0, 9701, 1327, 1, 0, 0, 0, 9702, 9700, 1, 0, 0, 0, 9703, 9706, 3, 1330, 665, 0, 9704, 9706, 1, 0, 0, 0, 9705, 9703, 1, 0, 0, 0, 9705, 9704, 1, 0, 0, 0, 9706, 1329, 1, 0, 0, 0, 9707, 9712, 3, 1332, 666, 0, 9708, 9709, 5, 6, 0, 0, 9709, 9711, 3, 1332, 666, 0, 9710, 9708, 1, 0, 0, 0, 9711, 9714, 1, 0, 0, 0, 9712, 9710, 1, 0, 0, 0, 9712, 9713, 1, 0, 0, 0, 9713, 1331, 1, 0, 0, 0, 9714, 9712, 1, 0, 0, 0, 9715, 9720, 3, 1162, 581, 0, 9716, 9717, 5, 36, 0, 0, 9717, 9721, 3, 1380, 690, 0, 9718, 9721, 3, 1382, 691, 0, 9719, 9721, 1, 0, 0, 0, 9720, 9716, 1, 0, 0, 0, 9720, 9718, 1, 0, 0, 0, 9720, 9719, 1, 0, 0, 0, 9721, 9724, 1, 0, 0, 0, 9722, 9724, 5, 9, 0, 0, 9723, 9715, 1, 0, 0, 0, 9723, 9722, 1, 0, 0, 0, 9724, 1333, 1, 0, 0, 0, 9725, 9730, 3, 1336, 668, 0, 9726, 9727, 5, 6, 0, 0, 9727, 9729, 3, 1336, 668, 0, 9728, 9726, 1, 0, 0, 0, 9729, 9732, 1, 0, 0, 0, 9730, 9728, 1, 0, 0, 0, 9730, 9731, 1, 0, 0, 0, 9731, 1335, 1, 0, 0, 0, 9732, 9730, 1, 0, 0, 0, 9733, 9735, 3, 1372, 686, 0, 9734, 9736, 3, 1324, 662, 0, 9735, 9734, 1, 0, 0, 0, 9735, 9736, 1, 0, 0, 0, 9736, 1337, 1, 0, 0, 0, 9737, 9742, 3, 1340, 670, 0, 9738, 9739, 5, 6, 0, 0, 9739, 9741, 3, 1340, 670, 0, 9740, 9738, 1, 0, 0, 0, 9741, 9744, 1, 0, 0, 0, 9742, 9740, 1, 0, 0, 0, 9742, 9743, 1, 0, 0, 0, 9743, 1339, 1, 0, 0, 0, 9744, 9742, 1, 0, 0, 0, 9745, 9746, 3, 1372, 686, 0, 9746, 1341, 1, 0, 0, 0, 9747, 9748, 3, 1380, 690, 0, 9748, 1343, 1, 0, 0, 0, 9749, 9750, 3, 1358, 679, 0, 9750, 1345, 1, 0, 0, 0, 9751, 9759, 3, 1394, 697, 0, 9752, 9759, 3, 1376, 688, 0, 9753, 9754, 3, 1372, 686, 0, 9754, 9755, 3, 1324, 662, 0, 9755, 9759, 1, 0, 0, 0, 9756, 9759, 5, 119, 0, 0, 9757, 9759, 5, 126, 0, 0, 9758, 9751, 1, 0, 0, 0, 9758, 9752, 1, 0, 0, 0, 9758, 9753, 1, 0, 0, 0, 9758, 9756, 1, 0, 0, 0, 9758, 9757, 1, 0, 0, 0, 9759, 1347, 1, 0, 0, 0, 9760, 9793, 3, 1356, 678, 0, 9761, 9793, 3, 1354, 677, 0, 9762, 9793, 3, 1358, 679, 0, 9763, 9793, 3, 1352, 676, 0, 9764, 9793, 3, 1350, 675, 0, 9765, 9773, 3, 1346, 673, 0, 9766, 9774, 3, 1358, 679, 0, 9767, 9768, 5, 2, 0, 0, 9768, 9769, 3, 1282, 641, 0, 9769, 9770, 3, 996, 498, 0, 9770, 9771, 5, 3, 0, 0, 9771, 9772, 3, 1358, 679, 0, 9772, 9774, 1, 0, 0, 0, 9773, 9766, 1, 0, 0, 0, 9773, 9767, 1, 0, 0, 0, 9774, 9793, 1, 0, 0, 0, 9775, 9776, 3, 1124, 562, 0, 9776, 9777, 3, 1358, 679, 0, 9777, 9793, 1, 0, 0, 0, 9778, 9787, 3, 1152, 576, 0, 9779, 9780, 3, 1358, 679, 0, 9780, 9781, 3, 1156, 578, 0, 9781, 9788, 1, 0, 0, 0, 9782, 9783, 5, 2, 0, 0, 9783, 9784, 3, 1356, 678, 0, 9784, 9785, 5, 3, 0, 0, 9785, 9786, 3, 1358, 679, 0, 9786, 9788, 1, 0, 0, 0, 9787, 9779, 1, 0, 0, 0, 9787, 9782, 1, 0, 0, 0, 9788, 9793, 1, 0, 0, 0, 9789, 9793, 5, 96, 0, 0, 9790, 9793, 5, 60, 0, 0, 9791, 9793, 5, 78, 0, 0, 9792, 9760, 1, 0, 0, 0, 9792, 9761, 1, 0, 0, 0, 9792, 9762, 1, 0, 0, 0, 9792, 9763, 1, 0, 0, 0, 9792, 9764, 1, 0, 0, 0, 9792, 9765, 1, 0, 0, 0, 9792, 9775, 1, 0, 0, 0, 9792, 9778, 1, 0, 0, 0, 9792, 9789, 1, 0, 0, 0, 9792, 9790, 1, 0, 0, 0, 9792, 9791, 1, 0, 0, 0, 9793, 1349, 1, 0, 0, 0, 9794, 9795, 5, 654, 0, 0, 9795, 1351, 1, 0, 0, 0, 9796, 9797, 5, 650, 0, 0, 9797, 1353, 1, 0, 0, 0, 9798, 9799, 5, 660, 0, 0, 9799, 1355, 1, 0, 0, 0, 9800, 9801, 5, 658, 0, 0, 9801, 1357, 1, 0, 0, 0, 9802, 9803, 3, 1360, 680, 0, 9803, 9804, 3, 1362, 681, 0, 9804, 1359, 1, 0, 0, 0, 9805, 9817, 5, 645, 0, 0, 9806, 9817, 5, 647, 0, 0, 9807, 9811, 5, 649, 0, 0, 9808, 9810, 5, 677, 0, 0, 9809, 9808, 1, 0, 0, 0, 9810, 9813, 1, 0, 0, 0, 9811, 9809, 1, 0, 0, 0, 9811, 9812, 1, 0, 0, 0, 9812, 9814, 1, 0, 0, 0, 9813, 9811, 1, 0, 0, 0, 9814, 9817, 5, 678, 0, 0, 9815, 9817, 5, 671, 0, 0, 9816, 9805, 1, 0, 0, 0, 9816, 9806, 1, 0, 0, 0, 9816, 9807, 1, 0, 0, 0, 9816, 9815, 1, 0, 0, 0, 9817, 1361, 1, 0, 0, 0, 9818, 9819, 5, 487, 0, 0, 9819, 9822, 3, 1360, 680, 0, 9820, 9822, 1, 0, 0, 0, 9821, 9818, 1, 0, 0, 0, 9821, 9820, 1, 0, 0, 0, 9822, 1363, 1, 0, 0, 0, 9823, 9829, 3, 1356, 678, 0, 9824, 9825, 5, 12, 0, 0, 9825, 9829, 3, 1356, 678, 0, 9826, 9827, 5, 13, 0, 0, 9827, 9829, 3, 1356, 678, 0, 9828, 9823, 1, 0, 0, 0, 9828, 9824, 1, 0, 0, 0, 9828, 9826, 1, 0, 0, 0, 9829, 1365, 1, 0, 0, 0, 9830, 9831, 3, 1368, 684, 0, 9831, 1367, 1, 0, 0, 0, 9832, 9836, 3, 1378, 689, 0, 9833, 9836, 5, 52, 0, 0, 9834, 9836, 5, 89, 0, 0, 9835, 9832, 1, 0, 0, 0, 9835, 9833, 1, 0, 0, 0, 9835, 9834, 1, 0, 0, 0, 9836, 1369, 1, 0, 0, 0, 9837, 9842, 3, 1368, 684, 0, 9838, 9839, 5, 6, 0, 0, 9839, 9841, 3, 1368, 684, 0, 9840, 9838, 1, 0, 0, 0, 9841, 9844, 1, 0, 0, 0, 9842, 9840, 1, 0, 0, 0, 9842, 9843, 1, 0, 0, 0, 9843, 1371, 1, 0, 0, 0, 9844, 9842, 1, 0, 0, 0, 9845, 9852, 3, 1382, 691, 0, 9846, 9852, 3, 1386, 693, 0, 9847, 9852, 3, 1388, 694, 0, 9848, 9852, 3, 1608, 804, 0, 9849, 9852, 5, 119, 0, 0, 9850, 9852, 5, 126, 0, 0, 9851, 9845, 1, 0, 0, 0, 9851, 9846, 1, 0, 0, 0, 9851, 9847, 1, 0, 0, 0, 9851, 9848, 1, 0, 0, 0, 9851, 9849, 1, 0, 0, 0, 9851, 9850, 1, 0, 0, 0, 9852, 1373, 1, 0, 0, 0, 9853, 9858, 3, 1382, 691, 0, 9854, 9858, 3, 1386, 693, 0, 9855, 9858, 3, 1388, 694, 0, 9856, 9858, 3, 1608, 804, 0, 9857, 9853, 1, 0, 0, 0, 9857, 9854, 1, 0, 0, 0, 9857, 9855, 1, 0, 0, 0, 9857, 9856, 1, 0, 0, 0, 9858, 1375, 1, 0, 0, 0, 9859, 9864, 3, 1382, 691, 0, 9860, 9864, 3, 1386, 693, 0, 9861, 9864, 3, 1608, 804, 0, 9862, 9864, 3, 1390, 695, 0, 9863, 9859, 1, 0, 0, 0, 9863, 9860, 1, 0, 0, 0, 9863, 9861, 1, 0, 0, 0, 9863, 9862, 1, 0, 0, 0, 9864, 1377, 1, 0, 0, 0, 9865, 9870, 3, 1382, 691, 0, 9866, 9870, 3, 1386, 693, 0, 9867, 9870, 3, 1388, 694, 0, 9868, 9870, 3, 1390, 695, 0, 9869, 9865, 1, 0, 0, 0, 9869, 9866, 1, 0, 0, 0, 9869, 9867, 1, 0, 0, 0, 9869, 9868, 1, 0, 0, 0, 9870, 1379, 1, 0, 0, 0, 9871, 9878, 3, 1382, 691, 0, 9872, 9878, 3, 1608, 804, 0, 9873, 9878, 3, 1386, 693, 0, 9874, 9878, 3, 1388, 694, 0, 9875, 9878, 3, 1390, 695, 0, 9876, 9878, 3, 1392, 696, 0, 9877, 9871, 1, 0, 0, 0, 9877, 9872, 1, 0, 0, 0, 9877, 9873, 1, 0, 0, 0, 9877, 9874, 1, 0, 0, 0, 9877, 9875, 1, 0, 0, 0, 9877, 9876, 1, 0, 0, 0, 9878, 1381, 1, 0, 0, 0, 9879, 9880, 5, 636, 0, 0, 9880, 9887, 3, 1362, 681, 0, 9881, 9887, 5, 637, 0, 0, 9882, 9887, 5, 641, 0, 0, 9883, 9887, 3, 1208, 604, 0, 9884, 9887, 3, 1384, 692, 0, 9885, 9887, 3, 1608, 804, 0, 9886, 9879, 1, 0, 0, 0, 9886, 9881, 1, 0, 0, 0, 9886, 9882, 1, 0, 0, 0, 9886, 9883, 1, 0, 0, 0, 9886, 9884, 1, 0, 0, 0, 9886, 9885, 1, 0, 0, 0, 9887, 1383, 1, 0, 0, 0, 9888, 9889, 5, 662, 0, 0, 9889, 1385, 1, 0, 0, 0, 9890, 9891, 7, 60, 0, 0, 9891, 1387, 1, 0, 0, 0, 9892, 9945, 5, 380, 0, 0, 9893, 9945, 5, 381, 0, 0, 9894, 9945, 3, 1134, 567, 0, 9895, 9945, 5, 383, 0, 0, 9896, 9945, 5, 384, 0, 0, 9897, 9945, 3, 1142, 571, 0, 9898, 9945, 5, 386, 0, 0, 9899, 9945, 5, 387, 0, 0, 9900, 9945, 5, 388, 0, 0, 9901, 9945, 5, 389, 0, 0, 9902, 9945, 5, 390, 0, 0, 9903, 9945, 5, 391, 0, 0, 9904, 9945, 5, 392, 0, 0, 9905, 9945, 5, 470, 0, 0, 9906, 9945, 5, 393, 0, 0, 9907, 9945, 5, 394, 0, 0, 9908, 9945, 5, 395, 0, 0, 9909, 9945, 5, 396, 0, 0, 9910, 9945, 5, 397, 0, 0, 9911, 9945, 5, 398, 0, 0, 9912, 9945, 5, 399, 0, 0, 9913, 9945, 5, 400, 0, 0, 9914, 9945, 5, 489, 0, 0, 9915, 9945, 5, 401, 0, 0, 9916, 9945, 3, 1130, 565, 0, 9917, 9945, 5, 453, 0, 0, 9918, 9945, 5, 403, 0, 0, 9919, 9945, 5, 404, 0, 0, 9920, 9945, 5, 405, 0, 0, 9921, 9945, 5, 406, 0, 0, 9922, 9945, 5, 407, 0, 0, 9923, 9945, 5, 408, 0, 0, 9924, 9945, 5, 409, 0, 0, 9925, 9945, 5, 410, 0, 0, 9926, 9945, 5, 411, 0, 0, 9927, 9945, 5, 412, 0, 0, 9928, 9945, 5, 413, 0, 0, 9929, 9945, 5, 414, 0, 0, 9930, 9945, 5, 415, 0, 0, 9931, 9945, 5, 416, 0, 0, 9932, 9945, 5, 417, 0, 0, 9933, 9945, 5, 425, 0, 0, 9934, 9945, 5, 426, 0, 0, 9935, 9945, 5, 427, 0, 0, 9936, 9945, 5, 428, 0, 0, 9937, 9945, 5, 476, 0, 0, 9938, 9945, 5, 429, 0, 0, 9939, 9945, 5, 430, 0, 0, 9940, 9945, 5, 431, 0, 0, 9941, 9945, 5, 432, 0, 0, 9942, 9945, 5, 474, 0, 0, 9943, 9945, 3, 1394, 697, 0, 9944, 9892, 1, 0, 0, 0, 9944, 9893, 1, 0, 0, 0, 9944, 9894, 1, 0, 0, 0, 9944, 9895, 1, 0, 0, 0, 9944, 9896, 1, 0, 0, 0, 9944, 9897, 1, 0, 0, 0, 9944, 9898, 1, 0, 0, 0, 9944, 9899, 1, 0, 0, 0, 9944, 9900, 1, 0, 0, 0, 9944, 9901, 1, 0, 0, 0, 9944, 9902, 1, 0, 0, 0, 9944, 9903, 1, 0, 0, 0, 9944, 9904, 1, 0, 0, 0, 9944, 9905, 1, 0, 0, 0, 9944, 9906, 1, 0, 0, 0, 9944, 9907, 1, 0, 0, 0, 9944, 9908, 1, 0, 0, 0, 9944, 9909, 1, 0, 0, 0, 9944, 9910, 1, 0, 0, 0, 9944, 9911, 1, 0, 0, 0, 9944, 9912, 1, 0, 0, 0, 9944, 9913, 1, 0, 0, 0, 9944, 9914, 1, 0, 0, 0, 9944, 9915, 1, 0, 0, 0, 9944, 9916, 1, 0, 0, 0, 9944, 9917, 1, 0, 0, 0, 9944, 9918, 1, 0, 0, 0, 9944, 9919, 1, 0, 0, 0, 9944, 9920, 1, 0, 0, 0, 9944, 9921, 1, 0, 0, 0, 9944, 9922, 1, 0, 0, 0, 9944, 9923, 1, 0, 0, 0, 9944, 9924, 1, 0, 0, 0, 9944, 9925, 1, 0, 0, 0, 9944, 9926, 1, 0, 0, 0, 9944, 9927, 1, 0, 0, 0, 9944, 9928, 1, 0, 0, 0, 9944, 9929, 1, 0, 0, 0, 9944, 9930, 1, 0, 0, 0, 9944, 9931, 1, 0, 0, 0, 9944, 9932, 1, 0, 0, 0, 9944, 9933, 1, 0, 0, 0, 9944, 9934, 1, 0, 0, 0, 9944, 9935, 1, 0, 0, 0, 9944, 9936, 1, 0, 0, 0, 9944, 9937, 1, 0, 0, 0, 9944, 9938, 1, 0, 0, 0, 9944, 9939, 1, 0, 0, 0, 9944, 9940, 1, 0, 0, 0, 9944, 9941, 1, 0, 0, 0, 9944, 9942, 1, 0, 0, 0, 9944, 9943, 1, 0, 0, 0, 9945, 1389, 1, 0, 0, 0, 9946, 9947, 7, 61, 0, 0, 9947, 1391, 1, 0, 0, 0, 9948, 9949, 7, 62, 0, 0, 9949, 1393, 1, 0, 0, 0, 9950, 9951, 7, 63, 0, 0, 9951, 1395, 1, 0, 0, 0, 9952, 9953, 3, 1398, 699, 0, 9953, 9954, 3, 1408, 704, 0, 9954, 9955, 3, 1406, 703, 0, 9955, 1397, 1, 0, 0, 0, 9956, 9958, 3, 1400, 700, 0, 9957, 9956, 1, 0, 0, 0, 9958, 9961, 1, 0, 0, 0, 9959, 9957, 1, 0, 0, 0, 9959, 9960, 1, 0, 0, 0, 9960, 1399, 1, 0, 0, 0, 9961, 9959, 1, 0, 0, 0, 9962, 9963, 3, 1402, 701, 0, 9963, 9964, 5, 272, 0, 0, 9964, 9965, 5, 490, 0, 0, 9965, 9983, 1, 0, 0, 0, 9966, 9967, 3, 1402, 701, 0, 9967, 9968, 5, 491, 0, 0, 9968, 9969, 3, 1404, 702, 0, 9969, 9983, 1, 0, 0, 0, 9970, 9971, 3, 1402, 701, 0, 9971, 9972, 5, 492, 0, 0, 9972, 9973, 5, 493, 0, 0, 9973, 9983, 1, 0, 0, 0, 9974, 9975, 3, 1402, 701, 0, 9975, 9976, 5, 492, 0, 0, 9976, 9977, 5, 494, 0, 0, 9977, 9983, 1, 0, 0, 0, 9978, 9979, 3, 1402, 701, 0, 9979, 9980, 5, 492, 0, 0, 9980, 9981, 5, 495, 0, 0, 9981, 9983, 1, 0, 0, 0, 9982, 9962, 1, 0, 0, 0, 9982, 9966, 1, 0, 0, 0, 9982, 9970, 1, 0, 0, 0, 9982, 9974, 1, 0, 0, 0, 9982, 9978, 1, 0, 0, 0, 9983, 1401, 1, 0, 0, 0, 9984, 9985, 5, 29, 0, 0, 9985, 1403, 1, 0, 0, 0, 9986, 9991, 3, 1358, 679, 0, 9987, 9991, 3, 1392, 696, 0, 9988, 9991, 3, 1608, 804, 0, 9989, 9991, 3, 1386, 693, 0, 9990, 9986, 1, 0, 0, 0, 9990, 9987, 1, 0, 0, 0, 9990, 9988, 1, 0, 0, 0, 9990, 9989, 1, 0, 0, 0, 9991, 1405, 1, 0, 0, 0, 9992, 9995, 1, 0, 0, 0, 9993, 9995, 5, 7, 0, 0, 9994, 9992, 1, 0, 0, 0, 9994, 9993, 1, 0, 0, 0, 9995, 1407, 1, 0, 0, 0, 9996, 9997, 3, 1410, 705, 0, 9997, 9998, 5, 146, 0, 0, 9998, 9999, 3, 1452, 726, 0, 9999, 10000, 3, 1588, 794, 0, 10000, 10001, 5, 454, 0, 0, 10001, 10002, 3, 1602, 801, 0, 10002, 1409, 1, 0, 0, 0, 10003, 10008, 3, 1598, 799, 0, 10004, 10006, 3, 1412, 706, 0, 10005, 10007, 3, 1414, 707, 0, 10006, 10005, 1, 0, 0, 0, 10006, 10007, 1, 0, 0, 0, 10007, 10009, 1, 0, 0, 0, 10008, 10004, 1, 0, 0, 0, 10008, 10009, 1, 0, 0, 0, 10009, 1411, 1, 0, 0, 0, 10010, 10011, 5, 178, 0, 0, 10011, 1413, 1, 0, 0, 0, 10012, 10014, 3, 1418, 709, 0, 10013, 10012, 1, 0, 0, 0, 10014, 10015, 1, 0, 0, 0, 10015, 10013, 1, 0, 0, 0, 10015, 10016, 1, 0, 0, 0, 10016, 1415, 1, 0, 0, 0, 10017, 10018, 5, 18, 0, 0, 10018, 10019, 3, 1606, 803, 0, 10019, 10020, 5, 19, 0, 0, 10020, 1417, 1, 0, 0, 0, 10021, 10025, 3, 1420, 710, 0, 10022, 10025, 5, 178, 0, 0, 10023, 10025, 3, 1416, 708, 0, 10024, 10021, 1, 0, 0, 0, 10024, 10022, 1, 0, 0, 0, 10024, 10023, 1, 0, 0, 0, 10025, 1419, 1, 0, 0, 0, 10026, 10042, 3, 1436, 718, 0, 10027, 10028, 5, 496, 0, 0, 10028, 10029, 5, 62, 0, 0, 10029, 10043, 3, 1434, 717, 0, 10030, 10031, 3, 1438, 719, 0, 10031, 10032, 3, 1440, 720, 0, 10032, 10033, 3, 1442, 721, 0, 10033, 10034, 3, 1444, 722, 0, 10034, 10035, 3, 1446, 723, 0, 10035, 10043, 1, 0, 0, 0, 10036, 10037, 3, 1422, 711, 0, 10037, 10038, 5, 172, 0, 0, 10038, 10039, 3, 1426, 713, 0, 10039, 10040, 3, 1432, 716, 0, 10040, 10041, 3, 1424, 712, 0, 10041, 10043, 1, 0, 0, 0, 10042, 10027, 1, 0, 0, 0, 10042, 10030, 1, 0, 0, 0, 10042, 10036, 1, 0, 0, 0, 10043, 10044, 1, 0, 0, 0, 10044, 10045, 5, 7, 0, 0, 10045, 1421, 1, 0, 0, 0, 10046, 10051, 1, 0, 0, 0, 10047, 10048, 5, 262, 0, 0, 10048, 10051, 5, 317, 0, 0, 10049, 10051, 5, 317, 0, 0, 10050, 10046, 1, 0, 0, 0, 10050, 10047, 1, 0, 0, 0, 10050, 10049, 1, 0, 0, 0, 10051, 1423, 1, 0, 0, 0, 10052, 10053, 3, 960, 480, 0, 10053, 1425, 1, 0, 0, 0, 10054, 10060, 1, 0, 0, 0, 10055, 10056, 5, 2, 0, 0, 10056, 10057, 3, 1428, 714, 0, 10057, 10058, 5, 3, 0, 0, 10058, 10060, 1, 0, 0, 0, 10059, 10054, 1, 0, 0, 0, 10059, 10055, 1, 0, 0, 0, 10060, 1427, 1, 0, 0, 0, 10061, 10066, 3, 1430, 715, 0, 10062, 10063, 5, 6, 0, 0, 10063, 10065, 3, 1430, 715, 0, 10064, 10062, 1, 0, 0, 0, 10065, 10068, 1, 0, 0, 0, 10066, 10064, 1, 0, 0, 0, 10066, 10067, 1, 0, 0, 0, 10067, 1429, 1, 0, 0, 0, 10068, 10066, 1, 0, 0, 0, 10069, 10070, 3, 1436, 718, 0, 10070, 10071, 3, 1440, 720, 0, 10071, 1431, 1, 0, 0, 0, 10072, 10073, 7, 64, 0, 0, 10073, 1433, 1, 0, 0, 0, 10074, 10077, 5, 28, 0, 0, 10075, 10077, 3, 1372, 686, 0, 10076, 10074, 1, 0, 0, 0, 10076, 10075, 1, 0, 0, 0, 10077, 1435, 1, 0, 0, 0, 10078, 10079, 3, 1606, 803, 0, 10079, 1437, 1, 0, 0, 0, 10080, 10083, 1, 0, 0, 0, 10081, 10083, 5, 497, 0, 0, 10082, 10080, 1, 0, 0, 0, 10082, 10081, 1, 0, 0, 0, 10083, 1439, 1, 0, 0, 0, 10084, 10085, 3, 1118, 559, 0, 10085, 1441, 1, 0, 0, 0, 10086, 10090, 1, 0, 0, 0, 10087, 10088, 5, 43, 0, 0, 10088, 10090, 3, 524, 262, 0, 10089, 10086, 1, 0, 0, 0, 10089, 10087, 1, 0, 0, 0, 10090, 1443, 1, 0, 0, 0, 10091, 10095, 1, 0, 0, 0, 10092, 10093, 5, 77, 0, 0, 10093, 10095, 5, 78, 0, 0, 10094, 10091, 1, 0, 0, 0, 10094, 10092, 1, 0, 0, 0, 10095, 1445, 1, 0, 0, 0, 10096, 10101, 1, 0, 0, 0, 10097, 10098, 3, 1448, 724, 0, 10098, 10099, 3, 1610, 805, 0, 10099, 10101, 1, 0, 0, 0, 10100, 10096, 1, 0, 0, 0, 10100, 10097, 1, 0, 0, 0, 10101, 1447, 1, 0, 0, 0, 10102, 10105, 3, 1450, 725, 0, 10103, 10105, 5, 53, 0, 0, 10104, 10102, 1, 0, 0, 0, 10104, 10103, 1, 0, 0, 0, 10105, 1449, 1, 0, 0, 0, 10106, 10107, 7, 65, 0, 0, 10107, 1451, 1, 0, 0, 0, 10108, 10110, 3, 1454, 727, 0, 10109, 10108, 1, 0, 0, 0, 10110, 10113, 1, 0, 0, 0, 10111, 10109, 1, 0, 0, 0, 10111, 10112, 1, 0, 0, 0, 10112, 1453, 1, 0, 0, 0, 10113, 10111, 1, 0, 0, 0, 10114, 10115, 3, 1408, 704, 0, 10115, 10116, 5, 7, 0, 0, 10116, 10142, 1, 0, 0, 0, 10117, 10142, 3, 1520, 760, 0, 10118, 10142, 3, 1524, 762, 0, 10119, 10142, 3, 1462, 731, 0, 10120, 10142, 3, 1478, 739, 0, 10121, 10142, 3, 1484, 742, 0, 10122, 10142, 3, 1494, 747, 0, 10123, 10142, 3, 1496, 748, 0, 10124, 10142, 3, 1498, 749, 0, 10125, 10142, 3, 1512, 756, 0, 10126, 10142, 3, 1516, 758, 0, 10127, 10142, 3, 1536, 768, 0, 10128, 10142, 3, 1542, 771, 0, 10129, 10142, 3, 1544, 772, 0, 10130, 10142, 3, 1456, 728, 0, 10131, 10142, 3, 1458, 729, 0, 10132, 10142, 3, 1464, 732, 0, 10133, 10142, 3, 1552, 776, 0, 10134, 10142, 3, 1564, 782, 0, 10135, 10142, 3, 1572, 786, 0, 10136, 10142, 3, 1574, 787, 0, 10137, 10142, 3, 1576, 788, 0, 10138, 10142, 3, 1578, 789, 0, 10139, 10142, 3, 1580, 790, 0, 10140, 10142, 3, 1584, 792, 0, 10141, 10114, 1, 0, 0, 0, 10141, 10117, 1, 0, 0, 0, 10141, 10118, 1, 0, 0, 0, 10141, 10119, 1, 0, 0, 0, 10141, 10120, 1, 0, 0, 0, 10141, 10121, 1, 0, 0, 0, 10141, 10122, 1, 0, 0, 0, 10141, 10123, 1, 0, 0, 0, 10141, 10124, 1, 0, 0, 0, 10141, 10125, 1, 0, 0, 0, 10141, 10126, 1, 0, 0, 0, 10141, 10127, 1, 0, 0, 0, 10141, 10128, 1, 0, 0, 0, 10141, 10129, 1, 0, 0, 0, 10141, 10130, 1, 0, 0, 0, 10141, 10131, 1, 0, 0, 0, 10141, 10132, 1, 0, 0, 0, 10141, 10133, 1, 0, 0, 0, 10141, 10134, 1, 0, 0, 0, 10141, 10135, 1, 0, 0, 0, 10141, 10136, 1, 0, 0, 0, 10141, 10137, 1, 0, 0, 0, 10141, 10138, 1, 0, 0, 0, 10141, 10139, 1, 0, 0, 0, 10141, 10140, 1, 0, 0, 0, 10142, 1455, 1, 0, 0, 0, 10143, 10144, 5, 498, 0, 0, 10144, 10145, 3, 1614, 807, 0, 10145, 10146, 5, 7, 0, 0, 10146, 1457, 1, 0, 0, 0, 10147, 10148, 5, 433, 0, 0, 10148, 10149, 3, 1606, 803, 0, 10149, 10150, 5, 2, 0, 0, 10150, 10151, 3, 1460, 730, 0, 10151, 10152, 5, 3, 0, 0, 10152, 10153, 5, 7, 0, 0, 10153, 10162, 1, 0, 0, 0, 10154, 10155, 5, 57, 0, 0, 10155, 10156, 3, 1606, 803, 0, 10156, 10157, 5, 2, 0, 0, 10157, 10158, 3, 1460, 730, 0, 10158, 10159, 5, 3, 0, 0, 10159, 10160, 5, 7, 0, 0, 10160, 10162, 1, 0, 0, 0, 10161, 10147, 1, 0, 0, 0, 10161, 10154, 1, 0, 0, 0, 10162, 1459, 1, 0, 0, 0, 10163, 10166, 1, 0, 0, 0, 10164, 10166, 3, 1280, 640, 0, 10165, 10163, 1, 0, 0, 0, 10165, 10164, 1, 0, 0, 0, 10166, 1461, 1, 0, 0, 0, 10167, 10168, 3, 1476, 738, 0, 10168, 10169, 3, 1450, 725, 0, 10169, 10170, 3, 1610, 805, 0, 10170, 10171, 5, 7, 0, 0, 10171, 1463, 1, 0, 0, 0, 10172, 10173, 5, 499, 0, 0, 10173, 10174, 3, 1466, 733, 0, 10174, 10175, 5, 500, 0, 0, 10175, 10176, 3, 1468, 734, 0, 10176, 10177, 5, 7, 0, 0, 10177, 1465, 1, 0, 0, 0, 10178, 10182, 1, 0, 0, 0, 10179, 10182, 5, 434, 0, 0, 10180, 10182, 5, 501, 0, 0, 10181, 10178, 1, 0, 0, 0, 10181, 10179, 1, 0, 0, 0, 10181, 10180, 1, 0, 0, 0, 10182, 1467, 1, 0, 0, 0, 10183, 10188, 3, 1470, 735, 0, 10184, 10185, 5, 6, 0, 0, 10185, 10187, 3, 1470, 735, 0, 10186, 10184, 1, 0, 0, 0, 10187, 10190, 1, 0, 0, 0, 10188, 10186, 1, 0, 0, 0, 10188, 10189, 1, 0, 0, 0, 10189, 1469, 1, 0, 0, 0, 10190, 10188, 1, 0, 0, 0, 10191, 10192, 3, 1474, 737, 0, 10192, 10193, 3, 1450, 725, 0, 10193, 10194, 3, 1472, 736, 0, 10194, 1471, 1, 0, 0, 0, 10195, 10196, 3, 1372, 686, 0, 10196, 1473, 1, 0, 0, 0, 10197, 10198, 3, 1476, 738, 0, 10198, 1475, 1, 0, 0, 0, 10199, 10202, 3, 524, 262, 0, 10200, 10202, 5, 28, 0, 0, 10201, 10199, 1, 0, 0, 0, 10201, 10200, 1, 0, 0, 0, 10202, 10209, 1, 0, 0, 0, 10203, 10204, 5, 4, 0, 0, 10204, 10205, 3, 1616, 808, 0, 10205, 10206, 5, 5, 0, 0, 10206, 10208, 1, 0, 0, 0, 10207, 10203, 1, 0, 0, 0, 10208, 10211, 1, 0, 0, 0, 10209, 10207, 1, 0, 0, 0, 10209, 10210, 1, 0, 0, 0, 10210, 1477, 1, 0, 0, 0, 10211, 10209, 1, 0, 0, 0, 10212, 10213, 5, 220, 0, 0, 10213, 10214, 3, 1612, 806, 0, 10214, 10215, 5, 93, 0, 0, 10215, 10216, 3, 1452, 726, 0, 10216, 10217, 3, 1480, 740, 0, 10217, 10218, 3, 1482, 741, 0, 10218, 10219, 5, 454, 0, 0, 10219, 10220, 5, 220, 0, 0, 10220, 10221, 5, 7, 0, 0, 10221, 1479, 1, 0, 0, 0, 10222, 10223, 5, 502, 0, 0, 10223, 10224, 3, 1162, 581, 0, 10224, 10225, 5, 93, 0, 0, 10225, 10226, 3, 1452, 726, 0, 10226, 10228, 1, 0, 0, 0, 10227, 10222, 1, 0, 0, 0, 10228, 10231, 1, 0, 0, 0, 10229, 10227, 1, 0, 0, 0, 10229, 10230, 1, 0, 0, 0, 10230, 1481, 1, 0, 0, 0, 10231, 10229, 1, 0, 0, 0, 10232, 10236, 1, 0, 0, 0, 10233, 10234, 5, 58, 0, 0, 10234, 10236, 3, 1452, 726, 0, 10235, 10232, 1, 0, 0, 0, 10235, 10233, 1, 0, 0, 0, 10236, 1483, 1, 0, 0, 0, 10237, 10238, 5, 40, 0, 0, 10238, 10239, 3, 1486, 743, 0, 10239, 10240, 3, 1488, 744, 0, 10240, 10241, 3, 1492, 746, 0, 10241, 10242, 5, 454, 0, 0, 10242, 10243, 5, 40, 0, 0, 10243, 10244, 5, 7, 0, 0, 10244, 1485, 1, 0, 0, 0, 10245, 10248, 1, 0, 0, 0, 10246, 10248, 3, 1610, 805, 0, 10247, 10245, 1, 0, 0, 0, 10247, 10246, 1, 0, 0, 0, 10248, 1487, 1, 0, 0, 0, 10249, 10251, 3, 1490, 745, 0, 10250, 10249, 1, 0, 0, 0, 10251, 10252, 1, 0, 0, 0, 10252, 10250, 1, 0, 0, 0, 10252, 10253, 1, 0, 0, 0, 10253, 1489, 1, 0, 0, 0, 10254, 10255, 5, 102, 0, 0, 10255, 10256, 3, 1280, 640, 0, 10256, 10257, 5, 93, 0, 0, 10257, 10258, 3, 1452, 726, 0, 10258, 1491, 1, 0, 0, 0, 10259, 10263, 1, 0, 0, 0, 10260, 10261, 5, 58, 0, 0, 10261, 10263, 3, 1452, 726, 0, 10262, 10259, 1, 0, 0, 0, 10262, 10260, 1, 0, 0, 0, 10263, 1493, 1, 0, 0, 0, 10264, 10265, 3, 1600, 800, 0, 10265, 10266, 3, 1540, 770, 0, 10266, 1495, 1, 0, 0, 0, 10267, 10268, 3, 1600, 800, 0, 10268, 10269, 5, 503, 0, 0, 10269, 10270, 3, 1618, 809, 0, 10270, 10271, 3, 1540, 770, 0, 10271, 1497, 1, 0, 0, 0, 10272, 10273, 3, 1600, 800, 0, 10273, 10274, 5, 62, 0, 0, 10274, 10275, 3, 1500, 750, 0, 10275, 10276, 3, 1540, 770, 0, 10276, 1499, 1, 0, 0, 0, 10277, 10278, 3, 1510, 755, 0, 10278, 10294, 5, 68, 0, 0, 10279, 10280, 3, 954, 477, 0, 10280, 10281, 3, 1504, 752, 0, 10281, 10295, 1, 0, 0, 0, 10282, 10295, 3, 960, 480, 0, 10283, 10295, 3, 878, 439, 0, 10284, 10285, 5, 202, 0, 0, 10285, 10286, 3, 1162, 581, 0, 10286, 10287, 3, 1502, 751, 0, 10287, 10295, 1, 0, 0, 0, 10288, 10289, 3, 1506, 753, 0, 10289, 10290, 3, 1162, 581, 0, 10290, 10291, 5, 24, 0, 0, 10291, 10292, 3, 1162, 581, 0, 10292, 10293, 3, 1508, 754, 0, 10293, 10295, 1, 0, 0, 0, 10294, 10279, 1, 0, 0, 0, 10294, 10282, 1, 0, 0, 0, 10294, 10283, 1, 0, 0, 0, 10294, 10284, 1, 0, 0, 0, 10294, 10288, 1, 0, 0, 0, 10295, 1501, 1, 0, 0, 0, 10296, 10300, 1, 0, 0, 0, 10297, 10298, 5, 100, 0, 0, 10298, 10300, 3, 1280, 640, 0, 10299, 10296, 1, 0, 0, 0, 10299, 10297, 1, 0, 0, 0, 10300, 1503, 1, 0, 0, 0, 10301, 10314, 1, 0, 0, 0, 10302, 10303, 5, 2, 0, 0, 10303, 10308, 3, 1162, 581, 0, 10304, 10305, 5, 6, 0, 0, 10305, 10307, 3, 1162, 581, 0, 10306, 10304, 1, 0, 0, 0, 10307, 10310, 1, 0, 0, 0, 10308, 10306, 1, 0, 0, 0, 10308, 10309, 1, 0, 0, 0, 10309, 10311, 1, 0, 0, 0, 10310, 10308, 1, 0, 0, 0, 10311, 10312, 5, 3, 0, 0, 10312, 10314, 1, 0, 0, 0, 10313, 10301, 1, 0, 0, 0, 10313, 10302, 1, 0, 0, 0, 10314, 1505, 1, 0, 0, 0, 10315, 10318, 1, 0, 0, 0, 10316, 10318, 5, 504, 0, 0, 10317, 10315, 1, 0, 0, 0, 10317, 10316, 1, 0, 0, 0, 10318, 1507, 1, 0, 0, 0, 10319, 10323, 1, 0, 0, 0, 10320, 10321, 5, 147, 0, 0, 10321, 10323, 3, 1162, 581, 0, 10322, 10319, 1, 0, 0, 0, 10322, 10320, 1, 0, 0, 0, 10323, 1509, 1, 0, 0, 0, 10324, 10325, 3, 522, 261, 0, 10325, 1511, 1, 0, 0, 0, 10326, 10327, 3, 1600, 800, 0, 10327, 10328, 5, 505, 0, 0, 10328, 10329, 3, 1510, 755, 0, 10329, 10330, 3, 1514, 757, 0, 10330, 10331, 5, 68, 0, 0, 10331, 10332, 5, 35, 0, 0, 10332, 10333, 3, 1162, 581, 0, 10333, 10334, 3, 1540, 770, 0, 10334, 1513, 1, 0, 0, 0, 10335, 10339, 1, 0, 0, 0, 10336, 10337, 5, 506, 0, 0, 10337, 10339, 3, 1356, 678, 0, 10338, 10335, 1, 0, 0, 0, 10338, 10336, 1, 0, 0, 0, 10339, 1515, 1, 0, 0, 0, 10340, 10341, 3, 1518, 759, 0, 10341, 10342, 3, 1602, 801, 0, 10342, 10343, 3, 1604, 802, 0, 10343, 10344, 5, 7, 0, 0, 10344, 1517, 1, 0, 0, 0, 10345, 10346, 7, 66, 0, 0, 10346, 1519, 1, 0, 0, 0, 10347, 10359, 5, 508, 0, 0, 10348, 10349, 5, 261, 0, 0, 10349, 10360, 3, 1610, 805, 0, 10350, 10356, 5, 509, 0, 0, 10351, 10352, 5, 202, 0, 0, 10352, 10353, 3, 1162, 581, 0, 10353, 10354, 3, 1502, 751, 0, 10354, 10357, 1, 0, 0, 0, 10355, 10357, 3, 960, 480, 0, 10356, 10351, 1, 0, 0, 0, 10356, 10355, 1, 0, 0, 0, 10357, 10360, 1, 0, 0, 0, 10358, 10360, 3, 1522, 761, 0, 10359, 10348, 1, 0, 0, 0, 10359, 10350, 1, 0, 0, 0, 10359, 10358, 1, 0, 0, 0, 10360, 10361, 1, 0, 0, 0, 10361, 10362, 5, 7, 0, 0, 10362, 1521, 1, 0, 0, 0, 10363, 10366, 1, 0, 0, 0, 10364, 10366, 3, 1610, 805, 0, 10365, 10363, 1, 0, 0, 0, 10365, 10364, 1, 0, 0, 0, 10366, 1523, 1, 0, 0, 0, 10367, 10368, 5, 510, 0, 0, 10368, 10369, 3, 1526, 763, 0, 10369, 10370, 3, 1358, 679, 0, 10370, 10371, 3, 1528, 764, 0, 10371, 10372, 3, 1530, 765, 0, 10372, 10373, 5, 7, 0, 0, 10373, 10394, 1, 0, 0, 0, 10374, 10375, 5, 510, 0, 0, 10375, 10376, 3, 1526, 763, 0, 10376, 10377, 3, 1382, 691, 0, 10377, 10378, 3, 1530, 765, 0, 10378, 10379, 5, 7, 0, 0, 10379, 10394, 1, 0, 0, 0, 10380, 10381, 5, 510, 0, 0, 10381, 10382, 3, 1526, 763, 0, 10382, 10383, 5, 511, 0, 0, 10383, 10384, 3, 1358, 679, 0, 10384, 10385, 3, 1530, 765, 0, 10385, 10386, 5, 7, 0, 0, 10386, 10394, 1, 0, 0, 0, 10387, 10388, 5, 510, 0, 0, 10388, 10389, 3, 1526, 763, 0, 10389, 10390, 3, 1530, 765, 0, 10390, 10391, 5, 7, 0, 0, 10391, 10394, 1, 0, 0, 0, 10392, 10394, 5, 510, 0, 0, 10393, 10367, 1, 0, 0, 0, 10393, 10374, 1, 0, 0, 0, 10393, 10380, 1, 0, 0, 0, 10393, 10387, 1, 0, 0, 0, 10393, 10392, 1, 0, 0, 0, 10394, 1525, 1, 0, 0, 0, 10395, 10404, 1, 0, 0, 0, 10396, 10404, 1, 0, 0, 0, 10397, 10404, 5, 512, 0, 0, 10398, 10404, 5, 513, 0, 0, 10399, 10404, 5, 514, 0, 0, 10400, 10404, 5, 515, 0, 0, 10401, 10404, 5, 516, 0, 0, 10402, 10404, 5, 517, 0, 0, 10403, 10395, 1, 0, 0, 0, 10403, 10396, 1, 0, 0, 0, 10403, 10397, 1, 0, 0, 0, 10403, 10398, 1, 0, 0, 0, 10403, 10399, 1, 0, 0, 0, 10403, 10400, 1, 0, 0, 0, 10403, 10401, 1, 0, 0, 0, 10403, 10402, 1, 0, 0, 0, 10404, 1527, 1, 0, 0, 0, 10405, 10413, 1, 0, 0, 0, 10406, 10407, 5, 6, 0, 0, 10407, 10409, 3, 1162, 581, 0, 10408, 10406, 1, 0, 0, 0, 10409, 10410, 1, 0, 0, 0, 10410, 10408, 1, 0, 0, 0, 10410, 10411, 1, 0, 0, 0, 10411, 10413, 1, 0, 0, 0, 10412, 10405, 1, 0, 0, 0, 10412, 10408, 1, 0, 0, 0, 10413, 1529, 1, 0, 0, 0, 10414, 10418, 1, 0, 0, 0, 10415, 10416, 5, 100, 0, 0, 10416, 10418, 3, 1534, 767, 0, 10417, 10414, 1, 0, 0, 0, 10417, 10415, 1, 0, 0, 0, 10418, 1531, 1, 0, 0, 0, 10419, 10420, 3, 1382, 691, 0, 10420, 10421, 5, 10, 0, 0, 10421, 10422, 3, 1162, 581, 0, 10422, 1533, 1, 0, 0, 0, 10423, 10428, 3, 1532, 766, 0, 10424, 10425, 5, 6, 0, 0, 10425, 10427, 3, 1532, 766, 0, 10426, 10424, 1, 0, 0, 0, 10427, 10430, 1, 0, 0, 0, 10428, 10426, 1, 0, 0, 0, 10428, 10429, 1, 0, 0, 0, 10429, 1535, 1, 0, 0, 0, 10430, 10428, 1, 0, 0, 0, 10431, 10432, 5, 518, 0, 0, 10432, 10433, 3, 1610, 805, 0, 10433, 10434, 3, 1538, 769, 0, 10434, 10435, 5, 7, 0, 0, 10435, 1537, 1, 0, 0, 0, 10436, 10440, 1, 0, 0, 0, 10437, 10438, 5, 6, 0, 0, 10438, 10440, 3, 1610, 805, 0, 10439, 10436, 1, 0, 0, 0, 10439, 10437, 1, 0, 0, 0, 10440, 1539, 1, 0, 0, 0, 10441, 10442, 5, 519, 0, 0, 10442, 10443, 3, 1452, 726, 0, 10443, 10444, 5, 454, 0, 0, 10444, 10445, 5, 519, 0, 0, 10445, 10446, 3, 1602, 801, 0, 10446, 10447, 5, 7, 0, 0, 10447, 1541, 1, 0, 0, 0, 10448, 10449, 3, 1620, 810, 0, 10449, 10450, 5, 7, 0, 0, 10450, 1543, 1, 0, 0, 0, 10451, 10452, 5, 202, 0, 0, 10452, 10460, 3, 1162, 581, 0, 10453, 10454, 3, 1550, 775, 0, 10454, 10455, 3, 1546, 773, 0, 10455, 10461, 1, 0, 0, 0, 10456, 10457, 3, 1546, 773, 0, 10457, 10458, 3, 1550, 775, 0, 10458, 10461, 1, 0, 0, 0, 10459, 10461, 1, 0, 0, 0, 10460, 10453, 1, 0, 0, 0, 10460, 10456, 1, 0, 0, 0, 10460, 10459, 1, 0, 0, 0, 10461, 10462, 1, 0, 0, 0, 10462, 10463, 5, 7, 0, 0, 10463, 1545, 1, 0, 0, 0, 10464, 10468, 1, 0, 0, 0, 10465, 10466, 5, 100, 0, 0, 10466, 10468, 3, 1548, 774, 0, 10467, 10464, 1, 0, 0, 0, 10467, 10465, 1, 0, 0, 0, 10468, 1547, 1, 0, 0, 0, 10469, 10474, 3, 1162, 581, 0, 10470, 10471, 5, 6, 0, 0, 10471, 10473, 3, 1162, 581, 0, 10472, 10470, 1, 0, 0, 0, 10473, 10476, 1, 0, 0, 0, 10474, 10472, 1, 0, 0, 0, 10474, 10475, 1, 0, 0, 0, 10475, 1549, 1, 0, 0, 0, 10476, 10474, 1, 0, 0, 0, 10477, 10484, 1, 0, 0, 0, 10478, 10480, 5, 71, 0, 0, 10479, 10481, 5, 339, 0, 0, 10480, 10479, 1, 0, 0, 0, 10480, 10481, 1, 0, 0, 0, 10481, 10482, 1, 0, 0, 0, 10482, 10484, 3, 1566, 783, 0, 10483, 10477, 1, 0, 0, 0, 10483, 10478, 1, 0, 0, 0, 10484, 1551, 1, 0, 0, 0, 10485, 10503, 5, 520, 0, 0, 10486, 10487, 3, 1586, 793, 0, 10487, 10488, 3, 1560, 780, 0, 10488, 10494, 5, 62, 0, 0, 10489, 10495, 3, 960, 480, 0, 10490, 10491, 5, 202, 0, 0, 10491, 10492, 3, 1610, 805, 0, 10492, 10493, 3, 1558, 779, 0, 10493, 10495, 1, 0, 0, 0, 10494, 10489, 1, 0, 0, 0, 10494, 10490, 1, 0, 0, 0, 10495, 10504, 1, 0, 0, 0, 10496, 10501, 3, 1372, 686, 0, 10497, 10498, 5, 2, 0, 0, 10498, 10499, 3, 1556, 778, 0, 10499, 10500, 5, 3, 0, 0, 10500, 10502, 1, 0, 0, 0, 10501, 10497, 1, 0, 0, 0, 10501, 10502, 1, 0, 0, 0, 10502, 10504, 1, 0, 0, 0, 10503, 10486, 1, 0, 0, 0, 10503, 10496, 1, 0, 0, 0, 10504, 10505, 1, 0, 0, 0, 10505, 10506, 5, 7, 0, 0, 10506, 1553, 1, 0, 0, 0, 10507, 10508, 3, 1372, 686, 0, 10508, 10509, 5, 20, 0, 0, 10509, 10510, 3, 1162, 581, 0, 10510, 10513, 1, 0, 0, 0, 10511, 10513, 3, 1162, 581, 0, 10512, 10507, 1, 0, 0, 0, 10512, 10511, 1, 0, 0, 0, 10513, 1555, 1, 0, 0, 0, 10514, 10519, 3, 1554, 777, 0, 10515, 10516, 5, 6, 0, 0, 10516, 10518, 3, 1554, 777, 0, 10517, 10515, 1, 0, 0, 0, 10518, 10521, 1, 0, 0, 0, 10519, 10517, 1, 0, 0, 0, 10519, 10520, 1, 0, 0, 0, 10520, 1557, 1, 0, 0, 0, 10521, 10519, 1, 0, 0, 0, 10522, 10526, 1, 0, 0, 0, 10523, 10524, 5, 100, 0, 0, 10524, 10526, 3, 1280, 640, 0, 10525, 10522, 1, 0, 0, 0, 10525, 10523, 1, 0, 0, 0, 10526, 1559, 1, 0, 0, 0, 10527, 10532, 1, 0, 0, 0, 10528, 10529, 3, 1562, 781, 0, 10529, 10530, 5, 317, 0, 0, 10530, 10532, 1, 0, 0, 0, 10531, 10527, 1, 0, 0, 0, 10531, 10528, 1, 0, 0, 0, 10532, 1561, 1, 0, 0, 0, 10533, 10536, 1, 0, 0, 0, 10534, 10536, 5, 262, 0, 0, 10535, 10533, 1, 0, 0, 0, 10535, 10534, 1, 0, 0, 0, 10536, 1563, 1, 0, 0, 0, 10537, 10538, 5, 61, 0, 0, 10538, 10539, 3, 1570, 785, 0, 10539, 10540, 3, 1568, 784, 0, 10540, 10541, 3, 1586, 793, 0, 10541, 10542, 5, 71, 0, 0, 10542, 10543, 3, 1566, 783, 0, 10543, 10544, 5, 7, 0, 0, 10544, 1565, 1, 0, 0, 0, 10545, 10546, 3, 1280, 640, 0, 10546, 1567, 1, 0, 0, 0, 10547, 10551, 1, 0, 0, 0, 10548, 10551, 5, 64, 0, 0, 10549, 10551, 5, 68, 0, 0, 10550, 10547, 1, 0, 0, 0, 10550, 10548, 1, 0, 0, 0, 10550, 10549, 1, 0, 0, 0, 10551, 1569, 1, 0, 0, 0, 10552, 10570, 1, 0, 0, 0, 10553, 10570, 1, 0, 0, 0, 10554, 10570, 5, 261, 0, 0, 10555, 10570, 5, 286, 0, 0, 10556, 10570, 5, 207, 0, 0, 10557, 10570, 5, 240, 0, 0, 10558, 10559, 5, 130, 0, 0, 10559, 10570, 3, 1162, 581, 0, 10560, 10561, 5, 300, 0, 0, 10561, 10570, 3, 1162, 581, 0, 10562, 10570, 3, 1162, 581, 0, 10563, 10570, 5, 30, 0, 0, 10564, 10567, 7, 67, 0, 0, 10565, 10568, 3, 1162, 581, 0, 10566, 10568, 5, 30, 0, 0, 10567, 10565, 1, 0, 0, 0, 10567, 10566, 1, 0, 0, 0, 10567, 10568, 1, 0, 0, 0, 10568, 10570, 1, 0, 0, 0, 10569, 10552, 1, 0, 0, 0, 10569, 10553, 1, 0, 0, 0, 10569, 10554, 1, 0, 0, 0, 10569, 10555, 1, 0, 0, 0, 10569, 10556, 1, 0, 0, 0, 10569, 10557, 1, 0, 0, 0, 10569, 10558, 1, 0, 0, 0, 10569, 10560, 1, 0, 0, 0, 10569, 10562, 1, 0, 0, 0, 10569, 10563, 1, 0, 0, 0, 10569, 10564, 1, 0, 0, 0, 10570, 1571, 1, 0, 0, 0, 10571, 10572, 5, 258, 0, 0, 10572, 10573, 3, 1570, 785, 0, 10573, 10574, 3, 1586, 793, 0, 10574, 10575, 5, 7, 0, 0, 10575, 1573, 1, 0, 0, 0, 10576, 10577, 5, 157, 0, 0, 10577, 10578, 3, 1586, 793, 0, 10578, 10579, 5, 7, 0, 0, 10579, 1575, 1, 0, 0, 0, 10580, 10581, 5, 78, 0, 0, 10581, 10582, 5, 7, 0, 0, 10582, 1577, 1, 0, 0, 0, 10583, 10584, 5, 161, 0, 0, 10584, 10585, 3, 1582, 791, 0, 10585, 10586, 5, 7, 0, 0, 10586, 1579, 1, 0, 0, 0, 10587, 10588, 5, 312, 0, 0, 10588, 10589, 3, 1582, 791, 0, 10589, 10590, 5, 7, 0, 0, 10590, 1581, 1, 0, 0, 0, 10591, 10593, 5, 33, 0, 0, 10592, 10594, 5, 262, 0, 0, 10593, 10592, 1, 0, 0, 0, 10593, 10594, 1, 0, 0, 0, 10594, 10595, 1, 0, 0, 0, 10595, 10598, 5, 153, 0, 0, 10596, 10598, 1, 0, 0, 0, 10597, 10591, 1, 0, 0, 0, 10597, 10596, 1, 0, 0, 0, 10598, 1583, 1, 0, 0, 0, 10599, 10600, 5, 326, 0, 0, 10600, 10601, 3, 524, 262, 0, 10601, 10602, 5, 94, 0, 0, 10602, 10603, 5, 53, 0, 0, 10603, 10604, 5, 7, 0, 0, 10604, 10612, 1, 0, 0, 0, 10605, 10608, 5, 306, 0, 0, 10606, 10609, 3, 524, 262, 0, 10607, 10609, 5, 30, 0, 0, 10608, 10606, 1, 0, 0, 0, 10608, 10607, 1, 0, 0, 0, 10609, 10610, 1, 0, 0, 0, 10610, 10612, 5, 7, 0, 0, 10611, 10599, 1, 0, 0, 0, 10611, 10605, 1, 0, 0, 0, 10612, 1585, 1, 0, 0, 0, 10613, 10616, 3, 1372, 686, 0, 10614, 10616, 5, 28, 0, 0, 10615, 10613, 1, 0, 0, 0, 10615, 10614, 1, 0, 0, 0, 10616, 1587, 1, 0, 0, 0, 10617, 10621, 1, 0, 0, 0, 10618, 10619, 5, 517, 0, 0, 10619, 10621, 3, 1590, 795, 0, 10620, 10617, 1, 0, 0, 0, 10620, 10618, 1, 0, 0, 0, 10621, 1589, 1, 0, 0, 0, 10622, 10624, 3, 1592, 796, 0, 10623, 10622, 1, 0, 0, 0, 10624, 10625, 1, 0, 0, 0, 10625, 10623, 1, 0, 0, 0, 10625, 10626, 1, 0, 0, 0, 10626, 1591, 1, 0, 0, 0, 10627, 10628, 5, 102, 0, 0, 10628, 10629, 3, 1594, 797, 0, 10629, 10630, 5, 93, 0, 0, 10630, 10631, 3, 1452, 726, 0, 10631, 1593, 1, 0, 0, 0, 10632, 10637, 3, 1596, 798, 0, 10633, 10634, 5, 82, 0, 0, 10634, 10636, 3, 1596, 798, 0, 10635, 10633, 1, 0, 0, 0, 10636, 10639, 1, 0, 0, 0, 10637, 10635, 1, 0, 0, 0, 10637, 10638, 1, 0, 0, 0, 10638, 1595, 1, 0, 0, 0, 10639, 10637, 1, 0, 0, 0, 10640, 10644, 3, 1606, 803, 0, 10641, 10642, 5, 511, 0, 0, 10642, 10644, 3, 1358, 679, 0, 10643, 10640, 1, 0, 0, 0, 10643, 10641, 1, 0, 0, 0, 10644, 1597, 1, 0, 0, 0, 10645, 10648, 1, 0, 0, 0, 10646, 10648, 3, 1416, 708, 0, 10647, 10645, 1, 0, 0, 0, 10647, 10646, 1, 0, 0, 0, 10648, 1599, 1, 0, 0, 0, 10649, 10652, 1, 0, 0, 0, 10650, 10652, 3, 1416, 708, 0, 10651, 10649, 1, 0, 0, 0, 10651, 10650, 1, 0, 0, 0, 10652, 1601, 1, 0, 0, 0, 10653, 10656, 1, 0, 0, 0, 10654, 10656, 3, 1606, 803, 0, 10655, 10653, 1, 0, 0, 0, 10655, 10654, 1, 0, 0, 0, 10656, 1603, 1, 0, 0, 0, 10657, 10658, 5, 102, 0, 0, 10658, 10661, 3, 1614, 807, 0, 10659, 10661, 1, 0, 0, 0, 10660, 10657, 1, 0, 0, 0, 10660, 10659, 1, 0, 0, 0, 10661, 1605, 1, 0, 0, 0, 10662, 10665, 3, 1372, 686, 0, 10663, 10665, 3, 1608, 804, 0, 10664, 10662, 1, 0, 0, 0, 10664, 10663, 1, 0, 0, 0, 10665, 1607, 1, 0, 0, 0, 10666, 10667, 7, 68, 0, 0, 10667, 1609, 1, 0, 0, 0, 10668, 10669, 3, 1328, 664, 0, 10669, 10670, 3, 982, 491, 0, 10670, 10671, 3, 1054, 527, 0, 10671, 10672, 3, 1094, 547, 0, 10672, 10673, 3, 1024, 512, 0, 10673, 10674, 3, 1038, 519, 0, 10674, 10675, 3, 1240, 620, 0, 10675, 1611, 1, 0, 0, 0, 10676, 10677, 3, 1610, 805, 0, 10677, 1613, 1, 0, 0, 0, 10678, 10679, 3, 1610, 805, 0, 10679, 1615, 1, 0, 0, 0, 10680, 10681, 3, 1162, 581, 0, 10681, 1617, 1, 0, 0, 0, 10682, 10683, 3, 1162, 581, 0, 10683, 1619, 1, 0, 0, 0, 10684, 10685, 3, 8, 4, 0, 10685, 10686, 3, 1622, 811, 0, 10686, 1621, 1, 0, 0, 0, 10687, 10688, 5, 71, 0, 0, 10688, 10689, 3, 984, 492, 0, 10689, 10690, 3, 1566, 783, 0, 10690, 10693, 1, 0, 0, 0, 10691, 10693, 1, 0, 0, 0, 10692, 10687, 1, 0, 0, 0, 10692, 10691, 1, 0, 0, 0, 10693, 1623, 1, 0, 0, 0, 744, 1633, 1637, 1765, 1769, 1782, 1787, 1793, 1799, 1814, 1826, 1844, 1849, 1859, 1883, 1890, 1896, 1901, 1910, 1914, 1926, 1957, 1964, 1972, 1977, 1984, 1990, 2007, 2012, 2016, 2029, 2033, 2038, 2043, 2055, 2064, 2077, 2082, 2093, 2104, 2109, 2120, 2131, 2140, 2150, 2165, 2177, 2182, 2189, 2200, 2458, 2465, 2470, 2475, 2480, 2488, 2497, 2504, 2514, 2516, 2521, 2527, 2533, 2535, 2563, 2573, 2586, 2598, 2612, 2617, 2641, 2647, 2652, 2659, 2664, 2702, 2706, 2713, 2717, 2724, 2738, 2745, 2756, 2789, 2799, 2803, 2810, 2817, 2825, 2831, 2835, 2845, 2852, 2863, 2895, 2903, 2908, 2915, 2925, 2935, 2955, 2970, 2995, 3000, 3007, 3014, 3025, 3030, 3037, 3048, 3056, 3067, 3083, 3091, 3095, 3109, 3126, 3131, 3138, 3147, 3150, 3155, 3162, 3173, 3186, 3199, 3217, 3220, 3229, 3244, 3259, 3268, 3275, 3282, 3287, 3317, 3319, 3323, 3331, 3338, 3352, 3356, 3360, 3365, 3371, 3375, 3379, 3392, 3398, 3407, 3416, 3426, 3437, 3547, 3565, 3570, 3574, 3591, 3599, 3606, 3619, 3629, 3663, 3668, 3673, 3677, 3685, 3687, 3745, 3762, 3770, 3793, 3797, 3817, 3854, 3863, 3868, 3873, 3878, 3883, 3936, 3942, 3949, 3959, 3964, 3969, 3987, 3991, 4001, 4007, 4013, 4020, 4025, 4030, 4044, 4072, 4079, 4093, 4108, 4225, 4236, 4242, 4250, 4261, 4270, 4277, 4317, 4323, 4344, 4372, 4376, 4381, 4390, 4394, 4421, 4428, 4443, 4463, 4483, 4576, 4601, 4608, 4624, 4633, 4638, 4644, 4651, 4665, 4814, 4818, 4911, 4916, 4920, 4926, 4994, 5000, 5029, 5046, 5053, 5065, 5125, 5132, 5138, 5144, 5170, 5176, 5182, 5193, 5205, 5234, 5273, 5277, 5281, 5285, 5290, 5297, 5311, 5324, 5332, 5339, 5345, 5349, 5354, 5361, 5375, 5377, 5384, 5388, 5397, 5405, 5414, 5416, 5420, 5429, 5434, 5440, 5445, 5449, 5454, 5460, 5466, 5472, 5478, 5483, 5498, 5507, 5518, 5524, 5563, 5573, 5580, 5591, 5597, 5607, 5619, 5623, 5661, 5675, 5689, 5713, 5720, 5730, 5742, 5747, 5783, 5790, 5805, 5852, 5889, 5900, 5917, 6387, 6391, 6396, 6455, 6459, 6678, 6693, 6704, 6711, 6904, 6914, 6922, 6951, 6967, 7009, 7023, 7045, 7052, 7060, 7064, 7071, 7080, 7089, 7141, 7146, 7158, 7162, 7167, 7172, 7176, 7180, 7185, 7201, 7209, 7214, 7227, 7232, 7239, 7249, 7253, 7264, 7275, 7283, 7290, 7329, 7337, 7341, 7422, 7450, 7455, 7470, 7482, 7489, 7499, 7504, 7508, 7512, 7516, 7520, 7527, 7537, 7542, 7560, 7571, 7578, 7586, 7591, 7604, 7610, 7639, 7646, 7658, 7671, 7686, 7692, 7701, 7717, 7720, 7731, 7736, 7740, 7744, 7749, 7752, 7758, 7762, 7764, 7767, 7774, 7777, 7784, 7792, 7795, 7804, 7819, 7832, 7843, 7846, 7850, 7856, 7872, 7885, 7895, 7913, 7915, 7923, 7927, 7937, 7947, 7958, 7960, 7969, 7979, 7990, 8003, 8007, 8016, 8031, 8035, 8042, 8045, 8049, 8052, 8065, 8069, 8074, 8082, 8086, 8090, 8101, 8108, 8114, 8118, 8120, 8124, 8130, 8139, 8145, 8147, 8149, 8156, 8160, 8169, 8173, 8183, 8190, 8198, 8222, 8228, 8232, 8237, 8246, 8250, 8253, 8258, 8271, 8277, 8285, 8288, 8295, 8300, 8321, 8330, 8335, 8341, 8346, 8353, 8358, 8364, 8366, 8370, 8377, 8381, 8384, 8391, 8396, 8399, 8406, 8410, 8419, 8423, 8431, 8433, 8440, 8445, 8448, 8463, 8475, 8485, 8494, 8499, 8504, 8511, 8514, 8518, 8525, 8549, 8558, 8564, 8568, 8573, 8583, 8590, 8599, 8602, 8611, 8613, 8619, 8623, 8628, 8642, 8644, 8650, 8656, 8659, 8668, 8686, 8693, 8697, 8701, 8717, 8724, 8732, 8736, 8743, 8756, 8772, 8778, 8784, 8791, 8796, 8802, 8809, 8817, 8825, 8830, 8834, 8840, 8844, 8848, 8851, 8857, 8862, 8878, 8881, 8883, 8895, 8897, 8901, 8907, 8912, 8920, 8924, 8933, 8941, 8947, 8950, 8959, 8964, 8971, 8981, 9007, 9018, 9020, 9022, 9030, 9053, 9061, 9071, 9085, 9095, 9099, 9113, 9120, 9127, 9134, 9159, 9188, 9227, 9229, 9257, 9278, 9285, 9298, 9310, 9316, 9325, 9342, 9354, 9363, 9368, 9375, 9385, 9388, 9399, 9405, 9420, 9428, 9437, 9446, 9449, 9454, 9463, 9468, 9482, 9492, 9500, 9514, 9521, 9529, 9537, 9544, 9550, 9559, 9567, 9577, 9588, 9595, 9624, 9633, 9640, 9651, 9661, 9665, 9669, 9674, 9682, 9686, 9690, 9695, 9700, 9705, 9712, 9720, 9723, 9730, 9735, 9742, 9758, 9773, 9787, 9792, 9811, 9816, 9821, 9828, 9835, 9842, 9851, 9857, 9863, 9869, 9877, 9886, 9944, 9959, 9982, 9990, 9994, 10006, 10008, 10015, 10024, 10042, 10050, 10059, 10066, 10076, 10082, 10089, 10094, 10100, 10104, 10111, 10141, 10161, 10165, 10181, 10188, 10201, 10209, 10229, 10235, 10247, 10252, 10262, 10294, 10299, 10308, 10313, 10317, 10322, 10338, 10356, 10359, 10365, 10393, 10403, 10410, 10412, 10417, 10428, 10439, 10460, 10467, 10474, 10480, 10483, 10494, 10501, 10503, 10512, 10519, 10525, 10531, 10535, 10550, 10567, 10569, 10593, 10597, 10608, 10611, 10615, 10620, 10625, 10637, 10643, 10647, 10651, 10655, 10660, 10664, 10692, } deserializer := antlr.NewATNDeserializer(nil) staticData.atn = deserializer.Deserialize(staticData.serializedATN) atn := staticData.atn staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) decisionToDFA := staticData.decisionToDFA for index, state := range atn.DecisionToState { decisionToDFA[index] = antlr.NewDFA(state, index) } } // PostgreSQLParserInit initializes any static state used to implement PostgreSQLParser. By default the // static state used to implement the parser is lazily initialized during the first call to // NewPostgreSQLParser(). You can call this function if you wish to initialize the static state ahead // of time. func PostgreSQLParserInit() { staticData := &PostgreSQLParserParserStaticData staticData.once.Do(postgresqlparserParserInit) } // NewPostgreSQLParser produces a new parser instance for the optional input antlr.TokenStream. func NewPostgreSQLParser(input antlr.TokenStream) *PostgreSQLParser { PostgreSQLParserInit() this := new(PostgreSQLParser) this.BaseParser = antlr.NewBaseParser(input) staticData := &PostgreSQLParserParserStaticData this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) this.RuleNames = staticData.RuleNames this.LiteralNames = staticData.LiteralNames this.SymbolicNames = staticData.SymbolicNames this.GrammarFileName = "PostgreSQLParser.g4" return this } // Note that '@members' cannot be changed now, but this should have been 'globals' // If you are looking to have variables for each instance, use '@structmembers' // PostgreSQLParser tokens. const ( PostgreSQLParserEOF = antlr.TokenEOF PostgreSQLParserDollar = 1 PostgreSQLParserOPEN_PAREN = 2 PostgreSQLParserCLOSE_PAREN = 3 PostgreSQLParserOPEN_BRACKET = 4 PostgreSQLParserCLOSE_BRACKET = 5 PostgreSQLParserCOMMA = 6 PostgreSQLParserSEMI = 7 PostgreSQLParserCOLON = 8 PostgreSQLParserSTAR = 9 PostgreSQLParserEQUAL = 10 PostgreSQLParserDOT = 11 PostgreSQLParserPLUS = 12 PostgreSQLParserMINUS = 13 PostgreSQLParserSLASH = 14 PostgreSQLParserCARET = 15 PostgreSQLParserLT = 16 PostgreSQLParserGT = 17 PostgreSQLParserLESS_LESS = 18 PostgreSQLParserGREATER_GREATER = 19 PostgreSQLParserCOLON_EQUALS = 20 PostgreSQLParserLESS_EQUALS = 21 PostgreSQLParserEQUALS_GREATER = 22 PostgreSQLParserGREATER_EQUALS = 23 PostgreSQLParserDOT_DOT = 24 PostgreSQLParserNOT_EQUALS = 25 PostgreSQLParserTYPECAST = 26 PostgreSQLParserPERCENT = 27 PostgreSQLParserPARAM = 28 PostgreSQLParserOperator = 29 PostgreSQLParserALL = 30 PostgreSQLParserANALYSE = 31 PostgreSQLParserANALYZE = 32 PostgreSQLParserAND = 33 PostgreSQLParserANY = 34 PostgreSQLParserARRAY = 35 PostgreSQLParserAS = 36 PostgreSQLParserASC = 37 PostgreSQLParserASYMMETRIC = 38 PostgreSQLParserBOTH = 39 PostgreSQLParserCASE = 40 PostgreSQLParserCAST = 41 PostgreSQLParserCHECK = 42 PostgreSQLParserCOLLATE = 43 PostgreSQLParserCOLUMN = 44 PostgreSQLParserCONSTRAINT = 45 PostgreSQLParserCREATE = 46 PostgreSQLParserCURRENT_CATALOG = 47 PostgreSQLParserCURRENT_DATE = 48 PostgreSQLParserCURRENT_ROLE = 49 PostgreSQLParserCURRENT_TIME = 50 PostgreSQLParserCURRENT_TIMESTAMP = 51 PostgreSQLParserCURRENT_USER = 52 PostgreSQLParserDEFAULT = 53 PostgreSQLParserDEFERRABLE = 54 PostgreSQLParserDESC = 55 PostgreSQLParserDISTINCT = 56 PostgreSQLParserDO = 57 PostgreSQLParserELSE = 58 PostgreSQLParserEXCEPT = 59 PostgreSQLParserFALSE_P = 60 PostgreSQLParserFETCH = 61 PostgreSQLParserFOR = 62 PostgreSQLParserFOREIGN = 63 PostgreSQLParserFROM = 64 PostgreSQLParserGRANT = 65 PostgreSQLParserGROUP_P = 66 PostgreSQLParserHAVING = 67 PostgreSQLParserIN_P = 68 PostgreSQLParserINITIALLY = 69 PostgreSQLParserINTERSECT = 70 PostgreSQLParserINTO = 71 PostgreSQLParserLATERAL_P = 72 PostgreSQLParserLEADING = 73 PostgreSQLParserLIMIT = 74 PostgreSQLParserLOCALTIME = 75 PostgreSQLParserLOCALTIMESTAMP = 76 PostgreSQLParserNOT = 77 PostgreSQLParserNULL_P = 78 PostgreSQLParserOFFSET = 79 PostgreSQLParserON = 80 PostgreSQLParserONLY = 81 PostgreSQLParserOR = 82 PostgreSQLParserORDER = 83 PostgreSQLParserPLACING = 84 PostgreSQLParserPRIMARY = 85 PostgreSQLParserREFERENCES = 86 PostgreSQLParserRETURNING = 87 PostgreSQLParserSELECT = 88 PostgreSQLParserSESSION_USER = 89 PostgreSQLParserSOME = 90 PostgreSQLParserSYMMETRIC = 91 PostgreSQLParserTABLE = 92 PostgreSQLParserTHEN = 93 PostgreSQLParserTO = 94 PostgreSQLParserTRAILING = 95 PostgreSQLParserTRUE_P = 96 PostgreSQLParserUNION = 97 PostgreSQLParserUNIQUE = 98 PostgreSQLParserUSER = 99 PostgreSQLParserUSING = 100 PostgreSQLParserVARIADIC = 101 PostgreSQLParserWHEN = 102 PostgreSQLParserWHERE = 103 PostgreSQLParserWINDOW = 104 PostgreSQLParserWITH = 105 PostgreSQLParserAUTHORIZATION = 106 PostgreSQLParserBINARY = 107 PostgreSQLParserCOLLATION = 108 PostgreSQLParserCONCURRENTLY = 109 PostgreSQLParserCROSS = 110 PostgreSQLParserCURRENT_SCHEMA = 111 PostgreSQLParserFREEZE = 112 PostgreSQLParserFULL = 113 PostgreSQLParserILIKE = 114 PostgreSQLParserINNER_P = 115 PostgreSQLParserIS = 116 PostgreSQLParserISNULL = 117 PostgreSQLParserJOIN = 118 PostgreSQLParserLEFT = 119 PostgreSQLParserLIKE = 120 PostgreSQLParserNATURAL = 121 PostgreSQLParserNOTNULL = 122 PostgreSQLParserOUTER_P = 123 PostgreSQLParserOVER = 124 PostgreSQLParserOVERLAPS = 125 PostgreSQLParserRIGHT = 126 PostgreSQLParserSIMILAR = 127 PostgreSQLParserVERBOSE = 128 PostgreSQLParserABORT_P = 129 PostgreSQLParserABSOLUTE_P = 130 PostgreSQLParserACCESS = 131 PostgreSQLParserACTION = 132 PostgreSQLParserADD_P = 133 PostgreSQLParserADMIN = 134 PostgreSQLParserAFTER = 135 PostgreSQLParserAGGREGATE = 136 PostgreSQLParserALSO = 137 PostgreSQLParserALTER = 138 PostgreSQLParserALWAYS = 139 PostgreSQLParserASSERTION = 140 PostgreSQLParserASSIGNMENT = 141 PostgreSQLParserAT = 142 PostgreSQLParserATTRIBUTE = 143 PostgreSQLParserBACKWARD = 144 PostgreSQLParserBEFORE = 145 PostgreSQLParserBEGIN_P = 146 PostgreSQLParserBY = 147 PostgreSQLParserCACHE = 148 PostgreSQLParserCALLED = 149 PostgreSQLParserCASCADE = 150 PostgreSQLParserCASCADED = 151 PostgreSQLParserCATALOG = 152 PostgreSQLParserCHAIN = 153 PostgreSQLParserCHARACTERISTICS = 154 PostgreSQLParserCHECKPOINT = 155 PostgreSQLParserCLASS = 156 PostgreSQLParserCLOSE = 157 PostgreSQLParserCLUSTER = 158 PostgreSQLParserCOMMENT = 159 PostgreSQLParserCOMMENTS = 160 PostgreSQLParserCOMMIT = 161 PostgreSQLParserCOMMITTED = 162 PostgreSQLParserCONFIGURATION = 163 PostgreSQLParserCONNECTION = 164 PostgreSQLParserCONSTRAINTS = 165 PostgreSQLParserCONTENT_P = 166 PostgreSQLParserCONTINUE_P = 167 PostgreSQLParserCONVERSION_P = 168 PostgreSQLParserCOPY = 169 PostgreSQLParserCOST = 170 PostgreSQLParserCSV = 171 PostgreSQLParserCURSOR = 172 PostgreSQLParserCYCLE = 173 PostgreSQLParserDATA_P = 174 PostgreSQLParserDATABASE = 175 PostgreSQLParserDAY_P = 176 PostgreSQLParserDEALLOCATE = 177 PostgreSQLParserDECLARE = 178 PostgreSQLParserDEFAULTS = 179 PostgreSQLParserDEFERRED = 180 PostgreSQLParserDEFINER = 181 PostgreSQLParserDELETE_P = 182 PostgreSQLParserDELIMITER = 183 PostgreSQLParserDELIMITERS = 184 PostgreSQLParserDICTIONARY = 185 PostgreSQLParserDISABLE_P = 186 PostgreSQLParserDISCARD = 187 PostgreSQLParserDOCUMENT_P = 188 PostgreSQLParserDOMAIN_P = 189 PostgreSQLParserDOUBLE_P = 190 PostgreSQLParserDROP = 191 PostgreSQLParserEACH = 192 PostgreSQLParserENABLE_P = 193 PostgreSQLParserENCODING = 194 PostgreSQLParserENCRYPTED = 195 PostgreSQLParserENUM_P = 196 PostgreSQLParserESCAPE = 197 PostgreSQLParserEVENT = 198 PostgreSQLParserEXCLUDE = 199 PostgreSQLParserEXCLUDING = 200 PostgreSQLParserEXCLUSIVE = 201 PostgreSQLParserEXECUTE = 202 PostgreSQLParserEXPLAIN = 203 PostgreSQLParserEXTENSION = 204 PostgreSQLParserEXTERNAL = 205 PostgreSQLParserFAMILY = 206 PostgreSQLParserFIRST_P = 207 PostgreSQLParserFOLLOWING = 208 PostgreSQLParserFORCE = 209 PostgreSQLParserFORWARD = 210 PostgreSQLParserFUNCTION = 211 PostgreSQLParserFUNCTIONS = 212 PostgreSQLParserGLOBAL = 213 PostgreSQLParserGRANTED = 214 PostgreSQLParserHANDLER = 215 PostgreSQLParserHEADER_P = 216 PostgreSQLParserHOLD = 217 PostgreSQLParserHOUR_P = 218 PostgreSQLParserIDENTITY_P = 219 PostgreSQLParserIF_P = 220 PostgreSQLParserIMMEDIATE = 221 PostgreSQLParserIMMUTABLE = 222 PostgreSQLParserIMPLICIT_P = 223 PostgreSQLParserINCLUDING = 224 PostgreSQLParserINCREMENT = 225 PostgreSQLParserINDEX = 226 PostgreSQLParserINDEXES = 227 PostgreSQLParserINHERIT = 228 PostgreSQLParserINHERITS = 229 PostgreSQLParserINLINE_P = 230 PostgreSQLParserINSENSITIVE = 231 PostgreSQLParserINSERT = 232 PostgreSQLParserINSTEAD = 233 PostgreSQLParserINVOKER = 234 PostgreSQLParserISOLATION = 235 PostgreSQLParserKEY = 236 PostgreSQLParserLABEL = 237 PostgreSQLParserLANGUAGE = 238 PostgreSQLParserLARGE_P = 239 PostgreSQLParserLAST_P = 240 PostgreSQLParserLEAKPROOF = 241 PostgreSQLParserLEVEL = 242 PostgreSQLParserLISTEN = 243 PostgreSQLParserLOAD = 244 PostgreSQLParserLOCAL = 245 PostgreSQLParserLOCATION = 246 PostgreSQLParserLOCK_P = 247 PostgreSQLParserMAPPING = 248 PostgreSQLParserMATCH = 249 PostgreSQLParserMATCHED = 250 PostgreSQLParserMATERIALIZED = 251 PostgreSQLParserMAXVALUE = 252 PostgreSQLParserMERGE = 253 PostgreSQLParserMINUTE_P = 254 PostgreSQLParserMINVALUE = 255 PostgreSQLParserMODE = 256 PostgreSQLParserMONTH_P = 257 PostgreSQLParserMOVE = 258 PostgreSQLParserNAME_P = 259 PostgreSQLParserNAMES = 260 PostgreSQLParserNEXT = 261 PostgreSQLParserNO = 262 PostgreSQLParserNOTHING = 263 PostgreSQLParserNOTIFY = 264 PostgreSQLParserNOWAIT = 265 PostgreSQLParserNULLS_P = 266 PostgreSQLParserOBJECT_P = 267 PostgreSQLParserOF = 268 PostgreSQLParserOFF = 269 PostgreSQLParserOIDS = 270 PostgreSQLParserOPERATOR = 271 PostgreSQLParserOPTION = 272 PostgreSQLParserOPTIONS = 273 PostgreSQLParserOWNED = 274 PostgreSQLParserOWNER = 275 PostgreSQLParserPARSER = 276 PostgreSQLParserPARTIAL = 277 PostgreSQLParserPARTITION = 278 PostgreSQLParserPASSING = 279 PostgreSQLParserPASSWORD = 280 PostgreSQLParserPLANS = 281 PostgreSQLParserPRECEDING = 282 PostgreSQLParserPREPARE = 283 PostgreSQLParserPREPARED = 284 PostgreSQLParserPRESERVE = 285 PostgreSQLParserPRIOR = 286 PostgreSQLParserPRIVILEGES = 287 PostgreSQLParserPROCEDURAL = 288 PostgreSQLParserPROCEDURE = 289 PostgreSQLParserPROGRAM = 290 PostgreSQLParserQUOTE = 291 PostgreSQLParserRANGE = 292 PostgreSQLParserREAD = 293 PostgreSQLParserREASSIGN = 294 PostgreSQLParserRECHECK = 295 PostgreSQLParserRECURSIVE = 296 PostgreSQLParserREF = 297 PostgreSQLParserREFRESH = 298 PostgreSQLParserREINDEX = 299 PostgreSQLParserRELATIVE_P = 300 PostgreSQLParserRELEASE = 301 PostgreSQLParserRENAME = 302 PostgreSQLParserREPEATABLE = 303 PostgreSQLParserREPLACE = 304 PostgreSQLParserREPLICA = 305 PostgreSQLParserRESET = 306 PostgreSQLParserRESTART = 307 PostgreSQLParserRESTRICT = 308 PostgreSQLParserRETURNS = 309 PostgreSQLParserREVOKE = 310 PostgreSQLParserROLE = 311 PostgreSQLParserROLLBACK = 312 PostgreSQLParserROWS = 313 PostgreSQLParserRULE = 314 PostgreSQLParserSAVEPOINT = 315 PostgreSQLParserSCHEMA = 316 PostgreSQLParserSCROLL = 317 PostgreSQLParserSEARCH = 318 PostgreSQLParserSECOND_P = 319 PostgreSQLParserSECURITY = 320 PostgreSQLParserSEQUENCE = 321 PostgreSQLParserSEQUENCES = 322 PostgreSQLParserSERIALIZABLE = 323 PostgreSQLParserSERVER = 324 PostgreSQLParserSESSION = 325 PostgreSQLParserSET = 326 PostgreSQLParserSHARE = 327 PostgreSQLParserSHOW = 328 PostgreSQLParserSIMPLE = 329 PostgreSQLParserSNAPSHOT = 330 PostgreSQLParserSTABLE = 331 PostgreSQLParserSTANDALONE_P = 332 PostgreSQLParserSTART = 333 PostgreSQLParserSTATEMENT = 334 PostgreSQLParserSTATISTICS = 335 PostgreSQLParserSTDIN = 336 PostgreSQLParserSTDOUT = 337 PostgreSQLParserSTORAGE = 338 PostgreSQLParserSTRICT_P = 339 PostgreSQLParserSTRIP_P = 340 PostgreSQLParserSYSID = 341 PostgreSQLParserSYSTEM_P = 342 PostgreSQLParserTABLES = 343 PostgreSQLParserTABLESPACE = 344 PostgreSQLParserTEMP = 345 PostgreSQLParserTEMPLATE = 346 PostgreSQLParserTEMPORARY = 347 PostgreSQLParserTEXT_P = 348 PostgreSQLParserTRANSACTION = 349 PostgreSQLParserTRIGGER = 350 PostgreSQLParserTRUNCATE = 351 PostgreSQLParserTRUSTED = 352 PostgreSQLParserTYPE_P = 353 PostgreSQLParserTYPES_P = 354 PostgreSQLParserUNBOUNDED = 355 PostgreSQLParserUNCOMMITTED = 356 PostgreSQLParserUNENCRYPTED = 357 PostgreSQLParserUNKNOWN = 358 PostgreSQLParserUNLISTEN = 359 PostgreSQLParserUNLOGGED = 360 PostgreSQLParserUNTIL = 361 PostgreSQLParserUPDATE = 362 PostgreSQLParserVACUUM = 363 PostgreSQLParserVALID = 364 PostgreSQLParserVALIDATE = 365 PostgreSQLParserVALIDATOR = 366 PostgreSQLParserVARYING = 367 PostgreSQLParserVERSION_P = 368 PostgreSQLParserVIEW = 369 PostgreSQLParserVOLATILE = 370 PostgreSQLParserWHITESPACE_P = 371 PostgreSQLParserWITHOUT = 372 PostgreSQLParserWORK = 373 PostgreSQLParserWRAPPER = 374 PostgreSQLParserWRITE = 375 PostgreSQLParserXML_P = 376 PostgreSQLParserYEAR_P = 377 PostgreSQLParserYES_P = 378 PostgreSQLParserZONE = 379 PostgreSQLParserBETWEEN = 380 PostgreSQLParserBIGINT = 381 PostgreSQLParserBIT = 382 PostgreSQLParserBOOLEAN_P = 383 PostgreSQLParserCHAR_P = 384 PostgreSQLParserCHARACTER = 385 PostgreSQLParserCOALESCE = 386 PostgreSQLParserDEC = 387 PostgreSQLParserDECIMAL_P = 388 PostgreSQLParserEXISTS = 389 PostgreSQLParserEXTRACT = 390 PostgreSQLParserFLOAT_P = 391 PostgreSQLParserGREATEST = 392 PostgreSQLParserINOUT = 393 PostgreSQLParserINT_P = 394 PostgreSQLParserINTEGER = 395 PostgreSQLParserINTERVAL = 396 PostgreSQLParserLEAST = 397 PostgreSQLParserNATIONAL = 398 PostgreSQLParserNCHAR = 399 PostgreSQLParserNONE = 400 PostgreSQLParserNULLIF = 401 PostgreSQLParserNUMERIC = 402 PostgreSQLParserOVERLAY = 403 PostgreSQLParserPOSITION = 404 PostgreSQLParserPRECISION = 405 PostgreSQLParserREAL = 406 PostgreSQLParserROW = 407 PostgreSQLParserSETOF = 408 PostgreSQLParserSMALLINT = 409 PostgreSQLParserSUBSTRING = 410 PostgreSQLParserTIME = 411 PostgreSQLParserTIMESTAMP = 412 PostgreSQLParserTREAT = 413 PostgreSQLParserTRIM = 414 PostgreSQLParserVALUES = 415 PostgreSQLParserVARCHAR = 416 PostgreSQLParserXMLATTRIBUTES = 417 PostgreSQLParserXMLCOMMENT = 418 PostgreSQLParserXMLAGG = 419 PostgreSQLParserXML_IS_WELL_FORMED = 420 PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT = 421 PostgreSQLParserXML_IS_WELL_FORMED_CONTENT = 422 PostgreSQLParserXPATH = 423 PostgreSQLParserXPATH_EXISTS = 424 PostgreSQLParserXMLCONCAT = 425 PostgreSQLParserXMLELEMENT = 426 PostgreSQLParserXMLEXISTS = 427 PostgreSQLParserXMLFOREST = 428 PostgreSQLParserXMLPARSE = 429 PostgreSQLParserXMLPI = 430 PostgreSQLParserXMLROOT = 431 PostgreSQLParserXMLSERIALIZE = 432 PostgreSQLParserCALL = 433 PostgreSQLParserCURRENT_P = 434 PostgreSQLParserATTACH = 435 PostgreSQLParserDETACH = 436 PostgreSQLParserEXPRESSION = 437 PostgreSQLParserGENERATED = 438 PostgreSQLParserLOGGED = 439 PostgreSQLParserSTORED = 440 PostgreSQLParserINCLUDE = 441 PostgreSQLParserROUTINE = 442 PostgreSQLParserTRANSFORM = 443 PostgreSQLParserIMPORT_P = 444 PostgreSQLParserPOLICY = 445 PostgreSQLParserMETHOD = 446 PostgreSQLParserREFERENCING = 447 PostgreSQLParserNEW = 448 PostgreSQLParserOLD = 449 PostgreSQLParserVALUE_P = 450 PostgreSQLParserSUBSCRIPTION = 451 PostgreSQLParserPUBLICATION = 452 PostgreSQLParserOUT_P = 453 PostgreSQLParserEND_P = 454 PostgreSQLParserROUTINES = 455 PostgreSQLParserSCHEMAS = 456 PostgreSQLParserPROCEDURES = 457 PostgreSQLParserINPUT_P = 458 PostgreSQLParserSUPPORT = 459 PostgreSQLParserPARALLEL = 460 PostgreSQLParserSQL_P = 461 PostgreSQLParserDEPENDS = 462 PostgreSQLParserOVERRIDING = 463 PostgreSQLParserCONFLICT = 464 PostgreSQLParserSKIP_P = 465 PostgreSQLParserLOCKED = 466 PostgreSQLParserTIES = 467 PostgreSQLParserROLLUP = 468 PostgreSQLParserCUBE = 469 PostgreSQLParserGROUPING = 470 PostgreSQLParserSETS = 471 PostgreSQLParserTABLESAMPLE = 472 PostgreSQLParserORDINALITY = 473 PostgreSQLParserXMLTABLE = 474 PostgreSQLParserCOLUMNS = 475 PostgreSQLParserXMLNAMESPACES = 476 PostgreSQLParserROWTYPE = 477 PostgreSQLParserNORMALIZED = 478 PostgreSQLParserWITHIN = 479 PostgreSQLParserFILTER = 480 PostgreSQLParserGROUPS = 481 PostgreSQLParserOTHERS = 482 PostgreSQLParserNFC = 483 PostgreSQLParserNFD = 484 PostgreSQLParserNFKC = 485 PostgreSQLParserNFKD = 486 PostgreSQLParserUESCAPE = 487 PostgreSQLParserVIEWS = 488 PostgreSQLParserNORMALIZE = 489 PostgreSQLParserDUMP = 490 PostgreSQLParserPRINT_STRICT_PARAMS = 491 PostgreSQLParserVARIABLE_CONFLICT = 492 PostgreSQLParserERROR = 493 PostgreSQLParserUSE_VARIABLE = 494 PostgreSQLParserUSE_COLUMN = 495 PostgreSQLParserALIAS = 496 PostgreSQLParserCONSTANT = 497 PostgreSQLParserPERFORM = 498 PostgreSQLParserGET = 499 PostgreSQLParserDIAGNOSTICS = 500 PostgreSQLParserSTACKED = 501 PostgreSQLParserELSIF = 502 PostgreSQLParserWHILE = 503 PostgreSQLParserREVERSE = 504 PostgreSQLParserFOREACH = 505 PostgreSQLParserSLICE = 506 PostgreSQLParserEXIT = 507 PostgreSQLParserRETURN = 508 PostgreSQLParserQUERY = 509 PostgreSQLParserRAISE = 510 PostgreSQLParserSQLSTATE = 511 PostgreSQLParserDEBUG = 512 PostgreSQLParserLOG = 513 PostgreSQLParserINFO = 514 PostgreSQLParserNOTICE = 515 PostgreSQLParserWARNING = 516 PostgreSQLParserEXCEPTION = 517 PostgreSQLParserASSERT = 518 PostgreSQLParserLOOP = 519 PostgreSQLParserOPEN = 520 PostgreSQLParserABS = 521 PostgreSQLParserCBRT = 522 PostgreSQLParserCEIL = 523 PostgreSQLParserCEILING = 524 PostgreSQLParserDEGREES = 525 PostgreSQLParserDIV = 526 PostgreSQLParserEXP = 527 PostgreSQLParserFACTORIAL = 528 PostgreSQLParserFLOOR = 529 PostgreSQLParserGCD = 530 PostgreSQLParserLCM = 531 PostgreSQLParserLN = 532 PostgreSQLParserLOG10 = 533 PostgreSQLParserMIN_SCALE = 534 PostgreSQLParserMOD = 535 PostgreSQLParserPI = 536 PostgreSQLParserPOWER = 537 PostgreSQLParserRADIANS = 538 PostgreSQLParserROUND = 539 PostgreSQLParserSCALE = 540 PostgreSQLParserSIGN = 541 PostgreSQLParserSQRT = 542 PostgreSQLParserTRIM_SCALE = 543 PostgreSQLParserTRUNC = 544 PostgreSQLParserWIDTH_BUCKET = 545 PostgreSQLParserRANDOM = 546 PostgreSQLParserSETSEED = 547 PostgreSQLParserACOS = 548 PostgreSQLParserACOSD = 549 PostgreSQLParserASIN = 550 PostgreSQLParserASIND = 551 PostgreSQLParserATAN = 552 PostgreSQLParserATAND = 553 PostgreSQLParserATAN2 = 554 PostgreSQLParserATAN2D = 555 PostgreSQLParserCOS = 556 PostgreSQLParserCOSD = 557 PostgreSQLParserCOT = 558 PostgreSQLParserCOTD = 559 PostgreSQLParserSIN = 560 PostgreSQLParserSIND = 561 PostgreSQLParserTAN = 562 PostgreSQLParserTAND = 563 PostgreSQLParserSINH = 564 PostgreSQLParserCOSH = 565 PostgreSQLParserTANH = 566 PostgreSQLParserASINH = 567 PostgreSQLParserACOSH = 568 PostgreSQLParserATANH = 569 PostgreSQLParserBIT_LENGTH = 570 PostgreSQLParserCHAR_LENGTH = 571 PostgreSQLParserCHARACTER_LENGTH = 572 PostgreSQLParserLOWER = 573 PostgreSQLParserOCTET_LENGTH = 574 PostgreSQLParserUPPER = 575 PostgreSQLParserASCII = 576 PostgreSQLParserBTRIM = 577 PostgreSQLParserCHR = 578 PostgreSQLParserCONCAT = 579 PostgreSQLParserCONCAT_WS = 580 PostgreSQLParserFORMAT = 581 PostgreSQLParserINITCAP = 582 PostgreSQLParserLENGTH = 583 PostgreSQLParserLPAD = 584 PostgreSQLParserLTRIM = 585 PostgreSQLParserMD5 = 586 PostgreSQLParserPARSE_IDENT = 587 PostgreSQLParserPG_CLIENT_ENCODING = 588 PostgreSQLParserQUOTE_IDENT = 589 PostgreSQLParserQUOTE_LITERAL = 590 PostgreSQLParserQUOTE_NULLABLE = 591 PostgreSQLParserREGEXP_COUNT = 592 PostgreSQLParserREGEXP_INSTR = 593 PostgreSQLParserREGEXP_LIKE = 594 PostgreSQLParserREGEXP_MATCH = 595 PostgreSQLParserREGEXP_MATCHES = 596 PostgreSQLParserREGEXP_REPLACE = 597 PostgreSQLParserREGEXP_SPLIT_TO_ARRAY = 598 PostgreSQLParserREGEXP_SPLIT_TO_TABLE = 599 PostgreSQLParserREGEXP_SUBSTR = 600 PostgreSQLParserREPEAT = 601 PostgreSQLParserRPAD = 602 PostgreSQLParserRTRIM = 603 PostgreSQLParserSPLIT_PART = 604 PostgreSQLParserSTARTS_WITH = 605 PostgreSQLParserSTRING_TO_ARRAY = 606 PostgreSQLParserSTRING_TO_TABLE = 607 PostgreSQLParserSTRPOS = 608 PostgreSQLParserSUBSTR = 609 PostgreSQLParserTO_ASCII = 610 PostgreSQLParserTO_HEX = 611 PostgreSQLParserTRANSLATE = 612 PostgreSQLParserUNISTR = 613 PostgreSQLParserAGE = 614 PostgreSQLParserCLOCK_TIMESTAMP = 615 PostgreSQLParserDATE_BIN = 616 PostgreSQLParserDATE_PART = 617 PostgreSQLParserDATE_TRUNC = 618 PostgreSQLParserISFINITE = 619 PostgreSQLParserJUSTIFY_DAYS = 620 PostgreSQLParserJUSTIFY_HOURS = 621 PostgreSQLParserJUSTIFY_INTERVAL = 622 PostgreSQLParserMAKE_DATE = 623 PostgreSQLParserMAKE_INTERVAL = 624 PostgreSQLParserMAKE_TIME = 625 PostgreSQLParserMAKE_TIMESTAMP = 626 PostgreSQLParserMAKE_TIMESTAMPTZ = 627 PostgreSQLParserNOW = 628 PostgreSQLParserSTATEMENT_TIMESTAMP = 629 PostgreSQLParserTIMEOFDAY = 630 PostgreSQLParserTRANSACTION_TIMESTAMP = 631 PostgreSQLParserTO_TIMESTAMP = 632 PostgreSQLParserTO_CHAR = 633 PostgreSQLParserTO_DATE = 634 PostgreSQLParserTO_NUMBER = 635 PostgreSQLParserIdentifier = 636 PostgreSQLParserQuotedIdentifier = 637 PostgreSQLParserUnterminatedQuotedIdentifier = 638 PostgreSQLParserInvalidQuotedIdentifier = 639 PostgreSQLParserInvalidUnterminatedQuotedIdentifier = 640 PostgreSQLParserUnicodeQuotedIdentifier = 641 PostgreSQLParserUnterminatedUnicodeQuotedIdentifier = 642 PostgreSQLParserInvalidUnicodeQuotedIdentifier = 643 PostgreSQLParserInvalidUnterminatedUnicodeQuotedIdentifier = 644 PostgreSQLParserStringConstant = 645 PostgreSQLParserUnterminatedStringConstant = 646 PostgreSQLParserUnicodeEscapeStringConstant = 647 PostgreSQLParserUnterminatedUnicodeEscapeStringConstant = 648 PostgreSQLParserBeginDollarStringConstant = 649 PostgreSQLParserBinaryStringConstant = 650 PostgreSQLParserUnterminatedBinaryStringConstant = 651 PostgreSQLParserInvalidBinaryStringConstant = 652 PostgreSQLParserInvalidUnterminatedBinaryStringConstant = 653 PostgreSQLParserHexadecimalStringConstant = 654 PostgreSQLParserUnterminatedHexadecimalStringConstant = 655 PostgreSQLParserInvalidHexadecimalStringConstant = 656 PostgreSQLParserInvalidUnterminatedHexadecimalStringConstant = 657 PostgreSQLParserIntegral = 658 PostgreSQLParserNumericFail = 659 PostgreSQLParserNumeric = 660 PostgreSQLParserPLSQLVARIABLENAME = 661 PostgreSQLParserPLSQLIDENTIFIER = 662 PostgreSQLParserWhitespace = 663 PostgreSQLParserNewline = 664 PostgreSQLParserLineComment = 665 PostgreSQLParserBlockComment = 666 PostgreSQLParserUnterminatedBlockComment = 667 PostgreSQLParserMetaCommand = 668 PostgreSQLParserEndMetaCommand = 669 PostgreSQLParserErrorCharacter = 670 PostgreSQLParserEscapeStringConstant = 671 PostgreSQLParserUnterminatedEscapeStringConstant = 672 PostgreSQLParserInvalidEscapeStringConstant = 673 PostgreSQLParserInvalidUnterminatedEscapeStringConstant = 674 PostgreSQLParserAfterEscapeStringConstantMode_NotContinued = 675 PostgreSQLParserAfterEscapeStringConstantWithNewlineMode_NotContinued = 676 PostgreSQLParserDollarText = 677 PostgreSQLParserEndDollarStringConstant = 678 PostgreSQLParserAfterEscapeStringConstantWithNewlineMode_Continued = 679 ) // PostgreSQLParser rules. const ( PostgreSQLParserRULE_root = 0 PostgreSQLParserRULE_plsqlroot = 1 PostgreSQLParserRULE_stmtblock = 2 PostgreSQLParserRULE_stmtmulti = 3 PostgreSQLParserRULE_stmt = 4 PostgreSQLParserRULE_plsqlconsolecommand = 5 PostgreSQLParserRULE_callstmt = 6 PostgreSQLParserRULE_createrolestmt = 7 PostgreSQLParserRULE_opt_with = 8 PostgreSQLParserRULE_optrolelist = 9 PostgreSQLParserRULE_alteroptrolelist = 10 PostgreSQLParserRULE_alteroptroleelem = 11 PostgreSQLParserRULE_createoptroleelem = 12 PostgreSQLParserRULE_createuserstmt = 13 PostgreSQLParserRULE_alterrolestmt = 14 PostgreSQLParserRULE_opt_in_database = 15 PostgreSQLParserRULE_alterrolesetstmt = 16 PostgreSQLParserRULE_droprolestmt = 17 PostgreSQLParserRULE_creategroupstmt = 18 PostgreSQLParserRULE_altergroupstmt = 19 PostgreSQLParserRULE_add_drop = 20 PostgreSQLParserRULE_createschemastmt = 21 PostgreSQLParserRULE_optschemaname = 22 PostgreSQLParserRULE_optschemaeltlist = 23 PostgreSQLParserRULE_schema_stmt = 24 PostgreSQLParserRULE_variablesetstmt = 25 PostgreSQLParserRULE_set_rest = 26 PostgreSQLParserRULE_generic_set = 27 PostgreSQLParserRULE_set_rest_more = 28 PostgreSQLParserRULE_var_name = 29 PostgreSQLParserRULE_var_list = 30 PostgreSQLParserRULE_var_value = 31 PostgreSQLParserRULE_iso_level = 32 PostgreSQLParserRULE_opt_boolean_or_string = 33 PostgreSQLParserRULE_zone_value = 34 PostgreSQLParserRULE_opt_encoding = 35 PostgreSQLParserRULE_nonreservedword_or_sconst = 36 PostgreSQLParserRULE_variableresetstmt = 37 PostgreSQLParserRULE_reset_rest = 38 PostgreSQLParserRULE_generic_reset = 39 PostgreSQLParserRULE_setresetclause = 40 PostgreSQLParserRULE_functionsetresetclause = 41 PostgreSQLParserRULE_variableshowstmt = 42 PostgreSQLParserRULE_constraintssetstmt = 43 PostgreSQLParserRULE_constraints_set_list = 44 PostgreSQLParserRULE_constraints_set_mode = 45 PostgreSQLParserRULE_checkpointstmt = 46 PostgreSQLParserRULE_discardstmt = 47 PostgreSQLParserRULE_altertablestmt = 48 PostgreSQLParserRULE_alter_table_cmds = 49 PostgreSQLParserRULE_partition_cmd = 50 PostgreSQLParserRULE_index_partition_cmd = 51 PostgreSQLParserRULE_alter_table_cmd = 52 PostgreSQLParserRULE_alter_column_default = 53 PostgreSQLParserRULE_opt_drop_behavior = 54 PostgreSQLParserRULE_opt_collate_clause = 55 PostgreSQLParserRULE_alter_using = 56 PostgreSQLParserRULE_replica_identity = 57 PostgreSQLParserRULE_reloptions = 58 PostgreSQLParserRULE_opt_reloptions = 59 PostgreSQLParserRULE_reloption_list = 60 PostgreSQLParserRULE_reloption_elem = 61 PostgreSQLParserRULE_alter_identity_column_option_list = 62 PostgreSQLParserRULE_alter_identity_column_option = 63 PostgreSQLParserRULE_partitionboundspec = 64 PostgreSQLParserRULE_hash_partbound_elem = 65 PostgreSQLParserRULE_hash_partbound = 66 PostgreSQLParserRULE_altercompositetypestmt = 67 PostgreSQLParserRULE_alter_type_cmds = 68 PostgreSQLParserRULE_alter_type_cmd = 69 PostgreSQLParserRULE_closeportalstmt = 70 PostgreSQLParserRULE_copystmt = 71 PostgreSQLParserRULE_copy_from = 72 PostgreSQLParserRULE_opt_program = 73 PostgreSQLParserRULE_copy_file_name = 74 PostgreSQLParserRULE_copy_options = 75 PostgreSQLParserRULE_copy_opt_list = 76 PostgreSQLParserRULE_copy_opt_item = 77 PostgreSQLParserRULE_opt_binary = 78 PostgreSQLParserRULE_copy_delimiter = 79 PostgreSQLParserRULE_opt_using = 80 PostgreSQLParserRULE_copy_generic_opt_list = 81 PostgreSQLParserRULE_copy_generic_opt_elem = 82 PostgreSQLParserRULE_copy_generic_opt_arg = 83 PostgreSQLParserRULE_copy_generic_opt_arg_list = 84 PostgreSQLParserRULE_copy_generic_opt_arg_list_item = 85 PostgreSQLParserRULE_createstmt = 86 PostgreSQLParserRULE_opttemp = 87 PostgreSQLParserRULE_opttableelementlist = 88 PostgreSQLParserRULE_opttypedtableelementlist = 89 PostgreSQLParserRULE_tableelementlist = 90 PostgreSQLParserRULE_typedtableelementlist = 91 PostgreSQLParserRULE_tableelement = 92 PostgreSQLParserRULE_typedtableelement = 93 PostgreSQLParserRULE_columnDef = 94 PostgreSQLParserRULE_columnOptions = 95 PostgreSQLParserRULE_colquallist = 96 PostgreSQLParserRULE_colconstraint = 97 PostgreSQLParserRULE_colconstraintelem = 98 PostgreSQLParserRULE_generated_when = 99 PostgreSQLParserRULE_constraintattr = 100 PostgreSQLParserRULE_tablelikeclause = 101 PostgreSQLParserRULE_tablelikeoptionlist = 102 PostgreSQLParserRULE_tablelikeoption = 103 PostgreSQLParserRULE_tableconstraint = 104 PostgreSQLParserRULE_constraintelem = 105 PostgreSQLParserRULE_opt_no_inherit = 106 PostgreSQLParserRULE_opt_column_list = 107 PostgreSQLParserRULE_columnlist = 108 PostgreSQLParserRULE_columnElem = 109 PostgreSQLParserRULE_opt_c_include = 110 PostgreSQLParserRULE_key_match = 111 PostgreSQLParserRULE_exclusionconstraintlist = 112 PostgreSQLParserRULE_exclusionconstraintelem = 113 PostgreSQLParserRULE_exclusionwhereclause = 114 PostgreSQLParserRULE_key_actions = 115 PostgreSQLParserRULE_key_update = 116 PostgreSQLParserRULE_key_delete = 117 PostgreSQLParserRULE_key_action = 118 PostgreSQLParserRULE_optinherit = 119 PostgreSQLParserRULE_optpartitionspec = 120 PostgreSQLParserRULE_partitionspec = 121 PostgreSQLParserRULE_part_params = 122 PostgreSQLParserRULE_part_elem = 123 PostgreSQLParserRULE_table_access_method_clause = 124 PostgreSQLParserRULE_optwith = 125 PostgreSQLParserRULE_oncommitoption = 126 PostgreSQLParserRULE_opttablespace = 127 PostgreSQLParserRULE_optconstablespace = 128 PostgreSQLParserRULE_existingindex = 129 PostgreSQLParserRULE_createstatsstmt = 130 PostgreSQLParserRULE_alterstatsstmt = 131 PostgreSQLParserRULE_createasstmt = 132 PostgreSQLParserRULE_create_as_target = 133 PostgreSQLParserRULE_opt_with_data = 134 PostgreSQLParserRULE_creatematviewstmt = 135 PostgreSQLParserRULE_create_mv_target = 136 PostgreSQLParserRULE_optnolog = 137 PostgreSQLParserRULE_refreshmatviewstmt = 138 PostgreSQLParserRULE_createseqstmt = 139 PostgreSQLParserRULE_alterseqstmt = 140 PostgreSQLParserRULE_optseqoptlist = 141 PostgreSQLParserRULE_optparenthesizedseqoptlist = 142 PostgreSQLParserRULE_seqoptlist = 143 PostgreSQLParserRULE_seqoptelem = 144 PostgreSQLParserRULE_opt_by = 145 PostgreSQLParserRULE_numericonly = 146 PostgreSQLParserRULE_numericonly_list = 147 PostgreSQLParserRULE_createplangstmt = 148 PostgreSQLParserRULE_opt_trusted = 149 PostgreSQLParserRULE_handler_name = 150 PostgreSQLParserRULE_opt_inline_handler = 151 PostgreSQLParserRULE_validator_clause = 152 PostgreSQLParserRULE_opt_validator = 153 PostgreSQLParserRULE_opt_procedural = 154 PostgreSQLParserRULE_createtablespacestmt = 155 PostgreSQLParserRULE_opttablespaceowner = 156 PostgreSQLParserRULE_droptablespacestmt = 157 PostgreSQLParserRULE_createextensionstmt = 158 PostgreSQLParserRULE_create_extension_opt_list = 159 PostgreSQLParserRULE_create_extension_opt_item = 160 PostgreSQLParserRULE_alterextensionstmt = 161 PostgreSQLParserRULE_alter_extension_opt_list = 162 PostgreSQLParserRULE_alter_extension_opt_item = 163 PostgreSQLParserRULE_alterextensioncontentsstmt = 164 PostgreSQLParserRULE_createfdwstmt = 165 PostgreSQLParserRULE_fdw_option = 166 PostgreSQLParserRULE_fdw_options = 167 PostgreSQLParserRULE_opt_fdw_options = 168 PostgreSQLParserRULE_alterfdwstmt = 169 PostgreSQLParserRULE_create_generic_options = 170 PostgreSQLParserRULE_generic_option_list = 171 PostgreSQLParserRULE_alter_generic_options = 172 PostgreSQLParserRULE_alter_generic_option_list = 173 PostgreSQLParserRULE_alter_generic_option_elem = 174 PostgreSQLParserRULE_generic_option_elem = 175 PostgreSQLParserRULE_generic_option_name = 176 PostgreSQLParserRULE_generic_option_arg = 177 PostgreSQLParserRULE_createforeignserverstmt = 178 PostgreSQLParserRULE_opt_type = 179 PostgreSQLParserRULE_foreign_server_version = 180 PostgreSQLParserRULE_opt_foreign_server_version = 181 PostgreSQLParserRULE_alterforeignserverstmt = 182 PostgreSQLParserRULE_createforeigntablestmt = 183 PostgreSQLParserRULE_importforeignschemastmt = 184 PostgreSQLParserRULE_import_qualification_type = 185 PostgreSQLParserRULE_import_qualification = 186 PostgreSQLParserRULE_createusermappingstmt = 187 PostgreSQLParserRULE_auth_ident = 188 PostgreSQLParserRULE_dropusermappingstmt = 189 PostgreSQLParserRULE_alterusermappingstmt = 190 PostgreSQLParserRULE_createpolicystmt = 191 PostgreSQLParserRULE_alterpolicystmt = 192 PostgreSQLParserRULE_rowsecurityoptionalexpr = 193 PostgreSQLParserRULE_rowsecurityoptionalwithcheck = 194 PostgreSQLParserRULE_rowsecuritydefaulttorole = 195 PostgreSQLParserRULE_rowsecurityoptionaltorole = 196 PostgreSQLParserRULE_rowsecuritydefaultpermissive = 197 PostgreSQLParserRULE_rowsecuritydefaultforcmd = 198 PostgreSQLParserRULE_row_security_cmd = 199 PostgreSQLParserRULE_createamstmt = 200 PostgreSQLParserRULE_am_type = 201 PostgreSQLParserRULE_createtrigstmt = 202 PostgreSQLParserRULE_triggeractiontime = 203 PostgreSQLParserRULE_triggerevents = 204 PostgreSQLParserRULE_triggeroneevent = 205 PostgreSQLParserRULE_triggerreferencing = 206 PostgreSQLParserRULE_triggertransitions = 207 PostgreSQLParserRULE_triggertransition = 208 PostgreSQLParserRULE_transitionoldornew = 209 PostgreSQLParserRULE_transitionrowortable = 210 PostgreSQLParserRULE_transitionrelname = 211 PostgreSQLParserRULE_triggerforspec = 212 PostgreSQLParserRULE_triggerforopteach = 213 PostgreSQLParserRULE_triggerfortype = 214 PostgreSQLParserRULE_triggerwhen = 215 PostgreSQLParserRULE_function_or_procedure = 216 PostgreSQLParserRULE_triggerfuncargs = 217 PostgreSQLParserRULE_triggerfuncarg = 218 PostgreSQLParserRULE_optconstrfromtable = 219 PostgreSQLParserRULE_constraintattributespec = 220 PostgreSQLParserRULE_constraintattributeElem = 221 PostgreSQLParserRULE_createeventtrigstmt = 222 PostgreSQLParserRULE_event_trigger_when_list = 223 PostgreSQLParserRULE_event_trigger_when_item = 224 PostgreSQLParserRULE_event_trigger_value_list = 225 PostgreSQLParserRULE_altereventtrigstmt = 226 PostgreSQLParserRULE_enable_trigger = 227 PostgreSQLParserRULE_createassertionstmt = 228 PostgreSQLParserRULE_definestmt = 229 PostgreSQLParserRULE_definition = 230 PostgreSQLParserRULE_def_list = 231 PostgreSQLParserRULE_def_elem = 232 PostgreSQLParserRULE_def_arg = 233 PostgreSQLParserRULE_old_aggr_definition = 234 PostgreSQLParserRULE_old_aggr_list = 235 PostgreSQLParserRULE_old_aggr_elem = 236 PostgreSQLParserRULE_opt_enum_val_list = 237 PostgreSQLParserRULE_enum_val_list = 238 PostgreSQLParserRULE_alterenumstmt = 239 PostgreSQLParserRULE_opt_if_not_exists = 240 PostgreSQLParserRULE_createopclassstmt = 241 PostgreSQLParserRULE_opclass_item_list = 242 PostgreSQLParserRULE_opclass_item = 243 PostgreSQLParserRULE_opt_default = 244 PostgreSQLParserRULE_opt_opfamily = 245 PostgreSQLParserRULE_opclass_purpose = 246 PostgreSQLParserRULE_opt_recheck = 247 PostgreSQLParserRULE_createopfamilystmt = 248 PostgreSQLParserRULE_alteropfamilystmt = 249 PostgreSQLParserRULE_opclass_drop_list = 250 PostgreSQLParserRULE_opclass_drop = 251 PostgreSQLParserRULE_dropopclassstmt = 252 PostgreSQLParserRULE_dropopfamilystmt = 253 PostgreSQLParserRULE_dropownedstmt = 254 PostgreSQLParserRULE_reassignownedstmt = 255 PostgreSQLParserRULE_dropstmt = 256 PostgreSQLParserRULE_object_type_any_name = 257 PostgreSQLParserRULE_object_type_name = 258 PostgreSQLParserRULE_drop_type_name = 259 PostgreSQLParserRULE_object_type_name_on_any_name = 260 PostgreSQLParserRULE_any_name_list = 261 PostgreSQLParserRULE_any_name = 262 PostgreSQLParserRULE_attrs = 263 PostgreSQLParserRULE_type_name_list = 264 PostgreSQLParserRULE_truncatestmt = 265 PostgreSQLParserRULE_opt_restart_seqs = 266 PostgreSQLParserRULE_commentstmt = 267 PostgreSQLParserRULE_comment_text = 268 PostgreSQLParserRULE_seclabelstmt = 269 PostgreSQLParserRULE_opt_provider = 270 PostgreSQLParserRULE_security_label = 271 PostgreSQLParserRULE_fetchstmt = 272 PostgreSQLParserRULE_fetch_args = 273 PostgreSQLParserRULE_from_in = 274 PostgreSQLParserRULE_opt_from_in = 275 PostgreSQLParserRULE_grantstmt = 276 PostgreSQLParserRULE_revokestmt = 277 PostgreSQLParserRULE_privileges = 278 PostgreSQLParserRULE_privilege_list = 279 PostgreSQLParserRULE_privilege = 280 PostgreSQLParserRULE_privilege_target = 281 PostgreSQLParserRULE_grantee_list = 282 PostgreSQLParserRULE_grantee = 283 PostgreSQLParserRULE_opt_grant_grant_option = 284 PostgreSQLParserRULE_grantrolestmt = 285 PostgreSQLParserRULE_revokerolestmt = 286 PostgreSQLParserRULE_opt_grant_admin_option = 287 PostgreSQLParserRULE_opt_granted_by = 288 PostgreSQLParserRULE_alterdefaultprivilegesstmt = 289 PostgreSQLParserRULE_defacloptionlist = 290 PostgreSQLParserRULE_defacloption = 291 PostgreSQLParserRULE_defaclaction = 292 PostgreSQLParserRULE_defacl_privilege_target = 293 PostgreSQLParserRULE_indexstmt = 294 PostgreSQLParserRULE_opt_unique = 295 PostgreSQLParserRULE_opt_concurrently = 296 PostgreSQLParserRULE_opt_index_name = 297 PostgreSQLParserRULE_access_method_clause = 298 PostgreSQLParserRULE_index_params = 299 PostgreSQLParserRULE_index_elem_options = 300 PostgreSQLParserRULE_index_elem = 301 PostgreSQLParserRULE_opt_include = 302 PostgreSQLParserRULE_index_including_params = 303 PostgreSQLParserRULE_opt_collate = 304 PostgreSQLParserRULE_opt_class = 305 PostgreSQLParserRULE_opt_asc_desc = 306 PostgreSQLParserRULE_opt_nulls_order = 307 PostgreSQLParserRULE_createfunctionstmt = 308 PostgreSQLParserRULE_opt_or_replace = 309 PostgreSQLParserRULE_func_args = 310 PostgreSQLParserRULE_func_args_list = 311 PostgreSQLParserRULE_function_with_argtypes_list = 312 PostgreSQLParserRULE_function_with_argtypes = 313 PostgreSQLParserRULE_func_args_with_defaults = 314 PostgreSQLParserRULE_func_args_with_defaults_list = 315 PostgreSQLParserRULE_func_arg = 316 PostgreSQLParserRULE_arg_class = 317 PostgreSQLParserRULE_param_name = 318 PostgreSQLParserRULE_func_return = 319 PostgreSQLParserRULE_func_type = 320 PostgreSQLParserRULE_func_arg_with_default = 321 PostgreSQLParserRULE_aggr_arg = 322 PostgreSQLParserRULE_aggr_args = 323 PostgreSQLParserRULE_aggr_args_list = 324 PostgreSQLParserRULE_aggregate_with_argtypes = 325 PostgreSQLParserRULE_aggregate_with_argtypes_list = 326 PostgreSQLParserRULE_createfunc_opt_list = 327 PostgreSQLParserRULE_common_func_opt_item = 328 PostgreSQLParserRULE_createfunc_opt_item = 329 PostgreSQLParserRULE_func_as = 330 PostgreSQLParserRULE_transform_type_list = 331 PostgreSQLParserRULE_opt_definition = 332 PostgreSQLParserRULE_table_func_column = 333 PostgreSQLParserRULE_table_func_column_list = 334 PostgreSQLParserRULE_alterfunctionstmt = 335 PostgreSQLParserRULE_alterfunc_opt_list = 336 PostgreSQLParserRULE_opt_restrict = 337 PostgreSQLParserRULE_removefuncstmt = 338 PostgreSQLParserRULE_removeaggrstmt = 339 PostgreSQLParserRULE_removeoperstmt = 340 PostgreSQLParserRULE_oper_argtypes = 341 PostgreSQLParserRULE_any_operator = 342 PostgreSQLParserRULE_operator_with_argtypes_list = 343 PostgreSQLParserRULE_operator_with_argtypes = 344 PostgreSQLParserRULE_dostmt = 345 PostgreSQLParserRULE_dostmt_opt_list = 346 PostgreSQLParserRULE_dostmt_opt_item = 347 PostgreSQLParserRULE_createcaststmt = 348 PostgreSQLParserRULE_cast_context = 349 PostgreSQLParserRULE_dropcaststmt = 350 PostgreSQLParserRULE_opt_if_exists = 351 PostgreSQLParserRULE_createtransformstmt = 352 PostgreSQLParserRULE_transform_element_list = 353 PostgreSQLParserRULE_droptransformstmt = 354 PostgreSQLParserRULE_reindexstmt = 355 PostgreSQLParserRULE_reindex_target_type = 356 PostgreSQLParserRULE_reindex_target_multitable = 357 PostgreSQLParserRULE_reindex_option_list = 358 PostgreSQLParserRULE_reindex_option_elem = 359 PostgreSQLParserRULE_altertblspcstmt = 360 PostgreSQLParserRULE_renamestmt = 361 PostgreSQLParserRULE_opt_column = 362 PostgreSQLParserRULE_opt_set_data = 363 PostgreSQLParserRULE_alterobjectdependsstmt = 364 PostgreSQLParserRULE_opt_no = 365 PostgreSQLParserRULE_alterobjectschemastmt = 366 PostgreSQLParserRULE_alteroperatorstmt = 367 PostgreSQLParserRULE_operator_def_list = 368 PostgreSQLParserRULE_operator_def_elem = 369 PostgreSQLParserRULE_operator_def_arg = 370 PostgreSQLParserRULE_altertypestmt = 371 PostgreSQLParserRULE_alterownerstmt = 372 PostgreSQLParserRULE_createpublicationstmt = 373 PostgreSQLParserRULE_opt_publication_for_tables = 374 PostgreSQLParserRULE_publication_for_tables = 375 PostgreSQLParserRULE_alterpublicationstmt = 376 PostgreSQLParserRULE_createsubscriptionstmt = 377 PostgreSQLParserRULE_publication_name_list = 378 PostgreSQLParserRULE_publication_name_item = 379 PostgreSQLParserRULE_altersubscriptionstmt = 380 PostgreSQLParserRULE_dropsubscriptionstmt = 381 PostgreSQLParserRULE_rulestmt = 382 PostgreSQLParserRULE_ruleactionlist = 383 PostgreSQLParserRULE_ruleactionmulti = 384 PostgreSQLParserRULE_ruleactionstmt = 385 PostgreSQLParserRULE_ruleactionstmtOrEmpty = 386 PostgreSQLParserRULE_event = 387 PostgreSQLParserRULE_opt_instead = 388 PostgreSQLParserRULE_notifystmt = 389 PostgreSQLParserRULE_notify_payload = 390 PostgreSQLParserRULE_listenstmt = 391 PostgreSQLParserRULE_unlistenstmt = 392 PostgreSQLParserRULE_transactionstmt = 393 PostgreSQLParserRULE_opt_transaction = 394 PostgreSQLParserRULE_transaction_mode_item = 395 PostgreSQLParserRULE_transaction_mode_list = 396 PostgreSQLParserRULE_transaction_mode_list_or_empty = 397 PostgreSQLParserRULE_opt_transaction_chain = 398 PostgreSQLParserRULE_viewstmt = 399 PostgreSQLParserRULE_opt_check_option = 400 PostgreSQLParserRULE_loadstmt = 401 PostgreSQLParserRULE_createdbstmt = 402 PostgreSQLParserRULE_createdb_opt_list = 403 PostgreSQLParserRULE_createdb_opt_items = 404 PostgreSQLParserRULE_createdb_opt_item = 405 PostgreSQLParserRULE_createdb_opt_name = 406 PostgreSQLParserRULE_opt_equal = 407 PostgreSQLParserRULE_alterdatabasestmt = 408 PostgreSQLParserRULE_alterdatabasesetstmt = 409 PostgreSQLParserRULE_dropdbstmt = 410 PostgreSQLParserRULE_drop_option_list = 411 PostgreSQLParserRULE_drop_option = 412 PostgreSQLParserRULE_altercollationstmt = 413 PostgreSQLParserRULE_altersystemstmt = 414 PostgreSQLParserRULE_createdomainstmt = 415 PostgreSQLParserRULE_alterdomainstmt = 416 PostgreSQLParserRULE_opt_as = 417 PostgreSQLParserRULE_altertsdictionarystmt = 418 PostgreSQLParserRULE_altertsconfigurationstmt = 419 PostgreSQLParserRULE_any_with = 420 PostgreSQLParserRULE_createconversionstmt = 421 PostgreSQLParserRULE_clusterstmt = 422 PostgreSQLParserRULE_cluster_index_specification = 423 PostgreSQLParserRULE_vacuumstmt = 424 PostgreSQLParserRULE_analyzestmt = 425 PostgreSQLParserRULE_vac_analyze_option_list = 426 PostgreSQLParserRULE_analyze_keyword = 427 PostgreSQLParserRULE_vac_analyze_option_elem = 428 PostgreSQLParserRULE_vac_analyze_option_name = 429 PostgreSQLParserRULE_vac_analyze_option_arg = 430 PostgreSQLParserRULE_opt_analyze = 431 PostgreSQLParserRULE_opt_verbose = 432 PostgreSQLParserRULE_opt_full = 433 PostgreSQLParserRULE_opt_freeze = 434 PostgreSQLParserRULE_opt_name_list = 435 PostgreSQLParserRULE_vacuum_relation = 436 PostgreSQLParserRULE_vacuum_relation_list = 437 PostgreSQLParserRULE_opt_vacuum_relation_list = 438 PostgreSQLParserRULE_explainstmt = 439 PostgreSQLParserRULE_explainablestmt = 440 PostgreSQLParserRULE_explain_option_list = 441 PostgreSQLParserRULE_explain_option_elem = 442 PostgreSQLParserRULE_explain_option_name = 443 PostgreSQLParserRULE_explain_option_arg = 444 PostgreSQLParserRULE_preparestmt = 445 PostgreSQLParserRULE_prep_type_clause = 446 PostgreSQLParserRULE_preparablestmt = 447 PostgreSQLParserRULE_executestmt = 448 PostgreSQLParserRULE_execute_param_clause = 449 PostgreSQLParserRULE_deallocatestmt = 450 PostgreSQLParserRULE_insertstmt = 451 PostgreSQLParserRULE_insert_target = 452 PostgreSQLParserRULE_insert_rest = 453 PostgreSQLParserRULE_override_kind = 454 PostgreSQLParserRULE_insert_column_list = 455 PostgreSQLParserRULE_insert_column_item = 456 PostgreSQLParserRULE_opt_on_conflict = 457 PostgreSQLParserRULE_opt_conf_expr = 458 PostgreSQLParserRULE_returning_clause = 459 PostgreSQLParserRULE_mergestmt = 460 PostgreSQLParserRULE_merge_insert_clause = 461 PostgreSQLParserRULE_merge_update_clause = 462 PostgreSQLParserRULE_merge_delete_clause = 463 PostgreSQLParserRULE_deletestmt = 464 PostgreSQLParserRULE_using_clause = 465 PostgreSQLParserRULE_lockstmt = 466 PostgreSQLParserRULE_opt_lock = 467 PostgreSQLParserRULE_lock_type = 468 PostgreSQLParserRULE_opt_nowait = 469 PostgreSQLParserRULE_opt_nowait_or_skip = 470 PostgreSQLParserRULE_updatestmt = 471 PostgreSQLParserRULE_set_clause_list = 472 PostgreSQLParserRULE_set_clause = 473 PostgreSQLParserRULE_set_target = 474 PostgreSQLParserRULE_set_target_list = 475 PostgreSQLParserRULE_declarecursorstmt = 476 PostgreSQLParserRULE_cursor_name = 477 PostgreSQLParserRULE_cursor_options = 478 PostgreSQLParserRULE_opt_hold = 479 PostgreSQLParserRULE_selectstmt = 480 PostgreSQLParserRULE_select_with_parens = 481 PostgreSQLParserRULE_select_no_parens = 482 PostgreSQLParserRULE_select_clause = 483 PostgreSQLParserRULE_simple_select_intersect = 484 PostgreSQLParserRULE_simple_select_pramary = 485 PostgreSQLParserRULE_with_clause = 486 PostgreSQLParserRULE_cte_list = 487 PostgreSQLParserRULE_common_table_expr = 488 PostgreSQLParserRULE_opt_materialized = 489 PostgreSQLParserRULE_opt_with_clause = 490 PostgreSQLParserRULE_into_clause = 491 PostgreSQLParserRULE_opt_strict = 492 PostgreSQLParserRULE_opttempTableName = 493 PostgreSQLParserRULE_opt_table = 494 PostgreSQLParserRULE_all_or_distinct = 495 PostgreSQLParserRULE_distinct_clause = 496 PostgreSQLParserRULE_opt_all_clause = 497 PostgreSQLParserRULE_opt_sort_clause = 498 PostgreSQLParserRULE_sort_clause = 499 PostgreSQLParserRULE_sortby_list = 500 PostgreSQLParserRULE_sortby = 501 PostgreSQLParserRULE_select_limit = 502 PostgreSQLParserRULE_opt_select_limit = 503 PostgreSQLParserRULE_limit_clause = 504 PostgreSQLParserRULE_offset_clause = 505 PostgreSQLParserRULE_select_limit_value = 506 PostgreSQLParserRULE_select_offset_value = 507 PostgreSQLParserRULE_select_fetch_first_value = 508 PostgreSQLParserRULE_i_or_f_const = 509 PostgreSQLParserRULE_row_or_rows = 510 PostgreSQLParserRULE_first_or_next = 511 PostgreSQLParserRULE_group_clause = 512 PostgreSQLParserRULE_group_by_list = 513 PostgreSQLParserRULE_group_by_item = 514 PostgreSQLParserRULE_empty_grouping_set = 515 PostgreSQLParserRULE_rollup_clause = 516 PostgreSQLParserRULE_cube_clause = 517 PostgreSQLParserRULE_grouping_sets_clause = 518 PostgreSQLParserRULE_having_clause = 519 PostgreSQLParserRULE_for_locking_clause = 520 PostgreSQLParserRULE_opt_for_locking_clause = 521 PostgreSQLParserRULE_for_locking_items = 522 PostgreSQLParserRULE_for_locking_item = 523 PostgreSQLParserRULE_for_locking_strength = 524 PostgreSQLParserRULE_locked_rels_list = 525 PostgreSQLParserRULE_values_clause = 526 PostgreSQLParserRULE_from_clause = 527 PostgreSQLParserRULE_from_list = 528 PostgreSQLParserRULE_non_ansi_join = 529 PostgreSQLParserRULE_table_ref = 530 PostgreSQLParserRULE_alias_clause = 531 PostgreSQLParserRULE_opt_alias_clause = 532 PostgreSQLParserRULE_table_alias_clause = 533 PostgreSQLParserRULE_func_alias_clause = 534 PostgreSQLParserRULE_join_type = 535 PostgreSQLParserRULE_join_qual = 536 PostgreSQLParserRULE_relation_expr = 537 PostgreSQLParserRULE_relation_expr_list = 538 PostgreSQLParserRULE_relation_expr_opt_alias = 539 PostgreSQLParserRULE_tablesample_clause = 540 PostgreSQLParserRULE_opt_repeatable_clause = 541 PostgreSQLParserRULE_func_table = 542 PostgreSQLParserRULE_rowsfrom_item = 543 PostgreSQLParserRULE_rowsfrom_list = 544 PostgreSQLParserRULE_opt_col_def_list = 545 PostgreSQLParserRULE_opt_ordinality = 546 PostgreSQLParserRULE_where_clause = 547 PostgreSQLParserRULE_where_or_current_clause = 548 PostgreSQLParserRULE_opttablefuncelementlist = 549 PostgreSQLParserRULE_tablefuncelementlist = 550 PostgreSQLParserRULE_tablefuncelement = 551 PostgreSQLParserRULE_xmltable = 552 PostgreSQLParserRULE_xmltable_column_list = 553 PostgreSQLParserRULE_xmltable_column_el = 554 PostgreSQLParserRULE_xmltable_column_option_list = 555 PostgreSQLParserRULE_xmltable_column_option_el = 556 PostgreSQLParserRULE_xml_namespace_list = 557 PostgreSQLParserRULE_xml_namespace_el = 558 PostgreSQLParserRULE_typename = 559 PostgreSQLParserRULE_opt_array_bounds = 560 PostgreSQLParserRULE_simpletypename = 561 PostgreSQLParserRULE_consttypename = 562 PostgreSQLParserRULE_generictype = 563 PostgreSQLParserRULE_opt_type_modifiers = 564 PostgreSQLParserRULE_numeric = 565 PostgreSQLParserRULE_opt_float = 566 PostgreSQLParserRULE_bit = 567 PostgreSQLParserRULE_constbit = 568 PostgreSQLParserRULE_bitwithlength = 569 PostgreSQLParserRULE_bitwithoutlength = 570 PostgreSQLParserRULE_character = 571 PostgreSQLParserRULE_constcharacter = 572 PostgreSQLParserRULE_character_c = 573 PostgreSQLParserRULE_opt_varying = 574 PostgreSQLParserRULE_constdatetime = 575 PostgreSQLParserRULE_constinterval = 576 PostgreSQLParserRULE_opt_timezone = 577 PostgreSQLParserRULE_opt_interval = 578 PostgreSQLParserRULE_interval_second = 579 PostgreSQLParserRULE_opt_escape = 580 PostgreSQLParserRULE_a_expr = 581 PostgreSQLParserRULE_a_expr_qual = 582 PostgreSQLParserRULE_a_expr_lessless = 583 PostgreSQLParserRULE_a_expr_or = 584 PostgreSQLParserRULE_a_expr_and = 585 PostgreSQLParserRULE_a_expr_between = 586 PostgreSQLParserRULE_a_expr_in = 587 PostgreSQLParserRULE_a_expr_unary_not = 588 PostgreSQLParserRULE_a_expr_isnull = 589 PostgreSQLParserRULE_a_expr_is_not = 590 PostgreSQLParserRULE_a_expr_compare = 591 PostgreSQLParserRULE_a_expr_like = 592 PostgreSQLParserRULE_a_expr_qual_op = 593 PostgreSQLParserRULE_a_expr_unary_qualop = 594 PostgreSQLParserRULE_a_expr_add = 595 PostgreSQLParserRULE_a_expr_mul = 596 PostgreSQLParserRULE_a_expr_caret = 597 PostgreSQLParserRULE_a_expr_unary_sign = 598 PostgreSQLParserRULE_a_expr_at_time_zone = 599 PostgreSQLParserRULE_a_expr_collate = 600 PostgreSQLParserRULE_a_expr_typecast = 601 PostgreSQLParserRULE_b_expr = 602 PostgreSQLParserRULE_c_expr = 603 PostgreSQLParserRULE_plsqlvariablename = 604 PostgreSQLParserRULE_func_application = 605 PostgreSQLParserRULE_func_expr = 606 PostgreSQLParserRULE_func_expr_windowless = 607 PostgreSQLParserRULE_func_expr_common_subexpr = 608 PostgreSQLParserRULE_xml_root_version = 609 PostgreSQLParserRULE_opt_xml_root_standalone = 610 PostgreSQLParserRULE_xml_attributes = 611 PostgreSQLParserRULE_xml_attribute_list = 612 PostgreSQLParserRULE_xml_attribute_el = 613 PostgreSQLParserRULE_document_or_content = 614 PostgreSQLParserRULE_xml_whitespace_option = 615 PostgreSQLParserRULE_xmlexists_argument = 616 PostgreSQLParserRULE_xml_passing_mech = 617 PostgreSQLParserRULE_within_group_clause = 618 PostgreSQLParserRULE_filter_clause = 619 PostgreSQLParserRULE_window_clause = 620 PostgreSQLParserRULE_window_definition_list = 621 PostgreSQLParserRULE_window_definition = 622 PostgreSQLParserRULE_over_clause = 623 PostgreSQLParserRULE_window_specification = 624 PostgreSQLParserRULE_opt_existing_window_name = 625 PostgreSQLParserRULE_opt_partition_clause = 626 PostgreSQLParserRULE_opt_frame_clause = 627 PostgreSQLParserRULE_frame_extent = 628 PostgreSQLParserRULE_frame_bound = 629 PostgreSQLParserRULE_opt_window_exclusion_clause = 630 PostgreSQLParserRULE_row = 631 PostgreSQLParserRULE_explicit_row = 632 PostgreSQLParserRULE_implicit_row = 633 PostgreSQLParserRULE_sub_type = 634 PostgreSQLParserRULE_all_op = 635 PostgreSQLParserRULE_mathop = 636 PostgreSQLParserRULE_qual_op = 637 PostgreSQLParserRULE_qual_all_op = 638 PostgreSQLParserRULE_subquery_Op = 639 PostgreSQLParserRULE_expr_list = 640 PostgreSQLParserRULE_func_arg_list = 641 PostgreSQLParserRULE_func_arg_expr = 642 PostgreSQLParserRULE_type_list = 643 PostgreSQLParserRULE_array_expr = 644 PostgreSQLParserRULE_array_expr_list = 645 PostgreSQLParserRULE_extract_list = 646 PostgreSQLParserRULE_extract_arg = 647 PostgreSQLParserRULE_unicode_normal_form = 648 PostgreSQLParserRULE_overlay_list = 649 PostgreSQLParserRULE_position_list = 650 PostgreSQLParserRULE_substr_list = 651 PostgreSQLParserRULE_trim_list = 652 PostgreSQLParserRULE_in_expr = 653 PostgreSQLParserRULE_case_expr = 654 PostgreSQLParserRULE_when_clause_list = 655 PostgreSQLParserRULE_when_clause = 656 PostgreSQLParserRULE_case_default = 657 PostgreSQLParserRULE_case_arg = 658 PostgreSQLParserRULE_columnref = 659 PostgreSQLParserRULE_indirection_el = 660 PostgreSQLParserRULE_opt_slice_bound = 661 PostgreSQLParserRULE_indirection = 662 PostgreSQLParserRULE_opt_indirection = 663 PostgreSQLParserRULE_opt_target_list = 664 PostgreSQLParserRULE_target_list = 665 PostgreSQLParserRULE_target_el = 666 PostgreSQLParserRULE_qualified_name_list = 667 PostgreSQLParserRULE_qualified_name = 668 PostgreSQLParserRULE_name_list = 669 PostgreSQLParserRULE_name = 670 PostgreSQLParserRULE_attr_name = 671 PostgreSQLParserRULE_file_name = 672 PostgreSQLParserRULE_func_name = 673 PostgreSQLParserRULE_aexprconst = 674 PostgreSQLParserRULE_xconst = 675 PostgreSQLParserRULE_bconst = 676 PostgreSQLParserRULE_fconst = 677 PostgreSQLParserRULE_iconst = 678 PostgreSQLParserRULE_sconst = 679 PostgreSQLParserRULE_anysconst = 680 PostgreSQLParserRULE_opt_uescape = 681 PostgreSQLParserRULE_signediconst = 682 PostgreSQLParserRULE_roleid = 683 PostgreSQLParserRULE_rolespec = 684 PostgreSQLParserRULE_role_list = 685 PostgreSQLParserRULE_colid = 686 PostgreSQLParserRULE_table_alias = 687 PostgreSQLParserRULE_type_function_name = 688 PostgreSQLParserRULE_nonreservedword = 689 PostgreSQLParserRULE_collabel = 690 PostgreSQLParserRULE_identifier = 691 PostgreSQLParserRULE_plsqlidentifier = 692 PostgreSQLParserRULE_unreserved_keyword = 693 PostgreSQLParserRULE_col_name_keyword = 694 PostgreSQLParserRULE_type_func_name_keyword = 695 PostgreSQLParserRULE_reserved_keyword = 696 PostgreSQLParserRULE_builtin_function_name = 697 PostgreSQLParserRULE_pl_function = 698 PostgreSQLParserRULE_comp_options = 699 PostgreSQLParserRULE_comp_option = 700 PostgreSQLParserRULE_sharp = 701 PostgreSQLParserRULE_option_value = 702 PostgreSQLParserRULE_opt_semi = 703 PostgreSQLParserRULE_pl_block = 704 PostgreSQLParserRULE_decl_sect = 705 PostgreSQLParserRULE_decl_start = 706 PostgreSQLParserRULE_decl_stmts = 707 PostgreSQLParserRULE_label_decl = 708 PostgreSQLParserRULE_decl_stmt = 709 PostgreSQLParserRULE_decl_statement = 710 PostgreSQLParserRULE_opt_scrollable = 711 PostgreSQLParserRULE_decl_cursor_query = 712 PostgreSQLParserRULE_decl_cursor_args = 713 PostgreSQLParserRULE_decl_cursor_arglist = 714 PostgreSQLParserRULE_decl_cursor_arg = 715 PostgreSQLParserRULE_decl_is_for = 716 PostgreSQLParserRULE_decl_aliasitem = 717 PostgreSQLParserRULE_decl_varname = 718 PostgreSQLParserRULE_decl_const = 719 PostgreSQLParserRULE_decl_datatype = 720 PostgreSQLParserRULE_decl_collate = 721 PostgreSQLParserRULE_decl_notnull = 722 PostgreSQLParserRULE_decl_defval = 723 PostgreSQLParserRULE_decl_defkey = 724 PostgreSQLParserRULE_assign_operator = 725 PostgreSQLParserRULE_proc_sect = 726 PostgreSQLParserRULE_proc_stmt = 727 PostgreSQLParserRULE_stmt_perform = 728 PostgreSQLParserRULE_stmt_call = 729 PostgreSQLParserRULE_opt_expr_list = 730 PostgreSQLParserRULE_stmt_assign = 731 PostgreSQLParserRULE_stmt_getdiag = 732 PostgreSQLParserRULE_getdiag_area_opt = 733 PostgreSQLParserRULE_getdiag_list = 734 PostgreSQLParserRULE_getdiag_list_item = 735 PostgreSQLParserRULE_getdiag_item = 736 PostgreSQLParserRULE_getdiag_target = 737 PostgreSQLParserRULE_assign_var = 738 PostgreSQLParserRULE_stmt_if = 739 PostgreSQLParserRULE_stmt_elsifs = 740 PostgreSQLParserRULE_stmt_else = 741 PostgreSQLParserRULE_stmt_case = 742 PostgreSQLParserRULE_opt_expr_until_when = 743 PostgreSQLParserRULE_case_when_list = 744 PostgreSQLParserRULE_case_when = 745 PostgreSQLParserRULE_opt_case_else = 746 PostgreSQLParserRULE_stmt_loop = 747 PostgreSQLParserRULE_stmt_while = 748 PostgreSQLParserRULE_stmt_for = 749 PostgreSQLParserRULE_for_control = 750 PostgreSQLParserRULE_opt_for_using_expression = 751 PostgreSQLParserRULE_opt_cursor_parameters = 752 PostgreSQLParserRULE_opt_reverse = 753 PostgreSQLParserRULE_opt_by_expression = 754 PostgreSQLParserRULE_for_variable = 755 PostgreSQLParserRULE_stmt_foreach_a = 756 PostgreSQLParserRULE_foreach_slice = 757 PostgreSQLParserRULE_stmt_exit = 758 PostgreSQLParserRULE_exit_type = 759 PostgreSQLParserRULE_stmt_return = 760 PostgreSQLParserRULE_opt_return_result = 761 PostgreSQLParserRULE_stmt_raise = 762 PostgreSQLParserRULE_opt_stmt_raise_level = 763 PostgreSQLParserRULE_opt_raise_list = 764 PostgreSQLParserRULE_opt_raise_using = 765 PostgreSQLParserRULE_opt_raise_using_elem = 766 PostgreSQLParserRULE_opt_raise_using_elem_list = 767 PostgreSQLParserRULE_stmt_assert = 768 PostgreSQLParserRULE_opt_stmt_assert_message = 769 PostgreSQLParserRULE_loop_body = 770 PostgreSQLParserRULE_stmt_execsql = 771 PostgreSQLParserRULE_stmt_dynexecute = 772 PostgreSQLParserRULE_opt_execute_using = 773 PostgreSQLParserRULE_opt_execute_using_list = 774 PostgreSQLParserRULE_opt_execute_into = 775 PostgreSQLParserRULE_stmt_open = 776 PostgreSQLParserRULE_opt_open_bound_list_item = 777 PostgreSQLParserRULE_opt_open_bound_list = 778 PostgreSQLParserRULE_opt_open_using = 779 PostgreSQLParserRULE_opt_scroll_option = 780 PostgreSQLParserRULE_opt_scroll_option_no = 781 PostgreSQLParserRULE_stmt_fetch = 782 PostgreSQLParserRULE_into_target = 783 PostgreSQLParserRULE_opt_cursor_from = 784 PostgreSQLParserRULE_opt_fetch_direction = 785 PostgreSQLParserRULE_stmt_move = 786 PostgreSQLParserRULE_stmt_close = 787 PostgreSQLParserRULE_stmt_null = 788 PostgreSQLParserRULE_stmt_commit = 789 PostgreSQLParserRULE_stmt_rollback = 790 PostgreSQLParserRULE_plsql_opt_transaction_chain = 791 PostgreSQLParserRULE_stmt_set = 792 PostgreSQLParserRULE_cursor_variable = 793 PostgreSQLParserRULE_exception_sect = 794 PostgreSQLParserRULE_proc_exceptions = 795 PostgreSQLParserRULE_proc_exception = 796 PostgreSQLParserRULE_proc_conditions = 797 PostgreSQLParserRULE_proc_condition = 798 PostgreSQLParserRULE_opt_block_label = 799 PostgreSQLParserRULE_opt_loop_label = 800 PostgreSQLParserRULE_opt_label = 801 PostgreSQLParserRULE_opt_exitcond = 802 PostgreSQLParserRULE_any_identifier = 803 PostgreSQLParserRULE_plsql_unreserved_keyword = 804 PostgreSQLParserRULE_sql_expression = 805 PostgreSQLParserRULE_expr_until_then = 806 PostgreSQLParserRULE_expr_until_semi = 807 PostgreSQLParserRULE_expr_until_rightbracket = 808 PostgreSQLParserRULE_expr_until_loop = 809 PostgreSQLParserRULE_make_execsql_stmt = 810 PostgreSQLParserRULE_opt_returning_clause_into = 811 ) // IRootContext is an interface to support dynamic dispatch. type IRootContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Stmtblock() IStmtblockContext EOF() antlr.TerminalNode // IsRootContext differentiates from other interfaces. IsRootContext() } type RootContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRootContext() *RootContext { var p = new(RootContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_root return p } func InitEmptyRootContext(p *RootContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_root } func (*RootContext) IsRootContext() {} func NewRootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RootContext { var p = new(RootContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_root return p } func (s *RootContext) GetParser() antlr.Parser { return s.parser } func (s *RootContext) Stmtblock() IStmtblockContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmtblockContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmtblockContext) } func (s *RootContext) EOF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEOF, 0) } func (s *RootContext) GetRuleContext() antlr.RuleContext { return s } func (s *RootContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RootContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRoot(s) } } func (s *RootContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRoot(s) } } func (s *RootContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRoot(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Root() (localctx IRootContext) { localctx = NewRootContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 0, PostgreSQLParserRULE_root) p.EnterOuterAlt(localctx, 1) { p.SetState(1624) p.Stmtblock() } { p.SetState(1625) p.Match(PostgreSQLParserEOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPlsqlrootContext is an interface to support dynamic dispatch. type IPlsqlrootContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Pl_function() IPl_functionContext // IsPlsqlrootContext differentiates from other interfaces. IsPlsqlrootContext() } type PlsqlrootContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPlsqlrootContext() *PlsqlrootContext { var p = new(PlsqlrootContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_plsqlroot return p } func InitEmptyPlsqlrootContext(p *PlsqlrootContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_plsqlroot } func (*PlsqlrootContext) IsPlsqlrootContext() {} func NewPlsqlrootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PlsqlrootContext { var p = new(PlsqlrootContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_plsqlroot return p } func (s *PlsqlrootContext) GetParser() antlr.Parser { return s.parser } func (s *PlsqlrootContext) Pl_function() IPl_functionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPl_functionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPl_functionContext) } func (s *PlsqlrootContext) GetRuleContext() antlr.RuleContext { return s } func (s *PlsqlrootContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *PlsqlrootContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPlsqlroot(s) } } func (s *PlsqlrootContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPlsqlroot(s) } } func (s *PlsqlrootContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPlsqlroot(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Plsqlroot() (localctx IPlsqlrootContext) { localctx = NewPlsqlrootContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 2, PostgreSQLParserRULE_plsqlroot) p.EnterOuterAlt(localctx, 1) { p.SetState(1627) p.Pl_function() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmtblockContext is an interface to support dynamic dispatch. type IStmtblockContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Stmtmulti() IStmtmultiContext // IsStmtblockContext differentiates from other interfaces. IsStmtblockContext() } type StmtblockContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmtblockContext() *StmtblockContext { var p = new(StmtblockContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmtblock return p } func InitEmptyStmtblockContext(p *StmtblockContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmtblock } func (*StmtblockContext) IsStmtblockContext() {} func NewStmtblockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtblockContext { var p = new(StmtblockContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmtblock return p } func (s *StmtblockContext) GetParser() antlr.Parser { return s.parser } func (s *StmtblockContext) Stmtmulti() IStmtmultiContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmtmultiContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmtmultiContext) } func (s *StmtblockContext) GetRuleContext() antlr.RuleContext { return s } func (s *StmtblockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *StmtblockContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmtblock(s) } } func (s *StmtblockContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmtblock(s) } } func (s *StmtblockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmtblock(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmtblock() (localctx IStmtblockContext) { localctx = NewStmtblockContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 4, PostgreSQLParserRULE_stmtblock) p.EnterOuterAlt(localctx, 1) { p.SetState(1629) p.Stmtmulti() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmtmultiContext is an interface to support dynamic dispatch. type IStmtmultiContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllStmt() []IStmtContext Stmt(i int) IStmtContext AllSEMI() []antlr.TerminalNode SEMI(i int) antlr.TerminalNode // IsStmtmultiContext differentiates from other interfaces. IsStmtmultiContext() } type StmtmultiContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmtmultiContext() *StmtmultiContext { var p = new(StmtmultiContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmtmulti return p } func InitEmptyStmtmultiContext(p *StmtmultiContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmtmulti } func (*StmtmultiContext) IsStmtmultiContext() {} func NewStmtmultiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtmultiContext { var p = new(StmtmultiContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmtmulti return p } func (s *StmtmultiContext) GetParser() antlr.Parser { return s.parser } func (s *StmtmultiContext) AllStmt() []IStmtContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IStmtContext); ok { len++ } } tst := make([]IStmtContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IStmtContext); ok { tst[i] = t.(IStmtContext) i++ } } return tst } func (s *StmtmultiContext) Stmt(i int) IStmtContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmtContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IStmtContext) } func (s *StmtmultiContext) AllSEMI() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserSEMI) } func (s *StmtmultiContext) SEMI(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, i) } func (s *StmtmultiContext) GetRuleContext() antlr.RuleContext { return s } func (s *StmtmultiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *StmtmultiContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmtmulti(s) } } func (s *StmtmultiContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmtmulti(s) } } func (s *StmtmultiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmtmulti(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmtmulti() (localctx IStmtmultiContext) { localctx = NewStmtmultiContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 6, PostgreSQLParserRULE_stmtmulti) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(1637) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&2450028572476178436) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&1099654234113) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&4909769124516856321) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&4686037194794598403) != 0) || ((int64((_la-283)) & ^0x3f) == 0 && ((int64(1)<<(_la-283))&1170022785714177) != 0) || ((int64((_la-351)) & ^0x3f) == 0 && ((int64(1)<<(_la-351))&6401) != 0) || ((int64((_la-415)) & ^0x3f) == 0 && ((int64(1)<<(_la-415))&550292946945) != 0) || _la == PostgreSQLParserMetaCommand { { p.SetState(1631) p.Stmt() } p.SetState(1633) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserSEMI { { p.SetState(1632) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } } p.SetState(1639) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmtContext is an interface to support dynamic dispatch. type IStmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Altereventtrigstmt() IAltereventtrigstmtContext Altercollationstmt() IAltercollationstmtContext Alterdatabasestmt() IAlterdatabasestmtContext Alterdatabasesetstmt() IAlterdatabasesetstmtContext Alterdefaultprivilegesstmt() IAlterdefaultprivilegesstmtContext Alterdomainstmt() IAlterdomainstmtContext Alterenumstmt() IAlterenumstmtContext Alterextensionstmt() IAlterextensionstmtContext Alterextensioncontentsstmt() IAlterextensioncontentsstmtContext Alterfdwstmt() IAlterfdwstmtContext Alterforeignserverstmt() IAlterforeignserverstmtContext Alterfunctionstmt() IAlterfunctionstmtContext Altergroupstmt() IAltergroupstmtContext Alterobjectdependsstmt() IAlterobjectdependsstmtContext Alterobjectschemastmt() IAlterobjectschemastmtContext Alterownerstmt() IAlterownerstmtContext Alteroperatorstmt() IAlteroperatorstmtContext Altertypestmt() IAltertypestmtContext Alterpolicystmt() IAlterpolicystmtContext Alterseqstmt() IAlterseqstmtContext Altersystemstmt() IAltersystemstmtContext Altertablestmt() IAltertablestmtContext Altertblspcstmt() IAltertblspcstmtContext Altercompositetypestmt() IAltercompositetypestmtContext Alterpublicationstmt() IAlterpublicationstmtContext Alterrolesetstmt() IAlterrolesetstmtContext Alterrolestmt() IAlterrolestmtContext Altersubscriptionstmt() IAltersubscriptionstmtContext Alterstatsstmt() IAlterstatsstmtContext Altertsconfigurationstmt() IAltertsconfigurationstmtContext Altertsdictionarystmt() IAltertsdictionarystmtContext Alterusermappingstmt() IAlterusermappingstmtContext Analyzestmt() IAnalyzestmtContext Callstmt() ICallstmtContext Checkpointstmt() ICheckpointstmtContext Closeportalstmt() ICloseportalstmtContext Clusterstmt() IClusterstmtContext Commentstmt() ICommentstmtContext Constraintssetstmt() IConstraintssetstmtContext Copystmt() ICopystmtContext Createamstmt() ICreateamstmtContext Createasstmt() ICreateasstmtContext Createassertionstmt() ICreateassertionstmtContext Createcaststmt() ICreatecaststmtContext Createconversionstmt() ICreateconversionstmtContext Createdomainstmt() ICreatedomainstmtContext Createextensionstmt() ICreateextensionstmtContext Createfdwstmt() ICreatefdwstmtContext Createforeignserverstmt() ICreateforeignserverstmtContext Createforeigntablestmt() ICreateforeigntablestmtContext Createfunctionstmt() ICreatefunctionstmtContext Creategroupstmt() ICreategroupstmtContext Creatematviewstmt() ICreatematviewstmtContext Createopclassstmt() ICreateopclassstmtContext Createopfamilystmt() ICreateopfamilystmtContext Createpublicationstmt() ICreatepublicationstmtContext Alteropfamilystmt() IAlteropfamilystmtContext Createpolicystmt() ICreatepolicystmtContext Createplangstmt() ICreateplangstmtContext Createschemastmt() ICreateschemastmtContext Createseqstmt() ICreateseqstmtContext Createstmt() ICreatestmtContext Createsubscriptionstmt() ICreatesubscriptionstmtContext Createstatsstmt() ICreatestatsstmtContext Createtablespacestmt() ICreatetablespacestmtContext Createtransformstmt() ICreatetransformstmtContext Createtrigstmt() ICreatetrigstmtContext Createeventtrigstmt() ICreateeventtrigstmtContext Createrolestmt() ICreaterolestmtContext Createuserstmt() ICreateuserstmtContext Createusermappingstmt() ICreateusermappingstmtContext Createdbstmt() ICreatedbstmtContext Deallocatestmt() IDeallocatestmtContext Declarecursorstmt() IDeclarecursorstmtContext Definestmt() IDefinestmtContext Deletestmt() IDeletestmtContext Discardstmt() IDiscardstmtContext Dostmt() IDostmtContext Dropcaststmt() IDropcaststmtContext Dropopclassstmt() IDropopclassstmtContext Dropopfamilystmt() IDropopfamilystmtContext Dropownedstmt() IDropownedstmtContext Dropstmt() IDropstmtContext Dropsubscriptionstmt() IDropsubscriptionstmtContext Droptablespacestmt() IDroptablespacestmtContext Droptransformstmt() IDroptransformstmtContext Droprolestmt() IDroprolestmtContext Dropusermappingstmt() IDropusermappingstmtContext Dropdbstmt() IDropdbstmtContext Executestmt() IExecutestmtContext Explainstmt() IExplainstmtContext Fetchstmt() IFetchstmtContext Grantstmt() IGrantstmtContext Grantrolestmt() IGrantrolestmtContext Importforeignschemastmt() IImportforeignschemastmtContext Indexstmt() IIndexstmtContext Insertstmt() IInsertstmtContext Mergestmt() IMergestmtContext Listenstmt() IListenstmtContext Refreshmatviewstmt() IRefreshmatviewstmtContext Loadstmt() ILoadstmtContext Lockstmt() ILockstmtContext Notifystmt() INotifystmtContext Preparestmt() IPreparestmtContext Reassignownedstmt() IReassignownedstmtContext Reindexstmt() IReindexstmtContext Removeaggrstmt() IRemoveaggrstmtContext Removefuncstmt() IRemovefuncstmtContext Removeoperstmt() IRemoveoperstmtContext Renamestmt() IRenamestmtContext Revokestmt() IRevokestmtContext Revokerolestmt() IRevokerolestmtContext Rulestmt() IRulestmtContext Seclabelstmt() ISeclabelstmtContext Selectstmt() ISelectstmtContext Transactionstmt() ITransactionstmtContext Truncatestmt() ITruncatestmtContext Unlistenstmt() IUnlistenstmtContext Updatestmt() IUpdatestmtContext Vacuumstmt() IVacuumstmtContext Variableresetstmt() IVariableresetstmtContext Variablesetstmt() IVariablesetstmtContext Variableshowstmt() IVariableshowstmtContext Viewstmt() IViewstmtContext Plsqlconsolecommand() IPlsqlconsolecommandContext // IsStmtContext differentiates from other interfaces. IsStmtContext() } type StmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmtContext() *StmtContext { var p = new(StmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt return p } func InitEmptyStmtContext(p *StmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt } func (*StmtContext) IsStmtContext() {} func NewStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtContext { var p = new(StmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt return p } func (s *StmtContext) GetParser() antlr.Parser { return s.parser } func (s *StmtContext) Altereventtrigstmt() IAltereventtrigstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAltereventtrigstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAltereventtrigstmtContext) } func (s *StmtContext) Altercollationstmt() IAltercollationstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAltercollationstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAltercollationstmtContext) } func (s *StmtContext) Alterdatabasestmt() IAlterdatabasestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterdatabasestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterdatabasestmtContext) } func (s *StmtContext) Alterdatabasesetstmt() IAlterdatabasesetstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterdatabasesetstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterdatabasesetstmtContext) } func (s *StmtContext) Alterdefaultprivilegesstmt() IAlterdefaultprivilegesstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterdefaultprivilegesstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterdefaultprivilegesstmtContext) } func (s *StmtContext) Alterdomainstmt() IAlterdomainstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterdomainstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterdomainstmtContext) } func (s *StmtContext) Alterenumstmt() IAlterenumstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterenumstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterenumstmtContext) } func (s *StmtContext) Alterextensionstmt() IAlterextensionstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterextensionstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterextensionstmtContext) } func (s *StmtContext) Alterextensioncontentsstmt() IAlterextensioncontentsstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterextensioncontentsstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterextensioncontentsstmtContext) } func (s *StmtContext) Alterfdwstmt() IAlterfdwstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterfdwstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterfdwstmtContext) } func (s *StmtContext) Alterforeignserverstmt() IAlterforeignserverstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterforeignserverstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterforeignserverstmtContext) } func (s *StmtContext) Alterfunctionstmt() IAlterfunctionstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterfunctionstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterfunctionstmtContext) } func (s *StmtContext) Altergroupstmt() IAltergroupstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAltergroupstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAltergroupstmtContext) } func (s *StmtContext) Alterobjectdependsstmt() IAlterobjectdependsstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterobjectdependsstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterobjectdependsstmtContext) } func (s *StmtContext) Alterobjectschemastmt() IAlterobjectschemastmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterobjectschemastmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterobjectschemastmtContext) } func (s *StmtContext) Alterownerstmt() IAlterownerstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterownerstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterownerstmtContext) } func (s *StmtContext) Alteroperatorstmt() IAlteroperatorstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlteroperatorstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlteroperatorstmtContext) } func (s *StmtContext) Altertypestmt() IAltertypestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAltertypestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAltertypestmtContext) } func (s *StmtContext) Alterpolicystmt() IAlterpolicystmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterpolicystmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterpolicystmtContext) } func (s *StmtContext) Alterseqstmt() IAlterseqstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterseqstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterseqstmtContext) } func (s *StmtContext) Altersystemstmt() IAltersystemstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAltersystemstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAltersystemstmtContext) } func (s *StmtContext) Altertablestmt() IAltertablestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAltertablestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAltertablestmtContext) } func (s *StmtContext) Altertblspcstmt() IAltertblspcstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAltertblspcstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAltertblspcstmtContext) } func (s *StmtContext) Altercompositetypestmt() IAltercompositetypestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAltercompositetypestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAltercompositetypestmtContext) } func (s *StmtContext) Alterpublicationstmt() IAlterpublicationstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterpublicationstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterpublicationstmtContext) } func (s *StmtContext) Alterrolesetstmt() IAlterrolesetstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterrolesetstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterrolesetstmtContext) } func (s *StmtContext) Alterrolestmt() IAlterrolestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterrolestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterrolestmtContext) } func (s *StmtContext) Altersubscriptionstmt() IAltersubscriptionstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAltersubscriptionstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAltersubscriptionstmtContext) } func (s *StmtContext) Alterstatsstmt() IAlterstatsstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterstatsstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterstatsstmtContext) } func (s *StmtContext) Altertsconfigurationstmt() IAltertsconfigurationstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAltertsconfigurationstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAltertsconfigurationstmtContext) } func (s *StmtContext) Altertsdictionarystmt() IAltertsdictionarystmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAltertsdictionarystmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAltertsdictionarystmtContext) } func (s *StmtContext) Alterusermappingstmt() IAlterusermappingstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterusermappingstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterusermappingstmtContext) } func (s *StmtContext) Analyzestmt() IAnalyzestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAnalyzestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAnalyzestmtContext) } func (s *StmtContext) Callstmt() ICallstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICallstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICallstmtContext) } func (s *StmtContext) Checkpointstmt() ICheckpointstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICheckpointstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICheckpointstmtContext) } func (s *StmtContext) Closeportalstmt() ICloseportalstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICloseportalstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICloseportalstmtContext) } func (s *StmtContext) Clusterstmt() IClusterstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IClusterstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IClusterstmtContext) } func (s *StmtContext) Commentstmt() ICommentstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICommentstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICommentstmtContext) } func (s *StmtContext) Constraintssetstmt() IConstraintssetstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstraintssetstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstraintssetstmtContext) } func (s *StmtContext) Copystmt() ICopystmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICopystmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICopystmtContext) } func (s *StmtContext) Createamstmt() ICreateamstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateamstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateamstmtContext) } func (s *StmtContext) Createasstmt() ICreateasstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateasstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateasstmtContext) } func (s *StmtContext) Createassertionstmt() ICreateassertionstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateassertionstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateassertionstmtContext) } func (s *StmtContext) Createcaststmt() ICreatecaststmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatecaststmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatecaststmtContext) } func (s *StmtContext) Createconversionstmt() ICreateconversionstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateconversionstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateconversionstmtContext) } func (s *StmtContext) Createdomainstmt() ICreatedomainstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatedomainstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatedomainstmtContext) } func (s *StmtContext) Createextensionstmt() ICreateextensionstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateextensionstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateextensionstmtContext) } func (s *StmtContext) Createfdwstmt() ICreatefdwstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatefdwstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatefdwstmtContext) } func (s *StmtContext) Createforeignserverstmt() ICreateforeignserverstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateforeignserverstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateforeignserverstmtContext) } func (s *StmtContext) Createforeigntablestmt() ICreateforeigntablestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateforeigntablestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateforeigntablestmtContext) } func (s *StmtContext) Createfunctionstmt() ICreatefunctionstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatefunctionstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatefunctionstmtContext) } func (s *StmtContext) Creategroupstmt() ICreategroupstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreategroupstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreategroupstmtContext) } func (s *StmtContext) Creatematviewstmt() ICreatematviewstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatematviewstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatematviewstmtContext) } func (s *StmtContext) Createopclassstmt() ICreateopclassstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateopclassstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateopclassstmtContext) } func (s *StmtContext) Createopfamilystmt() ICreateopfamilystmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateopfamilystmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateopfamilystmtContext) } func (s *StmtContext) Createpublicationstmt() ICreatepublicationstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatepublicationstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatepublicationstmtContext) } func (s *StmtContext) Alteropfamilystmt() IAlteropfamilystmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlteropfamilystmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlteropfamilystmtContext) } func (s *StmtContext) Createpolicystmt() ICreatepolicystmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatepolicystmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatepolicystmtContext) } func (s *StmtContext) Createplangstmt() ICreateplangstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateplangstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateplangstmtContext) } func (s *StmtContext) Createschemastmt() ICreateschemastmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateschemastmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateschemastmtContext) } func (s *StmtContext) Createseqstmt() ICreateseqstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateseqstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateseqstmtContext) } func (s *StmtContext) Createstmt() ICreatestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatestmtContext) } func (s *StmtContext) Createsubscriptionstmt() ICreatesubscriptionstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatesubscriptionstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatesubscriptionstmtContext) } func (s *StmtContext) Createstatsstmt() ICreatestatsstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatestatsstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatestatsstmtContext) } func (s *StmtContext) Createtablespacestmt() ICreatetablespacestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatetablespacestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatetablespacestmtContext) } func (s *StmtContext) Createtransformstmt() ICreatetransformstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatetransformstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatetransformstmtContext) } func (s *StmtContext) Createtrigstmt() ICreatetrigstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatetrigstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatetrigstmtContext) } func (s *StmtContext) Createeventtrigstmt() ICreateeventtrigstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateeventtrigstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateeventtrigstmtContext) } func (s *StmtContext) Createrolestmt() ICreaterolestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreaterolestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreaterolestmtContext) } func (s *StmtContext) Createuserstmt() ICreateuserstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateuserstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateuserstmtContext) } func (s *StmtContext) Createusermappingstmt() ICreateusermappingstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateusermappingstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateusermappingstmtContext) } func (s *StmtContext) Createdbstmt() ICreatedbstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatedbstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatedbstmtContext) } func (s *StmtContext) Deallocatestmt() IDeallocatestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDeallocatestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDeallocatestmtContext) } func (s *StmtContext) Declarecursorstmt() IDeclarecursorstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDeclarecursorstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDeclarecursorstmtContext) } func (s *StmtContext) Definestmt() IDefinestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDefinestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDefinestmtContext) } func (s *StmtContext) Deletestmt() IDeletestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDeletestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDeletestmtContext) } func (s *StmtContext) Discardstmt() IDiscardstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDiscardstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDiscardstmtContext) } func (s *StmtContext) Dostmt() IDostmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDostmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDostmtContext) } func (s *StmtContext) Dropcaststmt() IDropcaststmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDropcaststmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDropcaststmtContext) } func (s *StmtContext) Dropopclassstmt() IDropopclassstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDropopclassstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDropopclassstmtContext) } func (s *StmtContext) Dropopfamilystmt() IDropopfamilystmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDropopfamilystmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDropopfamilystmtContext) } func (s *StmtContext) Dropownedstmt() IDropownedstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDropownedstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDropownedstmtContext) } func (s *StmtContext) Dropstmt() IDropstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDropstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDropstmtContext) } func (s *StmtContext) Dropsubscriptionstmt() IDropsubscriptionstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDropsubscriptionstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDropsubscriptionstmtContext) } func (s *StmtContext) Droptablespacestmt() IDroptablespacestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDroptablespacestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDroptablespacestmtContext) } func (s *StmtContext) Droptransformstmt() IDroptransformstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDroptransformstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDroptransformstmtContext) } func (s *StmtContext) Droprolestmt() IDroprolestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDroprolestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDroprolestmtContext) } func (s *StmtContext) Dropusermappingstmt() IDropusermappingstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDropusermappingstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDropusermappingstmtContext) } func (s *StmtContext) Dropdbstmt() IDropdbstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDropdbstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDropdbstmtContext) } func (s *StmtContext) Executestmt() IExecutestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExecutestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExecutestmtContext) } func (s *StmtContext) Explainstmt() IExplainstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExplainstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExplainstmtContext) } func (s *StmtContext) Fetchstmt() IFetchstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFetchstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFetchstmtContext) } func (s *StmtContext) Grantstmt() IGrantstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGrantstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGrantstmtContext) } func (s *StmtContext) Grantrolestmt() IGrantrolestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGrantrolestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGrantrolestmtContext) } func (s *StmtContext) Importforeignschemastmt() IImportforeignschemastmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IImportforeignschemastmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IImportforeignschemastmtContext) } func (s *StmtContext) Indexstmt() IIndexstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndexstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIndexstmtContext) } func (s *StmtContext) Insertstmt() IInsertstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInsertstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IInsertstmtContext) } func (s *StmtContext) Mergestmt() IMergestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IMergestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IMergestmtContext) } func (s *StmtContext) Listenstmt() IListenstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IListenstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IListenstmtContext) } func (s *StmtContext) Refreshmatviewstmt() IRefreshmatviewstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRefreshmatviewstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRefreshmatviewstmtContext) } func (s *StmtContext) Loadstmt() ILoadstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ILoadstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ILoadstmtContext) } func (s *StmtContext) Lockstmt() ILockstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ILockstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ILockstmtContext) } func (s *StmtContext) Notifystmt() INotifystmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INotifystmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INotifystmtContext) } func (s *StmtContext) Preparestmt() IPreparestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPreparestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPreparestmtContext) } func (s *StmtContext) Reassignownedstmt() IReassignownedstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReassignownedstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReassignownedstmtContext) } func (s *StmtContext) Reindexstmt() IReindexstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReindexstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReindexstmtContext) } func (s *StmtContext) Removeaggrstmt() IRemoveaggrstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRemoveaggrstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRemoveaggrstmtContext) } func (s *StmtContext) Removefuncstmt() IRemovefuncstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRemovefuncstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRemovefuncstmtContext) } func (s *StmtContext) Removeoperstmt() IRemoveoperstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRemoveoperstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRemoveoperstmtContext) } func (s *StmtContext) Renamestmt() IRenamestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRenamestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRenamestmtContext) } func (s *StmtContext) Revokestmt() IRevokestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRevokestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRevokestmtContext) } func (s *StmtContext) Revokerolestmt() IRevokerolestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRevokerolestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRevokerolestmtContext) } func (s *StmtContext) Rulestmt() IRulestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRulestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRulestmtContext) } func (s *StmtContext) Seclabelstmt() ISeclabelstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISeclabelstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISeclabelstmtContext) } func (s *StmtContext) Selectstmt() ISelectstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectstmtContext) } func (s *StmtContext) Transactionstmt() ITransactionstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITransactionstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITransactionstmtContext) } func (s *StmtContext) Truncatestmt() ITruncatestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITruncatestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITruncatestmtContext) } func (s *StmtContext) Unlistenstmt() IUnlistenstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUnlistenstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUnlistenstmtContext) } func (s *StmtContext) Updatestmt() IUpdatestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUpdatestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUpdatestmtContext) } func (s *StmtContext) Vacuumstmt() IVacuumstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVacuumstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVacuumstmtContext) } func (s *StmtContext) Variableresetstmt() IVariableresetstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVariableresetstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVariableresetstmtContext) } func (s *StmtContext) Variablesetstmt() IVariablesetstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVariablesetstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVariablesetstmtContext) } func (s *StmtContext) Variableshowstmt() IVariableshowstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVariableshowstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVariableshowstmtContext) } func (s *StmtContext) Viewstmt() IViewstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IViewstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IViewstmtContext) } func (s *StmtContext) Plsqlconsolecommand() IPlsqlconsolecommandContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPlsqlconsolecommandContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPlsqlconsolecommandContext) } func (s *StmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *StmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *StmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt(s) } } func (s *StmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt(s) } } func (s *StmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt() (localctx IStmtContext) { localctx = NewStmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 8, PostgreSQLParserRULE_stmt) p.SetState(1765) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(1640) p.Altereventtrigstmt() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(1641) p.Altercollationstmt() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(1642) p.Alterdatabasestmt() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(1643) p.Alterdatabasesetstmt() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(1644) p.Alterdefaultprivilegesstmt() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(1645) p.Alterdomainstmt() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(1646) p.Alterenumstmt() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(1647) p.Alterextensionstmt() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(1648) p.Alterextensioncontentsstmt() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(1649) p.Alterfdwstmt() } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(1650) p.Alterforeignserverstmt() } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(1651) p.Alterfunctionstmt() } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(1652) p.Altergroupstmt() } case 14: p.EnterOuterAlt(localctx, 14) { p.SetState(1653) p.Alterobjectdependsstmt() } case 15: p.EnterOuterAlt(localctx, 15) { p.SetState(1654) p.Alterobjectschemastmt() } case 16: p.EnterOuterAlt(localctx, 16) { p.SetState(1655) p.Alterownerstmt() } case 17: p.EnterOuterAlt(localctx, 17) { p.SetState(1656) p.Alteroperatorstmt() } case 18: p.EnterOuterAlt(localctx, 18) { p.SetState(1657) p.Altertypestmt() } case 19: p.EnterOuterAlt(localctx, 19) { p.SetState(1658) p.Alterpolicystmt() } case 20: p.EnterOuterAlt(localctx, 20) { p.SetState(1659) p.Alterseqstmt() } case 21: p.EnterOuterAlt(localctx, 21) { p.SetState(1660) p.Altersystemstmt() } case 22: p.EnterOuterAlt(localctx, 22) { p.SetState(1661) p.Altertablestmt() } case 23: p.EnterOuterAlt(localctx, 23) { p.SetState(1662) p.Altertblspcstmt() } case 24: p.EnterOuterAlt(localctx, 24) { p.SetState(1663) p.Altercompositetypestmt() } case 25: p.EnterOuterAlt(localctx, 25) { p.SetState(1664) p.Alterpublicationstmt() } case 26: p.EnterOuterAlt(localctx, 26) { p.SetState(1665) p.Alterrolesetstmt() } case 27: p.EnterOuterAlt(localctx, 27) { p.SetState(1666) p.Alterrolestmt() } case 28: p.EnterOuterAlt(localctx, 28) { p.SetState(1667) p.Altersubscriptionstmt() } case 29: p.EnterOuterAlt(localctx, 29) { p.SetState(1668) p.Alterstatsstmt() } case 30: p.EnterOuterAlt(localctx, 30) { p.SetState(1669) p.Altertsconfigurationstmt() } case 31: p.EnterOuterAlt(localctx, 31) { p.SetState(1670) p.Altertsdictionarystmt() } case 32: p.EnterOuterAlt(localctx, 32) { p.SetState(1671) p.Alterusermappingstmt() } case 33: p.EnterOuterAlt(localctx, 33) { p.SetState(1672) p.Analyzestmt() } case 34: p.EnterOuterAlt(localctx, 34) { p.SetState(1673) p.Callstmt() } case 35: p.EnterOuterAlt(localctx, 35) { p.SetState(1674) p.Checkpointstmt() } case 36: p.EnterOuterAlt(localctx, 36) { p.SetState(1675) p.Closeportalstmt() } case 37: p.EnterOuterAlt(localctx, 37) { p.SetState(1676) p.Clusterstmt() } case 38: p.EnterOuterAlt(localctx, 38) { p.SetState(1677) p.Commentstmt() } case 39: p.EnterOuterAlt(localctx, 39) { p.SetState(1678) p.Constraintssetstmt() } case 40: p.EnterOuterAlt(localctx, 40) { p.SetState(1679) p.Copystmt() } case 41: p.EnterOuterAlt(localctx, 41) { p.SetState(1680) p.Createamstmt() } case 42: p.EnterOuterAlt(localctx, 42) { p.SetState(1681) p.Createasstmt() } case 43: p.EnterOuterAlt(localctx, 43) { p.SetState(1682) p.Createassertionstmt() } case 44: p.EnterOuterAlt(localctx, 44) { p.SetState(1683) p.Createcaststmt() } case 45: p.EnterOuterAlt(localctx, 45) { p.SetState(1684) p.Createconversionstmt() } case 46: p.EnterOuterAlt(localctx, 46) { p.SetState(1685) p.Createdomainstmt() } case 47: p.EnterOuterAlt(localctx, 47) { p.SetState(1686) p.Createextensionstmt() } case 48: p.EnterOuterAlt(localctx, 48) { p.SetState(1687) p.Createfdwstmt() } case 49: p.EnterOuterAlt(localctx, 49) { p.SetState(1688) p.Createforeignserverstmt() } case 50: p.EnterOuterAlt(localctx, 50) { p.SetState(1689) p.Createforeigntablestmt() } case 51: p.EnterOuterAlt(localctx, 51) { p.SetState(1690) p.Createfunctionstmt() } case 52: p.EnterOuterAlt(localctx, 52) { p.SetState(1691) p.Creategroupstmt() } case 53: p.EnterOuterAlt(localctx, 53) { p.SetState(1692) p.Creatematviewstmt() } case 54: p.EnterOuterAlt(localctx, 54) { p.SetState(1693) p.Createopclassstmt() } case 55: p.EnterOuterAlt(localctx, 55) { p.SetState(1694) p.Createopfamilystmt() } case 56: p.EnterOuterAlt(localctx, 56) { p.SetState(1695) p.Createpublicationstmt() } case 57: p.EnterOuterAlt(localctx, 57) { p.SetState(1696) p.Alteropfamilystmt() } case 58: p.EnterOuterAlt(localctx, 58) { p.SetState(1697) p.Createpolicystmt() } case 59: p.EnterOuterAlt(localctx, 59) { p.SetState(1698) p.Createplangstmt() } case 60: p.EnterOuterAlt(localctx, 60) { p.SetState(1699) p.Createschemastmt() } case 61: p.EnterOuterAlt(localctx, 61) { p.SetState(1700) p.Createseqstmt() } case 62: p.EnterOuterAlt(localctx, 62) { p.SetState(1701) p.Createstmt() } case 63: p.EnterOuterAlt(localctx, 63) { p.SetState(1702) p.Createsubscriptionstmt() } case 64: p.EnterOuterAlt(localctx, 64) { p.SetState(1703) p.Createstatsstmt() } case 65: p.EnterOuterAlt(localctx, 65) { p.SetState(1704) p.Createtablespacestmt() } case 66: p.EnterOuterAlt(localctx, 66) { p.SetState(1705) p.Createtransformstmt() } case 67: p.EnterOuterAlt(localctx, 67) { p.SetState(1706) p.Createtrigstmt() } case 68: p.EnterOuterAlt(localctx, 68) { p.SetState(1707) p.Createeventtrigstmt() } case 69: p.EnterOuterAlt(localctx, 69) { p.SetState(1708) p.Createrolestmt() } case 70: p.EnterOuterAlt(localctx, 70) { p.SetState(1709) p.Createuserstmt() } case 71: p.EnterOuterAlt(localctx, 71) { p.SetState(1710) p.Createusermappingstmt() } case 72: p.EnterOuterAlt(localctx, 72) { p.SetState(1711) p.Createdbstmt() } case 73: p.EnterOuterAlt(localctx, 73) { p.SetState(1712) p.Deallocatestmt() } case 74: p.EnterOuterAlt(localctx, 74) { p.SetState(1713) p.Declarecursorstmt() } case 75: p.EnterOuterAlt(localctx, 75) { p.SetState(1714) p.Definestmt() } case 76: p.EnterOuterAlt(localctx, 76) { p.SetState(1715) p.Deletestmt() } case 77: p.EnterOuterAlt(localctx, 77) { p.SetState(1716) p.Discardstmt() } case 78: p.EnterOuterAlt(localctx, 78) { p.SetState(1717) p.Dostmt() } case 79: p.EnterOuterAlt(localctx, 79) { p.SetState(1718) p.Dropcaststmt() } case 80: p.EnterOuterAlt(localctx, 80) { p.SetState(1719) p.Dropopclassstmt() } case 81: p.EnterOuterAlt(localctx, 81) { p.SetState(1720) p.Dropopfamilystmt() } case 82: p.EnterOuterAlt(localctx, 82) { p.SetState(1721) p.Dropownedstmt() } case 83: p.EnterOuterAlt(localctx, 83) { p.SetState(1722) p.Dropstmt() } case 84: p.EnterOuterAlt(localctx, 84) { p.SetState(1723) p.Dropsubscriptionstmt() } case 85: p.EnterOuterAlt(localctx, 85) { p.SetState(1724) p.Droptablespacestmt() } case 86: p.EnterOuterAlt(localctx, 86) { p.SetState(1725) p.Droptransformstmt() } case 87: p.EnterOuterAlt(localctx, 87) { p.SetState(1726) p.Droprolestmt() } case 88: p.EnterOuterAlt(localctx, 88) { p.SetState(1727) p.Dropusermappingstmt() } case 89: p.EnterOuterAlt(localctx, 89) { p.SetState(1728) p.Dropdbstmt() } case 90: p.EnterOuterAlt(localctx, 90) { p.SetState(1729) p.Executestmt() } case 91: p.EnterOuterAlt(localctx, 91) { p.SetState(1730) p.Explainstmt() } case 92: p.EnterOuterAlt(localctx, 92) { p.SetState(1731) p.Fetchstmt() } case 93: p.EnterOuterAlt(localctx, 93) { p.SetState(1732) p.Grantstmt() } case 94: p.EnterOuterAlt(localctx, 94) { p.SetState(1733) p.Grantrolestmt() } case 95: p.EnterOuterAlt(localctx, 95) { p.SetState(1734) p.Importforeignschemastmt() } case 96: p.EnterOuterAlt(localctx, 96) { p.SetState(1735) p.Indexstmt() } case 97: p.EnterOuterAlt(localctx, 97) { p.SetState(1736) p.Insertstmt() } case 98: p.EnterOuterAlt(localctx, 98) { p.SetState(1737) p.Mergestmt() } case 99: p.EnterOuterAlt(localctx, 99) { p.SetState(1738) p.Listenstmt() } case 100: p.EnterOuterAlt(localctx, 100) { p.SetState(1739) p.Refreshmatviewstmt() } case 101: p.EnterOuterAlt(localctx, 101) { p.SetState(1740) p.Loadstmt() } case 102: p.EnterOuterAlt(localctx, 102) { p.SetState(1741) p.Lockstmt() } case 103: p.EnterOuterAlt(localctx, 103) { p.SetState(1742) p.Notifystmt() } case 104: p.EnterOuterAlt(localctx, 104) { p.SetState(1743) p.Preparestmt() } case 105: p.EnterOuterAlt(localctx, 105) { p.SetState(1744) p.Reassignownedstmt() } case 106: p.EnterOuterAlt(localctx, 106) { p.SetState(1745) p.Reindexstmt() } case 107: p.EnterOuterAlt(localctx, 107) { p.SetState(1746) p.Removeaggrstmt() } case 108: p.EnterOuterAlt(localctx, 108) { p.SetState(1747) p.Removefuncstmt() } case 109: p.EnterOuterAlt(localctx, 109) { p.SetState(1748) p.Removeoperstmt() } case 110: p.EnterOuterAlt(localctx, 110) { p.SetState(1749) p.Renamestmt() } case 111: p.EnterOuterAlt(localctx, 111) { p.SetState(1750) p.Revokestmt() } case 112: p.EnterOuterAlt(localctx, 112) { p.SetState(1751) p.Revokerolestmt() } case 113: p.EnterOuterAlt(localctx, 113) { p.SetState(1752) p.Rulestmt() } case 114: p.EnterOuterAlt(localctx, 114) { p.SetState(1753) p.Seclabelstmt() } case 115: p.EnterOuterAlt(localctx, 115) { p.SetState(1754) p.Selectstmt() } case 116: p.EnterOuterAlt(localctx, 116) { p.SetState(1755) p.Transactionstmt() } case 117: p.EnterOuterAlt(localctx, 117) { p.SetState(1756) p.Truncatestmt() } case 118: p.EnterOuterAlt(localctx, 118) { p.SetState(1757) p.Unlistenstmt() } case 119: p.EnterOuterAlt(localctx, 119) { p.SetState(1758) p.Updatestmt() } case 120: p.EnterOuterAlt(localctx, 120) { p.SetState(1759) p.Vacuumstmt() } case 121: p.EnterOuterAlt(localctx, 121) { p.SetState(1760) p.Variableresetstmt() } case 122: p.EnterOuterAlt(localctx, 122) { p.SetState(1761) p.Variablesetstmt() } case 123: p.EnterOuterAlt(localctx, 123) { p.SetState(1762) p.Variableshowstmt() } case 124: p.EnterOuterAlt(localctx, 124) { p.SetState(1763) p.Viewstmt() } case 125: p.EnterOuterAlt(localctx, 125) { p.SetState(1764) p.Plsqlconsolecommand() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPlsqlconsolecommandContext is an interface to support dynamic dispatch. type IPlsqlconsolecommandContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures MetaCommand() antlr.TerminalNode EndMetaCommand() antlr.TerminalNode // IsPlsqlconsolecommandContext differentiates from other interfaces. IsPlsqlconsolecommandContext() } type PlsqlconsolecommandContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPlsqlconsolecommandContext() *PlsqlconsolecommandContext { var p = new(PlsqlconsolecommandContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_plsqlconsolecommand return p } func InitEmptyPlsqlconsolecommandContext(p *PlsqlconsolecommandContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_plsqlconsolecommand } func (*PlsqlconsolecommandContext) IsPlsqlconsolecommandContext() {} func NewPlsqlconsolecommandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PlsqlconsolecommandContext { var p = new(PlsqlconsolecommandContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_plsqlconsolecommand return p } func (s *PlsqlconsolecommandContext) GetParser() antlr.Parser { return s.parser } func (s *PlsqlconsolecommandContext) MetaCommand() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMetaCommand, 0) } func (s *PlsqlconsolecommandContext) EndMetaCommand() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEndMetaCommand, 0) } func (s *PlsqlconsolecommandContext) GetRuleContext() antlr.RuleContext { return s } func (s *PlsqlconsolecommandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *PlsqlconsolecommandContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPlsqlconsolecommand(s) } } func (s *PlsqlconsolecommandContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPlsqlconsolecommand(s) } } func (s *PlsqlconsolecommandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPlsqlconsolecommand(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Plsqlconsolecommand() (localctx IPlsqlconsolecommandContext) { localctx = NewPlsqlconsolecommandContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 10, PostgreSQLParserRULE_plsqlconsolecommand) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1767) p.Match(PostgreSQLParserMetaCommand) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(1769) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserEndMetaCommand { { p.SetState(1768) p.Match(PostgreSQLParserEndMetaCommand) if p.HasError() { // Recognition error - abort rule goto errorExit } } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICallstmtContext is an interface to support dynamic dispatch. type ICallstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CALL() antlr.TerminalNode Func_application() IFunc_applicationContext // IsCallstmtContext differentiates from other interfaces. IsCallstmtContext() } type CallstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCallstmtContext() *CallstmtContext { var p = new(CallstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_callstmt return p } func InitEmptyCallstmtContext(p *CallstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_callstmt } func (*CallstmtContext) IsCallstmtContext() {} func NewCallstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CallstmtContext { var p = new(CallstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_callstmt return p } func (s *CallstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CallstmtContext) CALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCALL, 0) } func (s *CallstmtContext) Func_application() IFunc_applicationContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_applicationContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_applicationContext) } func (s *CallstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CallstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CallstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCallstmt(s) } } func (s *CallstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCallstmt(s) } } func (s *CallstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCallstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Callstmt() (localctx ICallstmtContext) { localctx = NewCallstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 12, PostgreSQLParserRULE_callstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(1771) p.Match(PostgreSQLParserCALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1772) p.Func_application() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreaterolestmtContext is an interface to support dynamic dispatch. type ICreaterolestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode ROLE() antlr.TerminalNode Roleid() IRoleidContext Opt_with() IOpt_withContext Optrolelist() IOptrolelistContext // IsCreaterolestmtContext differentiates from other interfaces. IsCreaterolestmtContext() } type CreaterolestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreaterolestmtContext() *CreaterolestmtContext { var p = new(CreaterolestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createrolestmt return p } func InitEmptyCreaterolestmtContext(p *CreaterolestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createrolestmt } func (*CreaterolestmtContext) IsCreaterolestmtContext() {} func NewCreaterolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreaterolestmtContext { var p = new(CreaterolestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createrolestmt return p } func (s *CreaterolestmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreaterolestmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreaterolestmtContext) ROLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLE, 0) } func (s *CreaterolestmtContext) Roleid() IRoleidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRoleidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRoleidContext) } func (s *CreaterolestmtContext) Opt_with() IOpt_withContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_withContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_withContext) } func (s *CreaterolestmtContext) Optrolelist() IOptrolelistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptrolelistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptrolelistContext) } func (s *CreaterolestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreaterolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreaterolestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreaterolestmt(s) } } func (s *CreaterolestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreaterolestmt(s) } } func (s *CreaterolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreaterolestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createrolestmt() (localctx ICreaterolestmtContext) { localctx = NewCreaterolestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 14, PostgreSQLParserRULE_createrolestmt) p.EnterOuterAlt(localctx, 1) { p.SetState(1774) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1775) p.Match(PostgreSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1776) p.Roleid() } { p.SetState(1777) p.Opt_with() } { p.SetState(1778) p.Optrolelist() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_withContext is an interface to support dynamic dispatch. type IOpt_withContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITH() antlr.TerminalNode // IsOpt_withContext differentiates from other interfaces. IsOpt_withContext() } type Opt_withContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_withContext() *Opt_withContext { var p = new(Opt_withContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_with return p } func InitEmptyOpt_withContext(p *Opt_withContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_with } func (*Opt_withContext) IsOpt_withContext() {} func NewOpt_withContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_withContext { var p = new(Opt_withContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_with return p } func (s *Opt_withContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_withContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *Opt_withContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_withContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_withContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_with(s) } } func (s *Opt_withContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_with(s) } } func (s *Opt_withContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_with(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_with() (localctx IOpt_withContext) { localctx = NewOpt_withContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 16, PostgreSQLParserRULE_opt_with) p.SetState(1782) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 4, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(1780) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOptrolelistContext is an interface to support dynamic dispatch. type IOptrolelistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllCreateoptroleelem() []ICreateoptroleelemContext Createoptroleelem(i int) ICreateoptroleelemContext // IsOptrolelistContext differentiates from other interfaces. IsOptrolelistContext() } type OptrolelistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOptrolelistContext() *OptrolelistContext { var p = new(OptrolelistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optrolelist return p } func InitEmptyOptrolelistContext(p *OptrolelistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optrolelist } func (*OptrolelistContext) IsOptrolelistContext() {} func NewOptrolelistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptrolelistContext { var p = new(OptrolelistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_optrolelist return p } func (s *OptrolelistContext) GetParser() antlr.Parser { return s.parser } func (s *OptrolelistContext) AllCreateoptroleelem() []ICreateoptroleelemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ICreateoptroleelemContext); ok { len++ } } tst := make([]ICreateoptroleelemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ICreateoptroleelemContext); ok { tst[i] = t.(ICreateoptroleelemContext) i++ } } return tst } func (s *OptrolelistContext) Createoptroleelem(i int) ICreateoptroleelemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateoptroleelemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ICreateoptroleelemContext) } func (s *OptrolelistContext) GetRuleContext() antlr.RuleContext { return s } func (s *OptrolelistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OptrolelistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOptrolelist(s) } } func (s *OptrolelistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOptrolelist(s) } } func (s *OptrolelistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOptrolelist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Optrolelist() (localctx IOptrolelistContext) { localctx = NewOptrolelistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 18, PostgreSQLParserRULE_optrolelist) var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(1787) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(1784) p.Createoptroleelem() } } p.SetState(1789) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlteroptrolelistContext is an interface to support dynamic dispatch. type IAlteroptrolelistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllAlteroptroleelem() []IAlteroptroleelemContext Alteroptroleelem(i int) IAlteroptroleelemContext // IsAlteroptrolelistContext differentiates from other interfaces. IsAlteroptrolelistContext() } type AlteroptrolelistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlteroptrolelistContext() *AlteroptrolelistContext { var p = new(AlteroptrolelistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alteroptrolelist return p } func InitEmptyAlteroptrolelistContext(p *AlteroptrolelistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alteroptrolelist } func (*AlteroptrolelistContext) IsAlteroptrolelistContext() {} func NewAlteroptrolelistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteroptrolelistContext { var p = new(AlteroptrolelistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alteroptrolelist return p } func (s *AlteroptrolelistContext) GetParser() antlr.Parser { return s.parser } func (s *AlteroptrolelistContext) AllAlteroptroleelem() []IAlteroptroleelemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAlteroptroleelemContext); ok { len++ } } tst := make([]IAlteroptroleelemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAlteroptroleelemContext); ok { tst[i] = t.(IAlteroptroleelemContext) i++ } } return tst } func (s *AlteroptrolelistContext) Alteroptroleelem(i int) IAlteroptroleelemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlteroptroleelemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAlteroptroleelemContext) } func (s *AlteroptrolelistContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlteroptrolelistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlteroptrolelistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlteroptrolelist(s) } } func (s *AlteroptrolelistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlteroptrolelist(s) } } func (s *AlteroptrolelistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlteroptrolelist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alteroptrolelist() (localctx IAlteroptrolelistContext) { localctx = NewAlteroptrolelistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 20, PostgreSQLParserRULE_alteroptrolelist) var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(1793) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 6, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(1790) p.Alteroptroleelem() } } p.SetState(1795) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 6, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlteroptroleelemContext is an interface to support dynamic dispatch. type IAlteroptroleelemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures PASSWORD() antlr.TerminalNode Sconst() ISconstContext NULL_P() antlr.TerminalNode ENCRYPTED() antlr.TerminalNode UNENCRYPTED() antlr.TerminalNode INHERIT() antlr.TerminalNode CONNECTION() antlr.TerminalNode LIMIT() antlr.TerminalNode Signediconst() ISignediconstContext VALID() antlr.TerminalNode UNTIL() antlr.TerminalNode USER() antlr.TerminalNode Role_list() IRole_listContext Identifier() IIdentifierContext // IsAlteroptroleelemContext differentiates from other interfaces. IsAlteroptroleelemContext() } type AlteroptroleelemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlteroptroleelemContext() *AlteroptroleelemContext { var p = new(AlteroptroleelemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alteroptroleelem return p } func InitEmptyAlteroptroleelemContext(p *AlteroptroleelemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alteroptroleelem } func (*AlteroptroleelemContext) IsAlteroptroleelemContext() {} func NewAlteroptroleelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteroptroleelemContext { var p = new(AlteroptroleelemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alteroptroleelem return p } func (s *AlteroptroleelemContext) GetParser() antlr.Parser { return s.parser } func (s *AlteroptroleelemContext) PASSWORD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPASSWORD, 0) } func (s *AlteroptroleelemContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *AlteroptroleelemContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *AlteroptroleelemContext) ENCRYPTED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserENCRYPTED, 0) } func (s *AlteroptroleelemContext) UNENCRYPTED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNENCRYPTED, 0) } func (s *AlteroptroleelemContext) INHERIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINHERIT, 0) } func (s *AlteroptroleelemContext) CONNECTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONNECTION, 0) } func (s *AlteroptroleelemContext) LIMIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLIMIT, 0) } func (s *AlteroptroleelemContext) Signediconst() ISignediconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISignediconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISignediconstContext) } func (s *AlteroptroleelemContext) VALID() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALID, 0) } func (s *AlteroptroleelemContext) UNTIL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNTIL, 0) } func (s *AlteroptroleelemContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *AlteroptroleelemContext) Role_list() IRole_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRole_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRole_listContext) } func (s *AlteroptroleelemContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *AlteroptroleelemContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlteroptroleelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlteroptroleelemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlteroptroleelem(s) } } func (s *AlteroptroleelemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlteroptroleelem(s) } } func (s *AlteroptroleelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlteroptroleelem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alteroptroleelem() (localctx IAlteroptroleelemContext) { localctx = NewAlteroptroleelemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 22, PostgreSQLParserRULE_alteroptroleelem) var _la int p.SetState(1814) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserPASSWORD: p.EnterOuterAlt(localctx, 1) { p.SetState(1796) p.Match(PostgreSQLParserPASSWORD) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(1799) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: { p.SetState(1797) p.Sconst() } case PostgreSQLParserNULL_P: { p.SetState(1798) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case PostgreSQLParserENCRYPTED, PostgreSQLParserUNENCRYPTED: p.EnterOuterAlt(localctx, 2) { p.SetState(1801) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserENCRYPTED || _la == PostgreSQLParserUNENCRYPTED) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(1802) p.Match(PostgreSQLParserPASSWORD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1803) p.Sconst() } case PostgreSQLParserINHERIT: p.EnterOuterAlt(localctx, 3) { p.SetState(1804) p.Match(PostgreSQLParserINHERIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserCONNECTION: p.EnterOuterAlt(localctx, 4) { p.SetState(1805) p.Match(PostgreSQLParserCONNECTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1806) p.Match(PostgreSQLParserLIMIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1807) p.Signediconst() } case PostgreSQLParserVALID: p.EnterOuterAlt(localctx, 5) { p.SetState(1808) p.Match(PostgreSQLParserVALID) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1809) p.Match(PostgreSQLParserUNTIL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1810) p.Sconst() } case PostgreSQLParserUSER: p.EnterOuterAlt(localctx, 6) { p.SetState(1811) p.Match(PostgreSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1812) p.Role_list() } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserOUTER_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserBACKWARD, PostgreSQLParserCHAIN, PostgreSQLParserCLOSE, PostgreSQLParserCOMMIT, PostgreSQLParserCONTINUE_P, PostgreSQLParserCURSOR, PostgreSQLParserFIRST_P, PostgreSQLParserFORWARD, PostgreSQLParserINSERT, PostgreSQLParserLAST_P, PostgreSQLParserMOVE, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserOPTION, PostgreSQLParserPRIOR, PostgreSQLParserRELATIVE_P, PostgreSQLParserRESET, PostgreSQLParserROLLBACK, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSET, PostgreSQLParserTYPE_P, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserROWTYPE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 7) { p.SetState(1813) p.Identifier() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateoptroleelemContext is an interface to support dynamic dispatch. type ICreateoptroleelemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Alteroptroleelem() IAlteroptroleelemContext SYSID() antlr.TerminalNode Iconst() IIconstContext ADMIN() antlr.TerminalNode Role_list() IRole_listContext ROLE() antlr.TerminalNode IN_P() antlr.TerminalNode GROUP_P() antlr.TerminalNode // IsCreateoptroleelemContext differentiates from other interfaces. IsCreateoptroleelemContext() } type CreateoptroleelemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateoptroleelemContext() *CreateoptroleelemContext { var p = new(CreateoptroleelemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createoptroleelem return p } func InitEmptyCreateoptroleelemContext(p *CreateoptroleelemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createoptroleelem } func (*CreateoptroleelemContext) IsCreateoptroleelemContext() {} func NewCreateoptroleelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateoptroleelemContext { var p = new(CreateoptroleelemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createoptroleelem return p } func (s *CreateoptroleelemContext) GetParser() antlr.Parser { return s.parser } func (s *CreateoptroleelemContext) Alteroptroleelem() IAlteroptroleelemContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlteroptroleelemContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlteroptroleelemContext) } func (s *CreateoptroleelemContext) SYSID() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSYSID, 0) } func (s *CreateoptroleelemContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *CreateoptroleelemContext) ADMIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserADMIN, 0) } func (s *CreateoptroleelemContext) Role_list() IRole_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRole_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRole_listContext) } func (s *CreateoptroleelemContext) ROLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLE, 0) } func (s *CreateoptroleelemContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *CreateoptroleelemContext) GROUP_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUP_P, 0) } func (s *CreateoptroleelemContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateoptroleelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateoptroleelemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateoptroleelem(s) } } func (s *CreateoptroleelemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateoptroleelem(s) } } func (s *CreateoptroleelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateoptroleelem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createoptroleelem() (localctx ICreateoptroleelemContext) { localctx = NewCreateoptroleelemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 24, PostgreSQLParserRULE_createoptroleelem) var _la int p.SetState(1826) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserUSER, PostgreSQLParserIS, PostgreSQLParserOUTER_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserBACKWARD, PostgreSQLParserCHAIN, PostgreSQLParserCLOSE, PostgreSQLParserCOMMIT, PostgreSQLParserCONNECTION, PostgreSQLParserCONTINUE_P, PostgreSQLParserCURSOR, PostgreSQLParserENCRYPTED, PostgreSQLParserFIRST_P, PostgreSQLParserFORWARD, PostgreSQLParserINHERIT, PostgreSQLParserINSERT, PostgreSQLParserLAST_P, PostgreSQLParserMOVE, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserOPTION, PostgreSQLParserPASSWORD, PostgreSQLParserPRIOR, PostgreSQLParserRELATIVE_P, PostgreSQLParserRESET, PostgreSQLParserROLLBACK, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSET, PostgreSQLParserTYPE_P, PostgreSQLParserUNENCRYPTED, PostgreSQLParserVALID, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserROWTYPE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(1816) p.Alteroptroleelem() } case PostgreSQLParserSYSID: p.EnterOuterAlt(localctx, 2) { p.SetState(1817) p.Match(PostgreSQLParserSYSID) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1818) p.Iconst() } case PostgreSQLParserADMIN: p.EnterOuterAlt(localctx, 3) { p.SetState(1819) p.Match(PostgreSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1820) p.Role_list() } case PostgreSQLParserROLE: p.EnterOuterAlt(localctx, 4) { p.SetState(1821) p.Match(PostgreSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1822) p.Role_list() } case PostgreSQLParserIN_P: p.EnterOuterAlt(localctx, 5) { p.SetState(1823) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1824) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserGROUP_P || _la == PostgreSQLParserROLE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(1825) p.Role_list() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateuserstmtContext is an interface to support dynamic dispatch. type ICreateuserstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode USER() antlr.TerminalNode Roleid() IRoleidContext Opt_with() IOpt_withContext Optrolelist() IOptrolelistContext // IsCreateuserstmtContext differentiates from other interfaces. IsCreateuserstmtContext() } type CreateuserstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateuserstmtContext() *CreateuserstmtContext { var p = new(CreateuserstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createuserstmt return p } func InitEmptyCreateuserstmtContext(p *CreateuserstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createuserstmt } func (*CreateuserstmtContext) IsCreateuserstmtContext() {} func NewCreateuserstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateuserstmtContext { var p = new(CreateuserstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createuserstmt return p } func (s *CreateuserstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateuserstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateuserstmtContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *CreateuserstmtContext) Roleid() IRoleidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRoleidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRoleidContext) } func (s *CreateuserstmtContext) Opt_with() IOpt_withContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_withContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_withContext) } func (s *CreateuserstmtContext) Optrolelist() IOptrolelistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptrolelistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptrolelistContext) } func (s *CreateuserstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateuserstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateuserstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateuserstmt(s) } } func (s *CreateuserstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateuserstmt(s) } } func (s *CreateuserstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateuserstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createuserstmt() (localctx ICreateuserstmtContext) { localctx = NewCreateuserstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 26, PostgreSQLParserRULE_createuserstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(1828) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1829) p.Match(PostgreSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1830) p.Roleid() } { p.SetState(1831) p.Opt_with() } { p.SetState(1832) p.Optrolelist() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterrolestmtContext is an interface to support dynamic dispatch. type IAlterrolestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode Rolespec() IRolespecContext Opt_with() IOpt_withContext Alteroptrolelist() IAlteroptrolelistContext ROLE() antlr.TerminalNode USER() antlr.TerminalNode // IsAlterrolestmtContext differentiates from other interfaces. IsAlterrolestmtContext() } type AlterrolestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterrolestmtContext() *AlterrolestmtContext { var p = new(AlterrolestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterrolestmt return p } func InitEmptyAlterrolestmtContext(p *AlterrolestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterrolestmt } func (*AlterrolestmtContext) IsAlterrolestmtContext() {} func NewAlterrolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterrolestmtContext { var p = new(AlterrolestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterrolestmt return p } func (s *AlterrolestmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterrolestmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterrolestmtContext) Rolespec() IRolespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRolespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRolespecContext) } func (s *AlterrolestmtContext) Opt_with() IOpt_withContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_withContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_withContext) } func (s *AlterrolestmtContext) Alteroptrolelist() IAlteroptrolelistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlteroptrolelistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlteroptrolelistContext) } func (s *AlterrolestmtContext) ROLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLE, 0) } func (s *AlterrolestmtContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *AlterrolestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterrolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterrolestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterrolestmt(s) } } func (s *AlterrolestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterrolestmt(s) } } func (s *AlterrolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterrolestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterrolestmt() (localctx IAlterrolestmtContext) { localctx = NewAlterrolestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 28, PostgreSQLParserRULE_alterrolestmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1834) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1835) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserUSER || _la == PostgreSQLParserROLE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(1836) p.Rolespec() } { p.SetState(1837) p.Opt_with() } { p.SetState(1838) p.Alteroptrolelist() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_in_databaseContext is an interface to support dynamic dispatch. type IOpt_in_databaseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures IN_P() antlr.TerminalNode DATABASE() antlr.TerminalNode Name() INameContext // IsOpt_in_databaseContext differentiates from other interfaces. IsOpt_in_databaseContext() } type Opt_in_databaseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_in_databaseContext() *Opt_in_databaseContext { var p = new(Opt_in_databaseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_in_database return p } func InitEmptyOpt_in_databaseContext(p *Opt_in_databaseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_in_database } func (*Opt_in_databaseContext) IsOpt_in_databaseContext() {} func NewOpt_in_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_in_databaseContext { var p = new(Opt_in_databaseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_in_database return p } func (s *Opt_in_databaseContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_in_databaseContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *Opt_in_databaseContext) DATABASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATABASE, 0) } func (s *Opt_in_databaseContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *Opt_in_databaseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_in_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_in_databaseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_in_database(s) } } func (s *Opt_in_databaseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_in_database(s) } } func (s *Opt_in_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_in_database(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_in_database() (localctx IOpt_in_databaseContext) { localctx = NewOpt_in_databaseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 30, PostgreSQLParserRULE_opt_in_database) p.SetState(1844) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserRESET, PostgreSQLParserSET: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserIN_P: p.EnterOuterAlt(localctx, 2) { p.SetState(1841) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1842) p.Match(PostgreSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1843) p.Name() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterrolesetstmtContext is an interface to support dynamic dispatch. type IAlterrolesetstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode Rolespec() IRolespecContext Opt_in_database() IOpt_in_databaseContext Setresetclause() ISetresetclauseContext ROLE() antlr.TerminalNode USER() antlr.TerminalNode ALL() antlr.TerminalNode // IsAlterrolesetstmtContext differentiates from other interfaces. IsAlterrolesetstmtContext() } type AlterrolesetstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterrolesetstmtContext() *AlterrolesetstmtContext { var p = new(AlterrolesetstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterrolesetstmt return p } func InitEmptyAlterrolesetstmtContext(p *AlterrolesetstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterrolesetstmt } func (*AlterrolesetstmtContext) IsAlterrolesetstmtContext() {} func NewAlterrolesetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterrolesetstmtContext { var p = new(AlterrolesetstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterrolesetstmt return p } func (s *AlterrolesetstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterrolesetstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterrolesetstmtContext) Rolespec() IRolespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRolespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRolespecContext) } func (s *AlterrolesetstmtContext) Opt_in_database() IOpt_in_databaseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_in_databaseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_in_databaseContext) } func (s *AlterrolesetstmtContext) Setresetclause() ISetresetclauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISetresetclauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISetresetclauseContext) } func (s *AlterrolesetstmtContext) ROLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLE, 0) } func (s *AlterrolesetstmtContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *AlterrolesetstmtContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *AlterrolesetstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterrolesetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterrolesetstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterrolesetstmt(s) } } func (s *AlterrolesetstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterrolesetstmt(s) } } func (s *AlterrolesetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterrolesetstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterrolesetstmt() (localctx IAlterrolesetstmtContext) { localctx = NewAlterrolesetstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 32, PostgreSQLParserRULE_alterrolesetstmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1846) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1847) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserUSER || _la == PostgreSQLParserROLE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } p.SetState(1849) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserALL { { p.SetState(1848) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(1851) p.Rolespec() } { p.SetState(1852) p.Opt_in_database() } { p.SetState(1853) p.Setresetclause() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDroprolestmtContext is an interface to support dynamic dispatch. type IDroprolestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DROP() antlr.TerminalNode Role_list() IRole_listContext ROLE() antlr.TerminalNode USER() antlr.TerminalNode GROUP_P() antlr.TerminalNode IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsDroprolestmtContext differentiates from other interfaces. IsDroprolestmtContext() } type DroprolestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDroprolestmtContext() *DroprolestmtContext { var p = new(DroprolestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_droprolestmt return p } func InitEmptyDroprolestmtContext(p *DroprolestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_droprolestmt } func (*DroprolestmtContext) IsDroprolestmtContext() {} func NewDroprolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DroprolestmtContext { var p = new(DroprolestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_droprolestmt return p } func (s *DroprolestmtContext) GetParser() antlr.Parser { return s.parser } func (s *DroprolestmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *DroprolestmtContext) Role_list() IRole_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRole_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRole_listContext) } func (s *DroprolestmtContext) ROLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLE, 0) } func (s *DroprolestmtContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *DroprolestmtContext) GROUP_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUP_P, 0) } func (s *DroprolestmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *DroprolestmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *DroprolestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DroprolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DroprolestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDroprolestmt(s) } } func (s *DroprolestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDroprolestmt(s) } } func (s *DroprolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDroprolestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Droprolestmt() (localctx IDroprolestmtContext) { localctx = NewDroprolestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 34, PostgreSQLParserRULE_droprolestmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1855) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1856) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserGROUP_P || _la == PostgreSQLParserUSER || _la == PostgreSQLParserROLE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } p.SetState(1859) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 12, p.GetParserRuleContext()) == 1 { { p.SetState(1857) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1858) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(1861) p.Role_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreategroupstmtContext is an interface to support dynamic dispatch. type ICreategroupstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode GROUP_P() antlr.TerminalNode Roleid() IRoleidContext Opt_with() IOpt_withContext Optrolelist() IOptrolelistContext // IsCreategroupstmtContext differentiates from other interfaces. IsCreategroupstmtContext() } type CreategroupstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreategroupstmtContext() *CreategroupstmtContext { var p = new(CreategroupstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_creategroupstmt return p } func InitEmptyCreategroupstmtContext(p *CreategroupstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_creategroupstmt } func (*CreategroupstmtContext) IsCreategroupstmtContext() {} func NewCreategroupstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreategroupstmtContext { var p = new(CreategroupstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_creategroupstmt return p } func (s *CreategroupstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreategroupstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreategroupstmtContext) GROUP_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUP_P, 0) } func (s *CreategroupstmtContext) Roleid() IRoleidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRoleidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRoleidContext) } func (s *CreategroupstmtContext) Opt_with() IOpt_withContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_withContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_withContext) } func (s *CreategroupstmtContext) Optrolelist() IOptrolelistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptrolelistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptrolelistContext) } func (s *CreategroupstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreategroupstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreategroupstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreategroupstmt(s) } } func (s *CreategroupstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreategroupstmt(s) } } func (s *CreategroupstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreategroupstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Creategroupstmt() (localctx ICreategroupstmtContext) { localctx = NewCreategroupstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 36, PostgreSQLParserRULE_creategroupstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(1863) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1864) p.Match(PostgreSQLParserGROUP_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1865) p.Roleid() } { p.SetState(1866) p.Opt_with() } { p.SetState(1867) p.Optrolelist() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAltergroupstmtContext is an interface to support dynamic dispatch. type IAltergroupstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode GROUP_P() antlr.TerminalNode Rolespec() IRolespecContext Add_drop() IAdd_dropContext USER() antlr.TerminalNode Role_list() IRole_listContext // IsAltergroupstmtContext differentiates from other interfaces. IsAltergroupstmtContext() } type AltergroupstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAltergroupstmtContext() *AltergroupstmtContext { var p = new(AltergroupstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altergroupstmt return p } func InitEmptyAltergroupstmtContext(p *AltergroupstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altergroupstmt } func (*AltergroupstmtContext) IsAltergroupstmtContext() {} func NewAltergroupstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltergroupstmtContext { var p = new(AltergroupstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_altergroupstmt return p } func (s *AltergroupstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AltergroupstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AltergroupstmtContext) GROUP_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUP_P, 0) } func (s *AltergroupstmtContext) Rolespec() IRolespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRolespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRolespecContext) } func (s *AltergroupstmtContext) Add_drop() IAdd_dropContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAdd_dropContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAdd_dropContext) } func (s *AltergroupstmtContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *AltergroupstmtContext) Role_list() IRole_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRole_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRole_listContext) } func (s *AltergroupstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AltergroupstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AltergroupstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAltergroupstmt(s) } } func (s *AltergroupstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAltergroupstmt(s) } } func (s *AltergroupstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAltergroupstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Altergroupstmt() (localctx IAltergroupstmtContext) { localctx = NewAltergroupstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 38, PostgreSQLParserRULE_altergroupstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(1869) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1870) p.Match(PostgreSQLParserGROUP_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1871) p.Rolespec() } { p.SetState(1872) p.Add_drop() } { p.SetState(1873) p.Match(PostgreSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1874) p.Role_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAdd_dropContext is an interface to support dynamic dispatch. type IAdd_dropContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ADD_P() antlr.TerminalNode DROP() antlr.TerminalNode // IsAdd_dropContext differentiates from other interfaces. IsAdd_dropContext() } type Add_dropContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAdd_dropContext() *Add_dropContext { var p = new(Add_dropContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_add_drop return p } func InitEmptyAdd_dropContext(p *Add_dropContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_add_drop } func (*Add_dropContext) IsAdd_dropContext() {} func NewAdd_dropContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_dropContext { var p = new(Add_dropContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_add_drop return p } func (s *Add_dropContext) GetParser() antlr.Parser { return s.parser } func (s *Add_dropContext) ADD_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserADD_P, 0) } func (s *Add_dropContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *Add_dropContext) GetRuleContext() antlr.RuleContext { return s } func (s *Add_dropContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Add_dropContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAdd_drop(s) } } func (s *Add_dropContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAdd_drop(s) } } func (s *Add_dropContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAdd_drop(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Add_drop() (localctx IAdd_dropContext) { localctx = NewAdd_dropContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 40, PostgreSQLParserRULE_add_drop) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1876) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserADD_P || _la == PostgreSQLParserDROP) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateschemastmtContext is an interface to support dynamic dispatch. type ICreateschemastmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode SCHEMA() antlr.TerminalNode Optschemaeltlist() IOptschemaeltlistContext Optschemaname() IOptschemanameContext AUTHORIZATION() antlr.TerminalNode Rolespec() IRolespecContext Colid() IColidContext IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsCreateschemastmtContext differentiates from other interfaces. IsCreateschemastmtContext() } type CreateschemastmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateschemastmtContext() *CreateschemastmtContext { var p = new(CreateschemastmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createschemastmt return p } func InitEmptyCreateschemastmtContext(p *CreateschemastmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createschemastmt } func (*CreateschemastmtContext) IsCreateschemastmtContext() {} func NewCreateschemastmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateschemastmtContext { var p = new(CreateschemastmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createschemastmt return p } func (s *CreateschemastmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateschemastmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateschemastmtContext) SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMA, 0) } func (s *CreateschemastmtContext) Optschemaeltlist() IOptschemaeltlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptschemaeltlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptschemaeltlistContext) } func (s *CreateschemastmtContext) Optschemaname() IOptschemanameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptschemanameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptschemanameContext) } func (s *CreateschemastmtContext) AUTHORIZATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAUTHORIZATION, 0) } func (s *CreateschemastmtContext) Rolespec() IRolespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRolespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRolespecContext) } func (s *CreateschemastmtContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *CreateschemastmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *CreateschemastmtContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *CreateschemastmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *CreateschemastmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateschemastmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateschemastmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateschemastmt(s) } } func (s *CreateschemastmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateschemastmt(s) } } func (s *CreateschemastmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateschemastmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createschemastmt() (localctx ICreateschemastmtContext) { localctx = NewCreateschemastmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 42, PostgreSQLParserRULE_createschemastmt) p.EnterOuterAlt(localctx, 1) { p.SetState(1878) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1879) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(1883) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 13, p.GetParserRuleContext()) == 1 { { p.SetState(1880) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1881) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1882) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } p.SetState(1890) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 14, p.GetParserRuleContext()) { case 1: { p.SetState(1885) p.Optschemaname() } { p.SetState(1886) p.Match(PostgreSQLParserAUTHORIZATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1887) p.Rolespec() } case 2: { p.SetState(1889) p.Colid() } case antlr.ATNInvalidAltNumber: goto errorExit } { p.SetState(1892) p.Optschemaeltlist() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOptschemanameContext is an interface to support dynamic dispatch. type IOptschemanameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext // IsOptschemanameContext differentiates from other interfaces. IsOptschemanameContext() } type OptschemanameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOptschemanameContext() *OptschemanameContext { var p = new(OptschemanameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optschemaname return p } func InitEmptyOptschemanameContext(p *OptschemanameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optschemaname } func (*OptschemanameContext) IsOptschemanameContext() {} func NewOptschemanameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptschemanameContext { var p = new(OptschemanameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_optschemaname return p } func (s *OptschemanameContext) GetParser() antlr.Parser { return s.parser } func (s *OptschemanameContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *OptschemanameContext) GetRuleContext() antlr.RuleContext { return s } func (s *OptschemanameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OptschemanameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOptschemaname(s) } } func (s *OptschemanameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOptschemaname(s) } } func (s *OptschemanameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOptschemaname(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Optschemaname() (localctx IOptschemanameContext) { localctx = NewOptschemanameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 44, PostgreSQLParserRULE_optschemaname) p.SetState(1896) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(1894) p.Colid() } case PostgreSQLParserAUTHORIZATION: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOptschemaeltlistContext is an interface to support dynamic dispatch. type IOptschemaeltlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllSchema_stmt() []ISchema_stmtContext Schema_stmt(i int) ISchema_stmtContext // IsOptschemaeltlistContext differentiates from other interfaces. IsOptschemaeltlistContext() } type OptschemaeltlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOptschemaeltlistContext() *OptschemaeltlistContext { var p = new(OptschemaeltlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optschemaeltlist return p } func InitEmptyOptschemaeltlistContext(p *OptschemaeltlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optschemaeltlist } func (*OptschemaeltlistContext) IsOptschemaeltlistContext() {} func NewOptschemaeltlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptschemaeltlistContext { var p = new(OptschemaeltlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_optschemaeltlist return p } func (s *OptschemaeltlistContext) GetParser() antlr.Parser { return s.parser } func (s *OptschemaeltlistContext) AllSchema_stmt() []ISchema_stmtContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISchema_stmtContext); ok { len++ } } tst := make([]ISchema_stmtContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISchema_stmtContext); ok { tst[i] = t.(ISchema_stmtContext) i++ } } return tst } func (s *OptschemaeltlistContext) Schema_stmt(i int) ISchema_stmtContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISchema_stmtContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISchema_stmtContext) } func (s *OptschemaeltlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *OptschemaeltlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OptschemaeltlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOptschemaeltlist(s) } } func (s *OptschemaeltlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOptschemaeltlist(s) } } func (s *OptschemaeltlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOptschemaeltlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Optschemaeltlist() (localctx IOptschemaeltlistContext) { localctx = NewOptschemaeltlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 46, PostgreSQLParserRULE_optschemaeltlist) var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(1901) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 16, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(1898) p.Schema_stmt() } } p.SetState(1903) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 16, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISchema_stmtContext is an interface to support dynamic dispatch. type ISchema_stmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Createstmt() ICreatestmtContext Indexstmt() IIndexstmtContext Createseqstmt() ICreateseqstmtContext Createtrigstmt() ICreatetrigstmtContext Grantstmt() IGrantstmtContext Viewstmt() IViewstmtContext // IsSchema_stmtContext differentiates from other interfaces. IsSchema_stmtContext() } type Schema_stmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySchema_stmtContext() *Schema_stmtContext { var p = new(Schema_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_schema_stmt return p } func InitEmptySchema_stmtContext(p *Schema_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_schema_stmt } func (*Schema_stmtContext) IsSchema_stmtContext() {} func NewSchema_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_stmtContext { var p = new(Schema_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_schema_stmt return p } func (s *Schema_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Schema_stmtContext) Createstmt() ICreatestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatestmtContext) } func (s *Schema_stmtContext) Indexstmt() IIndexstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndexstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIndexstmtContext) } func (s *Schema_stmtContext) Createseqstmt() ICreateseqstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateseqstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateseqstmtContext) } func (s *Schema_stmtContext) Createtrigstmt() ICreatetrigstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatetrigstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatetrigstmtContext) } func (s *Schema_stmtContext) Grantstmt() IGrantstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGrantstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGrantstmtContext) } func (s *Schema_stmtContext) Viewstmt() IViewstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IViewstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IViewstmtContext) } func (s *Schema_stmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *Schema_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Schema_stmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSchema_stmt(s) } } func (s *Schema_stmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSchema_stmt(s) } } func (s *Schema_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSchema_stmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Schema_stmt() (localctx ISchema_stmtContext) { localctx = NewSchema_stmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 48, PostgreSQLParserRULE_schema_stmt) p.SetState(1910) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 17, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(1904) p.Createstmt() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(1905) p.Indexstmt() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(1906) p.Createseqstmt() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(1907) p.Createtrigstmt() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(1908) p.Grantstmt() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(1909) p.Viewstmt() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IVariablesetstmtContext is an interface to support dynamic dispatch. type IVariablesetstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SET() antlr.TerminalNode Set_rest() ISet_restContext LOCAL() antlr.TerminalNode SESSION() antlr.TerminalNode // IsVariablesetstmtContext differentiates from other interfaces. IsVariablesetstmtContext() } type VariablesetstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyVariablesetstmtContext() *VariablesetstmtContext { var p = new(VariablesetstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_variablesetstmt return p } func InitEmptyVariablesetstmtContext(p *VariablesetstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_variablesetstmt } func (*VariablesetstmtContext) IsVariablesetstmtContext() {} func NewVariablesetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariablesetstmtContext { var p = new(VariablesetstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_variablesetstmt return p } func (s *VariablesetstmtContext) GetParser() antlr.Parser { return s.parser } func (s *VariablesetstmtContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *VariablesetstmtContext) Set_rest() ISet_restContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISet_restContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISet_restContext) } func (s *VariablesetstmtContext) LOCAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCAL, 0) } func (s *VariablesetstmtContext) SESSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSESSION, 0) } func (s *VariablesetstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *VariablesetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *VariablesetstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterVariablesetstmt(s) } } func (s *VariablesetstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitVariablesetstmt(s) } } func (s *VariablesetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitVariablesetstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Variablesetstmt() (localctx IVariablesetstmtContext) { localctx = NewVariablesetstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 50, PostgreSQLParserRULE_variablesetstmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1912) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(1914) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 18, p.GetParserRuleContext()) == 1 { { p.SetState(1913) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserLOCAL || _la == PostgreSQLParserSESSION) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(1916) p.Set_rest() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISet_restContext is an interface to support dynamic dispatch. type ISet_restContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TRANSACTION() antlr.TerminalNode Transaction_mode_list() ITransaction_mode_listContext SESSION() antlr.TerminalNode CHARACTERISTICS() antlr.TerminalNode AS() antlr.TerminalNode Set_rest_more() ISet_rest_moreContext // IsSet_restContext differentiates from other interfaces. IsSet_restContext() } type Set_restContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySet_restContext() *Set_restContext { var p = new(Set_restContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_set_rest return p } func InitEmptySet_restContext(p *Set_restContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_set_rest } func (*Set_restContext) IsSet_restContext() {} func NewSet_restContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_restContext { var p = new(Set_restContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_set_rest return p } func (s *Set_restContext) GetParser() antlr.Parser { return s.parser } func (s *Set_restContext) TRANSACTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSACTION, 0) } func (s *Set_restContext) Transaction_mode_list() ITransaction_mode_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITransaction_mode_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITransaction_mode_listContext) } func (s *Set_restContext) SESSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSESSION, 0) } func (s *Set_restContext) CHARACTERISTICS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHARACTERISTICS, 0) } func (s *Set_restContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Set_restContext) Set_rest_more() ISet_rest_moreContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISet_rest_moreContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISet_rest_moreContext) } func (s *Set_restContext) GetRuleContext() antlr.RuleContext { return s } func (s *Set_restContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Set_restContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSet_rest(s) } } func (s *Set_restContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSet_rest(s) } } func (s *Set_restContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSet_rest(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Set_rest() (localctx ISet_restContext) { localctx = NewSet_restContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 52, PostgreSQLParserRULE_set_rest) p.SetState(1926) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 19, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(1918) p.Match(PostgreSQLParserTRANSACTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1919) p.Transaction_mode_list() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(1920) p.Match(PostgreSQLParserSESSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1921) p.Match(PostgreSQLParserCHARACTERISTICS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1922) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1923) p.Match(PostgreSQLParserTRANSACTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1924) p.Transaction_mode_list() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(1925) p.Set_rest_more() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGeneric_setContext is an interface to support dynamic dispatch. type IGeneric_setContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Var_name() IVar_nameContext Var_list() IVar_listContext TO() antlr.TerminalNode EQUAL() antlr.TerminalNode // IsGeneric_setContext differentiates from other interfaces. IsGeneric_setContext() } type Generic_setContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGeneric_setContext() *Generic_setContext { var p = new(Generic_setContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generic_set return p } func InitEmptyGeneric_setContext(p *Generic_setContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generic_set } func (*Generic_setContext) IsGeneric_setContext() {} func NewGeneric_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_setContext { var p = new(Generic_setContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_generic_set return p } func (s *Generic_setContext) GetParser() antlr.Parser { return s.parser } func (s *Generic_setContext) Var_name() IVar_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVar_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVar_nameContext) } func (s *Generic_setContext) Var_list() IVar_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVar_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVar_listContext) } func (s *Generic_setContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *Generic_setContext) EQUAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEQUAL, 0) } func (s *Generic_setContext) GetRuleContext() antlr.RuleContext { return s } func (s *Generic_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Generic_setContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGeneric_set(s) } } func (s *Generic_setContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGeneric_set(s) } } func (s *Generic_setContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGeneric_set(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Generic_set() (localctx IGeneric_setContext) { localctx = NewGeneric_setContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 54, PostgreSQLParserRULE_generic_set) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1928) p.Var_name() } { p.SetState(1929) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserEQUAL || _la == PostgreSQLParserTO) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(1930) p.Var_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISet_rest_moreContext is an interface to support dynamic dispatch. type ISet_rest_moreContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Generic_set() IGeneric_setContext Var_name() IVar_nameContext FROM() antlr.TerminalNode CURRENT_P() antlr.TerminalNode TIME() antlr.TerminalNode ZONE() antlr.TerminalNode Zone_value() IZone_valueContext CATALOG() antlr.TerminalNode Sconst() ISconstContext SCHEMA() antlr.TerminalNode NAMES() antlr.TerminalNode Opt_encoding() IOpt_encodingContext ROLE() antlr.TerminalNode Nonreservedword_or_sconst() INonreservedword_or_sconstContext SESSION() antlr.TerminalNode AUTHORIZATION() antlr.TerminalNode XML_P() antlr.TerminalNode OPTION() antlr.TerminalNode Document_or_content() IDocument_or_contentContext TRANSACTION() antlr.TerminalNode SNAPSHOT() antlr.TerminalNode // IsSet_rest_moreContext differentiates from other interfaces. IsSet_rest_moreContext() } type Set_rest_moreContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySet_rest_moreContext() *Set_rest_moreContext { var p = new(Set_rest_moreContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_set_rest_more return p } func InitEmptySet_rest_moreContext(p *Set_rest_moreContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_set_rest_more } func (*Set_rest_moreContext) IsSet_rest_moreContext() {} func NewSet_rest_moreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_rest_moreContext { var p = new(Set_rest_moreContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_set_rest_more return p } func (s *Set_rest_moreContext) GetParser() antlr.Parser { return s.parser } func (s *Set_rest_moreContext) Generic_set() IGeneric_setContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGeneric_setContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGeneric_setContext) } func (s *Set_rest_moreContext) Var_name() IVar_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVar_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVar_nameContext) } func (s *Set_rest_moreContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *Set_rest_moreContext) CURRENT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_P, 0) } func (s *Set_rest_moreContext) TIME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTIME, 0) } func (s *Set_rest_moreContext) ZONE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserZONE, 0) } func (s *Set_rest_moreContext) Zone_value() IZone_valueContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IZone_valueContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IZone_valueContext) } func (s *Set_rest_moreContext) CATALOG() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCATALOG, 0) } func (s *Set_rest_moreContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Set_rest_moreContext) SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMA, 0) } func (s *Set_rest_moreContext) NAMES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNAMES, 0) } func (s *Set_rest_moreContext) Opt_encoding() IOpt_encodingContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_encodingContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_encodingContext) } func (s *Set_rest_moreContext) ROLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLE, 0) } func (s *Set_rest_moreContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INonreservedword_or_sconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INonreservedword_or_sconstContext) } func (s *Set_rest_moreContext) SESSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSESSION, 0) } func (s *Set_rest_moreContext) AUTHORIZATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAUTHORIZATION, 0) } func (s *Set_rest_moreContext) XML_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXML_P, 0) } func (s *Set_rest_moreContext) OPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPTION, 0) } func (s *Set_rest_moreContext) Document_or_content() IDocument_or_contentContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDocument_or_contentContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDocument_or_contentContext) } func (s *Set_rest_moreContext) TRANSACTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSACTION, 0) } func (s *Set_rest_moreContext) SNAPSHOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSNAPSHOT, 0) } func (s *Set_rest_moreContext) GetRuleContext() antlr.RuleContext { return s } func (s *Set_rest_moreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Set_rest_moreContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSet_rest_more(s) } } func (s *Set_rest_moreContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSet_rest_more(s) } } func (s *Set_rest_moreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSet_rest_more(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Set_rest_more() (localctx ISet_rest_moreContext) { localctx = NewSet_rest_moreContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 56, PostgreSQLParserRULE_set_rest_more) p.SetState(1957) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 20, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(1932) p.Generic_set() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(1933) p.Var_name() } { p.SetState(1934) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1935) p.Match(PostgreSQLParserCURRENT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(1937) p.Match(PostgreSQLParserTIME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1938) p.Match(PostgreSQLParserZONE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1939) p.Zone_value() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(1940) p.Match(PostgreSQLParserCATALOG) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1941) p.Sconst() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(1942) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1943) p.Sconst() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(1944) p.Match(PostgreSQLParserNAMES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1945) p.Opt_encoding() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(1946) p.Match(PostgreSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1947) p.Nonreservedword_or_sconst() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(1948) p.Match(PostgreSQLParserSESSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1949) p.Match(PostgreSQLParserAUTHORIZATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1950) p.Nonreservedword_or_sconst() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(1951) p.Match(PostgreSQLParserXML_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1952) p.Match(PostgreSQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1953) p.Document_or_content() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(1954) p.Match(PostgreSQLParserTRANSACTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1955) p.Match(PostgreSQLParserSNAPSHOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1956) p.Sconst() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IVar_nameContext is an interface to support dynamic dispatch. type IVar_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllColid() []IColidContext Colid(i int) IColidContext AllDOT() []antlr.TerminalNode DOT(i int) antlr.TerminalNode // IsVar_nameContext differentiates from other interfaces. IsVar_nameContext() } type Var_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyVar_nameContext() *Var_nameContext { var p = new(Var_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_var_name return p } func InitEmptyVar_nameContext(p *Var_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_var_name } func (*Var_nameContext) IsVar_nameContext() {} func NewVar_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Var_nameContext { var p = new(Var_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_var_name return p } func (s *Var_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Var_nameContext) AllColid() []IColidContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IColidContext); ok { len++ } } tst := make([]IColidContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IColidContext); ok { tst[i] = t.(IColidContext) i++ } } return tst } func (s *Var_nameContext) Colid(i int) IColidContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IColidContext) } func (s *Var_nameContext) AllDOT() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserDOT) } func (s *Var_nameContext) DOT(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOT, i) } func (s *Var_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Var_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Var_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterVar_name(s) } } func (s *Var_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitVar_name(s) } } func (s *Var_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitVar_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Var_name() (localctx IVar_nameContext) { localctx = NewVar_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 58, PostgreSQLParserRULE_var_name) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1959) p.Colid() } p.SetState(1964) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserDOT { { p.SetState(1960) p.Match(PostgreSQLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1961) p.Colid() } p.SetState(1966) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IVar_listContext is an interface to support dynamic dispatch. type IVar_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllVar_value() []IVar_valueContext Var_value(i int) IVar_valueContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsVar_listContext differentiates from other interfaces. IsVar_listContext() } type Var_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyVar_listContext() *Var_listContext { var p = new(Var_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_var_list return p } func InitEmptyVar_listContext(p *Var_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_var_list } func (*Var_listContext) IsVar_listContext() {} func NewVar_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Var_listContext { var p = new(Var_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_var_list return p } func (s *Var_listContext) GetParser() antlr.Parser { return s.parser } func (s *Var_listContext) AllVar_value() []IVar_valueContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IVar_valueContext); ok { len++ } } tst := make([]IVar_valueContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IVar_valueContext); ok { tst[i] = t.(IVar_valueContext) i++ } } return tst } func (s *Var_listContext) Var_value(i int) IVar_valueContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVar_valueContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IVar_valueContext) } func (s *Var_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Var_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Var_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Var_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Var_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterVar_list(s) } } func (s *Var_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitVar_list(s) } } func (s *Var_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitVar_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Var_list() (localctx IVar_listContext) { localctx = NewVar_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 60, PostgreSQLParserRULE_var_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1967) p.Var_value() } p.SetState(1972) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(1968) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1969) p.Var_value() } p.SetState(1974) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IVar_valueContext is an interface to support dynamic dispatch. type IVar_valueContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_boolean_or_string() IOpt_boolean_or_stringContext Numericonly() INumericonlyContext // IsVar_valueContext differentiates from other interfaces. IsVar_valueContext() } type Var_valueContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyVar_valueContext() *Var_valueContext { var p = new(Var_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_var_value return p } func InitEmptyVar_valueContext(p *Var_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_var_value } func (*Var_valueContext) IsVar_valueContext() {} func NewVar_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Var_valueContext { var p = new(Var_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_var_value return p } func (s *Var_valueContext) GetParser() antlr.Parser { return s.parser } func (s *Var_valueContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_boolean_or_stringContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_boolean_or_stringContext) } func (s *Var_valueContext) Numericonly() INumericonlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericonlyContext) } func (s *Var_valueContext) GetRuleContext() antlr.RuleContext { return s } func (s *Var_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Var_valueContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterVar_value(s) } } func (s *Var_valueContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitVar_value(s) } } func (s *Var_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitVar_value(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Var_value() (localctx IVar_valueContext) { localctx = NewVar_valueContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 62, PostgreSQLParserRULE_var_value) p.SetState(1977) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserON, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(1975) p.Opt_boolean_or_string() } case PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserIntegral, PostgreSQLParserNumeric: p.EnterOuterAlt(localctx, 2) { p.SetState(1976) p.Numericonly() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IIso_levelContext is an interface to support dynamic dispatch. type IIso_levelContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures READ() antlr.TerminalNode UNCOMMITTED() antlr.TerminalNode COMMITTED() antlr.TerminalNode REPEATABLE() antlr.TerminalNode SERIALIZABLE() antlr.TerminalNode // IsIso_levelContext differentiates from other interfaces. IsIso_levelContext() } type Iso_levelContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyIso_levelContext() *Iso_levelContext { var p = new(Iso_levelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_iso_level return p } func InitEmptyIso_levelContext(p *Iso_levelContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_iso_level } func (*Iso_levelContext) IsIso_levelContext() {} func NewIso_levelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Iso_levelContext { var p = new(Iso_levelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_iso_level return p } func (s *Iso_levelContext) GetParser() antlr.Parser { return s.parser } func (s *Iso_levelContext) READ() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREAD, 0) } func (s *Iso_levelContext) UNCOMMITTED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNCOMMITTED, 0) } func (s *Iso_levelContext) COMMITTED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMITTED, 0) } func (s *Iso_levelContext) REPEATABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREPEATABLE, 0) } func (s *Iso_levelContext) SERIALIZABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSERIALIZABLE, 0) } func (s *Iso_levelContext) GetRuleContext() antlr.RuleContext { return s } func (s *Iso_levelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Iso_levelContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterIso_level(s) } } func (s *Iso_levelContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitIso_level(s) } } func (s *Iso_levelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitIso_level(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Iso_level() (localctx IIso_levelContext) { localctx = NewIso_levelContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 64, PostgreSQLParserRULE_iso_level) var _la int p.SetState(1984) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserREAD: p.EnterOuterAlt(localctx, 1) { p.SetState(1979) p.Match(PostgreSQLParserREAD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1980) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserCOMMITTED || _la == PostgreSQLParserUNCOMMITTED) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } case PostgreSQLParserREPEATABLE: p.EnterOuterAlt(localctx, 2) { p.SetState(1981) p.Match(PostgreSQLParserREPEATABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(1982) p.Match(PostgreSQLParserREAD) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSERIALIZABLE: p.EnterOuterAlt(localctx, 3) { p.SetState(1983) p.Match(PostgreSQLParserSERIALIZABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_boolean_or_stringContext is an interface to support dynamic dispatch. type IOpt_boolean_or_stringContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TRUE_P() antlr.TerminalNode FALSE_P() antlr.TerminalNode ON() antlr.TerminalNode Nonreservedword_or_sconst() INonreservedword_or_sconstContext // IsOpt_boolean_or_stringContext differentiates from other interfaces. IsOpt_boolean_or_stringContext() } type Opt_boolean_or_stringContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_boolean_or_stringContext() *Opt_boolean_or_stringContext { var p = new(Opt_boolean_or_stringContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_boolean_or_string return p } func InitEmptyOpt_boolean_or_stringContext(p *Opt_boolean_or_stringContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_boolean_or_string } func (*Opt_boolean_or_stringContext) IsOpt_boolean_or_stringContext() {} func NewOpt_boolean_or_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_boolean_or_stringContext { var p = new(Opt_boolean_or_stringContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_boolean_or_string return p } func (s *Opt_boolean_or_stringContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_boolean_or_stringContext) TRUE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRUE_P, 0) } func (s *Opt_boolean_or_stringContext) FALSE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFALSE_P, 0) } func (s *Opt_boolean_or_stringContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *Opt_boolean_or_stringContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INonreservedword_or_sconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INonreservedword_or_sconstContext) } func (s *Opt_boolean_or_stringContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_boolean_or_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_boolean_or_stringContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_boolean_or_string(s) } } func (s *Opt_boolean_or_stringContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_boolean_or_string(s) } } func (s *Opt_boolean_or_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_boolean_or_string(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_boolean_or_string() (localctx IOpt_boolean_or_stringContext) { localctx = NewOpt_boolean_or_stringContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 66, PostgreSQLParserRULE_opt_boolean_or_string) p.SetState(1990) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserTRUE_P: p.EnterOuterAlt(localctx, 1) { p.SetState(1986) p.Match(PostgreSQLParserTRUE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserFALSE_P: p.EnterOuterAlt(localctx, 2) { p.SetState(1987) p.Match(PostgreSQLParserFALSE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserON: p.EnterOuterAlt(localctx, 3) { p.SetState(1988) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 4) { p.SetState(1989) p.Nonreservedword_or_sconst() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IZone_valueContext is an interface to support dynamic dispatch. type IZone_valueContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sconst() ISconstContext Identifier() IIdentifierContext Constinterval() IConstintervalContext Opt_interval() IOpt_intervalContext OPEN_PAREN() antlr.TerminalNode Iconst() IIconstContext CLOSE_PAREN() antlr.TerminalNode Numericonly() INumericonlyContext DEFAULT() antlr.TerminalNode LOCAL() antlr.TerminalNode // IsZone_valueContext differentiates from other interfaces. IsZone_valueContext() } type Zone_valueContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyZone_valueContext() *Zone_valueContext { var p = new(Zone_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_zone_value return p } func InitEmptyZone_valueContext(p *Zone_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_zone_value } func (*Zone_valueContext) IsZone_valueContext() {} func NewZone_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Zone_valueContext { var p = new(Zone_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_zone_value return p } func (s *Zone_valueContext) GetParser() antlr.Parser { return s.parser } func (s *Zone_valueContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Zone_valueContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *Zone_valueContext) Constinterval() IConstintervalContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstintervalContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstintervalContext) } func (s *Zone_valueContext) Opt_interval() IOpt_intervalContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_intervalContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_intervalContext) } func (s *Zone_valueContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Zone_valueContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *Zone_valueContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Zone_valueContext) Numericonly() INumericonlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericonlyContext) } func (s *Zone_valueContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Zone_valueContext) LOCAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCAL, 0) } func (s *Zone_valueContext) GetRuleContext() antlr.RuleContext { return s } func (s *Zone_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Zone_valueContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterZone_value(s) } } func (s *Zone_valueContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitZone_value(s) } } func (s *Zone_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitZone_value(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Zone_value() (localctx IZone_valueContext) { localctx = NewZone_valueContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 68, PostgreSQLParserRULE_zone_value) p.SetState(2007) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 26, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(1992) p.Sconst() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(1993) p.Identifier() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(1994) p.Constinterval() } { p.SetState(1995) p.Sconst() } { p.SetState(1996) p.Opt_interval() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(1998) p.Constinterval() } { p.SetState(1999) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2000) p.Iconst() } { p.SetState(2001) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2002) p.Sconst() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(2004) p.Numericonly() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(2005) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(2006) p.Match(PostgreSQLParserLOCAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_encodingContext is an interface to support dynamic dispatch. type IOpt_encodingContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sconst() ISconstContext DEFAULT() antlr.TerminalNode // IsOpt_encodingContext differentiates from other interfaces. IsOpt_encodingContext() } type Opt_encodingContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_encodingContext() *Opt_encodingContext { var p = new(Opt_encodingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_encoding return p } func InitEmptyOpt_encodingContext(p *Opt_encodingContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_encoding } func (*Opt_encodingContext) IsOpt_encodingContext() {} func NewOpt_encodingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_encodingContext { var p = new(Opt_encodingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_encoding return p } func (s *Opt_encodingContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_encodingContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Opt_encodingContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Opt_encodingContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_encodingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_encodingContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_encoding(s) } } func (s *Opt_encodingContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_encoding(s) } } func (s *Opt_encodingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_encoding(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_encoding() (localctx IOpt_encodingContext) { localctx = NewOpt_encodingContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 70, PostgreSQLParserRULE_opt_encoding) p.SetState(2012) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(2009) p.Sconst() } case PostgreSQLParserDEFAULT: p.EnterOuterAlt(localctx, 2) { p.SetState(2010) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAS, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCALLED, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTERNAL, PostgreSQLParserIMMUTABLE, PostgreSQLParserINSERT, PostgreSQLParserLANGUAGE, PostgreSQLParserLEAKPROOF, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTABLE, PostgreSQLParserSTART, PostgreSQLParserSTRICT_P, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVOLATILE, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 3) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // INonreservedword_or_sconstContext is an interface to support dynamic dispatch. type INonreservedword_or_sconstContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Nonreservedword() INonreservedwordContext Sconst() ISconstContext // IsNonreservedword_or_sconstContext differentiates from other interfaces. IsNonreservedword_or_sconstContext() } type Nonreservedword_or_sconstContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyNonreservedword_or_sconstContext() *Nonreservedword_or_sconstContext { var p = new(Nonreservedword_or_sconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_nonreservedword_or_sconst return p } func InitEmptyNonreservedword_or_sconstContext(p *Nonreservedword_or_sconstContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_nonreservedword_or_sconst } func (*Nonreservedword_or_sconstContext) IsNonreservedword_or_sconstContext() {} func NewNonreservedword_or_sconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Nonreservedword_or_sconstContext { var p = new(Nonreservedword_or_sconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_nonreservedword_or_sconst return p } func (s *Nonreservedword_or_sconstContext) GetParser() antlr.Parser { return s.parser } func (s *Nonreservedword_or_sconstContext) Nonreservedword() INonreservedwordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INonreservedwordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INonreservedwordContext) } func (s *Nonreservedword_or_sconstContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Nonreservedword_or_sconstContext) GetRuleContext() antlr.RuleContext { return s } func (s *Nonreservedword_or_sconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Nonreservedword_or_sconstContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterNonreservedword_or_sconst(s) } } func (s *Nonreservedword_or_sconstContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitNonreservedword_or_sconst(s) } } func (s *Nonreservedword_or_sconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitNonreservedword_or_sconst(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Nonreservedword_or_sconst() (localctx INonreservedword_or_sconstContext) { localctx = NewNonreservedword_or_sconstContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 72, PostgreSQLParserRULE_nonreservedword_or_sconst) p.SetState(2016) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(2014) p.Nonreservedword() } case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 2) { p.SetState(2015) p.Sconst() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IVariableresetstmtContext is an interface to support dynamic dispatch. type IVariableresetstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures RESET() antlr.TerminalNode Reset_rest() IReset_restContext // IsVariableresetstmtContext differentiates from other interfaces. IsVariableresetstmtContext() } type VariableresetstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyVariableresetstmtContext() *VariableresetstmtContext { var p = new(VariableresetstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_variableresetstmt return p } func InitEmptyVariableresetstmtContext(p *VariableresetstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_variableresetstmt } func (*VariableresetstmtContext) IsVariableresetstmtContext() {} func NewVariableresetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableresetstmtContext { var p = new(VariableresetstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_variableresetstmt return p } func (s *VariableresetstmtContext) GetParser() antlr.Parser { return s.parser } func (s *VariableresetstmtContext) RESET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESET, 0) } func (s *VariableresetstmtContext) Reset_rest() IReset_restContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReset_restContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReset_restContext) } func (s *VariableresetstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *VariableresetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *VariableresetstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterVariableresetstmt(s) } } func (s *VariableresetstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitVariableresetstmt(s) } } func (s *VariableresetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitVariableresetstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Variableresetstmt() (localctx IVariableresetstmtContext) { localctx = NewVariableresetstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 74, PostgreSQLParserRULE_variableresetstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(2018) p.Match(PostgreSQLParserRESET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2019) p.Reset_rest() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IReset_restContext is an interface to support dynamic dispatch. type IReset_restContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Generic_reset() IGeneric_resetContext TIME() antlr.TerminalNode ZONE() antlr.TerminalNode TRANSACTION() antlr.TerminalNode ISOLATION() antlr.TerminalNode LEVEL() antlr.TerminalNode SESSION() antlr.TerminalNode AUTHORIZATION() antlr.TerminalNode // IsReset_restContext differentiates from other interfaces. IsReset_restContext() } type Reset_restContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyReset_restContext() *Reset_restContext { var p = new(Reset_restContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reset_rest return p } func InitEmptyReset_restContext(p *Reset_restContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reset_rest } func (*Reset_restContext) IsReset_restContext() {} func NewReset_restContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reset_restContext { var p = new(Reset_restContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_reset_rest return p } func (s *Reset_restContext) GetParser() antlr.Parser { return s.parser } func (s *Reset_restContext) Generic_reset() IGeneric_resetContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGeneric_resetContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGeneric_resetContext) } func (s *Reset_restContext) TIME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTIME, 0) } func (s *Reset_restContext) ZONE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserZONE, 0) } func (s *Reset_restContext) TRANSACTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSACTION, 0) } func (s *Reset_restContext) ISOLATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserISOLATION, 0) } func (s *Reset_restContext) LEVEL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEVEL, 0) } func (s *Reset_restContext) SESSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSESSION, 0) } func (s *Reset_restContext) AUTHORIZATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAUTHORIZATION, 0) } func (s *Reset_restContext) GetRuleContext() antlr.RuleContext { return s } func (s *Reset_restContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Reset_restContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterReset_rest(s) } } func (s *Reset_restContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitReset_rest(s) } } func (s *Reset_restContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitReset_rest(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Reset_rest() (localctx IReset_restContext) { localctx = NewReset_restContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 76, PostgreSQLParserRULE_reset_rest) p.SetState(2029) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 29, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(2021) p.Generic_reset() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(2022) p.Match(PostgreSQLParserTIME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2023) p.Match(PostgreSQLParserZONE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(2024) p.Match(PostgreSQLParserTRANSACTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2025) p.Match(PostgreSQLParserISOLATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2026) p.Match(PostgreSQLParserLEVEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(2027) p.Match(PostgreSQLParserSESSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2028) p.Match(PostgreSQLParserAUTHORIZATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGeneric_resetContext is an interface to support dynamic dispatch. type IGeneric_resetContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Var_name() IVar_nameContext ALL() antlr.TerminalNode // IsGeneric_resetContext differentiates from other interfaces. IsGeneric_resetContext() } type Generic_resetContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGeneric_resetContext() *Generic_resetContext { var p = new(Generic_resetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generic_reset return p } func InitEmptyGeneric_resetContext(p *Generic_resetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generic_reset } func (*Generic_resetContext) IsGeneric_resetContext() {} func NewGeneric_resetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_resetContext { var p = new(Generic_resetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_generic_reset return p } func (s *Generic_resetContext) GetParser() antlr.Parser { return s.parser } func (s *Generic_resetContext) Var_name() IVar_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVar_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVar_nameContext) } func (s *Generic_resetContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *Generic_resetContext) GetRuleContext() antlr.RuleContext { return s } func (s *Generic_resetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Generic_resetContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGeneric_reset(s) } } func (s *Generic_resetContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGeneric_reset(s) } } func (s *Generic_resetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGeneric_reset(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Generic_reset() (localctx IGeneric_resetContext) { localctx = NewGeneric_resetContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 78, PostgreSQLParserRULE_generic_reset) p.SetState(2033) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(2031) p.Var_name() } case PostgreSQLParserALL: p.EnterOuterAlt(localctx, 2) { p.SetState(2032) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISetresetclauseContext is an interface to support dynamic dispatch. type ISetresetclauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SET() antlr.TerminalNode Set_rest() ISet_restContext Variableresetstmt() IVariableresetstmtContext // IsSetresetclauseContext differentiates from other interfaces. IsSetresetclauseContext() } type SetresetclauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySetresetclauseContext() *SetresetclauseContext { var p = new(SetresetclauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_setresetclause return p } func InitEmptySetresetclauseContext(p *SetresetclauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_setresetclause } func (*SetresetclauseContext) IsSetresetclauseContext() {} func NewSetresetclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetresetclauseContext { var p = new(SetresetclauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_setresetclause return p } func (s *SetresetclauseContext) GetParser() antlr.Parser { return s.parser } func (s *SetresetclauseContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *SetresetclauseContext) Set_rest() ISet_restContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISet_restContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISet_restContext) } func (s *SetresetclauseContext) Variableresetstmt() IVariableresetstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVariableresetstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVariableresetstmtContext) } func (s *SetresetclauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *SetresetclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SetresetclauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSetresetclause(s) } } func (s *SetresetclauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSetresetclause(s) } } func (s *SetresetclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSetresetclause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Setresetclause() (localctx ISetresetclauseContext) { localctx = NewSetresetclauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 80, PostgreSQLParserRULE_setresetclause) p.SetState(2038) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSET: p.EnterOuterAlt(localctx, 1) { p.SetState(2035) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2036) p.Set_rest() } case PostgreSQLParserRESET: p.EnterOuterAlt(localctx, 2) { p.SetState(2037) p.Variableresetstmt() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunctionsetresetclauseContext is an interface to support dynamic dispatch. type IFunctionsetresetclauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SET() antlr.TerminalNode Set_rest_more() ISet_rest_moreContext Variableresetstmt() IVariableresetstmtContext // IsFunctionsetresetclauseContext differentiates from other interfaces. IsFunctionsetresetclauseContext() } type FunctionsetresetclauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunctionsetresetclauseContext() *FunctionsetresetclauseContext { var p = new(FunctionsetresetclauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_functionsetresetclause return p } func InitEmptyFunctionsetresetclauseContext(p *FunctionsetresetclauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_functionsetresetclause } func (*FunctionsetresetclauseContext) IsFunctionsetresetclauseContext() {} func NewFunctionsetresetclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionsetresetclauseContext { var p = new(FunctionsetresetclauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_functionsetresetclause return p } func (s *FunctionsetresetclauseContext) GetParser() antlr.Parser { return s.parser } func (s *FunctionsetresetclauseContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *FunctionsetresetclauseContext) Set_rest_more() ISet_rest_moreContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISet_rest_moreContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISet_rest_moreContext) } func (s *FunctionsetresetclauseContext) Variableresetstmt() IVariableresetstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVariableresetstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVariableresetstmtContext) } func (s *FunctionsetresetclauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *FunctionsetresetclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *FunctionsetresetclauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunctionsetresetclause(s) } } func (s *FunctionsetresetclauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunctionsetresetclause(s) } } func (s *FunctionsetresetclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunctionsetresetclause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Functionsetresetclause() (localctx IFunctionsetresetclauseContext) { localctx = NewFunctionsetresetclauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 82, PostgreSQLParserRULE_functionsetresetclause) p.SetState(2043) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSET: p.EnterOuterAlt(localctx, 1) { p.SetState(2040) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2041) p.Set_rest_more() } case PostgreSQLParserRESET: p.EnterOuterAlt(localctx, 2) { p.SetState(2042) p.Variableresetstmt() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IVariableshowstmtContext is an interface to support dynamic dispatch. type IVariableshowstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SHOW() antlr.TerminalNode Var_name() IVar_nameContext TIME() antlr.TerminalNode ZONE() antlr.TerminalNode TRANSACTION() antlr.TerminalNode ISOLATION() antlr.TerminalNode LEVEL() antlr.TerminalNode SESSION() antlr.TerminalNode AUTHORIZATION() antlr.TerminalNode ALL() antlr.TerminalNode // IsVariableshowstmtContext differentiates from other interfaces. IsVariableshowstmtContext() } type VariableshowstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyVariableshowstmtContext() *VariableshowstmtContext { var p = new(VariableshowstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_variableshowstmt return p } func InitEmptyVariableshowstmtContext(p *VariableshowstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_variableshowstmt } func (*VariableshowstmtContext) IsVariableshowstmtContext() {} func NewVariableshowstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableshowstmtContext { var p = new(VariableshowstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_variableshowstmt return p } func (s *VariableshowstmtContext) GetParser() antlr.Parser { return s.parser } func (s *VariableshowstmtContext) SHOW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSHOW, 0) } func (s *VariableshowstmtContext) Var_name() IVar_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVar_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVar_nameContext) } func (s *VariableshowstmtContext) TIME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTIME, 0) } func (s *VariableshowstmtContext) ZONE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserZONE, 0) } func (s *VariableshowstmtContext) TRANSACTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSACTION, 0) } func (s *VariableshowstmtContext) ISOLATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserISOLATION, 0) } func (s *VariableshowstmtContext) LEVEL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEVEL, 0) } func (s *VariableshowstmtContext) SESSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSESSION, 0) } func (s *VariableshowstmtContext) AUTHORIZATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAUTHORIZATION, 0) } func (s *VariableshowstmtContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *VariableshowstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *VariableshowstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *VariableshowstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterVariableshowstmt(s) } } func (s *VariableshowstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitVariableshowstmt(s) } } func (s *VariableshowstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitVariableshowstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Variableshowstmt() (localctx IVariableshowstmtContext) { localctx = NewVariableshowstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 84, PostgreSQLParserRULE_variableshowstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(2045) p.Match(PostgreSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2055) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 33, p.GetParserRuleContext()) { case 1: { p.SetState(2046) p.Var_name() } case 2: { p.SetState(2047) p.Match(PostgreSQLParserTIME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2048) p.Match(PostgreSQLParserZONE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: { p.SetState(2049) p.Match(PostgreSQLParserTRANSACTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2050) p.Match(PostgreSQLParserISOLATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2051) p.Match(PostgreSQLParserLEVEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: { p.SetState(2052) p.Match(PostgreSQLParserSESSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2053) p.Match(PostgreSQLParserAUTHORIZATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: { p.SetState(2054) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IConstraintssetstmtContext is an interface to support dynamic dispatch. type IConstraintssetstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SET() antlr.TerminalNode CONSTRAINTS() antlr.TerminalNode Constraints_set_list() IConstraints_set_listContext Constraints_set_mode() IConstraints_set_modeContext // IsConstraintssetstmtContext differentiates from other interfaces. IsConstraintssetstmtContext() } type ConstraintssetstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyConstraintssetstmtContext() *ConstraintssetstmtContext { var p = new(ConstraintssetstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constraintssetstmt return p } func InitEmptyConstraintssetstmtContext(p *ConstraintssetstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constraintssetstmt } func (*ConstraintssetstmtContext) IsConstraintssetstmtContext() {} func NewConstraintssetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintssetstmtContext { var p = new(ConstraintssetstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_constraintssetstmt return p } func (s *ConstraintssetstmtContext) GetParser() antlr.Parser { return s.parser } func (s *ConstraintssetstmtContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *ConstraintssetstmtContext) CONSTRAINTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTRAINTS, 0) } func (s *ConstraintssetstmtContext) Constraints_set_list() IConstraints_set_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstraints_set_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstraints_set_listContext) } func (s *ConstraintssetstmtContext) Constraints_set_mode() IConstraints_set_modeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstraints_set_modeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstraints_set_modeContext) } func (s *ConstraintssetstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *ConstraintssetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ConstraintssetstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterConstraintssetstmt(s) } } func (s *ConstraintssetstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitConstraintssetstmt(s) } } func (s *ConstraintssetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitConstraintssetstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Constraintssetstmt() (localctx IConstraintssetstmtContext) { localctx = NewConstraintssetstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 86, PostgreSQLParserRULE_constraintssetstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(2057) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2058) p.Match(PostgreSQLParserCONSTRAINTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2059) p.Constraints_set_list() } { p.SetState(2060) p.Constraints_set_mode() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IConstraints_set_listContext is an interface to support dynamic dispatch. type IConstraints_set_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALL() antlr.TerminalNode Qualified_name_list() IQualified_name_listContext // IsConstraints_set_listContext differentiates from other interfaces. IsConstraints_set_listContext() } type Constraints_set_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyConstraints_set_listContext() *Constraints_set_listContext { var p = new(Constraints_set_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constraints_set_list return p } func InitEmptyConstraints_set_listContext(p *Constraints_set_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constraints_set_list } func (*Constraints_set_listContext) IsConstraints_set_listContext() {} func NewConstraints_set_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraints_set_listContext { var p = new(Constraints_set_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_constraints_set_list return p } func (s *Constraints_set_listContext) GetParser() antlr.Parser { return s.parser } func (s *Constraints_set_listContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *Constraints_set_listContext) Qualified_name_list() IQualified_name_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_name_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_name_listContext) } func (s *Constraints_set_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Constraints_set_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Constraints_set_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterConstraints_set_list(s) } } func (s *Constraints_set_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitConstraints_set_list(s) } } func (s *Constraints_set_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitConstraints_set_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Constraints_set_list() (localctx IConstraints_set_listContext) { localctx = NewConstraints_set_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 88, PostgreSQLParserRULE_constraints_set_list) p.SetState(2064) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserALL: p.EnterOuterAlt(localctx, 1) { p.SetState(2062) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 2) { p.SetState(2063) p.Qualified_name_list() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IConstraints_set_modeContext is an interface to support dynamic dispatch. type IConstraints_set_modeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DEFERRED() antlr.TerminalNode IMMEDIATE() antlr.TerminalNode // IsConstraints_set_modeContext differentiates from other interfaces. IsConstraints_set_modeContext() } type Constraints_set_modeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyConstraints_set_modeContext() *Constraints_set_modeContext { var p = new(Constraints_set_modeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constraints_set_mode return p } func InitEmptyConstraints_set_modeContext(p *Constraints_set_modeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constraints_set_mode } func (*Constraints_set_modeContext) IsConstraints_set_modeContext() {} func NewConstraints_set_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraints_set_modeContext { var p = new(Constraints_set_modeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_constraints_set_mode return p } func (s *Constraints_set_modeContext) GetParser() antlr.Parser { return s.parser } func (s *Constraints_set_modeContext) DEFERRED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFERRED, 0) } func (s *Constraints_set_modeContext) IMMEDIATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIMMEDIATE, 0) } func (s *Constraints_set_modeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Constraints_set_modeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Constraints_set_modeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterConstraints_set_mode(s) } } func (s *Constraints_set_modeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitConstraints_set_mode(s) } } func (s *Constraints_set_modeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitConstraints_set_mode(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Constraints_set_mode() (localctx IConstraints_set_modeContext) { localctx = NewConstraints_set_modeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 90, PostgreSQLParserRULE_constraints_set_mode) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2066) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserDEFERRED || _la == PostgreSQLParserIMMEDIATE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICheckpointstmtContext is an interface to support dynamic dispatch. type ICheckpointstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CHECKPOINT() antlr.TerminalNode // IsCheckpointstmtContext differentiates from other interfaces. IsCheckpointstmtContext() } type CheckpointstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCheckpointstmtContext() *CheckpointstmtContext { var p = new(CheckpointstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_checkpointstmt return p } func InitEmptyCheckpointstmtContext(p *CheckpointstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_checkpointstmt } func (*CheckpointstmtContext) IsCheckpointstmtContext() {} func NewCheckpointstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CheckpointstmtContext { var p = new(CheckpointstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_checkpointstmt return p } func (s *CheckpointstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CheckpointstmtContext) CHECKPOINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHECKPOINT, 0) } func (s *CheckpointstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CheckpointstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CheckpointstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCheckpointstmt(s) } } func (s *CheckpointstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCheckpointstmt(s) } } func (s *CheckpointstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCheckpointstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Checkpointstmt() (localctx ICheckpointstmtContext) { localctx = NewCheckpointstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 92, PostgreSQLParserRULE_checkpointstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(2068) p.Match(PostgreSQLParserCHECKPOINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDiscardstmtContext is an interface to support dynamic dispatch. type IDiscardstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DISCARD() antlr.TerminalNode ALL() antlr.TerminalNode TEMP() antlr.TerminalNode TEMPORARY() antlr.TerminalNode PLANS() antlr.TerminalNode SEQUENCES() antlr.TerminalNode // IsDiscardstmtContext differentiates from other interfaces. IsDiscardstmtContext() } type DiscardstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDiscardstmtContext() *DiscardstmtContext { var p = new(DiscardstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_discardstmt return p } func InitEmptyDiscardstmtContext(p *DiscardstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_discardstmt } func (*DiscardstmtContext) IsDiscardstmtContext() {} func NewDiscardstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DiscardstmtContext { var p = new(DiscardstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_discardstmt return p } func (s *DiscardstmtContext) GetParser() antlr.Parser { return s.parser } func (s *DiscardstmtContext) DISCARD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDISCARD, 0) } func (s *DiscardstmtContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *DiscardstmtContext) TEMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEMP, 0) } func (s *DiscardstmtContext) TEMPORARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEMPORARY, 0) } func (s *DiscardstmtContext) PLANS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPLANS, 0) } func (s *DiscardstmtContext) SEQUENCES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEQUENCES, 0) } func (s *DiscardstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DiscardstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DiscardstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDiscardstmt(s) } } func (s *DiscardstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDiscardstmt(s) } } func (s *DiscardstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDiscardstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Discardstmt() (localctx IDiscardstmtContext) { localctx = NewDiscardstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 94, PostgreSQLParserRULE_discardstmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2070) p.Match(PostgreSQLParserDISCARD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2071) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserALL || _la == PostgreSQLParserPLANS || _la == PostgreSQLParserSEQUENCES || _la == PostgreSQLParserTEMP || _la == PostgreSQLParserTEMPORARY) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAltertablestmtContext is an interface to support dynamic dispatch. type IAltertablestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode TABLE() antlr.TerminalNode Relation_expr() IRelation_exprContext Alter_table_cmds() IAlter_table_cmdsContext Partition_cmd() IPartition_cmdContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode ALL() antlr.TerminalNode IN_P() antlr.TerminalNode AllTABLESPACE() []antlr.TerminalNode TABLESPACE(i int) antlr.TerminalNode AllName() []INameContext Name(i int) INameContext SET() antlr.TerminalNode Opt_nowait() IOpt_nowaitContext OWNED() antlr.TerminalNode BY() antlr.TerminalNode Role_list() IRole_listContext INDEX() antlr.TerminalNode Qualified_name() IQualified_nameContext Index_partition_cmd() IIndex_partition_cmdContext SEQUENCE() antlr.TerminalNode VIEW() antlr.TerminalNode MATERIALIZED() antlr.TerminalNode FOREIGN() antlr.TerminalNode // IsAltertablestmtContext differentiates from other interfaces. IsAltertablestmtContext() } type AltertablestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAltertablestmtContext() *AltertablestmtContext { var p = new(AltertablestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altertablestmt return p } func InitEmptyAltertablestmtContext(p *AltertablestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altertablestmt } func (*AltertablestmtContext) IsAltertablestmtContext() {} func NewAltertablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertablestmtContext { var p = new(AltertablestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_altertablestmt return p } func (s *AltertablestmtContext) GetParser() antlr.Parser { return s.parser } func (s *AltertablestmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AltertablestmtContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *AltertablestmtContext) Relation_expr() IRelation_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRelation_exprContext) } func (s *AltertablestmtContext) Alter_table_cmds() IAlter_table_cmdsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_table_cmdsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlter_table_cmdsContext) } func (s *AltertablestmtContext) Partition_cmd() IPartition_cmdContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPartition_cmdContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPartition_cmdContext) } func (s *AltertablestmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *AltertablestmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *AltertablestmtContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *AltertablestmtContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *AltertablestmtContext) AllTABLESPACE() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserTABLESPACE) } func (s *AltertablestmtContext) TABLESPACE(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, i) } func (s *AltertablestmtContext) AllName() []INameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(INameContext); ok { len++ } } tst := make([]INameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(INameContext); ok { tst[i] = t.(INameContext) i++ } } return tst } func (s *AltertablestmtContext) Name(i int) INameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(INameContext) } func (s *AltertablestmtContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *AltertablestmtContext) Opt_nowait() IOpt_nowaitContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_nowaitContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_nowaitContext) } func (s *AltertablestmtContext) OWNED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOWNED, 0) } func (s *AltertablestmtContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *AltertablestmtContext) Role_list() IRole_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRole_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRole_listContext) } func (s *AltertablestmtContext) INDEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINDEX, 0) } func (s *AltertablestmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *AltertablestmtContext) Index_partition_cmd() IIndex_partition_cmdContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndex_partition_cmdContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIndex_partition_cmdContext) } func (s *AltertablestmtContext) SEQUENCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEQUENCE, 0) } func (s *AltertablestmtContext) VIEW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVIEW, 0) } func (s *AltertablestmtContext) MATERIALIZED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMATERIALIZED, 0) } func (s *AltertablestmtContext) FOREIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREIGN, 0) } func (s *AltertablestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AltertablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AltertablestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAltertablestmt(s) } } func (s *AltertablestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAltertablestmt(s) } } func (s *AltertablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAltertablestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Altertablestmt() (localctx IAltertablestmtContext) { localctx = NewAltertablestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 96, PostgreSQLParserRULE_altertablestmt) var _la int p.SetState(2182) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 46, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(2073) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2074) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2077) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 35, p.GetParserRuleContext()) == 1 { { p.SetState(2075) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2076) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(2079) p.Relation_expr() } p.SetState(2082) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserNOT, PostgreSQLParserADD_P, PostgreSQLParserALTER, PostgreSQLParserCLUSTER, PostgreSQLParserDISABLE_P, PostgreSQLParserDROP, PostgreSQLParserENABLE_P, PostgreSQLParserFORCE, PostgreSQLParserINHERIT, PostgreSQLParserNO, PostgreSQLParserOF, PostgreSQLParserOPTIONS, PostgreSQLParserOWNER, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserSET, PostgreSQLParserVALIDATE: { p.SetState(2080) p.Alter_table_cmds() } case PostgreSQLParserATTACH, PostgreSQLParserDETACH: { p.SetState(2081) p.Partition_cmd() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(2084) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2085) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2086) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2087) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2088) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2089) p.Name() } p.SetState(2093) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserOWNED { { p.SetState(2090) p.Match(PostgreSQLParserOWNED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2091) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2092) p.Role_list() } } { p.SetState(2095) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2096) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2097) p.Name() } { p.SetState(2098) p.Opt_nowait() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(2100) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2101) p.Match(PostgreSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2104) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 38, p.GetParserRuleContext()) == 1 { { p.SetState(2102) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2103) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(2106) p.Qualified_name() } p.SetState(2109) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserNOT, PostgreSQLParserADD_P, PostgreSQLParserALTER, PostgreSQLParserCLUSTER, PostgreSQLParserDISABLE_P, PostgreSQLParserDROP, PostgreSQLParserENABLE_P, PostgreSQLParserFORCE, PostgreSQLParserINHERIT, PostgreSQLParserNO, PostgreSQLParserOF, PostgreSQLParserOPTIONS, PostgreSQLParserOWNER, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserSET, PostgreSQLParserVALIDATE: { p.SetState(2107) p.Alter_table_cmds() } case PostgreSQLParserATTACH: { p.SetState(2108) p.Index_partition_cmd() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(2111) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2112) p.Match(PostgreSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2113) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2114) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2115) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2116) p.Name() } p.SetState(2120) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserOWNED { { p.SetState(2117) p.Match(PostgreSQLParserOWNED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2118) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2119) p.Role_list() } } { p.SetState(2122) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2123) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2124) p.Name() } { p.SetState(2125) p.Opt_nowait() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(2127) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2128) p.Match(PostgreSQLParserSEQUENCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2131) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 41, p.GetParserRuleContext()) == 1 { { p.SetState(2129) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2130) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(2133) p.Qualified_name() } { p.SetState(2134) p.Alter_table_cmds() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(2136) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2137) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2140) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 42, p.GetParserRuleContext()) == 1 { { p.SetState(2138) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2139) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(2142) p.Qualified_name() } { p.SetState(2143) p.Alter_table_cmds() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(2145) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2146) p.Match(PostgreSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2147) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2150) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 43, p.GetParserRuleContext()) == 1 { { p.SetState(2148) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2149) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(2152) p.Qualified_name() } { p.SetState(2153) p.Alter_table_cmds() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(2155) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2156) p.Match(PostgreSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2157) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2158) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2159) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2160) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2161) p.Name() } p.SetState(2165) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserOWNED { { p.SetState(2162) p.Match(PostgreSQLParserOWNED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2163) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2164) p.Role_list() } } { p.SetState(2167) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2168) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2169) p.Name() } { p.SetState(2170) p.Opt_nowait() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(2172) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2173) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2174) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2177) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 45, p.GetParserRuleContext()) == 1 { { p.SetState(2175) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2176) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(2179) p.Relation_expr() } { p.SetState(2180) p.Alter_table_cmds() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlter_table_cmdsContext is an interface to support dynamic dispatch. type IAlter_table_cmdsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllAlter_table_cmd() []IAlter_table_cmdContext Alter_table_cmd(i int) IAlter_table_cmdContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsAlter_table_cmdsContext differentiates from other interfaces. IsAlter_table_cmdsContext() } type Alter_table_cmdsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlter_table_cmdsContext() *Alter_table_cmdsContext { var p = new(Alter_table_cmdsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_table_cmds return p } func InitEmptyAlter_table_cmdsContext(p *Alter_table_cmdsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_table_cmds } func (*Alter_table_cmdsContext) IsAlter_table_cmdsContext() {} func NewAlter_table_cmdsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_cmdsContext { var p = new(Alter_table_cmdsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alter_table_cmds return p } func (s *Alter_table_cmdsContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_cmdsContext) AllAlter_table_cmd() []IAlter_table_cmdContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAlter_table_cmdContext); ok { len++ } } tst := make([]IAlter_table_cmdContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAlter_table_cmdContext); ok { tst[i] = t.(IAlter_table_cmdContext) i++ } } return tst } func (s *Alter_table_cmdsContext) Alter_table_cmd(i int) IAlter_table_cmdContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_table_cmdContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAlter_table_cmdContext) } func (s *Alter_table_cmdsContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Alter_table_cmdsContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Alter_table_cmdsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alter_table_cmdsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alter_table_cmdsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlter_table_cmds(s) } } func (s *Alter_table_cmdsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlter_table_cmds(s) } } func (s *Alter_table_cmdsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlter_table_cmds(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alter_table_cmds() (localctx IAlter_table_cmdsContext) { localctx = NewAlter_table_cmdsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 98, PostgreSQLParserRULE_alter_table_cmds) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2184) p.Alter_table_cmd() } p.SetState(2189) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(2185) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2186) p.Alter_table_cmd() } p.SetState(2191) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPartition_cmdContext is an interface to support dynamic dispatch. type IPartition_cmdContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ATTACH() antlr.TerminalNode PARTITION() antlr.TerminalNode Qualified_name() IQualified_nameContext Partitionboundspec() IPartitionboundspecContext DETACH() antlr.TerminalNode // IsPartition_cmdContext differentiates from other interfaces. IsPartition_cmdContext() } type Partition_cmdContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPartition_cmdContext() *Partition_cmdContext { var p = new(Partition_cmdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_partition_cmd return p } func InitEmptyPartition_cmdContext(p *Partition_cmdContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_partition_cmd } func (*Partition_cmdContext) IsPartition_cmdContext() {} func NewPartition_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_cmdContext { var p = new(Partition_cmdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_partition_cmd return p } func (s *Partition_cmdContext) GetParser() antlr.Parser { return s.parser } func (s *Partition_cmdContext) ATTACH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserATTACH, 0) } func (s *Partition_cmdContext) PARTITION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARTITION, 0) } func (s *Partition_cmdContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *Partition_cmdContext) Partitionboundspec() IPartitionboundspecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPartitionboundspecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPartitionboundspecContext) } func (s *Partition_cmdContext) DETACH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDETACH, 0) } func (s *Partition_cmdContext) GetRuleContext() antlr.RuleContext { return s } func (s *Partition_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Partition_cmdContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPartition_cmd(s) } } func (s *Partition_cmdContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPartition_cmd(s) } } func (s *Partition_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPartition_cmd(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Partition_cmd() (localctx IPartition_cmdContext) { localctx = NewPartition_cmdContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 100, PostgreSQLParserRULE_partition_cmd) p.SetState(2200) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserATTACH: p.EnterOuterAlt(localctx, 1) { p.SetState(2192) p.Match(PostgreSQLParserATTACH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2193) p.Match(PostgreSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2194) p.Qualified_name() } { p.SetState(2195) p.Partitionboundspec() } case PostgreSQLParserDETACH: p.EnterOuterAlt(localctx, 2) { p.SetState(2197) p.Match(PostgreSQLParserDETACH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2198) p.Match(PostgreSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2199) p.Qualified_name() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IIndex_partition_cmdContext is an interface to support dynamic dispatch. type IIndex_partition_cmdContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ATTACH() antlr.TerminalNode PARTITION() antlr.TerminalNode Qualified_name() IQualified_nameContext // IsIndex_partition_cmdContext differentiates from other interfaces. IsIndex_partition_cmdContext() } type Index_partition_cmdContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyIndex_partition_cmdContext() *Index_partition_cmdContext { var p = new(Index_partition_cmdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_index_partition_cmd return p } func InitEmptyIndex_partition_cmdContext(p *Index_partition_cmdContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_index_partition_cmd } func (*Index_partition_cmdContext) IsIndex_partition_cmdContext() {} func NewIndex_partition_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_partition_cmdContext { var p = new(Index_partition_cmdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_index_partition_cmd return p } func (s *Index_partition_cmdContext) GetParser() antlr.Parser { return s.parser } func (s *Index_partition_cmdContext) ATTACH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserATTACH, 0) } func (s *Index_partition_cmdContext) PARTITION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARTITION, 0) } func (s *Index_partition_cmdContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *Index_partition_cmdContext) GetRuleContext() antlr.RuleContext { return s } func (s *Index_partition_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Index_partition_cmdContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterIndex_partition_cmd(s) } } func (s *Index_partition_cmdContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitIndex_partition_cmd(s) } } func (s *Index_partition_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitIndex_partition_cmd(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Index_partition_cmd() (localctx IIndex_partition_cmdContext) { localctx = NewIndex_partition_cmdContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 102, PostgreSQLParserRULE_index_partition_cmd) p.EnterOuterAlt(localctx, 1) { p.SetState(2202) p.Match(PostgreSQLParserATTACH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2203) p.Match(PostgreSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2204) p.Qualified_name() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlter_table_cmdContext is an interface to support dynamic dispatch. type IAlter_table_cmdContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ADD_P() antlr.TerminalNode ColumnDef() IColumnDefContext IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode COLUMN() antlr.TerminalNode ALTER() antlr.TerminalNode Opt_column() IOpt_columnContext AllColid() []IColidContext Colid(i int) IColidContext Alter_column_default() IAlter_column_defaultContext DROP() antlr.TerminalNode NULL_P() antlr.TerminalNode SET() antlr.TerminalNode EXPRESSION() antlr.TerminalNode STATISTICS() antlr.TerminalNode Signediconst() ISignediconstContext Iconst() IIconstContext Reloptions() IReloptionsContext RESET() antlr.TerminalNode STORAGE() antlr.TerminalNode GENERATED() antlr.TerminalNode Generated_when() IGenerated_whenContext AS() antlr.TerminalNode IDENTITY_P() antlr.TerminalNode Optparenthesizedseqoptlist() IOptparenthesizedseqoptlistContext Alter_identity_column_option_list() IAlter_identity_column_option_listContext Opt_drop_behavior() IOpt_drop_behaviorContext Opt_set_data() IOpt_set_dataContext TYPE_P() antlr.TerminalNode Typename() ITypenameContext Opt_collate_clause() IOpt_collate_clauseContext Alter_using() IAlter_usingContext Alter_generic_options() IAlter_generic_optionsContext Tableconstraint() ITableconstraintContext CONSTRAINT() antlr.TerminalNode Name() INameContext Constraintattributespec() IConstraintattributespecContext VALIDATE() antlr.TerminalNode WITHOUT() antlr.TerminalNode OIDS() antlr.TerminalNode CLUSTER() antlr.TerminalNode ON() antlr.TerminalNode LOGGED() antlr.TerminalNode UNLOGGED() antlr.TerminalNode ENABLE_P() antlr.TerminalNode TRIGGER() antlr.TerminalNode ALWAYS() antlr.TerminalNode REPLICA() antlr.TerminalNode ALL() antlr.TerminalNode USER() antlr.TerminalNode DISABLE_P() antlr.TerminalNode RULE() antlr.TerminalNode INHERIT() antlr.TerminalNode Qualified_name() IQualified_nameContext NO() antlr.TerminalNode OF() antlr.TerminalNode Any_name() IAny_nameContext OWNER() antlr.TerminalNode TO() antlr.TerminalNode Rolespec() IRolespecContext TABLESPACE() antlr.TerminalNode Replica_identity() IReplica_identityContext ROW() antlr.TerminalNode LEVEL() antlr.TerminalNode SECURITY() antlr.TerminalNode FORCE() antlr.TerminalNode // IsAlter_table_cmdContext differentiates from other interfaces. IsAlter_table_cmdContext() } type Alter_table_cmdContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlter_table_cmdContext() *Alter_table_cmdContext { var p = new(Alter_table_cmdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_table_cmd return p } func InitEmptyAlter_table_cmdContext(p *Alter_table_cmdContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_table_cmd } func (*Alter_table_cmdContext) IsAlter_table_cmdContext() {} func NewAlter_table_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_cmdContext { var p = new(Alter_table_cmdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alter_table_cmd return p } func (s *Alter_table_cmdContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_table_cmdContext) ADD_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserADD_P, 0) } func (s *Alter_table_cmdContext) ColumnDef() IColumnDefContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColumnDefContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColumnDefContext) } func (s *Alter_table_cmdContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *Alter_table_cmdContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *Alter_table_cmdContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *Alter_table_cmdContext) COLUMN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLUMN, 0) } func (s *Alter_table_cmdContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *Alter_table_cmdContext) Opt_column() IOpt_columnContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_columnContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_columnContext) } func (s *Alter_table_cmdContext) AllColid() []IColidContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IColidContext); ok { len++ } } tst := make([]IColidContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IColidContext); ok { tst[i] = t.(IColidContext) i++ } } return tst } func (s *Alter_table_cmdContext) Colid(i int) IColidContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IColidContext) } func (s *Alter_table_cmdContext) Alter_column_default() IAlter_column_defaultContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_column_defaultContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlter_column_defaultContext) } func (s *Alter_table_cmdContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *Alter_table_cmdContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *Alter_table_cmdContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *Alter_table_cmdContext) EXPRESSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXPRESSION, 0) } func (s *Alter_table_cmdContext) STATISTICS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTATISTICS, 0) } func (s *Alter_table_cmdContext) Signediconst() ISignediconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISignediconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISignediconstContext) } func (s *Alter_table_cmdContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *Alter_table_cmdContext) Reloptions() IReloptionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReloptionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReloptionsContext) } func (s *Alter_table_cmdContext) RESET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESET, 0) } func (s *Alter_table_cmdContext) STORAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTORAGE, 0) } func (s *Alter_table_cmdContext) GENERATED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGENERATED, 0) } func (s *Alter_table_cmdContext) Generated_when() IGenerated_whenContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGenerated_whenContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGenerated_whenContext) } func (s *Alter_table_cmdContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Alter_table_cmdContext) IDENTITY_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIDENTITY_P, 0) } func (s *Alter_table_cmdContext) Optparenthesizedseqoptlist() IOptparenthesizedseqoptlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptparenthesizedseqoptlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptparenthesizedseqoptlistContext) } func (s *Alter_table_cmdContext) Alter_identity_column_option_list() IAlter_identity_column_option_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_identity_column_option_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlter_identity_column_option_listContext) } func (s *Alter_table_cmdContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *Alter_table_cmdContext) Opt_set_data() IOpt_set_dataContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_set_dataContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_set_dataContext) } func (s *Alter_table_cmdContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *Alter_table_cmdContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *Alter_table_cmdContext) Opt_collate_clause() IOpt_collate_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_collate_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_collate_clauseContext) } func (s *Alter_table_cmdContext) Alter_using() IAlter_usingContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_usingContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlter_usingContext) } func (s *Alter_table_cmdContext) Alter_generic_options() IAlter_generic_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_generic_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlter_generic_optionsContext) } func (s *Alter_table_cmdContext) Tableconstraint() ITableconstraintContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITableconstraintContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITableconstraintContext) } func (s *Alter_table_cmdContext) CONSTRAINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTRAINT, 0) } func (s *Alter_table_cmdContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *Alter_table_cmdContext) Constraintattributespec() IConstraintattributespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstraintattributespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstraintattributespecContext) } func (s *Alter_table_cmdContext) VALIDATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALIDATE, 0) } func (s *Alter_table_cmdContext) WITHOUT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITHOUT, 0) } func (s *Alter_table_cmdContext) OIDS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOIDS, 0) } func (s *Alter_table_cmdContext) CLUSTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLUSTER, 0) } func (s *Alter_table_cmdContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *Alter_table_cmdContext) LOGGED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOGGED, 0) } func (s *Alter_table_cmdContext) UNLOGGED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNLOGGED, 0) } func (s *Alter_table_cmdContext) ENABLE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserENABLE_P, 0) } func (s *Alter_table_cmdContext) TRIGGER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRIGGER, 0) } func (s *Alter_table_cmdContext) ALWAYS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALWAYS, 0) } func (s *Alter_table_cmdContext) REPLICA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREPLICA, 0) } func (s *Alter_table_cmdContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *Alter_table_cmdContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *Alter_table_cmdContext) DISABLE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDISABLE_P, 0) } func (s *Alter_table_cmdContext) RULE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRULE, 0) } func (s *Alter_table_cmdContext) INHERIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINHERIT, 0) } func (s *Alter_table_cmdContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *Alter_table_cmdContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Alter_table_cmdContext) OF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOF, 0) } func (s *Alter_table_cmdContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *Alter_table_cmdContext) OWNER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOWNER, 0) } func (s *Alter_table_cmdContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *Alter_table_cmdContext) Rolespec() IRolespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRolespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRolespecContext) } func (s *Alter_table_cmdContext) TABLESPACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, 0) } func (s *Alter_table_cmdContext) Replica_identity() IReplica_identityContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReplica_identityContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReplica_identityContext) } func (s *Alter_table_cmdContext) ROW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROW, 0) } func (s *Alter_table_cmdContext) LEVEL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEVEL, 0) } func (s *Alter_table_cmdContext) SECURITY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSECURITY, 0) } func (s *Alter_table_cmdContext) FORCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFORCE, 0) } func (s *Alter_table_cmdContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alter_table_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alter_table_cmdContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlter_table_cmd(s) } } func (s *Alter_table_cmdContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlter_table_cmd(s) } } func (s *Alter_table_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlter_table_cmd(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alter_table_cmd() (localctx IAlter_table_cmdContext) { localctx = NewAlter_table_cmdContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 104, PostgreSQLParserRULE_alter_table_cmd) p.SetState(2458) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 49, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(2206) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2207) p.ColumnDef() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(2208) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2209) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2210) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2211) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2212) p.ColumnDef() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(2213) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2214) p.Match(PostgreSQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2215) p.ColumnDef() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(2216) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2217) p.Match(PostgreSQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2218) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2219) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2220) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2221) p.ColumnDef() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(2222) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2223) p.Opt_column() } { p.SetState(2224) p.Colid() } { p.SetState(2225) p.Alter_column_default() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(2227) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2228) p.Opt_column() } { p.SetState(2229) p.Colid() } { p.SetState(2230) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2231) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2232) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(2234) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2235) p.Opt_column() } { p.SetState(2236) p.Colid() } { p.SetState(2237) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2238) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2239) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(2241) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2242) p.Opt_column() } { p.SetState(2243) p.Colid() } { p.SetState(2244) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2245) p.Match(PostgreSQLParserEXPRESSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(2247) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2248) p.Opt_column() } { p.SetState(2249) p.Colid() } { p.SetState(2250) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2251) p.Match(PostgreSQLParserEXPRESSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2252) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2253) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(2255) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2256) p.Opt_column() } { p.SetState(2257) p.Colid() } { p.SetState(2258) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2259) p.Match(PostgreSQLParserSTATISTICS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2260) p.Signediconst() } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(2262) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2263) p.Opt_column() } { p.SetState(2264) p.Iconst() } { p.SetState(2265) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2266) p.Match(PostgreSQLParserSTATISTICS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2267) p.Signediconst() } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(2269) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2270) p.Opt_column() } { p.SetState(2271) p.Colid() } { p.SetState(2272) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2273) p.Reloptions() } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(2275) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2276) p.Opt_column() } { p.SetState(2277) p.Colid() } { p.SetState(2278) p.Match(PostgreSQLParserRESET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2279) p.Reloptions() } case 14: p.EnterOuterAlt(localctx, 14) { p.SetState(2281) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2282) p.Opt_column() } { p.SetState(2283) p.Colid() } { p.SetState(2284) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2285) p.Match(PostgreSQLParserSTORAGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2286) p.Colid() } case 15: p.EnterOuterAlt(localctx, 15) { p.SetState(2288) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2289) p.Opt_column() } { p.SetState(2290) p.Colid() } { p.SetState(2291) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2292) p.Match(PostgreSQLParserGENERATED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2293) p.Generated_when() } { p.SetState(2294) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2295) p.Match(PostgreSQLParserIDENTITY_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2296) p.Optparenthesizedseqoptlist() } case 16: p.EnterOuterAlt(localctx, 16) { p.SetState(2298) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2299) p.Opt_column() } { p.SetState(2300) p.Colid() } { p.SetState(2301) p.Alter_identity_column_option_list() } case 17: p.EnterOuterAlt(localctx, 17) { p.SetState(2303) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2304) p.Opt_column() } { p.SetState(2305) p.Colid() } { p.SetState(2306) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2307) p.Match(PostgreSQLParserIDENTITY_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 18: p.EnterOuterAlt(localctx, 18) { p.SetState(2309) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2310) p.Opt_column() } { p.SetState(2311) p.Colid() } { p.SetState(2312) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2313) p.Match(PostgreSQLParserIDENTITY_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2314) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2315) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 19: p.EnterOuterAlt(localctx, 19) { p.SetState(2317) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2318) p.Opt_column() } { p.SetState(2319) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2320) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2321) p.Colid() } { p.SetState(2322) p.Opt_drop_behavior() } case 20: p.EnterOuterAlt(localctx, 20) { p.SetState(2324) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2325) p.Opt_column() } { p.SetState(2326) p.Colid() } { p.SetState(2327) p.Opt_drop_behavior() } case 21: p.EnterOuterAlt(localctx, 21) { p.SetState(2329) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2330) p.Opt_column() } { p.SetState(2331) p.Colid() } { p.SetState(2332) p.Opt_set_data() } { p.SetState(2333) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2334) p.Typename() } { p.SetState(2335) p.Opt_collate_clause() } { p.SetState(2336) p.Alter_using() } case 22: p.EnterOuterAlt(localctx, 22) { p.SetState(2338) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2339) p.Opt_column() } { p.SetState(2340) p.Colid() } { p.SetState(2341) p.Alter_generic_options() } case 23: p.EnterOuterAlt(localctx, 23) { p.SetState(2343) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2344) p.Tableconstraint() } case 24: p.EnterOuterAlt(localctx, 24) { p.SetState(2345) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2346) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2347) p.Name() } { p.SetState(2348) p.Constraintattributespec() } case 25: p.EnterOuterAlt(localctx, 25) { p.SetState(2350) p.Match(PostgreSQLParserVALIDATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2351) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2352) p.Name() } case 26: p.EnterOuterAlt(localctx, 26) { p.SetState(2353) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2354) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2355) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2356) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2357) p.Name() } { p.SetState(2358) p.Opt_drop_behavior() } case 27: p.EnterOuterAlt(localctx, 27) { p.SetState(2360) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2361) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2362) p.Name() } { p.SetState(2363) p.Opt_drop_behavior() } case 28: p.EnterOuterAlt(localctx, 28) { p.SetState(2365) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2366) p.Match(PostgreSQLParserWITHOUT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2367) p.Match(PostgreSQLParserOIDS) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 29: p.EnterOuterAlt(localctx, 29) { p.SetState(2368) p.Match(PostgreSQLParserCLUSTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2369) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2370) p.Name() } case 30: p.EnterOuterAlt(localctx, 30) { p.SetState(2371) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2372) p.Match(PostgreSQLParserWITHOUT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2373) p.Match(PostgreSQLParserCLUSTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 31: p.EnterOuterAlt(localctx, 31) { p.SetState(2374) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2375) p.Match(PostgreSQLParserLOGGED) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 32: p.EnterOuterAlt(localctx, 32) { p.SetState(2376) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2377) p.Match(PostgreSQLParserUNLOGGED) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 33: p.EnterOuterAlt(localctx, 33) { p.SetState(2378) p.Match(PostgreSQLParserENABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2379) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2380) p.Name() } case 34: p.EnterOuterAlt(localctx, 34) { p.SetState(2381) p.Match(PostgreSQLParserENABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2382) p.Match(PostgreSQLParserALWAYS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2383) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2384) p.Name() } case 35: p.EnterOuterAlt(localctx, 35) { p.SetState(2385) p.Match(PostgreSQLParserENABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2386) p.Match(PostgreSQLParserREPLICA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2387) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2388) p.Name() } case 36: p.EnterOuterAlt(localctx, 36) { p.SetState(2389) p.Match(PostgreSQLParserENABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2390) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2391) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 37: p.EnterOuterAlt(localctx, 37) { p.SetState(2392) p.Match(PostgreSQLParserENABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2393) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2394) p.Match(PostgreSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 38: p.EnterOuterAlt(localctx, 38) { p.SetState(2395) p.Match(PostgreSQLParserDISABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2396) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2397) p.Name() } case 39: p.EnterOuterAlt(localctx, 39) { p.SetState(2398) p.Match(PostgreSQLParserDISABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2399) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2400) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 40: p.EnterOuterAlt(localctx, 40) { p.SetState(2401) p.Match(PostgreSQLParserDISABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2402) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2403) p.Match(PostgreSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 41: p.EnterOuterAlt(localctx, 41) { p.SetState(2404) p.Match(PostgreSQLParserENABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2405) p.Match(PostgreSQLParserRULE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2406) p.Name() } case 42: p.EnterOuterAlt(localctx, 42) { p.SetState(2407) p.Match(PostgreSQLParserENABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2408) p.Match(PostgreSQLParserALWAYS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2409) p.Match(PostgreSQLParserRULE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2410) p.Name() } case 43: p.EnterOuterAlt(localctx, 43) { p.SetState(2411) p.Match(PostgreSQLParserENABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2412) p.Match(PostgreSQLParserREPLICA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2413) p.Match(PostgreSQLParserRULE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2414) p.Name() } case 44: p.EnterOuterAlt(localctx, 44) { p.SetState(2415) p.Match(PostgreSQLParserDISABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2416) p.Match(PostgreSQLParserRULE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2417) p.Name() } case 45: p.EnterOuterAlt(localctx, 45) { p.SetState(2418) p.Match(PostgreSQLParserINHERIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2419) p.Qualified_name() } case 46: p.EnterOuterAlt(localctx, 46) { p.SetState(2420) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2421) p.Match(PostgreSQLParserINHERIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2422) p.Qualified_name() } case 47: p.EnterOuterAlt(localctx, 47) { p.SetState(2423) p.Match(PostgreSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2424) p.Any_name() } case 48: p.EnterOuterAlt(localctx, 48) { p.SetState(2425) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2426) p.Match(PostgreSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 49: p.EnterOuterAlt(localctx, 49) { p.SetState(2427) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2428) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2429) p.Rolespec() } case 50: p.EnterOuterAlt(localctx, 50) { p.SetState(2430) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2431) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2432) p.Name() } case 51: p.EnterOuterAlt(localctx, 51) { p.SetState(2433) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2434) p.Reloptions() } case 52: p.EnterOuterAlt(localctx, 52) { p.SetState(2435) p.Match(PostgreSQLParserRESET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2436) p.Reloptions() } case 53: p.EnterOuterAlt(localctx, 53) { p.SetState(2437) p.Match(PostgreSQLParserREPLICA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2438) p.Match(PostgreSQLParserIDENTITY_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2439) p.Replica_identity() } case 54: p.EnterOuterAlt(localctx, 54) { p.SetState(2440) p.Match(PostgreSQLParserENABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2441) p.Match(PostgreSQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2442) p.Match(PostgreSQLParserLEVEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2443) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 55: p.EnterOuterAlt(localctx, 55) { p.SetState(2444) p.Match(PostgreSQLParserDISABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2445) p.Match(PostgreSQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2446) p.Match(PostgreSQLParserLEVEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2447) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 56: p.EnterOuterAlt(localctx, 56) { p.SetState(2448) p.Match(PostgreSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2449) p.Match(PostgreSQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2450) p.Match(PostgreSQLParserLEVEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2451) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 57: p.EnterOuterAlt(localctx, 57) { p.SetState(2452) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2453) p.Match(PostgreSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2454) p.Match(PostgreSQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2455) p.Match(PostgreSQLParserLEVEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2456) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 58: p.EnterOuterAlt(localctx, 58) { p.SetState(2457) p.Alter_generic_options() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlter_column_defaultContext is an interface to support dynamic dispatch. type IAlter_column_defaultContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SET() antlr.TerminalNode DEFAULT() antlr.TerminalNode A_expr() IA_exprContext DROP() antlr.TerminalNode // IsAlter_column_defaultContext differentiates from other interfaces. IsAlter_column_defaultContext() } type Alter_column_defaultContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlter_column_defaultContext() *Alter_column_defaultContext { var p = new(Alter_column_defaultContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_column_default return p } func InitEmptyAlter_column_defaultContext(p *Alter_column_defaultContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_column_default } func (*Alter_column_defaultContext) IsAlter_column_defaultContext() {} func NewAlter_column_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_column_defaultContext { var p = new(Alter_column_defaultContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alter_column_default return p } func (s *Alter_column_defaultContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_column_defaultContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *Alter_column_defaultContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Alter_column_defaultContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Alter_column_defaultContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *Alter_column_defaultContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alter_column_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alter_column_defaultContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlter_column_default(s) } } func (s *Alter_column_defaultContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlter_column_default(s) } } func (s *Alter_column_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlter_column_default(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alter_column_default() (localctx IAlter_column_defaultContext) { localctx = NewAlter_column_defaultContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 106, PostgreSQLParserRULE_alter_column_default) p.SetState(2465) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSET: p.EnterOuterAlt(localctx, 1) { p.SetState(2460) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2461) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2462) p.A_expr() } case PostgreSQLParserDROP: p.EnterOuterAlt(localctx, 2) { p.SetState(2463) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2464) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_drop_behaviorContext is an interface to support dynamic dispatch. type IOpt_drop_behaviorContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CASCADE() antlr.TerminalNode RESTRICT() antlr.TerminalNode // IsOpt_drop_behaviorContext differentiates from other interfaces. IsOpt_drop_behaviorContext() } type Opt_drop_behaviorContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_drop_behaviorContext() *Opt_drop_behaviorContext { var p = new(Opt_drop_behaviorContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_drop_behavior return p } func InitEmptyOpt_drop_behaviorContext(p *Opt_drop_behaviorContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_drop_behavior } func (*Opt_drop_behaviorContext) IsOpt_drop_behaviorContext() {} func NewOpt_drop_behaviorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_drop_behaviorContext { var p = new(Opt_drop_behaviorContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_drop_behavior return p } func (s *Opt_drop_behaviorContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_drop_behaviorContext) CASCADE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCASCADE, 0) } func (s *Opt_drop_behaviorContext) RESTRICT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESTRICT, 0) } func (s *Opt_drop_behaviorContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_drop_behaviorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_drop_behaviorContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_drop_behavior(s) } } func (s *Opt_drop_behaviorContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_drop_behavior(s) } } func (s *Opt_drop_behaviorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_drop_behavior(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_drop_behavior() (localctx IOpt_drop_behaviorContext) { localctx = NewOpt_drop_behaviorContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 108, PostgreSQLParserRULE_opt_drop_behavior) p.SetState(2470) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCASCADE: p.EnterOuterAlt(localctx, 1) { p.SetState(2467) p.Match(PostgreSQLParserCASCADE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserRESTRICT: p.EnterOuterAlt(localctx, 2) { p.SetState(2468) p.Match(PostgreSQLParserRESTRICT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 3) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_collate_clauseContext is an interface to support dynamic dispatch. type IOpt_collate_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures COLLATE() antlr.TerminalNode Any_name() IAny_nameContext // IsOpt_collate_clauseContext differentiates from other interfaces. IsOpt_collate_clauseContext() } type Opt_collate_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_collate_clauseContext() *Opt_collate_clauseContext { var p = new(Opt_collate_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_collate_clause return p } func InitEmptyOpt_collate_clauseContext(p *Opt_collate_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_collate_clause } func (*Opt_collate_clauseContext) IsOpt_collate_clauseContext() {} func NewOpt_collate_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_collate_clauseContext { var p = new(Opt_collate_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_collate_clause return p } func (s *Opt_collate_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_collate_clauseContext) COLLATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATE, 0) } func (s *Opt_collate_clauseContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *Opt_collate_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_collate_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_collate_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_collate_clause(s) } } func (s *Opt_collate_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_collate_clause(s) } } func (s *Opt_collate_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_collate_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_collate_clause() (localctx IOpt_collate_clauseContext) { localctx = NewOpt_collate_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 110, PostgreSQLParserRULE_opt_collate_clause) p.SetState(2475) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCOLLATE: p.EnterOuterAlt(localctx, 1) { p.SetState(2472) p.Match(PostgreSQLParserCOLLATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2473) p.Any_name() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUSING, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCASCADE, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserRESTRICT, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlter_usingContext is an interface to support dynamic dispatch. type IAlter_usingContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USING() antlr.TerminalNode A_expr() IA_exprContext // IsAlter_usingContext differentiates from other interfaces. IsAlter_usingContext() } type Alter_usingContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlter_usingContext() *Alter_usingContext { var p = new(Alter_usingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_using return p } func InitEmptyAlter_usingContext(p *Alter_usingContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_using } func (*Alter_usingContext) IsAlter_usingContext() {} func NewAlter_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_usingContext { var p = new(Alter_usingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alter_using return p } func (s *Alter_usingContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_usingContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *Alter_usingContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Alter_usingContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alter_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alter_usingContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlter_using(s) } } func (s *Alter_usingContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlter_using(s) } } func (s *Alter_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlter_using(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alter_using() (localctx IAlter_usingContext) { localctx = NewAlter_usingContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 112, PostgreSQLParserRULE_alter_using) p.SetState(2480) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 1) { p.SetState(2477) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2478) p.A_expr() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IReplica_identityContext is an interface to support dynamic dispatch. type IReplica_identityContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NOTHING() antlr.TerminalNode FULL() antlr.TerminalNode DEFAULT() antlr.TerminalNode USING() antlr.TerminalNode INDEX() antlr.TerminalNode Name() INameContext // IsReplica_identityContext differentiates from other interfaces. IsReplica_identityContext() } type Replica_identityContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyReplica_identityContext() *Replica_identityContext { var p = new(Replica_identityContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_replica_identity return p } func InitEmptyReplica_identityContext(p *Replica_identityContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_replica_identity } func (*Replica_identityContext) IsReplica_identityContext() {} func NewReplica_identityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Replica_identityContext { var p = new(Replica_identityContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_replica_identity return p } func (s *Replica_identityContext) GetParser() antlr.Parser { return s.parser } func (s *Replica_identityContext) NOTHING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOTHING, 0) } func (s *Replica_identityContext) FULL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFULL, 0) } func (s *Replica_identityContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Replica_identityContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *Replica_identityContext) INDEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINDEX, 0) } func (s *Replica_identityContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *Replica_identityContext) GetRuleContext() antlr.RuleContext { return s } func (s *Replica_identityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Replica_identityContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterReplica_identity(s) } } func (s *Replica_identityContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitReplica_identity(s) } } func (s *Replica_identityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitReplica_identity(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Replica_identity() (localctx IReplica_identityContext) { localctx = NewReplica_identityContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 114, PostgreSQLParserRULE_replica_identity) p.SetState(2488) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserNOTHING: p.EnterOuterAlt(localctx, 1) { p.SetState(2482) p.Match(PostgreSQLParserNOTHING) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserFULL: p.EnterOuterAlt(localctx, 2) { p.SetState(2483) p.Match(PostgreSQLParserFULL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserDEFAULT: p.EnterOuterAlt(localctx, 3) { p.SetState(2484) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 4) { p.SetState(2485) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2486) p.Match(PostgreSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2487) p.Name() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IReloptionsContext is an interface to support dynamic dispatch. type IReloptionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Reloption_list() IReloption_listContext CLOSE_PAREN() antlr.TerminalNode // IsReloptionsContext differentiates from other interfaces. IsReloptionsContext() } type ReloptionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyReloptionsContext() *ReloptionsContext { var p = new(ReloptionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reloptions return p } func InitEmptyReloptionsContext(p *ReloptionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reloptions } func (*ReloptionsContext) IsReloptionsContext() {} func NewReloptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReloptionsContext { var p = new(ReloptionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_reloptions return p } func (s *ReloptionsContext) GetParser() antlr.Parser { return s.parser } func (s *ReloptionsContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *ReloptionsContext) Reloption_list() IReloption_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReloption_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReloption_listContext) } func (s *ReloptionsContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *ReloptionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *ReloptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ReloptionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterReloptions(s) } } func (s *ReloptionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitReloptions(s) } } func (s *ReloptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitReloptions(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Reloptions() (localctx IReloptionsContext) { localctx = NewReloptionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 116, PostgreSQLParserRULE_reloptions) p.EnterOuterAlt(localctx, 1) { p.SetState(2490) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2491) p.Reloption_list() } { p.SetState(2492) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_reloptionsContext is an interface to support dynamic dispatch. type IOpt_reloptionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITH() antlr.TerminalNode Reloptions() IReloptionsContext // IsOpt_reloptionsContext differentiates from other interfaces. IsOpt_reloptionsContext() } type Opt_reloptionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_reloptionsContext() *Opt_reloptionsContext { var p = new(Opt_reloptionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_reloptions return p } func InitEmptyOpt_reloptionsContext(p *Opt_reloptionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_reloptions } func (*Opt_reloptionsContext) IsOpt_reloptionsContext() {} func NewOpt_reloptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_reloptionsContext { var p = new(Opt_reloptionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_reloptions return p } func (s *Opt_reloptionsContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_reloptionsContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *Opt_reloptionsContext) Reloptions() IReloptionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReloptionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReloptionsContext) } func (s *Opt_reloptionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_reloptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_reloptionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_reloptions(s) } } func (s *Opt_reloptionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_reloptions(s) } } func (s *Opt_reloptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_reloptions(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_reloptions() (localctx IOpt_reloptionsContext) { localctx = NewOpt_reloptionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 118, PostgreSQLParserRULE_opt_reloptions) p.SetState(2497) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 55, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(2494) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2495) p.Reloptions() } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IReloption_listContext is an interface to support dynamic dispatch. type IReloption_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllReloption_elem() []IReloption_elemContext Reloption_elem(i int) IReloption_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsReloption_listContext differentiates from other interfaces. IsReloption_listContext() } type Reloption_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyReloption_listContext() *Reloption_listContext { var p = new(Reloption_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reloption_list return p } func InitEmptyReloption_listContext(p *Reloption_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reloption_list } func (*Reloption_listContext) IsReloption_listContext() {} func NewReloption_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reloption_listContext { var p = new(Reloption_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_reloption_list return p } func (s *Reloption_listContext) GetParser() antlr.Parser { return s.parser } func (s *Reloption_listContext) AllReloption_elem() []IReloption_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IReloption_elemContext); ok { len++ } } tst := make([]IReloption_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IReloption_elemContext); ok { tst[i] = t.(IReloption_elemContext) i++ } } return tst } func (s *Reloption_listContext) Reloption_elem(i int) IReloption_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReloption_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IReloption_elemContext) } func (s *Reloption_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Reloption_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Reloption_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Reloption_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Reloption_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterReloption_list(s) } } func (s *Reloption_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitReloption_list(s) } } func (s *Reloption_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitReloption_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Reloption_list() (localctx IReloption_listContext) { localctx = NewReloption_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 120, PostgreSQLParserRULE_reloption_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2499) p.Reloption_elem() } p.SetState(2504) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(2500) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2501) p.Reloption_elem() } p.SetState(2506) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IReloption_elemContext is an interface to support dynamic dispatch. type IReloption_elemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllCollabel() []ICollabelContext Collabel(i int) ICollabelContext EQUAL() antlr.TerminalNode Def_arg() IDef_argContext DOT() antlr.TerminalNode // IsReloption_elemContext differentiates from other interfaces. IsReloption_elemContext() } type Reloption_elemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyReloption_elemContext() *Reloption_elemContext { var p = new(Reloption_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reloption_elem return p } func InitEmptyReloption_elemContext(p *Reloption_elemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reloption_elem } func (*Reloption_elemContext) IsReloption_elemContext() {} func NewReloption_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reloption_elemContext { var p = new(Reloption_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_reloption_elem return p } func (s *Reloption_elemContext) GetParser() antlr.Parser { return s.parser } func (s *Reloption_elemContext) AllCollabel() []ICollabelContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ICollabelContext); ok { len++ } } tst := make([]ICollabelContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ICollabelContext); ok { tst[i] = t.(ICollabelContext) i++ } } return tst } func (s *Reloption_elemContext) Collabel(i int) ICollabelContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICollabelContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ICollabelContext) } func (s *Reloption_elemContext) EQUAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEQUAL, 0) } func (s *Reloption_elemContext) Def_arg() IDef_argContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDef_argContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDef_argContext) } func (s *Reloption_elemContext) DOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOT, 0) } func (s *Reloption_elemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Reloption_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Reloption_elemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterReloption_elem(s) } } func (s *Reloption_elemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitReloption_elem(s) } } func (s *Reloption_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitReloption_elem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Reloption_elem() (localctx IReloption_elemContext) { localctx = NewReloption_elemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 122, PostgreSQLParserRULE_reloption_elem) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2507) p.Collabel() } p.SetState(2516) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserEQUAL: { p.SetState(2508) p.Match(PostgreSQLParserEQUAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2509) p.Def_arg() } case PostgreSQLParserDOT: { p.SetState(2510) p.Match(PostgreSQLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2511) p.Collabel() } p.SetState(2514) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserEQUAL { { p.SetState(2512) p.Match(PostgreSQLParserEQUAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2513) p.Def_arg() } } case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA: default: } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlter_identity_column_option_listContext is an interface to support dynamic dispatch. type IAlter_identity_column_option_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllAlter_identity_column_option() []IAlter_identity_column_optionContext Alter_identity_column_option(i int) IAlter_identity_column_optionContext // IsAlter_identity_column_option_listContext differentiates from other interfaces. IsAlter_identity_column_option_listContext() } type Alter_identity_column_option_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlter_identity_column_option_listContext() *Alter_identity_column_option_listContext { var p = new(Alter_identity_column_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_identity_column_option_list return p } func InitEmptyAlter_identity_column_option_listContext(p *Alter_identity_column_option_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_identity_column_option_list } func (*Alter_identity_column_option_listContext) IsAlter_identity_column_option_listContext() {} func NewAlter_identity_column_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_identity_column_option_listContext { var p = new(Alter_identity_column_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alter_identity_column_option_list return p } func (s *Alter_identity_column_option_listContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_identity_column_option_listContext) AllAlter_identity_column_option() []IAlter_identity_column_optionContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAlter_identity_column_optionContext); ok { len++ } } tst := make([]IAlter_identity_column_optionContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAlter_identity_column_optionContext); ok { tst[i] = t.(IAlter_identity_column_optionContext) i++ } } return tst } func (s *Alter_identity_column_option_listContext) Alter_identity_column_option(i int) IAlter_identity_column_optionContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_identity_column_optionContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAlter_identity_column_optionContext) } func (s *Alter_identity_column_option_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alter_identity_column_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alter_identity_column_option_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlter_identity_column_option_list(s) } } func (s *Alter_identity_column_option_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlter_identity_column_option_list(s) } } func (s *Alter_identity_column_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlter_identity_column_option_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alter_identity_column_option_list() (localctx IAlter_identity_column_option_listContext) { localctx = NewAlter_identity_column_option_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 124, PostgreSQLParserRULE_alter_identity_column_option_list) var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(2519) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = 1 for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { switch _alt { case 1: { p.SetState(2518) p.Alter_identity_column_option() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.SetState(2521) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 59, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlter_identity_column_optionContext is an interface to support dynamic dispatch. type IAlter_identity_column_optionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures RESTART() antlr.TerminalNode Opt_with() IOpt_withContext Numericonly() INumericonlyContext SET() antlr.TerminalNode Seqoptelem() ISeqoptelemContext GENERATED() antlr.TerminalNode Generated_when() IGenerated_whenContext // IsAlter_identity_column_optionContext differentiates from other interfaces. IsAlter_identity_column_optionContext() } type Alter_identity_column_optionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlter_identity_column_optionContext() *Alter_identity_column_optionContext { var p = new(Alter_identity_column_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_identity_column_option return p } func InitEmptyAlter_identity_column_optionContext(p *Alter_identity_column_optionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_identity_column_option } func (*Alter_identity_column_optionContext) IsAlter_identity_column_optionContext() {} func NewAlter_identity_column_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_identity_column_optionContext { var p = new(Alter_identity_column_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alter_identity_column_option return p } func (s *Alter_identity_column_optionContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_identity_column_optionContext) RESTART() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESTART, 0) } func (s *Alter_identity_column_optionContext) Opt_with() IOpt_withContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_withContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_withContext) } func (s *Alter_identity_column_optionContext) Numericonly() INumericonlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericonlyContext) } func (s *Alter_identity_column_optionContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *Alter_identity_column_optionContext) Seqoptelem() ISeqoptelemContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISeqoptelemContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISeqoptelemContext) } func (s *Alter_identity_column_optionContext) GENERATED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGENERATED, 0) } func (s *Alter_identity_column_optionContext) Generated_when() IGenerated_whenContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGenerated_whenContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGenerated_whenContext) } func (s *Alter_identity_column_optionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alter_identity_column_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alter_identity_column_optionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlter_identity_column_option(s) } } func (s *Alter_identity_column_optionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlter_identity_column_option(s) } } func (s *Alter_identity_column_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlter_identity_column_option(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alter_identity_column_option() (localctx IAlter_identity_column_optionContext) { localctx = NewAlter_identity_column_optionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 126, PostgreSQLParserRULE_alter_identity_column_option) p.SetState(2535) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserRESTART: p.EnterOuterAlt(localctx, 1) { p.SetState(2523) p.Match(PostgreSQLParserRESTART) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2527) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 60, p.GetParserRuleContext()) == 1 { { p.SetState(2524) p.Opt_with() } { p.SetState(2525) p.Numericonly() } } else if p.HasError() { // JIM goto errorExit } case PostgreSQLParserSET: p.EnterOuterAlt(localctx, 2) { p.SetState(2529) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2533) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAS, PostgreSQLParserCACHE, PostgreSQLParserCYCLE, PostgreSQLParserINCREMENT, PostgreSQLParserMAXVALUE, PostgreSQLParserMINVALUE, PostgreSQLParserNO, PostgreSQLParserOWNED, PostgreSQLParserRESTART, PostgreSQLParserSEQUENCE, PostgreSQLParserSTART: { p.SetState(2530) p.Seqoptelem() } case PostgreSQLParserGENERATED: { p.SetState(2531) p.Match(PostgreSQLParserGENERATED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2532) p.Generated_when() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPartitionboundspecContext is an interface to support dynamic dispatch. type IPartitionboundspecContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FOR() antlr.TerminalNode VALUES() antlr.TerminalNode WITH() antlr.TerminalNode AllOPEN_PAREN() []antlr.TerminalNode OPEN_PAREN(i int) antlr.TerminalNode Hash_partbound() IHash_partboundContext AllCLOSE_PAREN() []antlr.TerminalNode CLOSE_PAREN(i int) antlr.TerminalNode IN_P() antlr.TerminalNode AllExpr_list() []IExpr_listContext Expr_list(i int) IExpr_listContext FROM() antlr.TerminalNode TO() antlr.TerminalNode DEFAULT() antlr.TerminalNode // IsPartitionboundspecContext differentiates from other interfaces. IsPartitionboundspecContext() } type PartitionboundspecContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPartitionboundspecContext() *PartitionboundspecContext { var p = new(PartitionboundspecContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_partitionboundspec return p } func InitEmptyPartitionboundspecContext(p *PartitionboundspecContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_partitionboundspec } func (*PartitionboundspecContext) IsPartitionboundspecContext() {} func NewPartitionboundspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionboundspecContext { var p = new(PartitionboundspecContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_partitionboundspec return p } func (s *PartitionboundspecContext) GetParser() antlr.Parser { return s.parser } func (s *PartitionboundspecContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *PartitionboundspecContext) VALUES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALUES, 0) } func (s *PartitionboundspecContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *PartitionboundspecContext) AllOPEN_PAREN() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserOPEN_PAREN) } func (s *PartitionboundspecContext) OPEN_PAREN(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, i) } func (s *PartitionboundspecContext) Hash_partbound() IHash_partboundContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IHash_partboundContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IHash_partboundContext) } func (s *PartitionboundspecContext) AllCLOSE_PAREN() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCLOSE_PAREN) } func (s *PartitionboundspecContext) CLOSE_PAREN(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, i) } func (s *PartitionboundspecContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *PartitionboundspecContext) AllExpr_list() []IExpr_listContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IExpr_listContext); ok { len++ } } tst := make([]IExpr_listContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IExpr_listContext); ok { tst[i] = t.(IExpr_listContext) i++ } } return tst } func (s *PartitionboundspecContext) Expr_list(i int) IExpr_listContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *PartitionboundspecContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *PartitionboundspecContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *PartitionboundspecContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *PartitionboundspecContext) GetRuleContext() antlr.RuleContext { return s } func (s *PartitionboundspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *PartitionboundspecContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPartitionboundspec(s) } } func (s *PartitionboundspecContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPartitionboundspec(s) } } func (s *PartitionboundspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPartitionboundspec(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Partitionboundspec() (localctx IPartitionboundspecContext) { localctx = NewPartitionboundspecContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 128, PostgreSQLParserRULE_partitionboundspec) p.SetState(2563) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 63, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(2537) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2538) p.Match(PostgreSQLParserVALUES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2539) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2540) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2541) p.Hash_partbound() } { p.SetState(2542) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(2544) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2545) p.Match(PostgreSQLParserVALUES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2546) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2547) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2548) p.Expr_list() } { p.SetState(2549) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(2551) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2552) p.Match(PostgreSQLParserVALUES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2553) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2554) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2555) p.Expr_list() } { p.SetState(2556) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2557) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2558) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2559) p.Expr_list() } { p.SetState(2560) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(2562) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IHash_partbound_elemContext is an interface to support dynamic dispatch. type IHash_partbound_elemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Nonreservedword() INonreservedwordContext Iconst() IIconstContext // IsHash_partbound_elemContext differentiates from other interfaces. IsHash_partbound_elemContext() } type Hash_partbound_elemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyHash_partbound_elemContext() *Hash_partbound_elemContext { var p = new(Hash_partbound_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_hash_partbound_elem return p } func InitEmptyHash_partbound_elemContext(p *Hash_partbound_elemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_hash_partbound_elem } func (*Hash_partbound_elemContext) IsHash_partbound_elemContext() {} func NewHash_partbound_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_partbound_elemContext { var p = new(Hash_partbound_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_hash_partbound_elem return p } func (s *Hash_partbound_elemContext) GetParser() antlr.Parser { return s.parser } func (s *Hash_partbound_elemContext) Nonreservedword() INonreservedwordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INonreservedwordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INonreservedwordContext) } func (s *Hash_partbound_elemContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *Hash_partbound_elemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Hash_partbound_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Hash_partbound_elemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterHash_partbound_elem(s) } } func (s *Hash_partbound_elemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitHash_partbound_elem(s) } } func (s *Hash_partbound_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitHash_partbound_elem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Hash_partbound_elem() (localctx IHash_partbound_elemContext) { localctx = NewHash_partbound_elemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 130, PostgreSQLParserRULE_hash_partbound_elem) p.EnterOuterAlt(localctx, 1) { p.SetState(2565) p.Nonreservedword() } { p.SetState(2566) p.Iconst() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IHash_partboundContext is an interface to support dynamic dispatch. type IHash_partboundContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllHash_partbound_elem() []IHash_partbound_elemContext Hash_partbound_elem(i int) IHash_partbound_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsHash_partboundContext differentiates from other interfaces. IsHash_partboundContext() } type Hash_partboundContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyHash_partboundContext() *Hash_partboundContext { var p = new(Hash_partboundContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_hash_partbound return p } func InitEmptyHash_partboundContext(p *Hash_partboundContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_hash_partbound } func (*Hash_partboundContext) IsHash_partboundContext() {} func NewHash_partboundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_partboundContext { var p = new(Hash_partboundContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_hash_partbound return p } func (s *Hash_partboundContext) GetParser() antlr.Parser { return s.parser } func (s *Hash_partboundContext) AllHash_partbound_elem() []IHash_partbound_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IHash_partbound_elemContext); ok { len++ } } tst := make([]IHash_partbound_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IHash_partbound_elemContext); ok { tst[i] = t.(IHash_partbound_elemContext) i++ } } return tst } func (s *Hash_partboundContext) Hash_partbound_elem(i int) IHash_partbound_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IHash_partbound_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IHash_partbound_elemContext) } func (s *Hash_partboundContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Hash_partboundContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Hash_partboundContext) GetRuleContext() antlr.RuleContext { return s } func (s *Hash_partboundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Hash_partboundContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterHash_partbound(s) } } func (s *Hash_partboundContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitHash_partbound(s) } } func (s *Hash_partboundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitHash_partbound(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Hash_partbound() (localctx IHash_partboundContext) { localctx = NewHash_partboundContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 132, PostgreSQLParserRULE_hash_partbound) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2568) p.Hash_partbound_elem() } p.SetState(2573) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(2569) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2570) p.Hash_partbound_elem() } p.SetState(2575) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAltercompositetypestmtContext is an interface to support dynamic dispatch. type IAltercompositetypestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode TYPE_P() antlr.TerminalNode Any_name() IAny_nameContext Alter_type_cmds() IAlter_type_cmdsContext // IsAltercompositetypestmtContext differentiates from other interfaces. IsAltercompositetypestmtContext() } type AltercompositetypestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAltercompositetypestmtContext() *AltercompositetypestmtContext { var p = new(AltercompositetypestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altercompositetypestmt return p } func InitEmptyAltercompositetypestmtContext(p *AltercompositetypestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altercompositetypestmt } func (*AltercompositetypestmtContext) IsAltercompositetypestmtContext() {} func NewAltercompositetypestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltercompositetypestmtContext { var p = new(AltercompositetypestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_altercompositetypestmt return p } func (s *AltercompositetypestmtContext) GetParser() antlr.Parser { return s.parser } func (s *AltercompositetypestmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AltercompositetypestmtContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *AltercompositetypestmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *AltercompositetypestmtContext) Alter_type_cmds() IAlter_type_cmdsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_type_cmdsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlter_type_cmdsContext) } func (s *AltercompositetypestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AltercompositetypestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AltercompositetypestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAltercompositetypestmt(s) } } func (s *AltercompositetypestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAltercompositetypestmt(s) } } func (s *AltercompositetypestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAltercompositetypestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Altercompositetypestmt() (localctx IAltercompositetypestmtContext) { localctx = NewAltercompositetypestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 134, PostgreSQLParserRULE_altercompositetypestmt) p.EnterOuterAlt(localctx, 1) { p.SetState(2576) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2577) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2578) p.Any_name() } { p.SetState(2579) p.Alter_type_cmds() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlter_type_cmdsContext is an interface to support dynamic dispatch. type IAlter_type_cmdsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllAlter_type_cmd() []IAlter_type_cmdContext Alter_type_cmd(i int) IAlter_type_cmdContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsAlter_type_cmdsContext differentiates from other interfaces. IsAlter_type_cmdsContext() } type Alter_type_cmdsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlter_type_cmdsContext() *Alter_type_cmdsContext { var p = new(Alter_type_cmdsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_type_cmds return p } func InitEmptyAlter_type_cmdsContext(p *Alter_type_cmdsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_type_cmds } func (*Alter_type_cmdsContext) IsAlter_type_cmdsContext() {} func NewAlter_type_cmdsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_type_cmdsContext { var p = new(Alter_type_cmdsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alter_type_cmds return p } func (s *Alter_type_cmdsContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_type_cmdsContext) AllAlter_type_cmd() []IAlter_type_cmdContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAlter_type_cmdContext); ok { len++ } } tst := make([]IAlter_type_cmdContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAlter_type_cmdContext); ok { tst[i] = t.(IAlter_type_cmdContext) i++ } } return tst } func (s *Alter_type_cmdsContext) Alter_type_cmd(i int) IAlter_type_cmdContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_type_cmdContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAlter_type_cmdContext) } func (s *Alter_type_cmdsContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Alter_type_cmdsContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Alter_type_cmdsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alter_type_cmdsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alter_type_cmdsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlter_type_cmds(s) } } func (s *Alter_type_cmdsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlter_type_cmds(s) } } func (s *Alter_type_cmdsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlter_type_cmds(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alter_type_cmds() (localctx IAlter_type_cmdsContext) { localctx = NewAlter_type_cmdsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 136, PostgreSQLParserRULE_alter_type_cmds) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2581) p.Alter_type_cmd() } p.SetState(2586) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(2582) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2583) p.Alter_type_cmd() } p.SetState(2588) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlter_type_cmdContext is an interface to support dynamic dispatch. type IAlter_type_cmdContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ADD_P() antlr.TerminalNode ATTRIBUTE() antlr.TerminalNode Tablefuncelement() ITablefuncelementContext Opt_drop_behavior() IOpt_drop_behaviorContext DROP() antlr.TerminalNode Colid() IColidContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode ALTER() antlr.TerminalNode Opt_set_data() IOpt_set_dataContext TYPE_P() antlr.TerminalNode Typename() ITypenameContext Opt_collate_clause() IOpt_collate_clauseContext // IsAlter_type_cmdContext differentiates from other interfaces. IsAlter_type_cmdContext() } type Alter_type_cmdContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlter_type_cmdContext() *Alter_type_cmdContext { var p = new(Alter_type_cmdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_type_cmd return p } func InitEmptyAlter_type_cmdContext(p *Alter_type_cmdContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_type_cmd } func (*Alter_type_cmdContext) IsAlter_type_cmdContext() {} func NewAlter_type_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_type_cmdContext { var p = new(Alter_type_cmdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alter_type_cmd return p } func (s *Alter_type_cmdContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_type_cmdContext) ADD_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserADD_P, 0) } func (s *Alter_type_cmdContext) ATTRIBUTE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserATTRIBUTE, 0) } func (s *Alter_type_cmdContext) Tablefuncelement() ITablefuncelementContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITablefuncelementContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITablefuncelementContext) } func (s *Alter_type_cmdContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *Alter_type_cmdContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *Alter_type_cmdContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Alter_type_cmdContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *Alter_type_cmdContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *Alter_type_cmdContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *Alter_type_cmdContext) Opt_set_data() IOpt_set_dataContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_set_dataContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_set_dataContext) } func (s *Alter_type_cmdContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *Alter_type_cmdContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *Alter_type_cmdContext) Opt_collate_clause() IOpt_collate_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_collate_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_collate_clauseContext) } func (s *Alter_type_cmdContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alter_type_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alter_type_cmdContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlter_type_cmd(s) } } func (s *Alter_type_cmdContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlter_type_cmd(s) } } func (s *Alter_type_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlter_type_cmd(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alter_type_cmd() (localctx IAlter_type_cmdContext) { localctx = NewAlter_type_cmdContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 138, PostgreSQLParserRULE_alter_type_cmd) p.SetState(2612) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserADD_P: p.EnterOuterAlt(localctx, 1) { p.SetState(2589) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2590) p.Match(PostgreSQLParserATTRIBUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2591) p.Tablefuncelement() } { p.SetState(2592) p.Opt_drop_behavior() } case PostgreSQLParserDROP: p.EnterOuterAlt(localctx, 2) { p.SetState(2594) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2595) p.Match(PostgreSQLParserATTRIBUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2598) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 66, p.GetParserRuleContext()) == 1 { { p.SetState(2596) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2597) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(2600) p.Colid() } { p.SetState(2601) p.Opt_drop_behavior() } case PostgreSQLParserALTER: p.EnterOuterAlt(localctx, 3) { p.SetState(2603) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2604) p.Match(PostgreSQLParserATTRIBUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2605) p.Colid() } { p.SetState(2606) p.Opt_set_data() } { p.SetState(2607) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2608) p.Typename() } { p.SetState(2609) p.Opt_collate_clause() } { p.SetState(2610) p.Opt_drop_behavior() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICloseportalstmtContext is an interface to support dynamic dispatch. type ICloseportalstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CLOSE() antlr.TerminalNode Cursor_name() ICursor_nameContext ALL() antlr.TerminalNode // IsCloseportalstmtContext differentiates from other interfaces. IsCloseportalstmtContext() } type CloseportalstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCloseportalstmtContext() *CloseportalstmtContext { var p = new(CloseportalstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_closeportalstmt return p } func InitEmptyCloseportalstmtContext(p *CloseportalstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_closeportalstmt } func (*CloseportalstmtContext) IsCloseportalstmtContext() {} func NewCloseportalstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CloseportalstmtContext { var p = new(CloseportalstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_closeportalstmt return p } func (s *CloseportalstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CloseportalstmtContext) CLOSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE, 0) } func (s *CloseportalstmtContext) Cursor_name() ICursor_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICursor_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICursor_nameContext) } func (s *CloseportalstmtContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *CloseportalstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CloseportalstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CloseportalstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCloseportalstmt(s) } } func (s *CloseportalstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCloseportalstmt(s) } } func (s *CloseportalstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCloseportalstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Closeportalstmt() (localctx ICloseportalstmtContext) { localctx = NewCloseportalstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 140, PostgreSQLParserRULE_closeportalstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(2614) p.Match(PostgreSQLParserCLOSE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2617) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: { p.SetState(2615) p.Cursor_name() } case PostgreSQLParserALL: { p.SetState(2616) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICopystmtContext is an interface to support dynamic dispatch. type ICopystmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures COPY() antlr.TerminalNode Opt_binary() IOpt_binaryContext Qualified_name() IQualified_nameContext Opt_column_list() IOpt_column_listContext Copy_from() ICopy_fromContext Opt_program() IOpt_programContext Copy_file_name() ICopy_file_nameContext Copy_delimiter() ICopy_delimiterContext Opt_with() IOpt_withContext Copy_options() ICopy_optionsContext Where_clause() IWhere_clauseContext OPEN_PAREN() antlr.TerminalNode Preparablestmt() IPreparablestmtContext CLOSE_PAREN() antlr.TerminalNode TO() antlr.TerminalNode // IsCopystmtContext differentiates from other interfaces. IsCopystmtContext() } type CopystmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCopystmtContext() *CopystmtContext { var p = new(CopystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copystmt return p } func InitEmptyCopystmtContext(p *CopystmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copystmt } func (*CopystmtContext) IsCopystmtContext() {} func NewCopystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CopystmtContext { var p = new(CopystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_copystmt return p } func (s *CopystmtContext) GetParser() antlr.Parser { return s.parser } func (s *CopystmtContext) COPY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOPY, 0) } func (s *CopystmtContext) Opt_binary() IOpt_binaryContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_binaryContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_binaryContext) } func (s *CopystmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *CopystmtContext) Opt_column_list() IOpt_column_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_column_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_column_listContext) } func (s *CopystmtContext) Copy_from() ICopy_fromContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICopy_fromContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICopy_fromContext) } func (s *CopystmtContext) Opt_program() IOpt_programContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_programContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_programContext) } func (s *CopystmtContext) Copy_file_name() ICopy_file_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICopy_file_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICopy_file_nameContext) } func (s *CopystmtContext) Copy_delimiter() ICopy_delimiterContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICopy_delimiterContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICopy_delimiterContext) } func (s *CopystmtContext) Opt_with() IOpt_withContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_withContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_withContext) } func (s *CopystmtContext) Copy_options() ICopy_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICopy_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICopy_optionsContext) } func (s *CopystmtContext) Where_clause() IWhere_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWhere_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWhere_clauseContext) } func (s *CopystmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *CopystmtContext) Preparablestmt() IPreparablestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPreparablestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPreparablestmtContext) } func (s *CopystmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *CopystmtContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *CopystmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CopystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CopystmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCopystmt(s) } } func (s *CopystmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCopystmt(s) } } func (s *CopystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCopystmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Copystmt() (localctx ICopystmtContext) { localctx = NewCopystmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 142, PostgreSQLParserRULE_copystmt) p.SetState(2641) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 69, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(2619) p.Match(PostgreSQLParserCOPY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2620) p.Opt_binary() } { p.SetState(2621) p.Qualified_name() } { p.SetState(2622) p.Opt_column_list() } { p.SetState(2623) p.Copy_from() } { p.SetState(2624) p.Opt_program() } { p.SetState(2625) p.Copy_file_name() } { p.SetState(2626) p.Copy_delimiter() } { p.SetState(2627) p.Opt_with() } { p.SetState(2628) p.Copy_options() } { p.SetState(2629) p.Where_clause() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(2631) p.Match(PostgreSQLParserCOPY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2632) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2633) p.Preparablestmt() } { p.SetState(2634) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2635) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2636) p.Opt_program() } { p.SetState(2637) p.Copy_file_name() } { p.SetState(2638) p.Opt_with() } { p.SetState(2639) p.Copy_options() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICopy_fromContext is an interface to support dynamic dispatch. type ICopy_fromContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FROM() antlr.TerminalNode TO() antlr.TerminalNode // IsCopy_fromContext differentiates from other interfaces. IsCopy_fromContext() } type Copy_fromContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCopy_fromContext() *Copy_fromContext { var p = new(Copy_fromContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_from return p } func InitEmptyCopy_fromContext(p *Copy_fromContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_from } func (*Copy_fromContext) IsCopy_fromContext() {} func NewCopy_fromContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_fromContext { var p = new(Copy_fromContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_copy_from return p } func (s *Copy_fromContext) GetParser() antlr.Parser { return s.parser } func (s *Copy_fromContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *Copy_fromContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *Copy_fromContext) GetRuleContext() antlr.RuleContext { return s } func (s *Copy_fromContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Copy_fromContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCopy_from(s) } } func (s *Copy_fromContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCopy_from(s) } } func (s *Copy_fromContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCopy_from(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Copy_from() (localctx ICopy_fromContext) { localctx = NewCopy_fromContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 144, PostgreSQLParserRULE_copy_from) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2643) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserFROM || _la == PostgreSQLParserTO) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_programContext is an interface to support dynamic dispatch. type IOpt_programContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures PROGRAM() antlr.TerminalNode // IsOpt_programContext differentiates from other interfaces. IsOpt_programContext() } type Opt_programContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_programContext() *Opt_programContext { var p = new(Opt_programContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_program return p } func InitEmptyOpt_programContext(p *Opt_programContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_program } func (*Opt_programContext) IsOpt_programContext() {} func NewOpt_programContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_programContext { var p = new(Opt_programContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_program return p } func (s *Opt_programContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_programContext) PROGRAM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROGRAM, 0) } func (s *Opt_programContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_programContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_programContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_program(s) } } func (s *Opt_programContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_program(s) } } func (s *Opt_programContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_program(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_program() (localctx IOpt_programContext) { localctx = NewOpt_programContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 146, PostgreSQLParserRULE_opt_program) p.SetState(2647) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserPROGRAM: p.EnterOuterAlt(localctx, 1) { p.SetState(2645) p.Match(PostgreSQLParserPROGRAM) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICopy_file_nameContext is an interface to support dynamic dispatch. type ICopy_file_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sconst() ISconstContext STDIN() antlr.TerminalNode STDOUT() antlr.TerminalNode // IsCopy_file_nameContext differentiates from other interfaces. IsCopy_file_nameContext() } type Copy_file_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCopy_file_nameContext() *Copy_file_nameContext { var p = new(Copy_file_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_file_name return p } func InitEmptyCopy_file_nameContext(p *Copy_file_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_file_name } func (*Copy_file_nameContext) IsCopy_file_nameContext() {} func NewCopy_file_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_file_nameContext { var p = new(Copy_file_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_copy_file_name return p } func (s *Copy_file_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Copy_file_nameContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Copy_file_nameContext) STDIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTDIN, 0) } func (s *Copy_file_nameContext) STDOUT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTDOUT, 0) } func (s *Copy_file_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Copy_file_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Copy_file_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCopy_file_name(s) } } func (s *Copy_file_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCopy_file_name(s) } } func (s *Copy_file_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCopy_file_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Copy_file_name() (localctx ICopy_file_nameContext) { localctx = NewCopy_file_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 148, PostgreSQLParserRULE_copy_file_name) p.SetState(2652) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(2649) p.Sconst() } case PostgreSQLParserSTDIN: p.EnterOuterAlt(localctx, 2) { p.SetState(2650) p.Match(PostgreSQLParserSTDIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSTDOUT: p.EnterOuterAlt(localctx, 3) { p.SetState(2651) p.Match(PostgreSQLParserSTDOUT) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICopy_optionsContext is an interface to support dynamic dispatch. type ICopy_optionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Copy_opt_list() ICopy_opt_listContext OPEN_PAREN() antlr.TerminalNode Copy_generic_opt_list() ICopy_generic_opt_listContext CLOSE_PAREN() antlr.TerminalNode // IsCopy_optionsContext differentiates from other interfaces. IsCopy_optionsContext() } type Copy_optionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCopy_optionsContext() *Copy_optionsContext { var p = new(Copy_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_options return p } func InitEmptyCopy_optionsContext(p *Copy_optionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_options } func (*Copy_optionsContext) IsCopy_optionsContext() {} func NewCopy_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_optionsContext { var p = new(Copy_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_copy_options return p } func (s *Copy_optionsContext) GetParser() antlr.Parser { return s.parser } func (s *Copy_optionsContext) Copy_opt_list() ICopy_opt_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICopy_opt_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICopy_opt_listContext) } func (s *Copy_optionsContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Copy_optionsContext) Copy_generic_opt_list() ICopy_generic_opt_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICopy_generic_opt_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICopy_generic_opt_listContext) } func (s *Copy_optionsContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Copy_optionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Copy_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Copy_optionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCopy_options(s) } } func (s *Copy_optionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCopy_options(s) } } func (s *Copy_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCopy_options(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Copy_options() (localctx ICopy_optionsContext) { localctx = NewCopy_optionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 150, PostgreSQLParserRULE_copy_options) p.SetState(2659) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 72, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(2654) p.Copy_opt_list() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(2655) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2656) p.Copy_generic_opt_list() } { p.SetState(2657) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICopy_opt_listContext is an interface to support dynamic dispatch. type ICopy_opt_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllCopy_opt_item() []ICopy_opt_itemContext Copy_opt_item(i int) ICopy_opt_itemContext // IsCopy_opt_listContext differentiates from other interfaces. IsCopy_opt_listContext() } type Copy_opt_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCopy_opt_listContext() *Copy_opt_listContext { var p = new(Copy_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_opt_list return p } func InitEmptyCopy_opt_listContext(p *Copy_opt_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_opt_list } func (*Copy_opt_listContext) IsCopy_opt_listContext() {} func NewCopy_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_opt_listContext { var p = new(Copy_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_copy_opt_list return p } func (s *Copy_opt_listContext) GetParser() antlr.Parser { return s.parser } func (s *Copy_opt_listContext) AllCopy_opt_item() []ICopy_opt_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ICopy_opt_itemContext); ok { len++ } } tst := make([]ICopy_opt_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ICopy_opt_itemContext); ok { tst[i] = t.(ICopy_opt_itemContext) i++ } } return tst } func (s *Copy_opt_listContext) Copy_opt_item(i int) ICopy_opt_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICopy_opt_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ICopy_opt_itemContext) } func (s *Copy_opt_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Copy_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Copy_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCopy_opt_list(s) } } func (s *Copy_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCopy_opt_list(s) } } func (s *Copy_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCopy_opt_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Copy_opt_list() (localctx ICopy_opt_listContext) { localctx = NewCopy_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 152, PostgreSQLParserRULE_copy_opt_list) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(2664) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ((int64((_la-78)) & ^0x3f) == 0 && ((int64(1)<<(_la-78))&17716740097) != 0) || ((int64((_la-171)) & ^0x3f) == 0 && ((int64(1)<<(_la-171))&35459325497345) != 0) || _la == PostgreSQLParserQUOTE { { p.SetState(2661) p.Copy_opt_item() } p.SetState(2666) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICopy_opt_itemContext is an interface to support dynamic dispatch. type ICopy_opt_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures BINARY() antlr.TerminalNode FREEZE() antlr.TerminalNode DELIMITER() antlr.TerminalNode Opt_as() IOpt_asContext Sconst() ISconstContext NULL_P() antlr.TerminalNode CSV() antlr.TerminalNode HEADER_P() antlr.TerminalNode QUOTE() antlr.TerminalNode ESCAPE() antlr.TerminalNode FORCE() antlr.TerminalNode Columnlist() IColumnlistContext STAR() antlr.TerminalNode NOT() antlr.TerminalNode ENCODING() antlr.TerminalNode // IsCopy_opt_itemContext differentiates from other interfaces. IsCopy_opt_itemContext() } type Copy_opt_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCopy_opt_itemContext() *Copy_opt_itemContext { var p = new(Copy_opt_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_opt_item return p } func InitEmptyCopy_opt_itemContext(p *Copy_opt_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_opt_item } func (*Copy_opt_itemContext) IsCopy_opt_itemContext() {} func NewCopy_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_opt_itemContext { var p = new(Copy_opt_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_copy_opt_item return p } func (s *Copy_opt_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Copy_opt_itemContext) BINARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBINARY, 0) } func (s *Copy_opt_itemContext) FREEZE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFREEZE, 0) } func (s *Copy_opt_itemContext) DELIMITER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDELIMITER, 0) } func (s *Copy_opt_itemContext) Opt_as() IOpt_asContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_asContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_asContext) } func (s *Copy_opt_itemContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Copy_opt_itemContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *Copy_opt_itemContext) CSV() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCSV, 0) } func (s *Copy_opt_itemContext) HEADER_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserHEADER_P, 0) } func (s *Copy_opt_itemContext) QUOTE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserQUOTE, 0) } func (s *Copy_opt_itemContext) ESCAPE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserESCAPE, 0) } func (s *Copy_opt_itemContext) FORCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFORCE, 0) } func (s *Copy_opt_itemContext) Columnlist() IColumnlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColumnlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColumnlistContext) } func (s *Copy_opt_itemContext) STAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTAR, 0) } func (s *Copy_opt_itemContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *Copy_opt_itemContext) ENCODING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserENCODING, 0) } func (s *Copy_opt_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Copy_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Copy_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCopy_opt_item(s) } } func (s *Copy_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCopy_opt_item(s) } } func (s *Copy_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCopy_opt_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Copy_opt_item() (localctx ICopy_opt_itemContext) { localctx = NewCopy_opt_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 154, PostgreSQLParserRULE_copy_opt_item) p.SetState(2702) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 74, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(2667) p.Match(PostgreSQLParserBINARY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(2668) p.Match(PostgreSQLParserFREEZE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(2669) p.Match(PostgreSQLParserDELIMITER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2670) p.Opt_as() } { p.SetState(2671) p.Sconst() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(2673) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2674) p.Opt_as() } { p.SetState(2675) p.Sconst() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(2677) p.Match(PostgreSQLParserCSV) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(2678) p.Match(PostgreSQLParserHEADER_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(2679) p.Match(PostgreSQLParserQUOTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2680) p.Opt_as() } { p.SetState(2681) p.Sconst() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(2683) p.Match(PostgreSQLParserESCAPE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2684) p.Opt_as() } { p.SetState(2685) p.Sconst() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(2687) p.Match(PostgreSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2688) p.Match(PostgreSQLParserQUOTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2689) p.Columnlist() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(2690) p.Match(PostgreSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2691) p.Match(PostgreSQLParserQUOTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2692) p.Match(PostgreSQLParserSTAR) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(2693) p.Match(PostgreSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2694) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2695) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2696) p.Columnlist() } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(2697) p.Match(PostgreSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2698) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2699) p.Columnlist() } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(2700) p.Match(PostgreSQLParserENCODING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2701) p.Sconst() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_binaryContext is an interface to support dynamic dispatch. type IOpt_binaryContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures BINARY() antlr.TerminalNode // IsOpt_binaryContext differentiates from other interfaces. IsOpt_binaryContext() } type Opt_binaryContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_binaryContext() *Opt_binaryContext { var p = new(Opt_binaryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_binary return p } func InitEmptyOpt_binaryContext(p *Opt_binaryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_binary } func (*Opt_binaryContext) IsOpt_binaryContext() {} func NewOpt_binaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_binaryContext { var p = new(Opt_binaryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_binary return p } func (s *Opt_binaryContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_binaryContext) BINARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBINARY, 0) } func (s *Opt_binaryContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_binaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_binaryContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_binary(s) } } func (s *Opt_binaryContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_binary(s) } } func (s *Opt_binaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_binary(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_binary() (localctx IOpt_binaryContext) { localctx = NewOpt_binaryContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 156, PostgreSQLParserRULE_opt_binary) p.SetState(2706) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserBINARY: p.EnterOuterAlt(localctx, 1) { p.SetState(2704) p.Match(PostgreSQLParserBINARY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICopy_delimiterContext is an interface to support dynamic dispatch. type ICopy_delimiterContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_using() IOpt_usingContext DELIMITERS() antlr.TerminalNode Sconst() ISconstContext // IsCopy_delimiterContext differentiates from other interfaces. IsCopy_delimiterContext() } type Copy_delimiterContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCopy_delimiterContext() *Copy_delimiterContext { var p = new(Copy_delimiterContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_delimiter return p } func InitEmptyCopy_delimiterContext(p *Copy_delimiterContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_delimiter } func (*Copy_delimiterContext) IsCopy_delimiterContext() {} func NewCopy_delimiterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_delimiterContext { var p = new(Copy_delimiterContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_copy_delimiter return p } func (s *Copy_delimiterContext) GetParser() antlr.Parser { return s.parser } func (s *Copy_delimiterContext) Opt_using() IOpt_usingContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_usingContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_usingContext) } func (s *Copy_delimiterContext) DELIMITERS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDELIMITERS, 0) } func (s *Copy_delimiterContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Copy_delimiterContext) GetRuleContext() antlr.RuleContext { return s } func (s *Copy_delimiterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Copy_delimiterContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCopy_delimiter(s) } } func (s *Copy_delimiterContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCopy_delimiter(s) } } func (s *Copy_delimiterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCopy_delimiter(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Copy_delimiter() (localctx ICopy_delimiterContext) { localctx = NewCopy_delimiterContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 158, PostgreSQLParserRULE_copy_delimiter) p.SetState(2713) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUSING, PostgreSQLParserDELIMITERS: p.EnterOuterAlt(localctx, 1) { p.SetState(2708) p.Opt_using() } { p.SetState(2709) p.Match(PostgreSQLParserDELIMITERS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2710) p.Sconst() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserNULL_P, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWHERE, PostgreSQLParserWITH, PostgreSQLParserBINARY, PostgreSQLParserFREEZE, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserCSV, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserENCODING, PostgreSQLParserESCAPE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserFORCE, PostgreSQLParserHEADER_P, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserQUOTE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_usingContext is an interface to support dynamic dispatch. type IOpt_usingContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USING() antlr.TerminalNode // IsOpt_usingContext differentiates from other interfaces. IsOpt_usingContext() } type Opt_usingContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_usingContext() *Opt_usingContext { var p = new(Opt_usingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_using return p } func InitEmptyOpt_usingContext(p *Opt_usingContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_using } func (*Opt_usingContext) IsOpt_usingContext() {} func NewOpt_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_usingContext { var p = new(Opt_usingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_using return p } func (s *Opt_usingContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_usingContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *Opt_usingContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_usingContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_using(s) } } func (s *Opt_usingContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_using(s) } } func (s *Opt_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_using(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_using() (localctx IOpt_usingContext) { localctx = NewOpt_usingContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 160, PostgreSQLParserRULE_opt_using) p.SetState(2717) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 1) { p.SetState(2715) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserDELIMITERS: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICopy_generic_opt_listContext is an interface to support dynamic dispatch. type ICopy_generic_opt_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllCopy_generic_opt_elem() []ICopy_generic_opt_elemContext Copy_generic_opt_elem(i int) ICopy_generic_opt_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsCopy_generic_opt_listContext differentiates from other interfaces. IsCopy_generic_opt_listContext() } type Copy_generic_opt_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCopy_generic_opt_listContext() *Copy_generic_opt_listContext { var p = new(Copy_generic_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_list return p } func InitEmptyCopy_generic_opt_listContext(p *Copy_generic_opt_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_list } func (*Copy_generic_opt_listContext) IsCopy_generic_opt_listContext() {} func NewCopy_generic_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_listContext { var p = new(Copy_generic_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_list return p } func (s *Copy_generic_opt_listContext) GetParser() antlr.Parser { return s.parser } func (s *Copy_generic_opt_listContext) AllCopy_generic_opt_elem() []ICopy_generic_opt_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ICopy_generic_opt_elemContext); ok { len++ } } tst := make([]ICopy_generic_opt_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ICopy_generic_opt_elemContext); ok { tst[i] = t.(ICopy_generic_opt_elemContext) i++ } } return tst } func (s *Copy_generic_opt_listContext) Copy_generic_opt_elem(i int) ICopy_generic_opt_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICopy_generic_opt_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ICopy_generic_opt_elemContext) } func (s *Copy_generic_opt_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Copy_generic_opt_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Copy_generic_opt_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Copy_generic_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Copy_generic_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCopy_generic_opt_list(s) } } func (s *Copy_generic_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCopy_generic_opt_list(s) } } func (s *Copy_generic_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCopy_generic_opt_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Copy_generic_opt_list() (localctx ICopy_generic_opt_listContext) { localctx = NewCopy_generic_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 162, PostgreSQLParserRULE_copy_generic_opt_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2719) p.Copy_generic_opt_elem() } p.SetState(2724) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(2720) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2721) p.Copy_generic_opt_elem() } p.SetState(2726) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICopy_generic_opt_elemContext is an interface to support dynamic dispatch. type ICopy_generic_opt_elemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Collabel() ICollabelContext Copy_generic_opt_arg() ICopy_generic_opt_argContext // IsCopy_generic_opt_elemContext differentiates from other interfaces. IsCopy_generic_opt_elemContext() } type Copy_generic_opt_elemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCopy_generic_opt_elemContext() *Copy_generic_opt_elemContext { var p = new(Copy_generic_opt_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_elem return p } func InitEmptyCopy_generic_opt_elemContext(p *Copy_generic_opt_elemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_elem } func (*Copy_generic_opt_elemContext) IsCopy_generic_opt_elemContext() {} func NewCopy_generic_opt_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_elemContext { var p = new(Copy_generic_opt_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_elem return p } func (s *Copy_generic_opt_elemContext) GetParser() antlr.Parser { return s.parser } func (s *Copy_generic_opt_elemContext) Collabel() ICollabelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICollabelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICollabelContext) } func (s *Copy_generic_opt_elemContext) Copy_generic_opt_arg() ICopy_generic_opt_argContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICopy_generic_opt_argContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICopy_generic_opt_argContext) } func (s *Copy_generic_opt_elemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Copy_generic_opt_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Copy_generic_opt_elemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCopy_generic_opt_elem(s) } } func (s *Copy_generic_opt_elemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCopy_generic_opt_elem(s) } } func (s *Copy_generic_opt_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCopy_generic_opt_elem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Copy_generic_opt_elem() (localctx ICopy_generic_opt_elemContext) { localctx = NewCopy_generic_opt_elemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 164, PostgreSQLParserRULE_copy_generic_opt_elem) p.EnterOuterAlt(localctx, 1) { p.SetState(2727) p.Collabel() } { p.SetState(2728) p.Copy_generic_opt_arg() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICopy_generic_opt_argContext is an interface to support dynamic dispatch. type ICopy_generic_opt_argContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_boolean_or_string() IOpt_boolean_or_stringContext Numericonly() INumericonlyContext STAR() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Copy_generic_opt_arg_list() ICopy_generic_opt_arg_listContext CLOSE_PAREN() antlr.TerminalNode // IsCopy_generic_opt_argContext differentiates from other interfaces. IsCopy_generic_opt_argContext() } type Copy_generic_opt_argContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCopy_generic_opt_argContext() *Copy_generic_opt_argContext { var p = new(Copy_generic_opt_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg return p } func InitEmptyCopy_generic_opt_argContext(p *Copy_generic_opt_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg } func (*Copy_generic_opt_argContext) IsCopy_generic_opt_argContext() {} func NewCopy_generic_opt_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_argContext { var p = new(Copy_generic_opt_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg return p } func (s *Copy_generic_opt_argContext) GetParser() antlr.Parser { return s.parser } func (s *Copy_generic_opt_argContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_boolean_or_stringContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_boolean_or_stringContext) } func (s *Copy_generic_opt_argContext) Numericonly() INumericonlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericonlyContext) } func (s *Copy_generic_opt_argContext) STAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTAR, 0) } func (s *Copy_generic_opt_argContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Copy_generic_opt_argContext) Copy_generic_opt_arg_list() ICopy_generic_opt_arg_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICopy_generic_opt_arg_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICopy_generic_opt_arg_listContext) } func (s *Copy_generic_opt_argContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Copy_generic_opt_argContext) GetRuleContext() antlr.RuleContext { return s } func (s *Copy_generic_opt_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Copy_generic_opt_argContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCopy_generic_opt_arg(s) } } func (s *Copy_generic_opt_argContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCopy_generic_opt_arg(s) } } func (s *Copy_generic_opt_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCopy_generic_opt_arg(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Copy_generic_opt_arg() (localctx ICopy_generic_opt_argContext) { localctx = NewCopy_generic_opt_argContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 166, PostgreSQLParserRULE_copy_generic_opt_arg) p.SetState(2738) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserON, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(2730) p.Opt_boolean_or_string() } case PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserIntegral, PostgreSQLParserNumeric: p.EnterOuterAlt(localctx, 2) { p.SetState(2731) p.Numericonly() } case PostgreSQLParserSTAR: p.EnterOuterAlt(localctx, 3) { p.SetState(2732) p.Match(PostgreSQLParserSTAR) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserOPEN_PAREN: p.EnterOuterAlt(localctx, 4) { p.SetState(2733) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2734) p.Copy_generic_opt_arg_list() } { p.SetState(2735) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA: p.EnterOuterAlt(localctx, 5) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICopy_generic_opt_arg_listContext is an interface to support dynamic dispatch. type ICopy_generic_opt_arg_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllCopy_generic_opt_arg_list_item() []ICopy_generic_opt_arg_list_itemContext Copy_generic_opt_arg_list_item(i int) ICopy_generic_opt_arg_list_itemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsCopy_generic_opt_arg_listContext differentiates from other interfaces. IsCopy_generic_opt_arg_listContext() } type Copy_generic_opt_arg_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCopy_generic_opt_arg_listContext() *Copy_generic_opt_arg_listContext { var p = new(Copy_generic_opt_arg_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg_list return p } func InitEmptyCopy_generic_opt_arg_listContext(p *Copy_generic_opt_arg_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg_list } func (*Copy_generic_opt_arg_listContext) IsCopy_generic_opt_arg_listContext() {} func NewCopy_generic_opt_arg_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_arg_listContext { var p = new(Copy_generic_opt_arg_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg_list return p } func (s *Copy_generic_opt_arg_listContext) GetParser() antlr.Parser { return s.parser } func (s *Copy_generic_opt_arg_listContext) AllCopy_generic_opt_arg_list_item() []ICopy_generic_opt_arg_list_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ICopy_generic_opt_arg_list_itemContext); ok { len++ } } tst := make([]ICopy_generic_opt_arg_list_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ICopy_generic_opt_arg_list_itemContext); ok { tst[i] = t.(ICopy_generic_opt_arg_list_itemContext) i++ } } return tst } func (s *Copy_generic_opt_arg_listContext) Copy_generic_opt_arg_list_item(i int) ICopy_generic_opt_arg_list_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICopy_generic_opt_arg_list_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ICopy_generic_opt_arg_list_itemContext) } func (s *Copy_generic_opt_arg_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Copy_generic_opt_arg_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Copy_generic_opt_arg_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Copy_generic_opt_arg_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Copy_generic_opt_arg_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCopy_generic_opt_arg_list(s) } } func (s *Copy_generic_opt_arg_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCopy_generic_opt_arg_list(s) } } func (s *Copy_generic_opt_arg_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCopy_generic_opt_arg_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Copy_generic_opt_arg_list() (localctx ICopy_generic_opt_arg_listContext) { localctx = NewCopy_generic_opt_arg_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 168, PostgreSQLParserRULE_copy_generic_opt_arg_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2740) p.Copy_generic_opt_arg_list_item() } p.SetState(2745) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(2741) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2742) p.Copy_generic_opt_arg_list_item() } p.SetState(2747) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICopy_generic_opt_arg_list_itemContext is an interface to support dynamic dispatch. type ICopy_generic_opt_arg_list_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_boolean_or_string() IOpt_boolean_or_stringContext // IsCopy_generic_opt_arg_list_itemContext differentiates from other interfaces. IsCopy_generic_opt_arg_list_itemContext() } type Copy_generic_opt_arg_list_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCopy_generic_opt_arg_list_itemContext() *Copy_generic_opt_arg_list_itemContext { var p = new(Copy_generic_opt_arg_list_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg_list_item return p } func InitEmptyCopy_generic_opt_arg_list_itemContext(p *Copy_generic_opt_arg_list_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg_list_item } func (*Copy_generic_opt_arg_list_itemContext) IsCopy_generic_opt_arg_list_itemContext() {} func NewCopy_generic_opt_arg_list_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_arg_list_itemContext { var p = new(Copy_generic_opt_arg_list_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_copy_generic_opt_arg_list_item return p } func (s *Copy_generic_opt_arg_list_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Copy_generic_opt_arg_list_itemContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_boolean_or_stringContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_boolean_or_stringContext) } func (s *Copy_generic_opt_arg_list_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Copy_generic_opt_arg_list_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Copy_generic_opt_arg_list_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCopy_generic_opt_arg_list_item(s) } } func (s *Copy_generic_opt_arg_list_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCopy_generic_opt_arg_list_item(s) } } func (s *Copy_generic_opt_arg_list_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCopy_generic_opt_arg_list_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Copy_generic_opt_arg_list_item() (localctx ICopy_generic_opt_arg_list_itemContext) { localctx = NewCopy_generic_opt_arg_list_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 170, PostgreSQLParserRULE_copy_generic_opt_arg_list_item) p.EnterOuterAlt(localctx, 1) { p.SetState(2748) p.Opt_boolean_or_string() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatestmtContext is an interface to support dynamic dispatch. type ICreatestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode Opttemp() IOpttempContext TABLE() antlr.TerminalNode AllQualified_name() []IQualified_nameContext Qualified_name(i int) IQualified_nameContext OPEN_PAREN() antlr.TerminalNode Opttableelementlist() IOpttableelementlistContext CLOSE_PAREN() antlr.TerminalNode Optinherit() IOptinheritContext Optpartitionspec() IOptpartitionspecContext Table_access_method_clause() ITable_access_method_clauseContext Optwith() IOptwithContext Oncommitoption() IOncommitoptionContext Opttablespace() IOpttablespaceContext OF() antlr.TerminalNode Any_name() IAny_nameContext Opttypedtableelementlist() IOpttypedtableelementlistContext PARTITION() antlr.TerminalNode Partitionboundspec() IPartitionboundspecContext IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsCreatestmtContext differentiates from other interfaces. IsCreatestmtContext() } type CreatestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatestmtContext() *CreatestmtContext { var p = new(CreatestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createstmt return p } func InitEmptyCreatestmtContext(p *CreatestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createstmt } func (*CreatestmtContext) IsCreatestmtContext() {} func NewCreatestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatestmtContext { var p = new(CreatestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createstmt return p } func (s *CreatestmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreatestmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreatestmtContext) Opttemp() IOpttempContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttempContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttempContext) } func (s *CreatestmtContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *CreatestmtContext) AllQualified_name() []IQualified_nameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IQualified_nameContext); ok { len++ } } tst := make([]IQualified_nameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IQualified_nameContext); ok { tst[i] = t.(IQualified_nameContext) i++ } } return tst } func (s *CreatestmtContext) Qualified_name(i int) IQualified_nameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *CreatestmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *CreatestmtContext) Opttableelementlist() IOpttableelementlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttableelementlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttableelementlistContext) } func (s *CreatestmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *CreatestmtContext) Optinherit() IOptinheritContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptinheritContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptinheritContext) } func (s *CreatestmtContext) Optpartitionspec() IOptpartitionspecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptpartitionspecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptpartitionspecContext) } func (s *CreatestmtContext) Table_access_method_clause() ITable_access_method_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITable_access_method_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITable_access_method_clauseContext) } func (s *CreatestmtContext) Optwith() IOptwithContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptwithContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptwithContext) } func (s *CreatestmtContext) Oncommitoption() IOncommitoptionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOncommitoptionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOncommitoptionContext) } func (s *CreatestmtContext) Opttablespace() IOpttablespaceContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttablespaceContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttablespaceContext) } func (s *CreatestmtContext) OF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOF, 0) } func (s *CreatestmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *CreatestmtContext) Opttypedtableelementlist() IOpttypedtableelementlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttypedtableelementlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttypedtableelementlistContext) } func (s *CreatestmtContext) PARTITION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARTITION, 0) } func (s *CreatestmtContext) Partitionboundspec() IPartitionboundspecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPartitionboundspecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPartitionboundspecContext) } func (s *CreatestmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *CreatestmtContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *CreatestmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *CreatestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreatestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreatestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatestmt(s) } } func (s *CreatestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatestmt(s) } } func (s *CreatestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createstmt() (localctx ICreatestmtContext) { localctx = NewCreatestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 172, PostgreSQLParserRULE_createstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(2750) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2751) p.Opttemp() } { p.SetState(2752) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2756) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 81, p.GetParserRuleContext()) == 1 { { p.SetState(2753) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2754) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2755) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(2758) p.Qualified_name() } p.SetState(2789) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN: { p.SetState(2759) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2760) p.Opttableelementlist() } { p.SetState(2761) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2762) p.Optinherit() } { p.SetState(2763) p.Optpartitionspec() } { p.SetState(2764) p.Table_access_method_clause() } { p.SetState(2765) p.Optwith() } { p.SetState(2766) p.Oncommitoption() } { p.SetState(2767) p.Opttablespace() } case PostgreSQLParserOF: { p.SetState(2769) p.Match(PostgreSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2770) p.Any_name() } { p.SetState(2771) p.Opttypedtableelementlist() } { p.SetState(2772) p.Optpartitionspec() } { p.SetState(2773) p.Table_access_method_clause() } { p.SetState(2774) p.Optwith() } { p.SetState(2775) p.Oncommitoption() } { p.SetState(2776) p.Opttablespace() } case PostgreSQLParserPARTITION: { p.SetState(2778) p.Match(PostgreSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2779) p.Match(PostgreSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2780) p.Qualified_name() } { p.SetState(2781) p.Opttypedtableelementlist() } { p.SetState(2782) p.Partitionboundspec() } { p.SetState(2783) p.Optpartitionspec() } { p.SetState(2784) p.Table_access_method_clause() } { p.SetState(2785) p.Optwith() } { p.SetState(2786) p.Oncommitoption() } { p.SetState(2787) p.Opttablespace() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpttempContext is an interface to support dynamic dispatch. type IOpttempContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TEMPORARY() antlr.TerminalNode TEMP() antlr.TerminalNode LOCAL() antlr.TerminalNode GLOBAL() antlr.TerminalNode UNLOGGED() antlr.TerminalNode // IsOpttempContext differentiates from other interfaces. IsOpttempContext() } type OpttempContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpttempContext() *OpttempContext { var p = new(OpttempContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opttemp return p } func InitEmptyOpttempContext(p *OpttempContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opttemp } func (*OpttempContext) IsOpttempContext() {} func NewOpttempContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttempContext { var p = new(OpttempContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opttemp return p } func (s *OpttempContext) GetParser() antlr.Parser { return s.parser } func (s *OpttempContext) TEMPORARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEMPORARY, 0) } func (s *OpttempContext) TEMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEMP, 0) } func (s *OpttempContext) LOCAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCAL, 0) } func (s *OpttempContext) GLOBAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGLOBAL, 0) } func (s *OpttempContext) UNLOGGED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNLOGGED, 0) } func (s *OpttempContext) GetRuleContext() antlr.RuleContext { return s } func (s *OpttempContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OpttempContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpttemp(s) } } func (s *OpttempContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpttemp(s) } } func (s *OpttempContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpttemp(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opttemp() (localctx IOpttempContext) { localctx = NewOpttempContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 174, PostgreSQLParserRULE_opttemp) var _la int p.SetState(2799) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserTEMPORARY: p.EnterOuterAlt(localctx, 1) { p.SetState(2791) p.Match(PostgreSQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserTEMP: p.EnterOuterAlt(localctx, 2) { p.SetState(2792) p.Match(PostgreSQLParserTEMP) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserLOCAL: p.EnterOuterAlt(localctx, 3) { p.SetState(2793) p.Match(PostgreSQLParserLOCAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2794) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserTEMP || _la == PostgreSQLParserTEMPORARY) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } case PostgreSQLParserGLOBAL: p.EnterOuterAlt(localctx, 4) { p.SetState(2795) p.Match(PostgreSQLParserGLOBAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2796) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserTEMP || _la == PostgreSQLParserTEMPORARY) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } case PostgreSQLParserUNLOGGED: p.EnterOuterAlt(localctx, 5) { p.SetState(2797) p.Match(PostgreSQLParserUNLOGGED) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserTABLE, PostgreSQLParserRECURSIVE, PostgreSQLParserSEQUENCE, PostgreSQLParserVIEW: p.EnterOuterAlt(localctx, 6) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpttableelementlistContext is an interface to support dynamic dispatch. type IOpttableelementlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Tableelementlist() ITableelementlistContext // IsOpttableelementlistContext differentiates from other interfaces. IsOpttableelementlistContext() } type OpttableelementlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpttableelementlistContext() *OpttableelementlistContext { var p = new(OpttableelementlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opttableelementlist return p } func InitEmptyOpttableelementlistContext(p *OpttableelementlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opttableelementlist } func (*OpttableelementlistContext) IsOpttableelementlistContext() {} func NewOpttableelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttableelementlistContext { var p = new(OpttableelementlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opttableelementlist return p } func (s *OpttableelementlistContext) GetParser() antlr.Parser { return s.parser } func (s *OpttableelementlistContext) Tableelementlist() ITableelementlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITableelementlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITableelementlistContext) } func (s *OpttableelementlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *OpttableelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OpttableelementlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpttableelementlist(s) } } func (s *OpttableelementlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpttableelementlist(s) } } func (s *OpttableelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpttableelementlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opttableelementlist() (localctx IOpttableelementlistContext) { localctx = NewOpttableelementlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 176, PostgreSQLParserRULE_opttableelementlist) p.SetState(2803) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserFOREIGN, PostgreSQLParserPRIMARY, PostgreSQLParserTABLE, PostgreSQLParserUNIQUE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(2801) p.Tableelementlist() } case PostgreSQLParserCLOSE_PAREN: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpttypedtableelementlistContext is an interface to support dynamic dispatch. type IOpttypedtableelementlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Typedtableelementlist() ITypedtableelementlistContext CLOSE_PAREN() antlr.TerminalNode // IsOpttypedtableelementlistContext differentiates from other interfaces. IsOpttypedtableelementlistContext() } type OpttypedtableelementlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpttypedtableelementlistContext() *OpttypedtableelementlistContext { var p = new(OpttypedtableelementlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opttypedtableelementlist return p } func InitEmptyOpttypedtableelementlistContext(p *OpttypedtableelementlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opttypedtableelementlist } func (*OpttypedtableelementlistContext) IsOpttypedtableelementlistContext() {} func NewOpttypedtableelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttypedtableelementlistContext { var p = new(OpttypedtableelementlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opttypedtableelementlist return p } func (s *OpttypedtableelementlistContext) GetParser() antlr.Parser { return s.parser } func (s *OpttypedtableelementlistContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *OpttypedtableelementlistContext) Typedtableelementlist() ITypedtableelementlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypedtableelementlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypedtableelementlistContext) } func (s *OpttypedtableelementlistContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *OpttypedtableelementlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *OpttypedtableelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OpttypedtableelementlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpttypedtableelementlist(s) } } func (s *OpttypedtableelementlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpttypedtableelementlist(s) } } func (s *OpttypedtableelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpttypedtableelementlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opttypedtableelementlist() (localctx IOpttypedtableelementlistContext) { localctx = NewOpttypedtableelementlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 178, PostgreSQLParserRULE_opttypedtableelementlist) p.SetState(2810) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 85, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(2805) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2806) p.Typedtableelementlist() } { p.SetState(2807) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITableelementlistContext is an interface to support dynamic dispatch. type ITableelementlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllTableelement() []ITableelementContext Tableelement(i int) ITableelementContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsTableelementlistContext differentiates from other interfaces. IsTableelementlistContext() } type TableelementlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTableelementlistContext() *TableelementlistContext { var p = new(TableelementlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tableelementlist return p } func InitEmptyTableelementlistContext(p *TableelementlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tableelementlist } func (*TableelementlistContext) IsTableelementlistContext() {} func NewTableelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableelementlistContext { var p = new(TableelementlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_tableelementlist return p } func (s *TableelementlistContext) GetParser() antlr.Parser { return s.parser } func (s *TableelementlistContext) AllTableelement() []ITableelementContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITableelementContext); ok { len++ } } tst := make([]ITableelementContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITableelementContext); ok { tst[i] = t.(ITableelementContext) i++ } } return tst } func (s *TableelementlistContext) Tableelement(i int) ITableelementContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITableelementContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITableelementContext) } func (s *TableelementlistContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *TableelementlistContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *TableelementlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *TableelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TableelementlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTableelementlist(s) } } func (s *TableelementlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTableelementlist(s) } } func (s *TableelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTableelementlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Tableelementlist() (localctx ITableelementlistContext) { localctx = NewTableelementlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 180, PostgreSQLParserRULE_tableelementlist) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2812) p.Tableelement() } p.SetState(2817) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(2813) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2814) p.Tableelement() } p.SetState(2819) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITypedtableelementlistContext is an interface to support dynamic dispatch. type ITypedtableelementlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllTypedtableelement() []ITypedtableelementContext Typedtableelement(i int) ITypedtableelementContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsTypedtableelementlistContext differentiates from other interfaces. IsTypedtableelementlistContext() } type TypedtableelementlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTypedtableelementlistContext() *TypedtableelementlistContext { var p = new(TypedtableelementlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_typedtableelementlist return p } func InitEmptyTypedtableelementlistContext(p *TypedtableelementlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_typedtableelementlist } func (*TypedtableelementlistContext) IsTypedtableelementlistContext() {} func NewTypedtableelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypedtableelementlistContext { var p = new(TypedtableelementlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_typedtableelementlist return p } func (s *TypedtableelementlistContext) GetParser() antlr.Parser { return s.parser } func (s *TypedtableelementlistContext) AllTypedtableelement() []ITypedtableelementContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITypedtableelementContext); ok { len++ } } tst := make([]ITypedtableelementContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITypedtableelementContext); ok { tst[i] = t.(ITypedtableelementContext) i++ } } return tst } func (s *TypedtableelementlistContext) Typedtableelement(i int) ITypedtableelementContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypedtableelementContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITypedtableelementContext) } func (s *TypedtableelementlistContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *TypedtableelementlistContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *TypedtableelementlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *TypedtableelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TypedtableelementlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTypedtableelementlist(s) } } func (s *TypedtableelementlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTypedtableelementlist(s) } } func (s *TypedtableelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTypedtableelementlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Typedtableelementlist() (localctx ITypedtableelementlistContext) { localctx = NewTypedtableelementlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 182, PostgreSQLParserRULE_typedtableelementlist) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2820) p.Typedtableelement() } p.SetState(2825) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(2821) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2822) p.Typedtableelement() } p.SetState(2827) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITableelementContext is an interface to support dynamic dispatch. type ITableelementContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Tableconstraint() ITableconstraintContext Tablelikeclause() ITablelikeclauseContext ColumnDef() IColumnDefContext // IsTableelementContext differentiates from other interfaces. IsTableelementContext() } type TableelementContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTableelementContext() *TableelementContext { var p = new(TableelementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tableelement return p } func InitEmptyTableelementContext(p *TableelementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tableelement } func (*TableelementContext) IsTableelementContext() {} func NewTableelementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableelementContext { var p = new(TableelementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_tableelement return p } func (s *TableelementContext) GetParser() antlr.Parser { return s.parser } func (s *TableelementContext) Tableconstraint() ITableconstraintContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITableconstraintContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITableconstraintContext) } func (s *TableelementContext) Tablelikeclause() ITablelikeclauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITablelikeclauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITablelikeclauseContext) } func (s *TableelementContext) ColumnDef() IColumnDefContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColumnDefContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColumnDefContext) } func (s *TableelementContext) GetRuleContext() antlr.RuleContext { return s } func (s *TableelementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TableelementContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTableelement(s) } } func (s *TableelementContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTableelement(s) } } func (s *TableelementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTableelement(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Tableelement() (localctx ITableelementContext) { localctx = NewTableelementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 184, PostgreSQLParserRULE_tableelement) p.SetState(2831) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 88, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(2828) p.Tableconstraint() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(2829) p.Tablelikeclause() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(2830) p.ColumnDef() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITypedtableelementContext is an interface to support dynamic dispatch. type ITypedtableelementContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ColumnOptions() IColumnOptionsContext Tableconstraint() ITableconstraintContext // IsTypedtableelementContext differentiates from other interfaces. IsTypedtableelementContext() } type TypedtableelementContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTypedtableelementContext() *TypedtableelementContext { var p = new(TypedtableelementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_typedtableelement return p } func InitEmptyTypedtableelementContext(p *TypedtableelementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_typedtableelement } func (*TypedtableelementContext) IsTypedtableelementContext() {} func NewTypedtableelementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypedtableelementContext { var p = new(TypedtableelementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_typedtableelement return p } func (s *TypedtableelementContext) GetParser() antlr.Parser { return s.parser } func (s *TypedtableelementContext) ColumnOptions() IColumnOptionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColumnOptionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColumnOptionsContext) } func (s *TypedtableelementContext) Tableconstraint() ITableconstraintContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITableconstraintContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITableconstraintContext) } func (s *TypedtableelementContext) GetRuleContext() antlr.RuleContext { return s } func (s *TypedtableelementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TypedtableelementContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTypedtableelement(s) } } func (s *TypedtableelementContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTypedtableelement(s) } } func (s *TypedtableelementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTypedtableelement(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Typedtableelement() (localctx ITypedtableelementContext) { localctx = NewTypedtableelementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 186, PostgreSQLParserRULE_typedtableelement) p.SetState(2835) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 89, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(2833) p.ColumnOptions() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(2834) p.Tableconstraint() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IColumnDefContext is an interface to support dynamic dispatch. type IColumnDefContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext Typename() ITypenameContext Create_generic_options() ICreate_generic_optionsContext Colquallist() IColquallistContext // IsColumnDefContext differentiates from other interfaces. IsColumnDefContext() } type ColumnDefContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyColumnDefContext() *ColumnDefContext { var p = new(ColumnDefContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_columnDef return p } func InitEmptyColumnDefContext(p *ColumnDefContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_columnDef } func (*ColumnDefContext) IsColumnDefContext() {} func NewColumnDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnDefContext { var p = new(ColumnDefContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_columnDef return p } func (s *ColumnDefContext) GetParser() antlr.Parser { return s.parser } func (s *ColumnDefContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *ColumnDefContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *ColumnDefContext) Create_generic_options() ICreate_generic_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreate_generic_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreate_generic_optionsContext) } func (s *ColumnDefContext) Colquallist() IColquallistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColquallistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColquallistContext) } func (s *ColumnDefContext) GetRuleContext() antlr.RuleContext { return s } func (s *ColumnDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ColumnDefContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterColumnDef(s) } } func (s *ColumnDefContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitColumnDef(s) } } func (s *ColumnDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitColumnDef(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) ColumnDef() (localctx IColumnDefContext) { localctx = NewColumnDefContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 188, PostgreSQLParserRULE_columnDef) p.EnterOuterAlt(localctx, 1) { p.SetState(2837) p.Colid() } { p.SetState(2838) p.Typename() } { p.SetState(2839) p.Create_generic_options() } { p.SetState(2840) p.Colquallist() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IColumnOptionsContext is an interface to support dynamic dispatch. type IColumnOptionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext Colquallist() IColquallistContext WITH() antlr.TerminalNode OPTIONS() antlr.TerminalNode // IsColumnOptionsContext differentiates from other interfaces. IsColumnOptionsContext() } type ColumnOptionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyColumnOptionsContext() *ColumnOptionsContext { var p = new(ColumnOptionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_columnOptions return p } func InitEmptyColumnOptionsContext(p *ColumnOptionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_columnOptions } func (*ColumnOptionsContext) IsColumnOptionsContext() {} func NewColumnOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnOptionsContext { var p = new(ColumnOptionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_columnOptions return p } func (s *ColumnOptionsContext) GetParser() antlr.Parser { return s.parser } func (s *ColumnOptionsContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *ColumnOptionsContext) Colquallist() IColquallistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColquallistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColquallistContext) } func (s *ColumnOptionsContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *ColumnOptionsContext) OPTIONS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPTIONS, 0) } func (s *ColumnOptionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *ColumnOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ColumnOptionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterColumnOptions(s) } } func (s *ColumnOptionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitColumnOptions(s) } } func (s *ColumnOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitColumnOptions(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) ColumnOptions() (localctx IColumnOptionsContext) { localctx = NewColumnOptionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 190, PostgreSQLParserRULE_columnOptions) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2842) p.Colid() } p.SetState(2845) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserWITH { { p.SetState(2843) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2844) p.Match(PostgreSQLParserOPTIONS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(2847) p.Colquallist() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IColquallistContext is an interface to support dynamic dispatch. type IColquallistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllColconstraint() []IColconstraintContext Colconstraint(i int) IColconstraintContext // IsColquallistContext differentiates from other interfaces. IsColquallistContext() } type ColquallistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyColquallistContext() *ColquallistContext { var p = new(ColquallistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_colquallist return p } func InitEmptyColquallistContext(p *ColquallistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_colquallist } func (*ColquallistContext) IsColquallistContext() {} func NewColquallistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColquallistContext { var p = new(ColquallistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_colquallist return p } func (s *ColquallistContext) GetParser() antlr.Parser { return s.parser } func (s *ColquallistContext) AllColconstraint() []IColconstraintContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IColconstraintContext); ok { len++ } } tst := make([]IColconstraintContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IColconstraintContext); ok { tst[i] = t.(IColconstraintContext) i++ } } return tst } func (s *ColquallistContext) Colconstraint(i int) IColconstraintContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColconstraintContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IColconstraintContext) } func (s *ColquallistContext) GetRuleContext() antlr.RuleContext { return s } func (s *ColquallistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ColquallistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterColquallist(s) } } func (s *ColquallistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitColquallist(s) } } func (s *ColquallistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitColquallist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Colquallist() (localctx IColquallistContext) { localctx = NewColquallistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 192, PostgreSQLParserRULE_colquallist) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(2852) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ((int64((_la-42)) & ^0x3f) == 0 && ((int64(1)<<(_la-42))&72084085530433547) != 0) || _la == PostgreSQLParserGENERATED { { p.SetState(2849) p.Colconstraint() } p.SetState(2854) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IColconstraintContext is an interface to support dynamic dispatch. type IColconstraintContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CONSTRAINT() antlr.TerminalNode Name() INameContext Colconstraintelem() IColconstraintelemContext Constraintattr() IConstraintattrContext COLLATE() antlr.TerminalNode Any_name() IAny_nameContext // IsColconstraintContext differentiates from other interfaces. IsColconstraintContext() } type ColconstraintContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyColconstraintContext() *ColconstraintContext { var p = new(ColconstraintContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_colconstraint return p } func InitEmptyColconstraintContext(p *ColconstraintContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_colconstraint } func (*ColconstraintContext) IsColconstraintContext() {} func NewColconstraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColconstraintContext { var p = new(ColconstraintContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_colconstraint return p } func (s *ColconstraintContext) GetParser() antlr.Parser { return s.parser } func (s *ColconstraintContext) CONSTRAINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTRAINT, 0) } func (s *ColconstraintContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *ColconstraintContext) Colconstraintelem() IColconstraintelemContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColconstraintelemContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColconstraintelemContext) } func (s *ColconstraintContext) Constraintattr() IConstraintattrContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstraintattrContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstraintattrContext) } func (s *ColconstraintContext) COLLATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATE, 0) } func (s *ColconstraintContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *ColconstraintContext) GetRuleContext() antlr.RuleContext { return s } func (s *ColconstraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ColconstraintContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterColconstraint(s) } } func (s *ColconstraintContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitColconstraint(s) } } func (s *ColconstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitColconstraint(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Colconstraint() (localctx IColconstraintContext) { localctx = NewColconstraintContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 194, PostgreSQLParserRULE_colconstraint) p.SetState(2863) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 92, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(2855) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2856) p.Name() } { p.SetState(2857) p.Colconstraintelem() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(2859) p.Colconstraintelem() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(2860) p.Constraintattr() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(2861) p.Match(PostgreSQLParserCOLLATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2862) p.Any_name() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IColconstraintelemContext is an interface to support dynamic dispatch. type IColconstraintelemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NOT() antlr.TerminalNode NULL_P() antlr.TerminalNode UNIQUE() antlr.TerminalNode Opt_definition() IOpt_definitionContext Optconstablespace() IOptconstablespaceContext PRIMARY() antlr.TerminalNode KEY() antlr.TerminalNode CHECK() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode A_expr() IA_exprContext CLOSE_PAREN() antlr.TerminalNode Opt_no_inherit() IOpt_no_inheritContext DEFAULT() antlr.TerminalNode B_expr() IB_exprContext GENERATED() antlr.TerminalNode Generated_when() IGenerated_whenContext AS() antlr.TerminalNode IDENTITY_P() antlr.TerminalNode Optparenthesizedseqoptlist() IOptparenthesizedseqoptlistContext STORED() antlr.TerminalNode REFERENCES() antlr.TerminalNode Qualified_name() IQualified_nameContext Opt_column_list() IOpt_column_listContext Key_match() IKey_matchContext Key_actions() IKey_actionsContext // IsColconstraintelemContext differentiates from other interfaces. IsColconstraintelemContext() } type ColconstraintelemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyColconstraintelemContext() *ColconstraintelemContext { var p = new(ColconstraintelemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_colconstraintelem return p } func InitEmptyColconstraintelemContext(p *ColconstraintelemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_colconstraintelem } func (*ColconstraintelemContext) IsColconstraintelemContext() {} func NewColconstraintelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColconstraintelemContext { var p = new(ColconstraintelemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_colconstraintelem return p } func (s *ColconstraintelemContext) GetParser() antlr.Parser { return s.parser } func (s *ColconstraintelemContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *ColconstraintelemContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *ColconstraintelemContext) UNIQUE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNIQUE, 0) } func (s *ColconstraintelemContext) Opt_definition() IOpt_definitionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_definitionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_definitionContext) } func (s *ColconstraintelemContext) Optconstablespace() IOptconstablespaceContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptconstablespaceContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptconstablespaceContext) } func (s *ColconstraintelemContext) PRIMARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRIMARY, 0) } func (s *ColconstraintelemContext) KEY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserKEY, 0) } func (s *ColconstraintelemContext) CHECK() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHECK, 0) } func (s *ColconstraintelemContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *ColconstraintelemContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *ColconstraintelemContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *ColconstraintelemContext) Opt_no_inherit() IOpt_no_inheritContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_no_inheritContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_no_inheritContext) } func (s *ColconstraintelemContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *ColconstraintelemContext) B_expr() IB_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IB_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IB_exprContext) } func (s *ColconstraintelemContext) GENERATED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGENERATED, 0) } func (s *ColconstraintelemContext) Generated_when() IGenerated_whenContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGenerated_whenContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGenerated_whenContext) } func (s *ColconstraintelemContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *ColconstraintelemContext) IDENTITY_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIDENTITY_P, 0) } func (s *ColconstraintelemContext) Optparenthesizedseqoptlist() IOptparenthesizedseqoptlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptparenthesizedseqoptlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptparenthesizedseqoptlistContext) } func (s *ColconstraintelemContext) STORED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTORED, 0) } func (s *ColconstraintelemContext) REFERENCES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREFERENCES, 0) } func (s *ColconstraintelemContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *ColconstraintelemContext) Opt_column_list() IOpt_column_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_column_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_column_listContext) } func (s *ColconstraintelemContext) Key_match() IKey_matchContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IKey_matchContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IKey_matchContext) } func (s *ColconstraintelemContext) Key_actions() IKey_actionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IKey_actionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IKey_actionsContext) } func (s *ColconstraintelemContext) GetRuleContext() antlr.RuleContext { return s } func (s *ColconstraintelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ColconstraintelemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterColconstraintelem(s) } } func (s *ColconstraintelemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitColconstraintelem(s) } } func (s *ColconstraintelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitColconstraintelem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Colconstraintelem() (localctx IColconstraintelemContext) { localctx = NewColconstraintelemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 196, PostgreSQLParserRULE_colconstraintelem) p.SetState(2903) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserNOT: p.EnterOuterAlt(localctx, 1) { p.SetState(2865) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2866) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserNULL_P: p.EnterOuterAlt(localctx, 2) { p.SetState(2867) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserUNIQUE: p.EnterOuterAlt(localctx, 3) { p.SetState(2868) p.Match(PostgreSQLParserUNIQUE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2869) p.Opt_definition() } { p.SetState(2870) p.Optconstablespace() } case PostgreSQLParserPRIMARY: p.EnterOuterAlt(localctx, 4) { p.SetState(2872) p.Match(PostgreSQLParserPRIMARY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2873) p.Match(PostgreSQLParserKEY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2874) p.Opt_definition() } { p.SetState(2875) p.Optconstablespace() } case PostgreSQLParserCHECK: p.EnterOuterAlt(localctx, 5) { p.SetState(2877) p.Match(PostgreSQLParserCHECK) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2878) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2879) p.A_expr() } { p.SetState(2880) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2881) p.Opt_no_inherit() } case PostgreSQLParserDEFAULT: p.EnterOuterAlt(localctx, 6) { p.SetState(2883) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2884) p.b_expr(0) } case PostgreSQLParserGENERATED: p.EnterOuterAlt(localctx, 7) { p.SetState(2885) p.Match(PostgreSQLParserGENERATED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2886) p.Generated_when() } { p.SetState(2887) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2895) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserIDENTITY_P: { p.SetState(2888) p.Match(PostgreSQLParserIDENTITY_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2889) p.Optparenthesizedseqoptlist() } case PostgreSQLParserOPEN_PAREN: { p.SetState(2890) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2891) p.A_expr() } { p.SetState(2892) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2893) p.Match(PostgreSQLParserSTORED) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case PostgreSQLParserREFERENCES: p.EnterOuterAlt(localctx, 8) { p.SetState(2897) p.Match(PostgreSQLParserREFERENCES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2898) p.Qualified_name() } { p.SetState(2899) p.Opt_column_list() } { p.SetState(2900) p.Key_match() } { p.SetState(2901) p.Key_actions() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGenerated_whenContext is an interface to support dynamic dispatch. type IGenerated_whenContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALWAYS() antlr.TerminalNode BY() antlr.TerminalNode DEFAULT() antlr.TerminalNode // IsGenerated_whenContext differentiates from other interfaces. IsGenerated_whenContext() } type Generated_whenContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGenerated_whenContext() *Generated_whenContext { var p = new(Generated_whenContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generated_when return p } func InitEmptyGenerated_whenContext(p *Generated_whenContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generated_when } func (*Generated_whenContext) IsGenerated_whenContext() {} func NewGenerated_whenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generated_whenContext { var p = new(Generated_whenContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_generated_when return p } func (s *Generated_whenContext) GetParser() antlr.Parser { return s.parser } func (s *Generated_whenContext) ALWAYS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALWAYS, 0) } func (s *Generated_whenContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *Generated_whenContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Generated_whenContext) GetRuleContext() antlr.RuleContext { return s } func (s *Generated_whenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Generated_whenContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGenerated_when(s) } } func (s *Generated_whenContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGenerated_when(s) } } func (s *Generated_whenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGenerated_when(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Generated_when() (localctx IGenerated_whenContext) { localctx = NewGenerated_whenContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 198, PostgreSQLParserRULE_generated_when) p.SetState(2908) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserALWAYS: p.EnterOuterAlt(localctx, 1) { p.SetState(2905) p.Match(PostgreSQLParserALWAYS) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserBY: p.EnterOuterAlt(localctx, 2) { p.SetState(2906) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2907) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IConstraintattrContext is an interface to support dynamic dispatch. type IConstraintattrContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DEFERRABLE() antlr.TerminalNode NOT() antlr.TerminalNode INITIALLY() antlr.TerminalNode DEFERRED() antlr.TerminalNode IMMEDIATE() antlr.TerminalNode // IsConstraintattrContext differentiates from other interfaces. IsConstraintattrContext() } type ConstraintattrContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyConstraintattrContext() *ConstraintattrContext { var p = new(ConstraintattrContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constraintattr return p } func InitEmptyConstraintattrContext(p *ConstraintattrContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constraintattr } func (*ConstraintattrContext) IsConstraintattrContext() {} func NewConstraintattrContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintattrContext { var p = new(ConstraintattrContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_constraintattr return p } func (s *ConstraintattrContext) GetParser() antlr.Parser { return s.parser } func (s *ConstraintattrContext) DEFERRABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFERRABLE, 0) } func (s *ConstraintattrContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *ConstraintattrContext) INITIALLY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINITIALLY, 0) } func (s *ConstraintattrContext) DEFERRED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFERRED, 0) } func (s *ConstraintattrContext) IMMEDIATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIMMEDIATE, 0) } func (s *ConstraintattrContext) GetRuleContext() antlr.RuleContext { return s } func (s *ConstraintattrContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ConstraintattrContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterConstraintattr(s) } } func (s *ConstraintattrContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitConstraintattr(s) } } func (s *ConstraintattrContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitConstraintattr(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Constraintattr() (localctx IConstraintattrContext) { localctx = NewConstraintattrContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 200, PostgreSQLParserRULE_constraintattr) var _la int p.SetState(2915) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserDEFERRABLE: p.EnterOuterAlt(localctx, 1) { p.SetState(2910) p.Match(PostgreSQLParserDEFERRABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserNOT: p.EnterOuterAlt(localctx, 2) { p.SetState(2911) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2912) p.Match(PostgreSQLParserDEFERRABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserINITIALLY: p.EnterOuterAlt(localctx, 3) { p.SetState(2913) p.Match(PostgreSQLParserINITIALLY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2914) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserDEFERRED || _la == PostgreSQLParserIMMEDIATE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITablelikeclauseContext is an interface to support dynamic dispatch. type ITablelikeclauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures LIKE() antlr.TerminalNode Qualified_name() IQualified_nameContext Tablelikeoptionlist() ITablelikeoptionlistContext // IsTablelikeclauseContext differentiates from other interfaces. IsTablelikeclauseContext() } type TablelikeclauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTablelikeclauseContext() *TablelikeclauseContext { var p = new(TablelikeclauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tablelikeclause return p } func InitEmptyTablelikeclauseContext(p *TablelikeclauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tablelikeclause } func (*TablelikeclauseContext) IsTablelikeclauseContext() {} func NewTablelikeclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablelikeclauseContext { var p = new(TablelikeclauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_tablelikeclause return p } func (s *TablelikeclauseContext) GetParser() antlr.Parser { return s.parser } func (s *TablelikeclauseContext) LIKE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLIKE, 0) } func (s *TablelikeclauseContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *TablelikeclauseContext) Tablelikeoptionlist() ITablelikeoptionlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITablelikeoptionlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITablelikeoptionlistContext) } func (s *TablelikeclauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *TablelikeclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TablelikeclauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTablelikeclause(s) } } func (s *TablelikeclauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTablelikeclause(s) } } func (s *TablelikeclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTablelikeclause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Tablelikeclause() (localctx ITablelikeclauseContext) { localctx = NewTablelikeclauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 202, PostgreSQLParserRULE_tablelikeclause) p.EnterOuterAlt(localctx, 1) { p.SetState(2917) p.Match(PostgreSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2918) p.Qualified_name() } { p.SetState(2919) p.Tablelikeoptionlist() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITablelikeoptionlistContext is an interface to support dynamic dispatch. type ITablelikeoptionlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllTablelikeoption() []ITablelikeoptionContext Tablelikeoption(i int) ITablelikeoptionContext AllINCLUDING() []antlr.TerminalNode INCLUDING(i int) antlr.TerminalNode AllEXCLUDING() []antlr.TerminalNode EXCLUDING(i int) antlr.TerminalNode // IsTablelikeoptionlistContext differentiates from other interfaces. IsTablelikeoptionlistContext() } type TablelikeoptionlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTablelikeoptionlistContext() *TablelikeoptionlistContext { var p = new(TablelikeoptionlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tablelikeoptionlist return p } func InitEmptyTablelikeoptionlistContext(p *TablelikeoptionlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tablelikeoptionlist } func (*TablelikeoptionlistContext) IsTablelikeoptionlistContext() {} func NewTablelikeoptionlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablelikeoptionlistContext { var p = new(TablelikeoptionlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_tablelikeoptionlist return p } func (s *TablelikeoptionlistContext) GetParser() antlr.Parser { return s.parser } func (s *TablelikeoptionlistContext) AllTablelikeoption() []ITablelikeoptionContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITablelikeoptionContext); ok { len++ } } tst := make([]ITablelikeoptionContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITablelikeoptionContext); ok { tst[i] = t.(ITablelikeoptionContext) i++ } } return tst } func (s *TablelikeoptionlistContext) Tablelikeoption(i int) ITablelikeoptionContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITablelikeoptionContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITablelikeoptionContext) } func (s *TablelikeoptionlistContext) AllINCLUDING() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserINCLUDING) } func (s *TablelikeoptionlistContext) INCLUDING(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserINCLUDING, i) } func (s *TablelikeoptionlistContext) AllEXCLUDING() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserEXCLUDING) } func (s *TablelikeoptionlistContext) EXCLUDING(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXCLUDING, i) } func (s *TablelikeoptionlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *TablelikeoptionlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TablelikeoptionlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTablelikeoptionlist(s) } } func (s *TablelikeoptionlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTablelikeoptionlist(s) } } func (s *TablelikeoptionlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTablelikeoptionlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Tablelikeoptionlist() (localctx ITablelikeoptionlistContext) { localctx = NewTablelikeoptionlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 204, PostgreSQLParserRULE_tablelikeoptionlist) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(2925) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserEXCLUDING || _la == PostgreSQLParserINCLUDING { { p.SetState(2921) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserEXCLUDING || _la == PostgreSQLParserINCLUDING) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(2922) p.Tablelikeoption() } p.SetState(2927) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITablelikeoptionContext is an interface to support dynamic dispatch. type ITablelikeoptionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures COMMENTS() antlr.TerminalNode CONSTRAINTS() antlr.TerminalNode DEFAULTS() antlr.TerminalNode IDENTITY_P() antlr.TerminalNode GENERATED() antlr.TerminalNode INDEXES() antlr.TerminalNode STATISTICS() antlr.TerminalNode STORAGE() antlr.TerminalNode ALL() antlr.TerminalNode // IsTablelikeoptionContext differentiates from other interfaces. IsTablelikeoptionContext() } type TablelikeoptionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTablelikeoptionContext() *TablelikeoptionContext { var p = new(TablelikeoptionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tablelikeoption return p } func InitEmptyTablelikeoptionContext(p *TablelikeoptionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tablelikeoption } func (*TablelikeoptionContext) IsTablelikeoptionContext() {} func NewTablelikeoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablelikeoptionContext { var p = new(TablelikeoptionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_tablelikeoption return p } func (s *TablelikeoptionContext) GetParser() antlr.Parser { return s.parser } func (s *TablelikeoptionContext) COMMENTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMENTS, 0) } func (s *TablelikeoptionContext) CONSTRAINTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTRAINTS, 0) } func (s *TablelikeoptionContext) DEFAULTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULTS, 0) } func (s *TablelikeoptionContext) IDENTITY_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIDENTITY_P, 0) } func (s *TablelikeoptionContext) GENERATED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGENERATED, 0) } func (s *TablelikeoptionContext) INDEXES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINDEXES, 0) } func (s *TablelikeoptionContext) STATISTICS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTATISTICS, 0) } func (s *TablelikeoptionContext) STORAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTORAGE, 0) } func (s *TablelikeoptionContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *TablelikeoptionContext) GetRuleContext() antlr.RuleContext { return s } func (s *TablelikeoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TablelikeoptionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTablelikeoption(s) } } func (s *TablelikeoptionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTablelikeoption(s) } } func (s *TablelikeoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTablelikeoption(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Tablelikeoption() (localctx ITablelikeoptionContext) { localctx = NewTablelikeoptionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 206, PostgreSQLParserRULE_tablelikeoption) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2928) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserALL || ((int64((_la-160)) & ^0x3f) == 0 && ((int64(1)<<(_la-160))&576460752303947809) != 0) || _la == PostgreSQLParserINDEXES || _la == PostgreSQLParserSTATISTICS || _la == PostgreSQLParserSTORAGE || _la == PostgreSQLParserGENERATED) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITableconstraintContext is an interface to support dynamic dispatch. type ITableconstraintContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CONSTRAINT() antlr.TerminalNode Name() INameContext Constraintelem() IConstraintelemContext // IsTableconstraintContext differentiates from other interfaces. IsTableconstraintContext() } type TableconstraintContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTableconstraintContext() *TableconstraintContext { var p = new(TableconstraintContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tableconstraint return p } func InitEmptyTableconstraintContext(p *TableconstraintContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tableconstraint } func (*TableconstraintContext) IsTableconstraintContext() {} func NewTableconstraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableconstraintContext { var p = new(TableconstraintContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_tableconstraint return p } func (s *TableconstraintContext) GetParser() antlr.Parser { return s.parser } func (s *TableconstraintContext) CONSTRAINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTRAINT, 0) } func (s *TableconstraintContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *TableconstraintContext) Constraintelem() IConstraintelemContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstraintelemContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstraintelemContext) } func (s *TableconstraintContext) GetRuleContext() antlr.RuleContext { return s } func (s *TableconstraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TableconstraintContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTableconstraint(s) } } func (s *TableconstraintContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTableconstraint(s) } } func (s *TableconstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTableconstraint(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Tableconstraint() (localctx ITableconstraintContext) { localctx = NewTableconstraintContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 208, PostgreSQLParserRULE_tableconstraint) p.SetState(2935) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCONSTRAINT: p.EnterOuterAlt(localctx, 1) { p.SetState(2930) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2931) p.Name() } { p.SetState(2932) p.Constraintelem() } case PostgreSQLParserCHECK, PostgreSQLParserFOREIGN, PostgreSQLParserPRIMARY, PostgreSQLParserUNIQUE, PostgreSQLParserEXCLUDE: p.EnterOuterAlt(localctx, 2) { p.SetState(2934) p.Constraintelem() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IConstraintelemContext is an interface to support dynamic dispatch. type IConstraintelemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CHECK() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode A_expr() IA_exprContext CLOSE_PAREN() antlr.TerminalNode Constraintattributespec() IConstraintattributespecContext UNIQUE() antlr.TerminalNode Columnlist() IColumnlistContext Opt_c_include() IOpt_c_includeContext Opt_definition() IOpt_definitionContext Optconstablespace() IOptconstablespaceContext Existingindex() IExistingindexContext PRIMARY() antlr.TerminalNode KEY() antlr.TerminalNode EXCLUDE() antlr.TerminalNode Access_method_clause() IAccess_method_clauseContext Exclusionconstraintlist() IExclusionconstraintlistContext Exclusionwhereclause() IExclusionwhereclauseContext FOREIGN() antlr.TerminalNode REFERENCES() antlr.TerminalNode Qualified_name() IQualified_nameContext Opt_column_list() IOpt_column_listContext Key_match() IKey_matchContext Key_actions() IKey_actionsContext // IsConstraintelemContext differentiates from other interfaces. IsConstraintelemContext() } type ConstraintelemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyConstraintelemContext() *ConstraintelemContext { var p = new(ConstraintelemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constraintelem return p } func InitEmptyConstraintelemContext(p *ConstraintelemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constraintelem } func (*ConstraintelemContext) IsConstraintelemContext() {} func NewConstraintelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintelemContext { var p = new(ConstraintelemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_constraintelem return p } func (s *ConstraintelemContext) GetParser() antlr.Parser { return s.parser } func (s *ConstraintelemContext) CHECK() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHECK, 0) } func (s *ConstraintelemContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *ConstraintelemContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *ConstraintelemContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *ConstraintelemContext) Constraintattributespec() IConstraintattributespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstraintattributespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstraintattributespecContext) } func (s *ConstraintelemContext) UNIQUE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNIQUE, 0) } func (s *ConstraintelemContext) Columnlist() IColumnlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColumnlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColumnlistContext) } func (s *ConstraintelemContext) Opt_c_include() IOpt_c_includeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_c_includeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_c_includeContext) } func (s *ConstraintelemContext) Opt_definition() IOpt_definitionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_definitionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_definitionContext) } func (s *ConstraintelemContext) Optconstablespace() IOptconstablespaceContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptconstablespaceContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptconstablespaceContext) } func (s *ConstraintelemContext) Existingindex() IExistingindexContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExistingindexContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExistingindexContext) } func (s *ConstraintelemContext) PRIMARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRIMARY, 0) } func (s *ConstraintelemContext) KEY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserKEY, 0) } func (s *ConstraintelemContext) EXCLUDE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXCLUDE, 0) } func (s *ConstraintelemContext) Access_method_clause() IAccess_method_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAccess_method_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAccess_method_clauseContext) } func (s *ConstraintelemContext) Exclusionconstraintlist() IExclusionconstraintlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExclusionconstraintlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExclusionconstraintlistContext) } func (s *ConstraintelemContext) Exclusionwhereclause() IExclusionwhereclauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExclusionwhereclauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExclusionwhereclauseContext) } func (s *ConstraintelemContext) FOREIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREIGN, 0) } func (s *ConstraintelemContext) REFERENCES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREFERENCES, 0) } func (s *ConstraintelemContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *ConstraintelemContext) Opt_column_list() IOpt_column_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_column_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_column_listContext) } func (s *ConstraintelemContext) Key_match() IKey_matchContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IKey_matchContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IKey_matchContext) } func (s *ConstraintelemContext) Key_actions() IKey_actionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IKey_actionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IKey_actionsContext) } func (s *ConstraintelemContext) GetRuleContext() antlr.RuleContext { return s } func (s *ConstraintelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ConstraintelemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterConstraintelem(s) } } func (s *ConstraintelemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitConstraintelem(s) } } func (s *ConstraintelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitConstraintelem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Constraintelem() (localctx IConstraintelemContext) { localctx = NewConstraintelemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 210, PostgreSQLParserRULE_constraintelem) p.SetState(2995) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCHECK: p.EnterOuterAlt(localctx, 1) { p.SetState(2937) p.Match(PostgreSQLParserCHECK) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2938) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2939) p.A_expr() } { p.SetState(2940) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2941) p.Constraintattributespec() } case PostgreSQLParserUNIQUE: p.EnterOuterAlt(localctx, 2) { p.SetState(2943) p.Match(PostgreSQLParserUNIQUE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2955) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN: { p.SetState(2944) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2945) p.Columnlist() } { p.SetState(2946) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2947) p.Opt_c_include() } { p.SetState(2948) p.Opt_definition() } { p.SetState(2949) p.Optconstablespace() } { p.SetState(2950) p.Constraintattributespec() } case PostgreSQLParserUSING: { p.SetState(2952) p.Existingindex() } { p.SetState(2953) p.Constraintattributespec() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case PostgreSQLParserPRIMARY: p.EnterOuterAlt(localctx, 3) { p.SetState(2957) p.Match(PostgreSQLParserPRIMARY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2958) p.Match(PostgreSQLParserKEY) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(2970) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN: { p.SetState(2959) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2960) p.Columnlist() } { p.SetState(2961) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2962) p.Opt_c_include() } { p.SetState(2963) p.Opt_definition() } { p.SetState(2964) p.Optconstablespace() } { p.SetState(2965) p.Constraintattributespec() } case PostgreSQLParserUSING: { p.SetState(2967) p.Existingindex() } { p.SetState(2968) p.Constraintattributespec() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case PostgreSQLParserEXCLUDE: p.EnterOuterAlt(localctx, 4) { p.SetState(2972) p.Match(PostgreSQLParserEXCLUDE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2973) p.Access_method_clause() } { p.SetState(2974) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2975) p.Exclusionconstraintlist() } { p.SetState(2976) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2977) p.Opt_c_include() } { p.SetState(2978) p.Opt_definition() } { p.SetState(2979) p.Optconstablespace() } { p.SetState(2980) p.Exclusionwhereclause() } { p.SetState(2981) p.Constraintattributespec() } case PostgreSQLParserFOREIGN: p.EnterOuterAlt(localctx, 5) { p.SetState(2983) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2984) p.Match(PostgreSQLParserKEY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2985) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2986) p.Columnlist() } { p.SetState(2987) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2988) p.Match(PostgreSQLParserREFERENCES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2989) p.Qualified_name() } { p.SetState(2990) p.Opt_column_list() } { p.SetState(2991) p.Key_match() } { p.SetState(2992) p.Key_actions() } { p.SetState(2993) p.Constraintattributespec() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_no_inheritContext is an interface to support dynamic dispatch. type IOpt_no_inheritContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NO() antlr.TerminalNode INHERIT() antlr.TerminalNode // IsOpt_no_inheritContext differentiates from other interfaces. IsOpt_no_inheritContext() } type Opt_no_inheritContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_no_inheritContext() *Opt_no_inheritContext { var p = new(Opt_no_inheritContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_no_inherit return p } func InitEmptyOpt_no_inheritContext(p *Opt_no_inheritContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_no_inherit } func (*Opt_no_inheritContext) IsOpt_no_inheritContext() {} func NewOpt_no_inheritContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_no_inheritContext { var p = new(Opt_no_inheritContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_no_inherit return p } func (s *Opt_no_inheritContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_no_inheritContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Opt_no_inheritContext) INHERIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINHERIT, 0) } func (s *Opt_no_inheritContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_no_inheritContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_no_inheritContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_no_inherit(s) } } func (s *Opt_no_inheritContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_no_inherit(s) } } func (s *Opt_no_inheritContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_no_inherit(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_no_inherit() (localctx IOpt_no_inheritContext) { localctx = NewOpt_no_inheritContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 212, PostgreSQLParserRULE_opt_no_inherit) p.SetState(3000) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserNO: p.EnterOuterAlt(localctx, 1) { p.SetState(2997) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(2998) p.Match(PostgreSQLParserINHERIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserDEFAULT, PostgreSQLParserDEFERRABLE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINITIALLY, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserPRIMARY, PostgreSQLParserREFERENCES, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUNIQUE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserGENERATED, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_column_listContext is an interface to support dynamic dispatch. type IOpt_column_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Columnlist() IColumnlistContext CLOSE_PAREN() antlr.TerminalNode // IsOpt_column_listContext differentiates from other interfaces. IsOpt_column_listContext() } type Opt_column_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_column_listContext() *Opt_column_listContext { var p = new(Opt_column_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_column_list return p } func InitEmptyOpt_column_listContext(p *Opt_column_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_column_list } func (*Opt_column_listContext) IsOpt_column_listContext() {} func NewOpt_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_column_listContext { var p = new(Opt_column_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_column_list return p } func (s *Opt_column_listContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_column_listContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Opt_column_listContext) Columnlist() IColumnlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColumnlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColumnlistContext) } func (s *Opt_column_listContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Opt_column_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_column_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_column_list(s) } } func (s *Opt_column_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_column_list(s) } } func (s *Opt_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_column_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_column_list() (localctx IOpt_column_listContext) { localctx = NewOpt_column_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 214, PostgreSQLParserRULE_opt_column_list) p.SetState(3007) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 103, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3002) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3003) p.Columnlist() } { p.SetState(3004) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IColumnlistContext is an interface to support dynamic dispatch. type IColumnlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllColumnElem() []IColumnElemContext ColumnElem(i int) IColumnElemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsColumnlistContext differentiates from other interfaces. IsColumnlistContext() } type ColumnlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyColumnlistContext() *ColumnlistContext { var p = new(ColumnlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_columnlist return p } func InitEmptyColumnlistContext(p *ColumnlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_columnlist } func (*ColumnlistContext) IsColumnlistContext() {} func NewColumnlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnlistContext { var p = new(ColumnlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_columnlist return p } func (s *ColumnlistContext) GetParser() antlr.Parser { return s.parser } func (s *ColumnlistContext) AllColumnElem() []IColumnElemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IColumnElemContext); ok { len++ } } tst := make([]IColumnElemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IColumnElemContext); ok { tst[i] = t.(IColumnElemContext) i++ } } return tst } func (s *ColumnlistContext) ColumnElem(i int) IColumnElemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColumnElemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IColumnElemContext) } func (s *ColumnlistContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *ColumnlistContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *ColumnlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *ColumnlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ColumnlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterColumnlist(s) } } func (s *ColumnlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitColumnlist(s) } } func (s *ColumnlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitColumnlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Columnlist() (localctx IColumnlistContext) { localctx = NewColumnlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 216, PostgreSQLParserRULE_columnlist) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3009) p.ColumnElem() } p.SetState(3014) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(3010) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3011) p.ColumnElem() } p.SetState(3016) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IColumnElemContext is an interface to support dynamic dispatch. type IColumnElemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext // IsColumnElemContext differentiates from other interfaces. IsColumnElemContext() } type ColumnElemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyColumnElemContext() *ColumnElemContext { var p = new(ColumnElemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_columnElem return p } func InitEmptyColumnElemContext(p *ColumnElemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_columnElem } func (*ColumnElemContext) IsColumnElemContext() {} func NewColumnElemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnElemContext { var p = new(ColumnElemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_columnElem return p } func (s *ColumnElemContext) GetParser() antlr.Parser { return s.parser } func (s *ColumnElemContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *ColumnElemContext) GetRuleContext() antlr.RuleContext { return s } func (s *ColumnElemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ColumnElemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterColumnElem(s) } } func (s *ColumnElemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitColumnElem(s) } } func (s *ColumnElemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitColumnElem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) ColumnElem() (localctx IColumnElemContext) { localctx = NewColumnElemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 218, PostgreSQLParserRULE_columnElem) p.EnterOuterAlt(localctx, 1) { p.SetState(3017) p.Colid() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_c_includeContext is an interface to support dynamic dispatch. type IOpt_c_includeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures INCLUDE() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Columnlist() IColumnlistContext CLOSE_PAREN() antlr.TerminalNode // IsOpt_c_includeContext differentiates from other interfaces. IsOpt_c_includeContext() } type Opt_c_includeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_c_includeContext() *Opt_c_includeContext { var p = new(Opt_c_includeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_c_include return p } func InitEmptyOpt_c_includeContext(p *Opt_c_includeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_c_include } func (*Opt_c_includeContext) IsOpt_c_includeContext() {} func NewOpt_c_includeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_c_includeContext { var p = new(Opt_c_includeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_c_include return p } func (s *Opt_c_includeContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_c_includeContext) INCLUDE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINCLUDE, 0) } func (s *Opt_c_includeContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Opt_c_includeContext) Columnlist() IColumnlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColumnlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColumnlistContext) } func (s *Opt_c_includeContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Opt_c_includeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_c_includeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_c_includeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_c_include(s) } } func (s *Opt_c_includeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_c_include(s) } } func (s *Opt_c_includeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_c_include(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_c_include() (localctx IOpt_c_includeContext) { localctx = NewOpt_c_includeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 220, PostgreSQLParserRULE_opt_c_include) p.SetState(3025) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserINCLUDE: p.EnterOuterAlt(localctx, 1) { p.SetState(3019) p.Match(PostgreSQLParserINCLUDE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3020) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3021) p.Columnlist() } { p.SetState(3022) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDEFERRABLE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINITIALLY, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUSING, PostgreSQLParserWHERE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNO, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IKey_matchContext is an interface to support dynamic dispatch. type IKey_matchContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures MATCH() antlr.TerminalNode FULL() antlr.TerminalNode PARTIAL() antlr.TerminalNode SIMPLE() antlr.TerminalNode // IsKey_matchContext differentiates from other interfaces. IsKey_matchContext() } type Key_matchContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyKey_matchContext() *Key_matchContext { var p = new(Key_matchContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_key_match return p } func InitEmptyKey_matchContext(p *Key_matchContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_key_match } func (*Key_matchContext) IsKey_matchContext() {} func NewKey_matchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_matchContext { var p = new(Key_matchContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_key_match return p } func (s *Key_matchContext) GetParser() antlr.Parser { return s.parser } func (s *Key_matchContext) MATCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMATCH, 0) } func (s *Key_matchContext) FULL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFULL, 0) } func (s *Key_matchContext) PARTIAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARTIAL, 0) } func (s *Key_matchContext) SIMPLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSIMPLE, 0) } func (s *Key_matchContext) GetRuleContext() antlr.RuleContext { return s } func (s *Key_matchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Key_matchContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterKey_match(s) } } func (s *Key_matchContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitKey_match(s) } } func (s *Key_matchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitKey_match(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Key_match() (localctx IKey_matchContext) { localctx = NewKey_matchContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 222, PostgreSQLParserRULE_key_match) var _la int p.SetState(3030) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserMATCH: p.EnterOuterAlt(localctx, 1) { p.SetState(3027) p.Match(PostgreSQLParserMATCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3028) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserFULL || _la == PostgreSQLParserPARTIAL || _la == PostgreSQLParserSIMPLE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserDEFAULT, PostgreSQLParserDEFERRABLE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINITIALLY, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserON, PostgreSQLParserPRIMARY, PostgreSQLParserREFERENCES, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUNIQUE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNO, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserGENERATED, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExclusionconstraintlistContext is an interface to support dynamic dispatch. type IExclusionconstraintlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllExclusionconstraintelem() []IExclusionconstraintelemContext Exclusionconstraintelem(i int) IExclusionconstraintelemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsExclusionconstraintlistContext differentiates from other interfaces. IsExclusionconstraintlistContext() } type ExclusionconstraintlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExclusionconstraintlistContext() *ExclusionconstraintlistContext { var p = new(ExclusionconstraintlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_exclusionconstraintlist return p } func InitEmptyExclusionconstraintlistContext(p *ExclusionconstraintlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_exclusionconstraintlist } func (*ExclusionconstraintlistContext) IsExclusionconstraintlistContext() {} func NewExclusionconstraintlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExclusionconstraintlistContext { var p = new(ExclusionconstraintlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_exclusionconstraintlist return p } func (s *ExclusionconstraintlistContext) GetParser() antlr.Parser { return s.parser } func (s *ExclusionconstraintlistContext) AllExclusionconstraintelem() []IExclusionconstraintelemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IExclusionconstraintelemContext); ok { len++ } } tst := make([]IExclusionconstraintelemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IExclusionconstraintelemContext); ok { tst[i] = t.(IExclusionconstraintelemContext) i++ } } return tst } func (s *ExclusionconstraintlistContext) Exclusionconstraintelem(i int) IExclusionconstraintelemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExclusionconstraintelemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IExclusionconstraintelemContext) } func (s *ExclusionconstraintlistContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *ExclusionconstraintlistContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *ExclusionconstraintlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *ExclusionconstraintlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ExclusionconstraintlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExclusionconstraintlist(s) } } func (s *ExclusionconstraintlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExclusionconstraintlist(s) } } func (s *ExclusionconstraintlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExclusionconstraintlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Exclusionconstraintlist() (localctx IExclusionconstraintlistContext) { localctx = NewExclusionconstraintlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 224, PostgreSQLParserRULE_exclusionconstraintlist) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3032) p.Exclusionconstraintelem() } p.SetState(3037) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(3033) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3034) p.Exclusionconstraintelem() } p.SetState(3039) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExclusionconstraintelemContext is an interface to support dynamic dispatch. type IExclusionconstraintelemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Index_elem() IIndex_elemContext WITH() antlr.TerminalNode Any_operator() IAny_operatorContext OPERATOR() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode CLOSE_PAREN() antlr.TerminalNode // IsExclusionconstraintelemContext differentiates from other interfaces. IsExclusionconstraintelemContext() } type ExclusionconstraintelemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExclusionconstraintelemContext() *ExclusionconstraintelemContext { var p = new(ExclusionconstraintelemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_exclusionconstraintelem return p } func InitEmptyExclusionconstraintelemContext(p *ExclusionconstraintelemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_exclusionconstraintelem } func (*ExclusionconstraintelemContext) IsExclusionconstraintelemContext() {} func NewExclusionconstraintelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExclusionconstraintelemContext { var p = new(ExclusionconstraintelemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_exclusionconstraintelem return p } func (s *ExclusionconstraintelemContext) GetParser() antlr.Parser { return s.parser } func (s *ExclusionconstraintelemContext) Index_elem() IIndex_elemContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndex_elemContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIndex_elemContext) } func (s *ExclusionconstraintelemContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *ExclusionconstraintelemContext) Any_operator() IAny_operatorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_operatorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_operatorContext) } func (s *ExclusionconstraintelemContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *ExclusionconstraintelemContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *ExclusionconstraintelemContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *ExclusionconstraintelemContext) GetRuleContext() antlr.RuleContext { return s } func (s *ExclusionconstraintelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ExclusionconstraintelemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExclusionconstraintelem(s) } } func (s *ExclusionconstraintelemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExclusionconstraintelem(s) } } func (s *ExclusionconstraintelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExclusionconstraintelem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Exclusionconstraintelem() (localctx IExclusionconstraintelemContext) { localctx = NewExclusionconstraintelemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 226, PostgreSQLParserRULE_exclusionconstraintelem) p.EnterOuterAlt(localctx, 1) { p.SetState(3040) p.Index_elem() } { p.SetState(3041) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(3048) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 108, p.GetParserRuleContext()) { case 1: { p.SetState(3042) p.Any_operator() } case 2: { p.SetState(3043) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3044) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3045) p.Any_operator() } { p.SetState(3046) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExclusionwhereclauseContext is an interface to support dynamic dispatch. type IExclusionwhereclauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WHERE() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode A_expr() IA_exprContext CLOSE_PAREN() antlr.TerminalNode // IsExclusionwhereclauseContext differentiates from other interfaces. IsExclusionwhereclauseContext() } type ExclusionwhereclauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExclusionwhereclauseContext() *ExclusionwhereclauseContext { var p = new(ExclusionwhereclauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_exclusionwhereclause return p } func InitEmptyExclusionwhereclauseContext(p *ExclusionwhereclauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_exclusionwhereclause } func (*ExclusionwhereclauseContext) IsExclusionwhereclauseContext() {} func NewExclusionwhereclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExclusionwhereclauseContext { var p = new(ExclusionwhereclauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_exclusionwhereclause return p } func (s *ExclusionwhereclauseContext) GetParser() antlr.Parser { return s.parser } func (s *ExclusionwhereclauseContext) WHERE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHERE, 0) } func (s *ExclusionwhereclauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *ExclusionwhereclauseContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *ExclusionwhereclauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *ExclusionwhereclauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *ExclusionwhereclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ExclusionwhereclauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExclusionwhereclause(s) } } func (s *ExclusionwhereclauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExclusionwhereclause(s) } } func (s *ExclusionwhereclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExclusionwhereclause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Exclusionwhereclause() (localctx IExclusionwhereclauseContext) { localctx = NewExclusionwhereclauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 228, PostgreSQLParserRULE_exclusionwhereclause) p.SetState(3056) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserWHERE: p.EnterOuterAlt(localctx, 1) { p.SetState(3050) p.Match(PostgreSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3051) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3052) p.A_expr() } { p.SetState(3053) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDEFERRABLE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINITIALLY, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNO, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IKey_actionsContext is an interface to support dynamic dispatch. type IKey_actionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Key_update() IKey_updateContext Key_delete() IKey_deleteContext // IsKey_actionsContext differentiates from other interfaces. IsKey_actionsContext() } type Key_actionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyKey_actionsContext() *Key_actionsContext { var p = new(Key_actionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_key_actions return p } func InitEmptyKey_actionsContext(p *Key_actionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_key_actions } func (*Key_actionsContext) IsKey_actionsContext() {} func NewKey_actionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_actionsContext { var p = new(Key_actionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_key_actions return p } func (s *Key_actionsContext) GetParser() antlr.Parser { return s.parser } func (s *Key_actionsContext) Key_update() IKey_updateContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IKey_updateContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IKey_updateContext) } func (s *Key_actionsContext) Key_delete() IKey_deleteContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IKey_deleteContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IKey_deleteContext) } func (s *Key_actionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Key_actionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Key_actionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterKey_actions(s) } } func (s *Key_actionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitKey_actions(s) } } func (s *Key_actionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitKey_actions(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Key_actions() (localctx IKey_actionsContext) { localctx = NewKey_actionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 230, PostgreSQLParserRULE_key_actions) p.SetState(3067) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 110, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3058) p.Key_update() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(3059) p.Key_delete() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(3060) p.Key_update() } { p.SetState(3061) p.Key_delete() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(3063) p.Key_delete() } { p.SetState(3064) p.Key_update() } case 5: p.EnterOuterAlt(localctx, 5) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IKey_updateContext is an interface to support dynamic dispatch. type IKey_updateContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ON() antlr.TerminalNode UPDATE() antlr.TerminalNode Key_action() IKey_actionContext // IsKey_updateContext differentiates from other interfaces. IsKey_updateContext() } type Key_updateContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyKey_updateContext() *Key_updateContext { var p = new(Key_updateContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_key_update return p } func InitEmptyKey_updateContext(p *Key_updateContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_key_update } func (*Key_updateContext) IsKey_updateContext() {} func NewKey_updateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_updateContext { var p = new(Key_updateContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_key_update return p } func (s *Key_updateContext) GetParser() antlr.Parser { return s.parser } func (s *Key_updateContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *Key_updateContext) UPDATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUPDATE, 0) } func (s *Key_updateContext) Key_action() IKey_actionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IKey_actionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IKey_actionContext) } func (s *Key_updateContext) GetRuleContext() antlr.RuleContext { return s } func (s *Key_updateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Key_updateContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterKey_update(s) } } func (s *Key_updateContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitKey_update(s) } } func (s *Key_updateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitKey_update(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Key_update() (localctx IKey_updateContext) { localctx = NewKey_updateContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 232, PostgreSQLParserRULE_key_update) p.EnterOuterAlt(localctx, 1) { p.SetState(3069) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3070) p.Match(PostgreSQLParserUPDATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3071) p.Key_action() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IKey_deleteContext is an interface to support dynamic dispatch. type IKey_deleteContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ON() antlr.TerminalNode DELETE_P() antlr.TerminalNode Key_action() IKey_actionContext // IsKey_deleteContext differentiates from other interfaces. IsKey_deleteContext() } type Key_deleteContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyKey_deleteContext() *Key_deleteContext { var p = new(Key_deleteContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_key_delete return p } func InitEmptyKey_deleteContext(p *Key_deleteContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_key_delete } func (*Key_deleteContext) IsKey_deleteContext() {} func NewKey_deleteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_deleteContext { var p = new(Key_deleteContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_key_delete return p } func (s *Key_deleteContext) GetParser() antlr.Parser { return s.parser } func (s *Key_deleteContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *Key_deleteContext) DELETE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDELETE_P, 0) } func (s *Key_deleteContext) Key_action() IKey_actionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IKey_actionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IKey_actionContext) } func (s *Key_deleteContext) GetRuleContext() antlr.RuleContext { return s } func (s *Key_deleteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Key_deleteContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterKey_delete(s) } } func (s *Key_deleteContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitKey_delete(s) } } func (s *Key_deleteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitKey_delete(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Key_delete() (localctx IKey_deleteContext) { localctx = NewKey_deleteContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 234, PostgreSQLParserRULE_key_delete) p.EnterOuterAlt(localctx, 1) { p.SetState(3073) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3074) p.Match(PostgreSQLParserDELETE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3075) p.Key_action() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IKey_actionContext is an interface to support dynamic dispatch. type IKey_actionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NO() antlr.TerminalNode ACTION() antlr.TerminalNode RESTRICT() antlr.TerminalNode CASCADE() antlr.TerminalNode SET() antlr.TerminalNode NULL_P() antlr.TerminalNode DEFAULT() antlr.TerminalNode // IsKey_actionContext differentiates from other interfaces. IsKey_actionContext() } type Key_actionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyKey_actionContext() *Key_actionContext { var p = new(Key_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_key_action return p } func InitEmptyKey_actionContext(p *Key_actionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_key_action } func (*Key_actionContext) IsKey_actionContext() {} func NewKey_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_actionContext { var p = new(Key_actionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_key_action return p } func (s *Key_actionContext) GetParser() antlr.Parser { return s.parser } func (s *Key_actionContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Key_actionContext) ACTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserACTION, 0) } func (s *Key_actionContext) RESTRICT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESTRICT, 0) } func (s *Key_actionContext) CASCADE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCASCADE, 0) } func (s *Key_actionContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *Key_actionContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *Key_actionContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Key_actionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Key_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Key_actionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterKey_action(s) } } func (s *Key_actionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitKey_action(s) } } func (s *Key_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitKey_action(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Key_action() (localctx IKey_actionContext) { localctx = NewKey_actionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 236, PostgreSQLParserRULE_key_action) var _la int p.SetState(3083) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserNO: p.EnterOuterAlt(localctx, 1) { p.SetState(3077) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3078) p.Match(PostgreSQLParserACTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserRESTRICT: p.EnterOuterAlt(localctx, 2) { p.SetState(3079) p.Match(PostgreSQLParserRESTRICT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserCASCADE: p.EnterOuterAlt(localctx, 3) { p.SetState(3080) p.Match(PostgreSQLParserCASCADE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSET: p.EnterOuterAlt(localctx, 4) { p.SetState(3081) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3082) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserDEFAULT || _la == PostgreSQLParserNULL_P) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOptinheritContext is an interface to support dynamic dispatch. type IOptinheritContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures INHERITS() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Qualified_name_list() IQualified_name_listContext CLOSE_PAREN() antlr.TerminalNode // IsOptinheritContext differentiates from other interfaces. IsOptinheritContext() } type OptinheritContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOptinheritContext() *OptinheritContext { var p = new(OptinheritContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optinherit return p } func InitEmptyOptinheritContext(p *OptinheritContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optinherit } func (*OptinheritContext) IsOptinheritContext() {} func NewOptinheritContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptinheritContext { var p = new(OptinheritContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_optinherit return p } func (s *OptinheritContext) GetParser() antlr.Parser { return s.parser } func (s *OptinheritContext) INHERITS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINHERITS, 0) } func (s *OptinheritContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *OptinheritContext) Qualified_name_list() IQualified_name_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_name_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_name_listContext) } func (s *OptinheritContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *OptinheritContext) GetRuleContext() antlr.RuleContext { return s } func (s *OptinheritContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OptinheritContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOptinherit(s) } } func (s *OptinheritContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOptinherit(s) } } func (s *OptinheritContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOptinherit(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Optinherit() (localctx IOptinheritContext) { localctx = NewOptinheritContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 238, PostgreSQLParserRULE_optinherit) p.SetState(3091) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserINHERITS: p.EnterOuterAlt(localctx, 1) { p.SetState(3085) p.Match(PostgreSQLParserINHERITS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3086) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3087) p.Qualified_name_list() } { p.SetState(3088) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserON, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUSING, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPARTITION, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSERVER, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTABLESPACE, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserWITHOUT, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOptpartitionspecContext is an interface to support dynamic dispatch. type IOptpartitionspecContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Partitionspec() IPartitionspecContext // IsOptpartitionspecContext differentiates from other interfaces. IsOptpartitionspecContext() } type OptpartitionspecContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOptpartitionspecContext() *OptpartitionspecContext { var p = new(OptpartitionspecContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optpartitionspec return p } func InitEmptyOptpartitionspecContext(p *OptpartitionspecContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optpartitionspec } func (*OptpartitionspecContext) IsOptpartitionspecContext() {} func NewOptpartitionspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptpartitionspecContext { var p = new(OptpartitionspecContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_optpartitionspec return p } func (s *OptpartitionspecContext) GetParser() antlr.Parser { return s.parser } func (s *OptpartitionspecContext) Partitionspec() IPartitionspecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPartitionspecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPartitionspecContext) } func (s *OptpartitionspecContext) GetRuleContext() antlr.RuleContext { return s } func (s *OptpartitionspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OptpartitionspecContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOptpartitionspec(s) } } func (s *OptpartitionspecContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOptpartitionspec(s) } } func (s *OptpartitionspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOptpartitionspec(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Optpartitionspec() (localctx IOptpartitionspecContext) { localctx = NewOptpartitionspecContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 240, PostgreSQLParserRULE_optpartitionspec) p.SetState(3095) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserPARTITION: p.EnterOuterAlt(localctx, 1) { p.SetState(3093) p.Partitionspec() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserON, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUSING, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTABLESPACE, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserWITHOUT, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPartitionspecContext is an interface to support dynamic dispatch. type IPartitionspecContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures PARTITION() antlr.TerminalNode BY() antlr.TerminalNode Colid() IColidContext OPEN_PAREN() antlr.TerminalNode Part_params() IPart_paramsContext CLOSE_PAREN() antlr.TerminalNode // IsPartitionspecContext differentiates from other interfaces. IsPartitionspecContext() } type PartitionspecContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPartitionspecContext() *PartitionspecContext { var p = new(PartitionspecContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_partitionspec return p } func InitEmptyPartitionspecContext(p *PartitionspecContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_partitionspec } func (*PartitionspecContext) IsPartitionspecContext() {} func NewPartitionspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionspecContext { var p = new(PartitionspecContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_partitionspec return p } func (s *PartitionspecContext) GetParser() antlr.Parser { return s.parser } func (s *PartitionspecContext) PARTITION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARTITION, 0) } func (s *PartitionspecContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *PartitionspecContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *PartitionspecContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *PartitionspecContext) Part_params() IPart_paramsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPart_paramsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPart_paramsContext) } func (s *PartitionspecContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *PartitionspecContext) GetRuleContext() antlr.RuleContext { return s } func (s *PartitionspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *PartitionspecContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPartitionspec(s) } } func (s *PartitionspecContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPartitionspec(s) } } func (s *PartitionspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPartitionspec(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Partitionspec() (localctx IPartitionspecContext) { localctx = NewPartitionspecContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 242, PostgreSQLParserRULE_partitionspec) p.EnterOuterAlt(localctx, 1) { p.SetState(3097) p.Match(PostgreSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3098) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3099) p.Colid() } { p.SetState(3100) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3101) p.Part_params() } { p.SetState(3102) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPart_paramsContext is an interface to support dynamic dispatch. type IPart_paramsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllPart_elem() []IPart_elemContext Part_elem(i int) IPart_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsPart_paramsContext differentiates from other interfaces. IsPart_paramsContext() } type Part_paramsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPart_paramsContext() *Part_paramsContext { var p = new(Part_paramsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_part_params return p } func InitEmptyPart_paramsContext(p *Part_paramsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_part_params } func (*Part_paramsContext) IsPart_paramsContext() {} func NewPart_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Part_paramsContext { var p = new(Part_paramsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_part_params return p } func (s *Part_paramsContext) GetParser() antlr.Parser { return s.parser } func (s *Part_paramsContext) AllPart_elem() []IPart_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IPart_elemContext); ok { len++ } } tst := make([]IPart_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IPart_elemContext); ok { tst[i] = t.(IPart_elemContext) i++ } } return tst } func (s *Part_paramsContext) Part_elem(i int) IPart_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPart_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IPart_elemContext) } func (s *Part_paramsContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Part_paramsContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Part_paramsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Part_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Part_paramsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPart_params(s) } } func (s *Part_paramsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPart_params(s) } } func (s *Part_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPart_params(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Part_params() (localctx IPart_paramsContext) { localctx = NewPart_paramsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 244, PostgreSQLParserRULE_part_params) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3104) p.Part_elem() } p.SetState(3109) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(3105) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3106) p.Part_elem() } p.SetState(3111) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPart_elemContext is an interface to support dynamic dispatch. type IPart_elemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext Opt_collate() IOpt_collateContext Opt_class() IOpt_classContext Func_expr_windowless() IFunc_expr_windowlessContext OPEN_PAREN() antlr.TerminalNode A_expr() IA_exprContext CLOSE_PAREN() antlr.TerminalNode // IsPart_elemContext differentiates from other interfaces. IsPart_elemContext() } type Part_elemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPart_elemContext() *Part_elemContext { var p = new(Part_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_part_elem return p } func InitEmptyPart_elemContext(p *Part_elemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_part_elem } func (*Part_elemContext) IsPart_elemContext() {} func NewPart_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Part_elemContext { var p = new(Part_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_part_elem return p } func (s *Part_elemContext) GetParser() antlr.Parser { return s.parser } func (s *Part_elemContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Part_elemContext) Opt_collate() IOpt_collateContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_collateContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_collateContext) } func (s *Part_elemContext) Opt_class() IOpt_classContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_classContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_classContext) } func (s *Part_elemContext) Func_expr_windowless() IFunc_expr_windowlessContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_expr_windowlessContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_expr_windowlessContext) } func (s *Part_elemContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Part_elemContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Part_elemContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Part_elemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Part_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Part_elemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPart_elem(s) } } func (s *Part_elemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPart_elem(s) } } func (s *Part_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPart_elem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Part_elem() (localctx IPart_elemContext) { localctx = NewPart_elemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 246, PostgreSQLParserRULE_part_elem) p.SetState(3126) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 115, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3112) p.Colid() } { p.SetState(3113) p.Opt_collate() } { p.SetState(3114) p.Opt_class() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(3116) p.Func_expr_windowless() } { p.SetState(3117) p.Opt_collate() } { p.SetState(3118) p.Opt_class() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(3120) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3121) p.A_expr() } { p.SetState(3122) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3123) p.Opt_collate() } { p.SetState(3124) p.Opt_class() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITable_access_method_clauseContext is an interface to support dynamic dispatch. type ITable_access_method_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USING() antlr.TerminalNode Name() INameContext // IsTable_access_method_clauseContext differentiates from other interfaces. IsTable_access_method_clauseContext() } type Table_access_method_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTable_access_method_clauseContext() *Table_access_method_clauseContext { var p = new(Table_access_method_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_table_access_method_clause return p } func InitEmptyTable_access_method_clauseContext(p *Table_access_method_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_table_access_method_clause } func (*Table_access_method_clauseContext) IsTable_access_method_clauseContext() {} func NewTable_access_method_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_access_method_clauseContext { var p = new(Table_access_method_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_table_access_method_clause return p } func (s *Table_access_method_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Table_access_method_clauseContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *Table_access_method_clauseContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *Table_access_method_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Table_access_method_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Table_access_method_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTable_access_method_clause(s) } } func (s *Table_access_method_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTable_access_method_clause(s) } } func (s *Table_access_method_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTable_access_method_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Table_access_method_clause() (localctx ITable_access_method_clauseContext) { localctx = NewTable_access_method_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 248, PostgreSQLParserRULE_table_access_method_clause) p.SetState(3131) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 1) { p.SetState(3128) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3129) p.Name() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAS, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserON, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTABLESPACE, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserWITHOUT, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOptwithContext is an interface to support dynamic dispatch. type IOptwithContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITH() antlr.TerminalNode Reloptions() IReloptionsContext WITHOUT() antlr.TerminalNode OIDS() antlr.TerminalNode // IsOptwithContext differentiates from other interfaces. IsOptwithContext() } type OptwithContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOptwithContext() *OptwithContext { var p = new(OptwithContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optwith return p } func InitEmptyOptwithContext(p *OptwithContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optwith } func (*OptwithContext) IsOptwithContext() {} func NewOptwithContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptwithContext { var p = new(OptwithContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_optwith return p } func (s *OptwithContext) GetParser() antlr.Parser { return s.parser } func (s *OptwithContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *OptwithContext) Reloptions() IReloptionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReloptionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReloptionsContext) } func (s *OptwithContext) WITHOUT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITHOUT, 0) } func (s *OptwithContext) OIDS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOIDS, 0) } func (s *OptwithContext) GetRuleContext() antlr.RuleContext { return s } func (s *OptwithContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OptwithContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOptwith(s) } } func (s *OptwithContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOptwith(s) } } func (s *OptwithContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOptwith(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Optwith() (localctx IOptwithContext) { localctx = NewOptwithContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 250, PostgreSQLParserRULE_optwith) p.SetState(3138) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 117, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3133) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3134) p.Reloptions() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(3135) p.Match(PostgreSQLParserWITHOUT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3136) p.Match(PostgreSQLParserOIDS) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOncommitoptionContext is an interface to support dynamic dispatch. type IOncommitoptionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ON() antlr.TerminalNode COMMIT() antlr.TerminalNode DROP() antlr.TerminalNode DELETE_P() antlr.TerminalNode ROWS() antlr.TerminalNode PRESERVE() antlr.TerminalNode // IsOncommitoptionContext differentiates from other interfaces. IsOncommitoptionContext() } type OncommitoptionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOncommitoptionContext() *OncommitoptionContext { var p = new(OncommitoptionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_oncommitoption return p } func InitEmptyOncommitoptionContext(p *OncommitoptionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_oncommitoption } func (*OncommitoptionContext) IsOncommitoptionContext() {} func NewOncommitoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OncommitoptionContext { var p = new(OncommitoptionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_oncommitoption return p } func (s *OncommitoptionContext) GetParser() antlr.Parser { return s.parser } func (s *OncommitoptionContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *OncommitoptionContext) COMMIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMIT, 0) } func (s *OncommitoptionContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *OncommitoptionContext) DELETE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDELETE_P, 0) } func (s *OncommitoptionContext) ROWS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROWS, 0) } func (s *OncommitoptionContext) PRESERVE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRESERVE, 0) } func (s *OncommitoptionContext) GetRuleContext() antlr.RuleContext { return s } func (s *OncommitoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OncommitoptionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOncommitoption(s) } } func (s *OncommitoptionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOncommitoption(s) } } func (s *OncommitoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOncommitoption(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Oncommitoption() (localctx IOncommitoptionContext) { localctx = NewOncommitoptionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 252, PostgreSQLParserRULE_oncommitoption) p.SetState(3150) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserON: p.EnterOuterAlt(localctx, 1) { p.SetState(3140) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3141) p.Match(PostgreSQLParserCOMMIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(3147) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserDROP: { p.SetState(3142) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserDELETE_P: { p.SetState(3143) p.Match(PostgreSQLParserDELETE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3144) p.Match(PostgreSQLParserROWS) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserPRESERVE: { p.SetState(3145) p.Match(PostgreSQLParserPRESERVE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3146) p.Match(PostgreSQLParserROWS) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAS, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTABLESPACE, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpttablespaceContext is an interface to support dynamic dispatch. type IOpttablespaceContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TABLESPACE() antlr.TerminalNode Name() INameContext // IsOpttablespaceContext differentiates from other interfaces. IsOpttablespaceContext() } type OpttablespaceContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpttablespaceContext() *OpttablespaceContext { var p = new(OpttablespaceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opttablespace return p } func InitEmptyOpttablespaceContext(p *OpttablespaceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opttablespace } func (*OpttablespaceContext) IsOpttablespaceContext() {} func NewOpttablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttablespaceContext { var p = new(OpttablespaceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opttablespace return p } func (s *OpttablespaceContext) GetParser() antlr.Parser { return s.parser } func (s *OpttablespaceContext) TABLESPACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, 0) } func (s *OpttablespaceContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *OpttablespaceContext) GetRuleContext() antlr.RuleContext { return s } func (s *OpttablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OpttablespaceContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpttablespace(s) } } func (s *OpttablespaceContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpttablespace(s) } } func (s *OpttablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpttablespace(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opttablespace() (localctx IOpttablespaceContext) { localctx = NewOpttablespaceContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 254, PostgreSQLParserRULE_opttablespace) p.SetState(3155) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserTABLESPACE: p.EnterOuterAlt(localctx, 1) { p.SetState(3152) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3153) p.Name() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAS, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWHERE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOptconstablespaceContext is an interface to support dynamic dispatch. type IOptconstablespaceContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USING() antlr.TerminalNode INDEX() antlr.TerminalNode TABLESPACE() antlr.TerminalNode Name() INameContext // IsOptconstablespaceContext differentiates from other interfaces. IsOptconstablespaceContext() } type OptconstablespaceContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOptconstablespaceContext() *OptconstablespaceContext { var p = new(OptconstablespaceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optconstablespace return p } func InitEmptyOptconstablespaceContext(p *OptconstablespaceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optconstablespace } func (*OptconstablespaceContext) IsOptconstablespaceContext() {} func NewOptconstablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptconstablespaceContext { var p = new(OptconstablespaceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_optconstablespace return p } func (s *OptconstablespaceContext) GetParser() antlr.Parser { return s.parser } func (s *OptconstablespaceContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *OptconstablespaceContext) INDEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINDEX, 0) } func (s *OptconstablespaceContext) TABLESPACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, 0) } func (s *OptconstablespaceContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *OptconstablespaceContext) GetRuleContext() antlr.RuleContext { return s } func (s *OptconstablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OptconstablespaceContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOptconstablespace(s) } } func (s *OptconstablespaceContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOptconstablespace(s) } } func (s *OptconstablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOptconstablespace(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Optconstablespace() (localctx IOptconstablespaceContext) { localctx = NewOptconstablespaceContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 256, PostgreSQLParserRULE_optconstablespace) p.SetState(3162) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 1) { p.SetState(3157) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3158) p.Match(PostgreSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3159) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3160) p.Name() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserDEFAULT, PostgreSQLParserDEFERRABLE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINITIALLY, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserPRIMARY, PostgreSQLParserREFERENCES, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUNIQUE, PostgreSQLParserWHERE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNO, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserGENERATED, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExistingindexContext is an interface to support dynamic dispatch. type IExistingindexContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USING() antlr.TerminalNode INDEX() antlr.TerminalNode Name() INameContext // IsExistingindexContext differentiates from other interfaces. IsExistingindexContext() } type ExistingindexContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExistingindexContext() *ExistingindexContext { var p = new(ExistingindexContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_existingindex return p } func InitEmptyExistingindexContext(p *ExistingindexContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_existingindex } func (*ExistingindexContext) IsExistingindexContext() {} func NewExistingindexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExistingindexContext { var p = new(ExistingindexContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_existingindex return p } func (s *ExistingindexContext) GetParser() antlr.Parser { return s.parser } func (s *ExistingindexContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *ExistingindexContext) INDEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINDEX, 0) } func (s *ExistingindexContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *ExistingindexContext) GetRuleContext() antlr.RuleContext { return s } func (s *ExistingindexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ExistingindexContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExistingindex(s) } } func (s *ExistingindexContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExistingindex(s) } } func (s *ExistingindexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExistingindex(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Existingindex() (localctx IExistingindexContext) { localctx = NewExistingindexContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 258, PostgreSQLParserRULE_existingindex) p.EnterOuterAlt(localctx, 1) { p.SetState(3164) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3165) p.Match(PostgreSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3166) p.Name() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatestatsstmtContext is an interface to support dynamic dispatch. type ICreatestatsstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode STATISTICS() antlr.TerminalNode Any_name() IAny_nameContext Opt_name_list() IOpt_name_listContext ON() antlr.TerminalNode Expr_list() IExpr_listContext FROM() antlr.TerminalNode From_list() IFrom_listContext IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsCreatestatsstmtContext differentiates from other interfaces. IsCreatestatsstmtContext() } type CreatestatsstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatestatsstmtContext() *CreatestatsstmtContext { var p = new(CreatestatsstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createstatsstmt return p } func InitEmptyCreatestatsstmtContext(p *CreatestatsstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createstatsstmt } func (*CreatestatsstmtContext) IsCreatestatsstmtContext() {} func NewCreatestatsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatestatsstmtContext { var p = new(CreatestatsstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createstatsstmt return p } func (s *CreatestatsstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreatestatsstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreatestatsstmtContext) STATISTICS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTATISTICS, 0) } func (s *CreatestatsstmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *CreatestatsstmtContext) Opt_name_list() IOpt_name_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_name_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_name_listContext) } func (s *CreatestatsstmtContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *CreatestatsstmtContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *CreatestatsstmtContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *CreatestatsstmtContext) From_list() IFrom_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFrom_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFrom_listContext) } func (s *CreatestatsstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *CreatestatsstmtContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *CreatestatsstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *CreatestatsstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreatestatsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreatestatsstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatestatsstmt(s) } } func (s *CreatestatsstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatestatsstmt(s) } } func (s *CreatestatsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatestatsstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createstatsstmt() (localctx ICreatestatsstmtContext) { localctx = NewCreatestatsstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 260, PostgreSQLParserRULE_createstatsstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3168) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3169) p.Match(PostgreSQLParserSTATISTICS) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(3173) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 122, p.GetParserRuleContext()) == 1 { { p.SetState(3170) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3171) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3172) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(3175) p.Any_name() } { p.SetState(3176) p.Opt_name_list() } { p.SetState(3177) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3178) p.Expr_list() } { p.SetState(3179) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3180) p.From_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterstatsstmtContext is an interface to support dynamic dispatch. type IAlterstatsstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode AllSTATISTICS() []antlr.TerminalNode STATISTICS(i int) antlr.TerminalNode Any_name() IAny_nameContext SET() antlr.TerminalNode Signediconst() ISignediconstContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsAlterstatsstmtContext differentiates from other interfaces. IsAlterstatsstmtContext() } type AlterstatsstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterstatsstmtContext() *AlterstatsstmtContext { var p = new(AlterstatsstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterstatsstmt return p } func InitEmptyAlterstatsstmtContext(p *AlterstatsstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterstatsstmt } func (*AlterstatsstmtContext) IsAlterstatsstmtContext() {} func NewAlterstatsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterstatsstmtContext { var p = new(AlterstatsstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterstatsstmt return p } func (s *AlterstatsstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterstatsstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterstatsstmtContext) AllSTATISTICS() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserSTATISTICS) } func (s *AlterstatsstmtContext) STATISTICS(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTATISTICS, i) } func (s *AlterstatsstmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *AlterstatsstmtContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *AlterstatsstmtContext) Signediconst() ISignediconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISignediconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISignediconstContext) } func (s *AlterstatsstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *AlterstatsstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *AlterstatsstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterstatsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterstatsstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterstatsstmt(s) } } func (s *AlterstatsstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterstatsstmt(s) } } func (s *AlterstatsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterstatsstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterstatsstmt() (localctx IAlterstatsstmtContext) { localctx = NewAlterstatsstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 262, PostgreSQLParserRULE_alterstatsstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3182) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3183) p.Match(PostgreSQLParserSTATISTICS) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(3186) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 123, p.GetParserRuleContext()) == 1 { { p.SetState(3184) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3185) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(3188) p.Any_name() } { p.SetState(3189) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3190) p.Match(PostgreSQLParserSTATISTICS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3191) p.Signediconst() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateasstmtContext is an interface to support dynamic dispatch. type ICreateasstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode Opttemp() IOpttempContext TABLE() antlr.TerminalNode Create_as_target() ICreate_as_targetContext AS() antlr.TerminalNode Selectstmt() ISelectstmtContext Opt_with_data() IOpt_with_dataContext IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsCreateasstmtContext differentiates from other interfaces. IsCreateasstmtContext() } type CreateasstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateasstmtContext() *CreateasstmtContext { var p = new(CreateasstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createasstmt return p } func InitEmptyCreateasstmtContext(p *CreateasstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createasstmt } func (*CreateasstmtContext) IsCreateasstmtContext() {} func NewCreateasstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateasstmtContext { var p = new(CreateasstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createasstmt return p } func (s *CreateasstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateasstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateasstmtContext) Opttemp() IOpttempContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttempContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttempContext) } func (s *CreateasstmtContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *CreateasstmtContext) Create_as_target() ICreate_as_targetContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreate_as_targetContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreate_as_targetContext) } func (s *CreateasstmtContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *CreateasstmtContext) Selectstmt() ISelectstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectstmtContext) } func (s *CreateasstmtContext) Opt_with_data() IOpt_with_dataContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_with_dataContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_with_dataContext) } func (s *CreateasstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *CreateasstmtContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *CreateasstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *CreateasstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateasstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateasstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateasstmt(s) } } func (s *CreateasstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateasstmt(s) } } func (s *CreateasstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateasstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createasstmt() (localctx ICreateasstmtContext) { localctx = NewCreateasstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 264, PostgreSQLParserRULE_createasstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3193) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3194) p.Opttemp() } { p.SetState(3195) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(3199) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 124, p.GetParserRuleContext()) == 1 { { p.SetState(3196) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3197) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3198) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(3201) p.Create_as_target() } { p.SetState(3202) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3203) p.Selectstmt() } { p.SetState(3204) p.Opt_with_data() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreate_as_targetContext is an interface to support dynamic dispatch. type ICreate_as_targetContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Qualified_name() IQualified_nameContext Opt_column_list() IOpt_column_listContext Table_access_method_clause() ITable_access_method_clauseContext Optwith() IOptwithContext Oncommitoption() IOncommitoptionContext Opttablespace() IOpttablespaceContext // IsCreate_as_targetContext differentiates from other interfaces. IsCreate_as_targetContext() } type Create_as_targetContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreate_as_targetContext() *Create_as_targetContext { var p = new(Create_as_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_create_as_target return p } func InitEmptyCreate_as_targetContext(p *Create_as_targetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_create_as_target } func (*Create_as_targetContext) IsCreate_as_targetContext() {} func NewCreate_as_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_as_targetContext { var p = new(Create_as_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_create_as_target return p } func (s *Create_as_targetContext) GetParser() antlr.Parser { return s.parser } func (s *Create_as_targetContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *Create_as_targetContext) Opt_column_list() IOpt_column_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_column_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_column_listContext) } func (s *Create_as_targetContext) Table_access_method_clause() ITable_access_method_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITable_access_method_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITable_access_method_clauseContext) } func (s *Create_as_targetContext) Optwith() IOptwithContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptwithContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptwithContext) } func (s *Create_as_targetContext) Oncommitoption() IOncommitoptionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOncommitoptionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOncommitoptionContext) } func (s *Create_as_targetContext) Opttablespace() IOpttablespaceContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttablespaceContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttablespaceContext) } func (s *Create_as_targetContext) GetRuleContext() antlr.RuleContext { return s } func (s *Create_as_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Create_as_targetContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreate_as_target(s) } } func (s *Create_as_targetContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreate_as_target(s) } } func (s *Create_as_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreate_as_target(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Create_as_target() (localctx ICreate_as_targetContext) { localctx = NewCreate_as_targetContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 266, PostgreSQLParserRULE_create_as_target) p.EnterOuterAlt(localctx, 1) { p.SetState(3206) p.Qualified_name() } { p.SetState(3207) p.Opt_column_list() } { p.SetState(3208) p.Table_access_method_clause() } { p.SetState(3209) p.Optwith() } { p.SetState(3210) p.Oncommitoption() } { p.SetState(3211) p.Opttablespace() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_with_dataContext is an interface to support dynamic dispatch. type IOpt_with_dataContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITH() antlr.TerminalNode DATA_P() antlr.TerminalNode NO() antlr.TerminalNode // IsOpt_with_dataContext differentiates from other interfaces. IsOpt_with_dataContext() } type Opt_with_dataContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_with_dataContext() *Opt_with_dataContext { var p = new(Opt_with_dataContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_with_data return p } func InitEmptyOpt_with_dataContext(p *Opt_with_dataContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_with_data } func (*Opt_with_dataContext) IsOpt_with_dataContext() {} func NewOpt_with_dataContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_with_dataContext { var p = new(Opt_with_dataContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_with_data return p } func (s *Opt_with_dataContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_with_dataContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *Opt_with_dataContext) DATA_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATA_P, 0) } func (s *Opt_with_dataContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Opt_with_dataContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_with_dataContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_with_dataContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_with_data(s) } } func (s *Opt_with_dataContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_with_data(s) } } func (s *Opt_with_dataContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_with_data(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_with_data() (localctx IOpt_with_dataContext) { localctx = NewOpt_with_dataContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 268, PostgreSQLParserRULE_opt_with_data) p.SetState(3220) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 126, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3213) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(3217) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserDATA_P: { p.SetState(3214) p.Match(PostgreSQLParserDATA_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserNO: { p.SetState(3215) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3216) p.Match(PostgreSQLParserDATA_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatematviewstmtContext is an interface to support dynamic dispatch. type ICreatematviewstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode Optnolog() IOptnologContext MATERIALIZED() antlr.TerminalNode VIEW() antlr.TerminalNode Create_mv_target() ICreate_mv_targetContext AS() antlr.TerminalNode Selectstmt() ISelectstmtContext Opt_with_data() IOpt_with_dataContext IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsCreatematviewstmtContext differentiates from other interfaces. IsCreatematviewstmtContext() } type CreatematviewstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatematviewstmtContext() *CreatematviewstmtContext { var p = new(CreatematviewstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_creatematviewstmt return p } func InitEmptyCreatematviewstmtContext(p *CreatematviewstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_creatematviewstmt } func (*CreatematviewstmtContext) IsCreatematviewstmtContext() {} func NewCreatematviewstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatematviewstmtContext { var p = new(CreatematviewstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_creatematviewstmt return p } func (s *CreatematviewstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreatematviewstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreatematviewstmtContext) Optnolog() IOptnologContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptnologContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptnologContext) } func (s *CreatematviewstmtContext) MATERIALIZED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMATERIALIZED, 0) } func (s *CreatematviewstmtContext) VIEW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVIEW, 0) } func (s *CreatematviewstmtContext) Create_mv_target() ICreate_mv_targetContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreate_mv_targetContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreate_mv_targetContext) } func (s *CreatematviewstmtContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *CreatematviewstmtContext) Selectstmt() ISelectstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectstmtContext) } func (s *CreatematviewstmtContext) Opt_with_data() IOpt_with_dataContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_with_dataContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_with_dataContext) } func (s *CreatematviewstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *CreatematviewstmtContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *CreatematviewstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *CreatematviewstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreatematviewstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreatematviewstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatematviewstmt(s) } } func (s *CreatematviewstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatematviewstmt(s) } } func (s *CreatematviewstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatematviewstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Creatematviewstmt() (localctx ICreatematviewstmtContext) { localctx = NewCreatematviewstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 270, PostgreSQLParserRULE_creatematviewstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3222) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3223) p.Optnolog() } { p.SetState(3224) p.Match(PostgreSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3225) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(3229) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 127, p.GetParserRuleContext()) == 1 { { p.SetState(3226) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3227) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3228) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(3231) p.Create_mv_target() } { p.SetState(3232) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3233) p.Selectstmt() } { p.SetState(3234) p.Opt_with_data() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreate_mv_targetContext is an interface to support dynamic dispatch. type ICreate_mv_targetContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Qualified_name() IQualified_nameContext Opt_column_list() IOpt_column_listContext Table_access_method_clause() ITable_access_method_clauseContext Opt_reloptions() IOpt_reloptionsContext Opttablespace() IOpttablespaceContext // IsCreate_mv_targetContext differentiates from other interfaces. IsCreate_mv_targetContext() } type Create_mv_targetContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreate_mv_targetContext() *Create_mv_targetContext { var p = new(Create_mv_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_create_mv_target return p } func InitEmptyCreate_mv_targetContext(p *Create_mv_targetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_create_mv_target } func (*Create_mv_targetContext) IsCreate_mv_targetContext() {} func NewCreate_mv_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_mv_targetContext { var p = new(Create_mv_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_create_mv_target return p } func (s *Create_mv_targetContext) GetParser() antlr.Parser { return s.parser } func (s *Create_mv_targetContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *Create_mv_targetContext) Opt_column_list() IOpt_column_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_column_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_column_listContext) } func (s *Create_mv_targetContext) Table_access_method_clause() ITable_access_method_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITable_access_method_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITable_access_method_clauseContext) } func (s *Create_mv_targetContext) Opt_reloptions() IOpt_reloptionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_reloptionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_reloptionsContext) } func (s *Create_mv_targetContext) Opttablespace() IOpttablespaceContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttablespaceContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttablespaceContext) } func (s *Create_mv_targetContext) GetRuleContext() antlr.RuleContext { return s } func (s *Create_mv_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Create_mv_targetContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreate_mv_target(s) } } func (s *Create_mv_targetContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreate_mv_target(s) } } func (s *Create_mv_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreate_mv_target(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Create_mv_target() (localctx ICreate_mv_targetContext) { localctx = NewCreate_mv_targetContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 272, PostgreSQLParserRULE_create_mv_target) p.EnterOuterAlt(localctx, 1) { p.SetState(3236) p.Qualified_name() } { p.SetState(3237) p.Opt_column_list() } { p.SetState(3238) p.Table_access_method_clause() } { p.SetState(3239) p.Opt_reloptions() } { p.SetState(3240) p.Opttablespace() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOptnologContext is an interface to support dynamic dispatch. type IOptnologContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures UNLOGGED() antlr.TerminalNode // IsOptnologContext differentiates from other interfaces. IsOptnologContext() } type OptnologContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOptnologContext() *OptnologContext { var p = new(OptnologContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optnolog return p } func InitEmptyOptnologContext(p *OptnologContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optnolog } func (*OptnologContext) IsOptnologContext() {} func NewOptnologContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptnologContext { var p = new(OptnologContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_optnolog return p } func (s *OptnologContext) GetParser() antlr.Parser { return s.parser } func (s *OptnologContext) UNLOGGED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNLOGGED, 0) } func (s *OptnologContext) GetRuleContext() antlr.RuleContext { return s } func (s *OptnologContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OptnologContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOptnolog(s) } } func (s *OptnologContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOptnolog(s) } } func (s *OptnologContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOptnolog(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Optnolog() (localctx IOptnologContext) { localctx = NewOptnologContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 274, PostgreSQLParserRULE_optnolog) p.SetState(3244) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUNLOGGED: p.EnterOuterAlt(localctx, 1) { p.SetState(3242) p.Match(PostgreSQLParserUNLOGGED) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserMATERIALIZED: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRefreshmatviewstmtContext is an interface to support dynamic dispatch. type IRefreshmatviewstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures REFRESH() antlr.TerminalNode MATERIALIZED() antlr.TerminalNode VIEW() antlr.TerminalNode Opt_concurrently() IOpt_concurrentlyContext Qualified_name() IQualified_nameContext Opt_with_data() IOpt_with_dataContext // IsRefreshmatviewstmtContext differentiates from other interfaces. IsRefreshmatviewstmtContext() } type RefreshmatviewstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRefreshmatviewstmtContext() *RefreshmatviewstmtContext { var p = new(RefreshmatviewstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_refreshmatviewstmt return p } func InitEmptyRefreshmatviewstmtContext(p *RefreshmatviewstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_refreshmatviewstmt } func (*RefreshmatviewstmtContext) IsRefreshmatviewstmtContext() {} func NewRefreshmatviewstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RefreshmatviewstmtContext { var p = new(RefreshmatviewstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_refreshmatviewstmt return p } func (s *RefreshmatviewstmtContext) GetParser() antlr.Parser { return s.parser } func (s *RefreshmatviewstmtContext) REFRESH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREFRESH, 0) } func (s *RefreshmatviewstmtContext) MATERIALIZED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMATERIALIZED, 0) } func (s *RefreshmatviewstmtContext) VIEW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVIEW, 0) } func (s *RefreshmatviewstmtContext) Opt_concurrently() IOpt_concurrentlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_concurrentlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_concurrentlyContext) } func (s *RefreshmatviewstmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *RefreshmatviewstmtContext) Opt_with_data() IOpt_with_dataContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_with_dataContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_with_dataContext) } func (s *RefreshmatviewstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *RefreshmatviewstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RefreshmatviewstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRefreshmatviewstmt(s) } } func (s *RefreshmatviewstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRefreshmatviewstmt(s) } } func (s *RefreshmatviewstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRefreshmatviewstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Refreshmatviewstmt() (localctx IRefreshmatviewstmtContext) { localctx = NewRefreshmatviewstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 276, PostgreSQLParserRULE_refreshmatviewstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3246) p.Match(PostgreSQLParserREFRESH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3247) p.Match(PostgreSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3248) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3249) p.Opt_concurrently() } { p.SetState(3250) p.Qualified_name() } { p.SetState(3251) p.Opt_with_data() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateseqstmtContext is an interface to support dynamic dispatch. type ICreateseqstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode Opttemp() IOpttempContext SEQUENCE() antlr.TerminalNode Qualified_name() IQualified_nameContext Optseqoptlist() IOptseqoptlistContext IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsCreateseqstmtContext differentiates from other interfaces. IsCreateseqstmtContext() } type CreateseqstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateseqstmtContext() *CreateseqstmtContext { var p = new(CreateseqstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createseqstmt return p } func InitEmptyCreateseqstmtContext(p *CreateseqstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createseqstmt } func (*CreateseqstmtContext) IsCreateseqstmtContext() {} func NewCreateseqstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateseqstmtContext { var p = new(CreateseqstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createseqstmt return p } func (s *CreateseqstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateseqstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateseqstmtContext) Opttemp() IOpttempContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttempContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttempContext) } func (s *CreateseqstmtContext) SEQUENCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEQUENCE, 0) } func (s *CreateseqstmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *CreateseqstmtContext) Optseqoptlist() IOptseqoptlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptseqoptlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptseqoptlistContext) } func (s *CreateseqstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *CreateseqstmtContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *CreateseqstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *CreateseqstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateseqstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateseqstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateseqstmt(s) } } func (s *CreateseqstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateseqstmt(s) } } func (s *CreateseqstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateseqstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createseqstmt() (localctx ICreateseqstmtContext) { localctx = NewCreateseqstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 278, PostgreSQLParserRULE_createseqstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3253) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3254) p.Opttemp() } { p.SetState(3255) p.Match(PostgreSQLParserSEQUENCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(3259) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 129, p.GetParserRuleContext()) == 1 { { p.SetState(3256) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3257) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3258) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(3261) p.Qualified_name() } { p.SetState(3262) p.Optseqoptlist() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterseqstmtContext is an interface to support dynamic dispatch. type IAlterseqstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode SEQUENCE() antlr.TerminalNode Qualified_name() IQualified_nameContext Seqoptlist() ISeqoptlistContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsAlterseqstmtContext differentiates from other interfaces. IsAlterseqstmtContext() } type AlterseqstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterseqstmtContext() *AlterseqstmtContext { var p = new(AlterseqstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterseqstmt return p } func InitEmptyAlterseqstmtContext(p *AlterseqstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterseqstmt } func (*AlterseqstmtContext) IsAlterseqstmtContext() {} func NewAlterseqstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterseqstmtContext { var p = new(AlterseqstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterseqstmt return p } func (s *AlterseqstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterseqstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterseqstmtContext) SEQUENCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEQUENCE, 0) } func (s *AlterseqstmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *AlterseqstmtContext) Seqoptlist() ISeqoptlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISeqoptlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISeqoptlistContext) } func (s *AlterseqstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *AlterseqstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *AlterseqstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterseqstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterseqstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterseqstmt(s) } } func (s *AlterseqstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterseqstmt(s) } } func (s *AlterseqstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterseqstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterseqstmt() (localctx IAlterseqstmtContext) { localctx = NewAlterseqstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 280, PostgreSQLParserRULE_alterseqstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3264) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3265) p.Match(PostgreSQLParserSEQUENCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(3268) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 130, p.GetParserRuleContext()) == 1 { { p.SetState(3266) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3267) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(3270) p.Qualified_name() } { p.SetState(3271) p.Seqoptlist() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOptseqoptlistContext is an interface to support dynamic dispatch. type IOptseqoptlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Seqoptlist() ISeqoptlistContext // IsOptseqoptlistContext differentiates from other interfaces. IsOptseqoptlistContext() } type OptseqoptlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOptseqoptlistContext() *OptseqoptlistContext { var p = new(OptseqoptlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optseqoptlist return p } func InitEmptyOptseqoptlistContext(p *OptseqoptlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optseqoptlist } func (*OptseqoptlistContext) IsOptseqoptlistContext() {} func NewOptseqoptlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptseqoptlistContext { var p = new(OptseqoptlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_optseqoptlist return p } func (s *OptseqoptlistContext) GetParser() antlr.Parser { return s.parser } func (s *OptseqoptlistContext) Seqoptlist() ISeqoptlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISeqoptlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISeqoptlistContext) } func (s *OptseqoptlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *OptseqoptlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OptseqoptlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOptseqoptlist(s) } } func (s *OptseqoptlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOptseqoptlist(s) } } func (s *OptseqoptlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOptseqoptlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Optseqoptlist() (localctx IOptseqoptlistContext) { localctx = NewOptseqoptlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 282, PostgreSQLParserRULE_optseqoptlist) p.SetState(3275) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 131, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3273) p.Seqoptlist() } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOptparenthesizedseqoptlistContext is an interface to support dynamic dispatch. type IOptparenthesizedseqoptlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Seqoptlist() ISeqoptlistContext CLOSE_PAREN() antlr.TerminalNode // IsOptparenthesizedseqoptlistContext differentiates from other interfaces. IsOptparenthesizedseqoptlistContext() } type OptparenthesizedseqoptlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOptparenthesizedseqoptlistContext() *OptparenthesizedseqoptlistContext { var p = new(OptparenthesizedseqoptlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optparenthesizedseqoptlist return p } func InitEmptyOptparenthesizedseqoptlistContext(p *OptparenthesizedseqoptlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optparenthesizedseqoptlist } func (*OptparenthesizedseqoptlistContext) IsOptparenthesizedseqoptlistContext() {} func NewOptparenthesizedseqoptlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptparenthesizedseqoptlistContext { var p = new(OptparenthesizedseqoptlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_optparenthesizedseqoptlist return p } func (s *OptparenthesizedseqoptlistContext) GetParser() antlr.Parser { return s.parser } func (s *OptparenthesizedseqoptlistContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *OptparenthesizedseqoptlistContext) Seqoptlist() ISeqoptlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISeqoptlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISeqoptlistContext) } func (s *OptparenthesizedseqoptlistContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *OptparenthesizedseqoptlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *OptparenthesizedseqoptlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OptparenthesizedseqoptlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOptparenthesizedseqoptlist(s) } } func (s *OptparenthesizedseqoptlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOptparenthesizedseqoptlist(s) } } func (s *OptparenthesizedseqoptlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOptparenthesizedseqoptlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Optparenthesizedseqoptlist() (localctx IOptparenthesizedseqoptlistContext) { localctx = NewOptparenthesizedseqoptlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 284, PostgreSQLParserRULE_optparenthesizedseqoptlist) p.SetState(3282) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 132, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3277) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3278) p.Seqoptlist() } { p.SetState(3279) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISeqoptlistContext is an interface to support dynamic dispatch. type ISeqoptlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllSeqoptelem() []ISeqoptelemContext Seqoptelem(i int) ISeqoptelemContext // IsSeqoptlistContext differentiates from other interfaces. IsSeqoptlistContext() } type SeqoptlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySeqoptlistContext() *SeqoptlistContext { var p = new(SeqoptlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_seqoptlist return p } func InitEmptySeqoptlistContext(p *SeqoptlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_seqoptlist } func (*SeqoptlistContext) IsSeqoptlistContext() {} func NewSeqoptlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SeqoptlistContext { var p = new(SeqoptlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_seqoptlist return p } func (s *SeqoptlistContext) GetParser() antlr.Parser { return s.parser } func (s *SeqoptlistContext) AllSeqoptelem() []ISeqoptelemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISeqoptelemContext); ok { len++ } } tst := make([]ISeqoptelemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISeqoptelemContext); ok { tst[i] = t.(ISeqoptelemContext) i++ } } return tst } func (s *SeqoptlistContext) Seqoptelem(i int) ISeqoptelemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISeqoptelemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISeqoptelemContext) } func (s *SeqoptlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *SeqoptlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SeqoptlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSeqoptlist(s) } } func (s *SeqoptlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSeqoptlist(s) } } func (s *SeqoptlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSeqoptlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Seqoptlist() (localctx ISeqoptlistContext) { localctx = NewSeqoptlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 286, PostgreSQLParserRULE_seqoptlist) var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(3285) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = 1 for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { switch _alt { case 1: { p.SetState(3284) p.Seqoptelem() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.SetState(3287) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 133, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISeqoptelemContext is an interface to support dynamic dispatch. type ISeqoptelemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AS() antlr.TerminalNode Simpletypename() ISimpletypenameContext CACHE() antlr.TerminalNode Numericonly() INumericonlyContext CYCLE() antlr.TerminalNode INCREMENT() antlr.TerminalNode Opt_by() IOpt_byContext MAXVALUE() antlr.TerminalNode MINVALUE() antlr.TerminalNode NO() antlr.TerminalNode OWNED() antlr.TerminalNode BY() antlr.TerminalNode Any_name() IAny_nameContext SEQUENCE() antlr.TerminalNode NAME_P() antlr.TerminalNode START() antlr.TerminalNode Opt_with() IOpt_withContext RESTART() antlr.TerminalNode // IsSeqoptelemContext differentiates from other interfaces. IsSeqoptelemContext() } type SeqoptelemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySeqoptelemContext() *SeqoptelemContext { var p = new(SeqoptelemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_seqoptelem return p } func InitEmptySeqoptelemContext(p *SeqoptelemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_seqoptelem } func (*SeqoptelemContext) IsSeqoptelemContext() {} func NewSeqoptelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SeqoptelemContext { var p = new(SeqoptelemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_seqoptelem return p } func (s *SeqoptelemContext) GetParser() antlr.Parser { return s.parser } func (s *SeqoptelemContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *SeqoptelemContext) Simpletypename() ISimpletypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISimpletypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISimpletypenameContext) } func (s *SeqoptelemContext) CACHE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCACHE, 0) } func (s *SeqoptelemContext) Numericonly() INumericonlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericonlyContext) } func (s *SeqoptelemContext) CYCLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCYCLE, 0) } func (s *SeqoptelemContext) INCREMENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINCREMENT, 0) } func (s *SeqoptelemContext) Opt_by() IOpt_byContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_byContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_byContext) } func (s *SeqoptelemContext) MAXVALUE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMAXVALUE, 0) } func (s *SeqoptelemContext) MINVALUE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMINVALUE, 0) } func (s *SeqoptelemContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *SeqoptelemContext) OWNED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOWNED, 0) } func (s *SeqoptelemContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *SeqoptelemContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *SeqoptelemContext) SEQUENCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEQUENCE, 0) } func (s *SeqoptelemContext) NAME_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNAME_P, 0) } func (s *SeqoptelemContext) START() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTART, 0) } func (s *SeqoptelemContext) Opt_with() IOpt_withContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_withContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_withContext) } func (s *SeqoptelemContext) RESTART() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESTART, 0) } func (s *SeqoptelemContext) GetRuleContext() antlr.RuleContext { return s } func (s *SeqoptelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SeqoptelemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSeqoptelem(s) } } func (s *SeqoptelemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSeqoptelem(s) } } func (s *SeqoptelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSeqoptelem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Seqoptelem() (localctx ISeqoptelemContext) { localctx = NewSeqoptelemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 288, PostgreSQLParserRULE_seqoptelem) var _la int p.SetState(3319) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAS: p.EnterOuterAlt(localctx, 1) { p.SetState(3289) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3290) p.Simpletypename() } case PostgreSQLParserCACHE: p.EnterOuterAlt(localctx, 2) { p.SetState(3291) p.Match(PostgreSQLParserCACHE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3292) p.Numericonly() } case PostgreSQLParserCYCLE: p.EnterOuterAlt(localctx, 3) { p.SetState(3293) p.Match(PostgreSQLParserCYCLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserINCREMENT: p.EnterOuterAlt(localctx, 4) { p.SetState(3294) p.Match(PostgreSQLParserINCREMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3295) p.Opt_by() } { p.SetState(3296) p.Numericonly() } case PostgreSQLParserMAXVALUE: p.EnterOuterAlt(localctx, 5) { p.SetState(3298) p.Match(PostgreSQLParserMAXVALUE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3299) p.Numericonly() } case PostgreSQLParserMINVALUE: p.EnterOuterAlt(localctx, 6) { p.SetState(3300) p.Match(PostgreSQLParserMINVALUE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3301) p.Numericonly() } case PostgreSQLParserNO: p.EnterOuterAlt(localctx, 7) { p.SetState(3302) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3303) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserCYCLE || _la == PostgreSQLParserMAXVALUE || _la == PostgreSQLParserMINVALUE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } case PostgreSQLParserOWNED: p.EnterOuterAlt(localctx, 8) { p.SetState(3304) p.Match(PostgreSQLParserOWNED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3305) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3306) p.Any_name() } case PostgreSQLParserSEQUENCE: p.EnterOuterAlt(localctx, 9) { p.SetState(3307) p.Match(PostgreSQLParserSEQUENCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3308) p.Match(PostgreSQLParserNAME_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3309) p.Any_name() } case PostgreSQLParserSTART: p.EnterOuterAlt(localctx, 10) { p.SetState(3310) p.Match(PostgreSQLParserSTART) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3311) p.Opt_with() } { p.SetState(3312) p.Numericonly() } case PostgreSQLParserRESTART: p.EnterOuterAlt(localctx, 11) { p.SetState(3314) p.Match(PostgreSQLParserRESTART) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3315) p.Opt_with() } p.SetState(3317) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserPLUS || _la == PostgreSQLParserMINUS || _la == PostgreSQLParserIntegral || _la == PostgreSQLParserNumeric { { p.SetState(3316) p.Numericonly() } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_byContext is an interface to support dynamic dispatch. type IOpt_byContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures BY() antlr.TerminalNode // IsOpt_byContext differentiates from other interfaces. IsOpt_byContext() } type Opt_byContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_byContext() *Opt_byContext { var p = new(Opt_byContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_by return p } func InitEmptyOpt_byContext(p *Opt_byContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_by } func (*Opt_byContext) IsOpt_byContext() {} func NewOpt_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_byContext { var p = new(Opt_byContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_by return p } func (s *Opt_byContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_byContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *Opt_byContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_byContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_by(s) } } func (s *Opt_byContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_by(s) } } func (s *Opt_byContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_by(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_by() (localctx IOpt_byContext) { localctx = NewOpt_byContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 290, PostgreSQLParserRULE_opt_by) p.SetState(3323) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserBY: p.EnterOuterAlt(localctx, 1) { p.SetState(3321) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserIntegral, PostgreSQLParserNumeric: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // INumericonlyContext is an interface to support dynamic dispatch. type INumericonlyContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Fconst() IFconstContext PLUS() antlr.TerminalNode MINUS() antlr.TerminalNode Signediconst() ISignediconstContext // IsNumericonlyContext differentiates from other interfaces. IsNumericonlyContext() } type NumericonlyContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyNumericonlyContext() *NumericonlyContext { var p = new(NumericonlyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_numericonly return p } func InitEmptyNumericonlyContext(p *NumericonlyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_numericonly } func (*NumericonlyContext) IsNumericonlyContext() {} func NewNumericonlyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumericonlyContext { var p = new(NumericonlyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_numericonly return p } func (s *NumericonlyContext) GetParser() antlr.Parser { return s.parser } func (s *NumericonlyContext) Fconst() IFconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFconstContext) } func (s *NumericonlyContext) PLUS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPLUS, 0) } func (s *NumericonlyContext) MINUS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMINUS, 0) } func (s *NumericonlyContext) Signediconst() ISignediconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISignediconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISignediconstContext) } func (s *NumericonlyContext) GetRuleContext() antlr.RuleContext { return s } func (s *NumericonlyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *NumericonlyContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterNumericonly(s) } } func (s *NumericonlyContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitNumericonly(s) } } func (s *NumericonlyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitNumericonly(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Numericonly() (localctx INumericonlyContext) { localctx = NewNumericonlyContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 292, PostgreSQLParserRULE_numericonly) p.SetState(3331) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 137, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3325) p.Fconst() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(3326) p.Match(PostgreSQLParserPLUS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3327) p.Fconst() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(3328) p.Match(PostgreSQLParserMINUS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3329) p.Fconst() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(3330) p.Signediconst() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // INumericonly_listContext is an interface to support dynamic dispatch. type INumericonly_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllNumericonly() []INumericonlyContext Numericonly(i int) INumericonlyContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsNumericonly_listContext differentiates from other interfaces. IsNumericonly_listContext() } type Numericonly_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyNumericonly_listContext() *Numericonly_listContext { var p = new(Numericonly_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_numericonly_list return p } func InitEmptyNumericonly_listContext(p *Numericonly_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_numericonly_list } func (*Numericonly_listContext) IsNumericonly_listContext() {} func NewNumericonly_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Numericonly_listContext { var p = new(Numericonly_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_numericonly_list return p } func (s *Numericonly_listContext) GetParser() antlr.Parser { return s.parser } func (s *Numericonly_listContext) AllNumericonly() []INumericonlyContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(INumericonlyContext); ok { len++ } } tst := make([]INumericonlyContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(INumericonlyContext); ok { tst[i] = t.(INumericonlyContext) i++ } } return tst } func (s *Numericonly_listContext) Numericonly(i int) INumericonlyContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonlyContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(INumericonlyContext) } func (s *Numericonly_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Numericonly_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Numericonly_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Numericonly_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Numericonly_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterNumericonly_list(s) } } func (s *Numericonly_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitNumericonly_list(s) } } func (s *Numericonly_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitNumericonly_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Numericonly_list() (localctx INumericonly_listContext) { localctx = NewNumericonly_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 294, PostgreSQLParserRULE_numericonly_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3333) p.Numericonly() } p.SetState(3338) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(3334) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3335) p.Numericonly() } p.SetState(3340) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateplangstmtContext is an interface to support dynamic dispatch. type ICreateplangstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode Opt_or_replace() IOpt_or_replaceContext Opt_trusted() IOpt_trustedContext Opt_procedural() IOpt_proceduralContext LANGUAGE() antlr.TerminalNode Name() INameContext HANDLER() antlr.TerminalNode Handler_name() IHandler_nameContext Opt_inline_handler() IOpt_inline_handlerContext Opt_validator() IOpt_validatorContext // IsCreateplangstmtContext differentiates from other interfaces. IsCreateplangstmtContext() } type CreateplangstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateplangstmtContext() *CreateplangstmtContext { var p = new(CreateplangstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createplangstmt return p } func InitEmptyCreateplangstmtContext(p *CreateplangstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createplangstmt } func (*CreateplangstmtContext) IsCreateplangstmtContext() {} func NewCreateplangstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateplangstmtContext { var p = new(CreateplangstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createplangstmt return p } func (s *CreateplangstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateplangstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateplangstmtContext) Opt_or_replace() IOpt_or_replaceContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_or_replaceContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_or_replaceContext) } func (s *CreateplangstmtContext) Opt_trusted() IOpt_trustedContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_trustedContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_trustedContext) } func (s *CreateplangstmtContext) Opt_procedural() IOpt_proceduralContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_proceduralContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_proceduralContext) } func (s *CreateplangstmtContext) LANGUAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLANGUAGE, 0) } func (s *CreateplangstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreateplangstmtContext) HANDLER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserHANDLER, 0) } func (s *CreateplangstmtContext) Handler_name() IHandler_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IHandler_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IHandler_nameContext) } func (s *CreateplangstmtContext) Opt_inline_handler() IOpt_inline_handlerContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_inline_handlerContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_inline_handlerContext) } func (s *CreateplangstmtContext) Opt_validator() IOpt_validatorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_validatorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_validatorContext) } func (s *CreateplangstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateplangstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateplangstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateplangstmt(s) } } func (s *CreateplangstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateplangstmt(s) } } func (s *CreateplangstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateplangstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createplangstmt() (localctx ICreateplangstmtContext) { localctx = NewCreateplangstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 296, PostgreSQLParserRULE_createplangstmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3341) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3342) p.Opt_or_replace() } { p.SetState(3343) p.Opt_trusted() } { p.SetState(3344) p.Opt_procedural() } { p.SetState(3345) p.Match(PostgreSQLParserLANGUAGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3346) p.Name() } p.SetState(3352) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserHANDLER { { p.SetState(3347) p.Match(PostgreSQLParserHANDLER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3348) p.Handler_name() } { p.SetState(3349) p.Opt_inline_handler() } { p.SetState(3350) p.Opt_validator() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_trustedContext is an interface to support dynamic dispatch. type IOpt_trustedContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TRUSTED() antlr.TerminalNode // IsOpt_trustedContext differentiates from other interfaces. IsOpt_trustedContext() } type Opt_trustedContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_trustedContext() *Opt_trustedContext { var p = new(Opt_trustedContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_trusted return p } func InitEmptyOpt_trustedContext(p *Opt_trustedContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_trusted } func (*Opt_trustedContext) IsOpt_trustedContext() {} func NewOpt_trustedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_trustedContext { var p = new(Opt_trustedContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_trusted return p } func (s *Opt_trustedContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_trustedContext) TRUSTED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRUSTED, 0) } func (s *Opt_trustedContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_trustedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_trustedContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_trusted(s) } } func (s *Opt_trustedContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_trusted(s) } } func (s *Opt_trustedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_trusted(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_trusted() (localctx IOpt_trustedContext) { localctx = NewOpt_trustedContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 298, PostgreSQLParserRULE_opt_trusted) p.SetState(3356) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserTRUSTED: p.EnterOuterAlt(localctx, 1) { p.SetState(3354) p.Match(PostgreSQLParserTRUSTED) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserLANGUAGE, PostgreSQLParserPROCEDURAL: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IHandler_nameContext is an interface to support dynamic dispatch. type IHandler_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Name() INameContext Attrs() IAttrsContext // IsHandler_nameContext differentiates from other interfaces. IsHandler_nameContext() } type Handler_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyHandler_nameContext() *Handler_nameContext { var p = new(Handler_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_handler_name return p } func InitEmptyHandler_nameContext(p *Handler_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_handler_name } func (*Handler_nameContext) IsHandler_nameContext() {} func NewHandler_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Handler_nameContext { var p = new(Handler_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_handler_name return p } func (s *Handler_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Handler_nameContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *Handler_nameContext) Attrs() IAttrsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAttrsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAttrsContext) } func (s *Handler_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Handler_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Handler_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterHandler_name(s) } } func (s *Handler_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitHandler_name(s) } } func (s *Handler_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitHandler_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Handler_name() (localctx IHandler_nameContext) { localctx = NewHandler_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 300, PostgreSQLParserRULE_handler_name) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3358) p.Name() } p.SetState(3360) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserDOT { { p.SetState(3359) p.Attrs() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_inline_handlerContext is an interface to support dynamic dispatch. type IOpt_inline_handlerContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures INLINE_P() antlr.TerminalNode Handler_name() IHandler_nameContext // IsOpt_inline_handlerContext differentiates from other interfaces. IsOpt_inline_handlerContext() } type Opt_inline_handlerContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_inline_handlerContext() *Opt_inline_handlerContext { var p = new(Opt_inline_handlerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_inline_handler return p } func InitEmptyOpt_inline_handlerContext(p *Opt_inline_handlerContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_inline_handler } func (*Opt_inline_handlerContext) IsOpt_inline_handlerContext() {} func NewOpt_inline_handlerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_inline_handlerContext { var p = new(Opt_inline_handlerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_inline_handler return p } func (s *Opt_inline_handlerContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_inline_handlerContext) INLINE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINLINE_P, 0) } func (s *Opt_inline_handlerContext) Handler_name() IHandler_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IHandler_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IHandler_nameContext) } func (s *Opt_inline_handlerContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_inline_handlerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_inline_handlerContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_inline_handler(s) } } func (s *Opt_inline_handlerContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_inline_handler(s) } } func (s *Opt_inline_handlerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_inline_handler(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_inline_handler() (localctx IOpt_inline_handlerContext) { localctx = NewOpt_inline_handlerContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 302, PostgreSQLParserRULE_opt_inline_handler) p.SetState(3365) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserINLINE_P: p.EnterOuterAlt(localctx, 1) { p.SetState(3362) p.Match(PostgreSQLParserINLINE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3363) p.Handler_name() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNO, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALIDATOR, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IValidator_clauseContext is an interface to support dynamic dispatch. type IValidator_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures VALIDATOR() antlr.TerminalNode Handler_name() IHandler_nameContext NO() antlr.TerminalNode // IsValidator_clauseContext differentiates from other interfaces. IsValidator_clauseContext() } type Validator_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyValidator_clauseContext() *Validator_clauseContext { var p = new(Validator_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_validator_clause return p } func InitEmptyValidator_clauseContext(p *Validator_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_validator_clause } func (*Validator_clauseContext) IsValidator_clauseContext() {} func NewValidator_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Validator_clauseContext { var p = new(Validator_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_validator_clause return p } func (s *Validator_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Validator_clauseContext) VALIDATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALIDATOR, 0) } func (s *Validator_clauseContext) Handler_name() IHandler_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IHandler_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IHandler_nameContext) } func (s *Validator_clauseContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Validator_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Validator_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Validator_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterValidator_clause(s) } } func (s *Validator_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitValidator_clause(s) } } func (s *Validator_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitValidator_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Validator_clause() (localctx IValidator_clauseContext) { localctx = NewValidator_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 304, PostgreSQLParserRULE_validator_clause) p.SetState(3371) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserVALIDATOR: p.EnterOuterAlt(localctx, 1) { p.SetState(3367) p.Match(PostgreSQLParserVALIDATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3368) p.Handler_name() } case PostgreSQLParserNO: p.EnterOuterAlt(localctx, 2) { p.SetState(3369) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3370) p.Match(PostgreSQLParserVALIDATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_validatorContext is an interface to support dynamic dispatch. type IOpt_validatorContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Validator_clause() IValidator_clauseContext // IsOpt_validatorContext differentiates from other interfaces. IsOpt_validatorContext() } type Opt_validatorContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_validatorContext() *Opt_validatorContext { var p = new(Opt_validatorContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_validator return p } func InitEmptyOpt_validatorContext(p *Opt_validatorContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_validator } func (*Opt_validatorContext) IsOpt_validatorContext() {} func NewOpt_validatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_validatorContext { var p = new(Opt_validatorContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_validator return p } func (s *Opt_validatorContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_validatorContext) Validator_clause() IValidator_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IValidator_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IValidator_clauseContext) } func (s *Opt_validatorContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_validatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_validatorContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_validator(s) } } func (s *Opt_validatorContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_validator(s) } } func (s *Opt_validatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_validator(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_validator() (localctx IOpt_validatorContext) { localctx = NewOpt_validatorContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 306, PostgreSQLParserRULE_opt_validator) p.SetState(3375) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserNO, PostgreSQLParserVALIDATOR: p.EnterOuterAlt(localctx, 1) { p.SetState(3373) p.Validator_clause() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_proceduralContext is an interface to support dynamic dispatch. type IOpt_proceduralContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures PROCEDURAL() antlr.TerminalNode // IsOpt_proceduralContext differentiates from other interfaces. IsOpt_proceduralContext() } type Opt_proceduralContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_proceduralContext() *Opt_proceduralContext { var p = new(Opt_proceduralContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_procedural return p } func InitEmptyOpt_proceduralContext(p *Opt_proceduralContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_procedural } func (*Opt_proceduralContext) IsOpt_proceduralContext() {} func NewOpt_proceduralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_proceduralContext { var p = new(Opt_proceduralContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_procedural return p } func (s *Opt_proceduralContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_proceduralContext) PROCEDURAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURAL, 0) } func (s *Opt_proceduralContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_proceduralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_proceduralContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_procedural(s) } } func (s *Opt_proceduralContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_procedural(s) } } func (s *Opt_proceduralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_procedural(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_procedural() (localctx IOpt_proceduralContext) { localctx = NewOpt_proceduralContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 308, PostgreSQLParserRULE_opt_procedural) p.SetState(3379) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserPROCEDURAL: p.EnterOuterAlt(localctx, 1) { p.SetState(3377) p.Match(PostgreSQLParserPROCEDURAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserLANGUAGE: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatetablespacestmtContext is an interface to support dynamic dispatch. type ICreatetablespacestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode TABLESPACE() antlr.TerminalNode Name() INameContext Opttablespaceowner() IOpttablespaceownerContext LOCATION() antlr.TerminalNode Sconst() ISconstContext Opt_reloptions() IOpt_reloptionsContext // IsCreatetablespacestmtContext differentiates from other interfaces. IsCreatetablespacestmtContext() } type CreatetablespacestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatetablespacestmtContext() *CreatetablespacestmtContext { var p = new(CreatetablespacestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createtablespacestmt return p } func InitEmptyCreatetablespacestmtContext(p *CreatetablespacestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createtablespacestmt } func (*CreatetablespacestmtContext) IsCreatetablespacestmtContext() {} func NewCreatetablespacestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatetablespacestmtContext { var p = new(CreatetablespacestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createtablespacestmt return p } func (s *CreatetablespacestmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreatetablespacestmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreatetablespacestmtContext) TABLESPACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, 0) } func (s *CreatetablespacestmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreatetablespacestmtContext) Opttablespaceowner() IOpttablespaceownerContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttablespaceownerContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttablespaceownerContext) } func (s *CreatetablespacestmtContext) LOCATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCATION, 0) } func (s *CreatetablespacestmtContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *CreatetablespacestmtContext) Opt_reloptions() IOpt_reloptionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_reloptionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_reloptionsContext) } func (s *CreatetablespacestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreatetablespacestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreatetablespacestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatetablespacestmt(s) } } func (s *CreatetablespacestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatetablespacestmt(s) } } func (s *CreatetablespacestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatetablespacestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createtablespacestmt() (localctx ICreatetablespacestmtContext) { localctx = NewCreatetablespacestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 310, PostgreSQLParserRULE_createtablespacestmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3381) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3382) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3383) p.Name() } { p.SetState(3384) p.Opttablespaceowner() } { p.SetState(3385) p.Match(PostgreSQLParserLOCATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3386) p.Sconst() } { p.SetState(3387) p.Opt_reloptions() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpttablespaceownerContext is an interface to support dynamic dispatch. type IOpttablespaceownerContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OWNER() antlr.TerminalNode Rolespec() IRolespecContext // IsOpttablespaceownerContext differentiates from other interfaces. IsOpttablespaceownerContext() } type OpttablespaceownerContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpttablespaceownerContext() *OpttablespaceownerContext { var p = new(OpttablespaceownerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opttablespaceowner return p } func InitEmptyOpttablespaceownerContext(p *OpttablespaceownerContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opttablespaceowner } func (*OpttablespaceownerContext) IsOpttablespaceownerContext() {} func NewOpttablespaceownerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttablespaceownerContext { var p = new(OpttablespaceownerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opttablespaceowner return p } func (s *OpttablespaceownerContext) GetParser() antlr.Parser { return s.parser } func (s *OpttablespaceownerContext) OWNER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOWNER, 0) } func (s *OpttablespaceownerContext) Rolespec() IRolespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRolespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRolespecContext) } func (s *OpttablespaceownerContext) GetRuleContext() antlr.RuleContext { return s } func (s *OpttablespaceownerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OpttablespaceownerContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpttablespaceowner(s) } } func (s *OpttablespaceownerContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpttablespaceowner(s) } } func (s *OpttablespaceownerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpttablespaceowner(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opttablespaceowner() (localctx IOpttablespaceownerContext) { localctx = NewOpttablespaceownerContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 312, PostgreSQLParserRULE_opttablespaceowner) p.SetState(3392) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOWNER: p.EnterOuterAlt(localctx, 1) { p.SetState(3389) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3390) p.Rolespec() } case PostgreSQLParserLOCATION: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDroptablespacestmtContext is an interface to support dynamic dispatch. type IDroptablespacestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DROP() antlr.TerminalNode TABLESPACE() antlr.TerminalNode Name() INameContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsDroptablespacestmtContext differentiates from other interfaces. IsDroptablespacestmtContext() } type DroptablespacestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDroptablespacestmtContext() *DroptablespacestmtContext { var p = new(DroptablespacestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_droptablespacestmt return p } func InitEmptyDroptablespacestmtContext(p *DroptablespacestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_droptablespacestmt } func (*DroptablespacestmtContext) IsDroptablespacestmtContext() {} func NewDroptablespacestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DroptablespacestmtContext { var p = new(DroptablespacestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_droptablespacestmt return p } func (s *DroptablespacestmtContext) GetParser() antlr.Parser { return s.parser } func (s *DroptablespacestmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *DroptablespacestmtContext) TABLESPACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, 0) } func (s *DroptablespacestmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *DroptablespacestmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *DroptablespacestmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *DroptablespacestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DroptablespacestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DroptablespacestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDroptablespacestmt(s) } } func (s *DroptablespacestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDroptablespacestmt(s) } } func (s *DroptablespacestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDroptablespacestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Droptablespacestmt() (localctx IDroptablespacestmtContext) { localctx = NewDroptablespacestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 314, PostgreSQLParserRULE_droptablespacestmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3394) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3395) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(3398) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 147, p.GetParserRuleContext()) == 1 { { p.SetState(3396) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3397) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(3400) p.Name() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateextensionstmtContext is an interface to support dynamic dispatch. type ICreateextensionstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode EXTENSION() antlr.TerminalNode Name() INameContext Opt_with() IOpt_withContext Create_extension_opt_list() ICreate_extension_opt_listContext IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsCreateextensionstmtContext differentiates from other interfaces. IsCreateextensionstmtContext() } type CreateextensionstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateextensionstmtContext() *CreateextensionstmtContext { var p = new(CreateextensionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createextensionstmt return p } func InitEmptyCreateextensionstmtContext(p *CreateextensionstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createextensionstmt } func (*CreateextensionstmtContext) IsCreateextensionstmtContext() {} func NewCreateextensionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateextensionstmtContext { var p = new(CreateextensionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createextensionstmt return p } func (s *CreateextensionstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateextensionstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateextensionstmtContext) EXTENSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXTENSION, 0) } func (s *CreateextensionstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreateextensionstmtContext) Opt_with() IOpt_withContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_withContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_withContext) } func (s *CreateextensionstmtContext) Create_extension_opt_list() ICreate_extension_opt_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreate_extension_opt_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreate_extension_opt_listContext) } func (s *CreateextensionstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *CreateextensionstmtContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *CreateextensionstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *CreateextensionstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateextensionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateextensionstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateextensionstmt(s) } } func (s *CreateextensionstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateextensionstmt(s) } } func (s *CreateextensionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateextensionstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createextensionstmt() (localctx ICreateextensionstmtContext) { localctx = NewCreateextensionstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 316, PostgreSQLParserRULE_createextensionstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3402) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3403) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(3407) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 148, p.GetParserRuleContext()) == 1 { { p.SetState(3404) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3405) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3406) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(3409) p.Name() } { p.SetState(3410) p.Opt_with() } { p.SetState(3411) p.Create_extension_opt_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreate_extension_opt_listContext is an interface to support dynamic dispatch. type ICreate_extension_opt_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllCreate_extension_opt_item() []ICreate_extension_opt_itemContext Create_extension_opt_item(i int) ICreate_extension_opt_itemContext // IsCreate_extension_opt_listContext differentiates from other interfaces. IsCreate_extension_opt_listContext() } type Create_extension_opt_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreate_extension_opt_listContext() *Create_extension_opt_listContext { var p = new(Create_extension_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_create_extension_opt_list return p } func InitEmptyCreate_extension_opt_listContext(p *Create_extension_opt_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_create_extension_opt_list } func (*Create_extension_opt_listContext) IsCreate_extension_opt_listContext() {} func NewCreate_extension_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_extension_opt_listContext { var p = new(Create_extension_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_create_extension_opt_list return p } func (s *Create_extension_opt_listContext) GetParser() antlr.Parser { return s.parser } func (s *Create_extension_opt_listContext) AllCreate_extension_opt_item() []ICreate_extension_opt_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ICreate_extension_opt_itemContext); ok { len++ } } tst := make([]ICreate_extension_opt_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ICreate_extension_opt_itemContext); ok { tst[i] = t.(ICreate_extension_opt_itemContext) i++ } } return tst } func (s *Create_extension_opt_listContext) Create_extension_opt_item(i int) ICreate_extension_opt_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreate_extension_opt_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ICreate_extension_opt_itemContext) } func (s *Create_extension_opt_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Create_extension_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Create_extension_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreate_extension_opt_list(s) } } func (s *Create_extension_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreate_extension_opt_list(s) } } func (s *Create_extension_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreate_extension_opt_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Create_extension_opt_list() (localctx ICreate_extension_opt_listContext) { localctx = NewCreate_extension_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 318, PostgreSQLParserRULE_create_extension_opt_list) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(3416) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserFROM || _la == PostgreSQLParserCASCADE || _la == PostgreSQLParserSCHEMA || _la == PostgreSQLParserVERSION_P { { p.SetState(3413) p.Create_extension_opt_item() } p.SetState(3418) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreate_extension_opt_itemContext is an interface to support dynamic dispatch. type ICreate_extension_opt_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SCHEMA() antlr.TerminalNode Name() INameContext VERSION_P() antlr.TerminalNode Nonreservedword_or_sconst() INonreservedword_or_sconstContext FROM() antlr.TerminalNode CASCADE() antlr.TerminalNode // IsCreate_extension_opt_itemContext differentiates from other interfaces. IsCreate_extension_opt_itemContext() } type Create_extension_opt_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreate_extension_opt_itemContext() *Create_extension_opt_itemContext { var p = new(Create_extension_opt_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_create_extension_opt_item return p } func InitEmptyCreate_extension_opt_itemContext(p *Create_extension_opt_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_create_extension_opt_item } func (*Create_extension_opt_itemContext) IsCreate_extension_opt_itemContext() {} func NewCreate_extension_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_extension_opt_itemContext { var p = new(Create_extension_opt_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_create_extension_opt_item return p } func (s *Create_extension_opt_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Create_extension_opt_itemContext) SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMA, 0) } func (s *Create_extension_opt_itemContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *Create_extension_opt_itemContext) VERSION_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVERSION_P, 0) } func (s *Create_extension_opt_itemContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INonreservedword_or_sconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INonreservedword_or_sconstContext) } func (s *Create_extension_opt_itemContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *Create_extension_opt_itemContext) CASCADE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCASCADE, 0) } func (s *Create_extension_opt_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Create_extension_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Create_extension_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreate_extension_opt_item(s) } } func (s *Create_extension_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreate_extension_opt_item(s) } } func (s *Create_extension_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreate_extension_opt_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Create_extension_opt_item() (localctx ICreate_extension_opt_itemContext) { localctx = NewCreate_extension_opt_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 320, PostgreSQLParserRULE_create_extension_opt_item) p.SetState(3426) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSCHEMA: p.EnterOuterAlt(localctx, 1) { p.SetState(3419) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3420) p.Name() } case PostgreSQLParserVERSION_P: p.EnterOuterAlt(localctx, 2) { p.SetState(3421) p.Match(PostgreSQLParserVERSION_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3422) p.Nonreservedword_or_sconst() } case PostgreSQLParserFROM: p.EnterOuterAlt(localctx, 3) { p.SetState(3423) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3424) p.Nonreservedword_or_sconst() } case PostgreSQLParserCASCADE: p.EnterOuterAlt(localctx, 4) { p.SetState(3425) p.Match(PostgreSQLParserCASCADE) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterextensionstmtContext is an interface to support dynamic dispatch. type IAlterextensionstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode EXTENSION() antlr.TerminalNode Name() INameContext UPDATE() antlr.TerminalNode Alter_extension_opt_list() IAlter_extension_opt_listContext // IsAlterextensionstmtContext differentiates from other interfaces. IsAlterextensionstmtContext() } type AlterextensionstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterextensionstmtContext() *AlterextensionstmtContext { var p = new(AlterextensionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterextensionstmt return p } func InitEmptyAlterextensionstmtContext(p *AlterextensionstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterextensionstmt } func (*AlterextensionstmtContext) IsAlterextensionstmtContext() {} func NewAlterextensionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterextensionstmtContext { var p = new(AlterextensionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterextensionstmt return p } func (s *AlterextensionstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterextensionstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterextensionstmtContext) EXTENSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXTENSION, 0) } func (s *AlterextensionstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *AlterextensionstmtContext) UPDATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUPDATE, 0) } func (s *AlterextensionstmtContext) Alter_extension_opt_list() IAlter_extension_opt_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_extension_opt_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlter_extension_opt_listContext) } func (s *AlterextensionstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterextensionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterextensionstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterextensionstmt(s) } } func (s *AlterextensionstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterextensionstmt(s) } } func (s *AlterextensionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterextensionstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterextensionstmt() (localctx IAlterextensionstmtContext) { localctx = NewAlterextensionstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 322, PostgreSQLParserRULE_alterextensionstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3428) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3429) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3430) p.Name() } { p.SetState(3431) p.Match(PostgreSQLParserUPDATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3432) p.Alter_extension_opt_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlter_extension_opt_listContext is an interface to support dynamic dispatch. type IAlter_extension_opt_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllAlter_extension_opt_item() []IAlter_extension_opt_itemContext Alter_extension_opt_item(i int) IAlter_extension_opt_itemContext // IsAlter_extension_opt_listContext differentiates from other interfaces. IsAlter_extension_opt_listContext() } type Alter_extension_opt_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlter_extension_opt_listContext() *Alter_extension_opt_listContext { var p = new(Alter_extension_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_extension_opt_list return p } func InitEmptyAlter_extension_opt_listContext(p *Alter_extension_opt_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_extension_opt_list } func (*Alter_extension_opt_listContext) IsAlter_extension_opt_listContext() {} func NewAlter_extension_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_extension_opt_listContext { var p = new(Alter_extension_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alter_extension_opt_list return p } func (s *Alter_extension_opt_listContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_extension_opt_listContext) AllAlter_extension_opt_item() []IAlter_extension_opt_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAlter_extension_opt_itemContext); ok { len++ } } tst := make([]IAlter_extension_opt_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAlter_extension_opt_itemContext); ok { tst[i] = t.(IAlter_extension_opt_itemContext) i++ } } return tst } func (s *Alter_extension_opt_listContext) Alter_extension_opt_item(i int) IAlter_extension_opt_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_extension_opt_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAlter_extension_opt_itemContext) } func (s *Alter_extension_opt_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alter_extension_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alter_extension_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlter_extension_opt_list(s) } } func (s *Alter_extension_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlter_extension_opt_list(s) } } func (s *Alter_extension_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlter_extension_opt_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alter_extension_opt_list() (localctx IAlter_extension_opt_listContext) { localctx = NewAlter_extension_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 324, PostgreSQLParserRULE_alter_extension_opt_list) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(3437) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserTO { { p.SetState(3434) p.Alter_extension_opt_item() } p.SetState(3439) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlter_extension_opt_itemContext is an interface to support dynamic dispatch. type IAlter_extension_opt_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TO() antlr.TerminalNode Nonreservedword_or_sconst() INonreservedword_or_sconstContext // IsAlter_extension_opt_itemContext differentiates from other interfaces. IsAlter_extension_opt_itemContext() } type Alter_extension_opt_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlter_extension_opt_itemContext() *Alter_extension_opt_itemContext { var p = new(Alter_extension_opt_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_extension_opt_item return p } func InitEmptyAlter_extension_opt_itemContext(p *Alter_extension_opt_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_extension_opt_item } func (*Alter_extension_opt_itemContext) IsAlter_extension_opt_itemContext() {} func NewAlter_extension_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_extension_opt_itemContext { var p = new(Alter_extension_opt_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alter_extension_opt_item return p } func (s *Alter_extension_opt_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_extension_opt_itemContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *Alter_extension_opt_itemContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INonreservedword_or_sconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INonreservedword_or_sconstContext) } func (s *Alter_extension_opt_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alter_extension_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alter_extension_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlter_extension_opt_item(s) } } func (s *Alter_extension_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlter_extension_opt_item(s) } } func (s *Alter_extension_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlter_extension_opt_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alter_extension_opt_item() (localctx IAlter_extension_opt_itemContext) { localctx = NewAlter_extension_opt_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 326, PostgreSQLParserRULE_alter_extension_opt_item) p.EnterOuterAlt(localctx, 1) { p.SetState(3440) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3441) p.Nonreservedword_or_sconst() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterextensioncontentsstmtContext is an interface to support dynamic dispatch. type IAlterextensioncontentsstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode EXTENSION() antlr.TerminalNode AllName() []INameContext Name(i int) INameContext Add_drop() IAdd_dropContext Object_type_name() IObject_type_nameContext Object_type_any_name() IObject_type_any_nameContext Any_name() IAny_nameContext AGGREGATE() antlr.TerminalNode Aggregate_with_argtypes() IAggregate_with_argtypesContext CAST() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode AllTypename() []ITypenameContext Typename(i int) ITypenameContext AS() antlr.TerminalNode CLOSE_PAREN() antlr.TerminalNode DOMAIN_P() antlr.TerminalNode FUNCTION() antlr.TerminalNode Function_with_argtypes() IFunction_with_argtypesContext OPERATOR() antlr.TerminalNode Operator_with_argtypes() IOperator_with_argtypesContext CLASS() antlr.TerminalNode USING() antlr.TerminalNode FAMILY() antlr.TerminalNode PROCEDURE() antlr.TerminalNode ROUTINE() antlr.TerminalNode TRANSFORM() antlr.TerminalNode FOR() antlr.TerminalNode LANGUAGE() antlr.TerminalNode TYPE_P() antlr.TerminalNode // IsAlterextensioncontentsstmtContext differentiates from other interfaces. IsAlterextensioncontentsstmtContext() } type AlterextensioncontentsstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterextensioncontentsstmtContext() *AlterextensioncontentsstmtContext { var p = new(AlterextensioncontentsstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterextensioncontentsstmt return p } func InitEmptyAlterextensioncontentsstmtContext(p *AlterextensioncontentsstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterextensioncontentsstmt } func (*AlterextensioncontentsstmtContext) IsAlterextensioncontentsstmtContext() {} func NewAlterextensioncontentsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterextensioncontentsstmtContext { var p = new(AlterextensioncontentsstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterextensioncontentsstmt return p } func (s *AlterextensioncontentsstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterextensioncontentsstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterextensioncontentsstmtContext) EXTENSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXTENSION, 0) } func (s *AlterextensioncontentsstmtContext) AllName() []INameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(INameContext); ok { len++ } } tst := make([]INameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(INameContext); ok { tst[i] = t.(INameContext) i++ } } return tst } func (s *AlterextensioncontentsstmtContext) Name(i int) INameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(INameContext) } func (s *AlterextensioncontentsstmtContext) Add_drop() IAdd_dropContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAdd_dropContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAdd_dropContext) } func (s *AlterextensioncontentsstmtContext) Object_type_name() IObject_type_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IObject_type_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IObject_type_nameContext) } func (s *AlterextensioncontentsstmtContext) Object_type_any_name() IObject_type_any_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IObject_type_any_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IObject_type_any_nameContext) } func (s *AlterextensioncontentsstmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *AlterextensioncontentsstmtContext) AGGREGATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAGGREGATE, 0) } func (s *AlterextensioncontentsstmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAggregate_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAggregate_with_argtypesContext) } func (s *AlterextensioncontentsstmtContext) CAST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCAST, 0) } func (s *AlterextensioncontentsstmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *AlterextensioncontentsstmtContext) AllTypename() []ITypenameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITypenameContext); ok { len++ } } tst := make([]ITypenameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITypenameContext); ok { tst[i] = t.(ITypenameContext) i++ } } return tst } func (s *AlterextensioncontentsstmtContext) Typename(i int) ITypenameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITypenameContext) } func (s *AlterextensioncontentsstmtContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *AlterextensioncontentsstmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *AlterextensioncontentsstmtContext) DOMAIN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOMAIN_P, 0) } func (s *AlterextensioncontentsstmtContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *AlterextensioncontentsstmtContext) Function_with_argtypes() IFunction_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunction_with_argtypesContext) } func (s *AlterextensioncontentsstmtContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *AlterextensioncontentsstmtContext) Operator_with_argtypes() IOperator_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOperator_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOperator_with_argtypesContext) } func (s *AlterextensioncontentsstmtContext) CLASS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLASS, 0) } func (s *AlterextensioncontentsstmtContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *AlterextensioncontentsstmtContext) FAMILY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFAMILY, 0) } func (s *AlterextensioncontentsstmtContext) PROCEDURE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURE, 0) } func (s *AlterextensioncontentsstmtContext) ROUTINE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUTINE, 0) } func (s *AlterextensioncontentsstmtContext) TRANSFORM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSFORM, 0) } func (s *AlterextensioncontentsstmtContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *AlterextensioncontentsstmtContext) LANGUAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLANGUAGE, 0) } func (s *AlterextensioncontentsstmtContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *AlterextensioncontentsstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterextensioncontentsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterextensioncontentsstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterextensioncontentsstmt(s) } } func (s *AlterextensioncontentsstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterextensioncontentsstmt(s) } } func (s *AlterextensioncontentsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterextensioncontentsstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterextensioncontentsstmt() (localctx IAlterextensioncontentsstmtContext) { localctx = NewAlterextensioncontentsstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 328, PostgreSQLParserRULE_alterextensioncontentsstmt) p.SetState(3547) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 152, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3443) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3444) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3445) p.Name() } { p.SetState(3446) p.Add_drop() } { p.SetState(3447) p.Object_type_name() } { p.SetState(3448) p.Name() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(3450) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3451) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3452) p.Name() } { p.SetState(3453) p.Add_drop() } { p.SetState(3454) p.Object_type_any_name() } { p.SetState(3455) p.Any_name() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(3457) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3458) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3459) p.Name() } { p.SetState(3460) p.Add_drop() } { p.SetState(3461) p.Match(PostgreSQLParserAGGREGATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3462) p.Aggregate_with_argtypes() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(3464) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3465) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3466) p.Name() } { p.SetState(3467) p.Add_drop() } { p.SetState(3468) p.Match(PostgreSQLParserCAST) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3469) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3470) p.Typename() } { p.SetState(3471) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3472) p.Typename() } { p.SetState(3473) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(3475) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3476) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3477) p.Name() } { p.SetState(3478) p.Add_drop() } { p.SetState(3479) p.Match(PostgreSQLParserDOMAIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3480) p.Typename() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(3482) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3483) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3484) p.Name() } { p.SetState(3485) p.Add_drop() } { p.SetState(3486) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3487) p.Function_with_argtypes() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(3489) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3490) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3491) p.Name() } { p.SetState(3492) p.Add_drop() } { p.SetState(3493) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3494) p.Operator_with_argtypes() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(3496) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3497) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3498) p.Name() } { p.SetState(3499) p.Add_drop() } { p.SetState(3500) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3501) p.Match(PostgreSQLParserCLASS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3502) p.Any_name() } { p.SetState(3503) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3504) p.Name() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(3506) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3507) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3508) p.Name() } { p.SetState(3509) p.Add_drop() } { p.SetState(3510) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3511) p.Match(PostgreSQLParserFAMILY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3512) p.Any_name() } { p.SetState(3513) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3514) p.Name() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(3516) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3517) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3518) p.Name() } { p.SetState(3519) p.Add_drop() } { p.SetState(3520) p.Match(PostgreSQLParserPROCEDURE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3521) p.Function_with_argtypes() } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(3523) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3524) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3525) p.Name() } { p.SetState(3526) p.Add_drop() } { p.SetState(3527) p.Match(PostgreSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3528) p.Function_with_argtypes() } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(3530) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3531) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3532) p.Name() } { p.SetState(3533) p.Add_drop() } { p.SetState(3534) p.Match(PostgreSQLParserTRANSFORM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3535) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3536) p.Typename() } { p.SetState(3537) p.Match(PostgreSQLParserLANGUAGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3538) p.Name() } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(3540) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3541) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3542) p.Name() } { p.SetState(3543) p.Add_drop() } { p.SetState(3544) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3545) p.Typename() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatefdwstmtContext is an interface to support dynamic dispatch. type ICreatefdwstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode FOREIGN() antlr.TerminalNode DATA_P() antlr.TerminalNode WRAPPER() antlr.TerminalNode Name() INameContext Opt_fdw_options() IOpt_fdw_optionsContext Create_generic_options() ICreate_generic_optionsContext // IsCreatefdwstmtContext differentiates from other interfaces. IsCreatefdwstmtContext() } type CreatefdwstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatefdwstmtContext() *CreatefdwstmtContext { var p = new(CreatefdwstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createfdwstmt return p } func InitEmptyCreatefdwstmtContext(p *CreatefdwstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createfdwstmt } func (*CreatefdwstmtContext) IsCreatefdwstmtContext() {} func NewCreatefdwstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatefdwstmtContext { var p = new(CreatefdwstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createfdwstmt return p } func (s *CreatefdwstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreatefdwstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreatefdwstmtContext) FOREIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREIGN, 0) } func (s *CreatefdwstmtContext) DATA_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATA_P, 0) } func (s *CreatefdwstmtContext) WRAPPER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWRAPPER, 0) } func (s *CreatefdwstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreatefdwstmtContext) Opt_fdw_options() IOpt_fdw_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_fdw_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_fdw_optionsContext) } func (s *CreatefdwstmtContext) Create_generic_options() ICreate_generic_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreate_generic_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreate_generic_optionsContext) } func (s *CreatefdwstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreatefdwstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreatefdwstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatefdwstmt(s) } } func (s *CreatefdwstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatefdwstmt(s) } } func (s *CreatefdwstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatefdwstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createfdwstmt() (localctx ICreatefdwstmtContext) { localctx = NewCreatefdwstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 330, PostgreSQLParserRULE_createfdwstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3549) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3550) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3551) p.Match(PostgreSQLParserDATA_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3552) p.Match(PostgreSQLParserWRAPPER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3553) p.Name() } { p.SetState(3554) p.Opt_fdw_options() } { p.SetState(3555) p.Create_generic_options() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFdw_optionContext is an interface to support dynamic dispatch. type IFdw_optionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures HANDLER() antlr.TerminalNode Handler_name() IHandler_nameContext NO() antlr.TerminalNode VALIDATOR() antlr.TerminalNode // IsFdw_optionContext differentiates from other interfaces. IsFdw_optionContext() } type Fdw_optionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFdw_optionContext() *Fdw_optionContext { var p = new(Fdw_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_fdw_option return p } func InitEmptyFdw_optionContext(p *Fdw_optionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_fdw_option } func (*Fdw_optionContext) IsFdw_optionContext() {} func NewFdw_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fdw_optionContext { var p = new(Fdw_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_fdw_option return p } func (s *Fdw_optionContext) GetParser() antlr.Parser { return s.parser } func (s *Fdw_optionContext) HANDLER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserHANDLER, 0) } func (s *Fdw_optionContext) Handler_name() IHandler_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IHandler_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IHandler_nameContext) } func (s *Fdw_optionContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Fdw_optionContext) VALIDATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALIDATOR, 0) } func (s *Fdw_optionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Fdw_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Fdw_optionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFdw_option(s) } } func (s *Fdw_optionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFdw_option(s) } } func (s *Fdw_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFdw_option(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Fdw_option() (localctx IFdw_optionContext) { localctx = NewFdw_optionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 332, PostgreSQLParserRULE_fdw_option) p.SetState(3565) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 153, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3557) p.Match(PostgreSQLParserHANDLER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3558) p.Handler_name() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(3559) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3560) p.Match(PostgreSQLParserHANDLER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(3561) p.Match(PostgreSQLParserVALIDATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3562) p.Handler_name() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(3563) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3564) p.Match(PostgreSQLParserVALIDATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFdw_optionsContext is an interface to support dynamic dispatch. type IFdw_optionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllFdw_option() []IFdw_optionContext Fdw_option(i int) IFdw_optionContext // IsFdw_optionsContext differentiates from other interfaces. IsFdw_optionsContext() } type Fdw_optionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFdw_optionsContext() *Fdw_optionsContext { var p = new(Fdw_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_fdw_options return p } func InitEmptyFdw_optionsContext(p *Fdw_optionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_fdw_options } func (*Fdw_optionsContext) IsFdw_optionsContext() {} func NewFdw_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fdw_optionsContext { var p = new(Fdw_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_fdw_options return p } func (s *Fdw_optionsContext) GetParser() antlr.Parser { return s.parser } func (s *Fdw_optionsContext) AllFdw_option() []IFdw_optionContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IFdw_optionContext); ok { len++ } } tst := make([]IFdw_optionContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IFdw_optionContext); ok { tst[i] = t.(IFdw_optionContext) i++ } } return tst } func (s *Fdw_optionsContext) Fdw_option(i int) IFdw_optionContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFdw_optionContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IFdw_optionContext) } func (s *Fdw_optionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Fdw_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Fdw_optionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFdw_options(s) } } func (s *Fdw_optionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFdw_options(s) } } func (s *Fdw_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFdw_options(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Fdw_options() (localctx IFdw_optionsContext) { localctx = NewFdw_optionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 334, PostgreSQLParserRULE_fdw_options) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(3568) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ok := true; ok; ok = _la == PostgreSQLParserHANDLER || _la == PostgreSQLParserNO || _la == PostgreSQLParserVALIDATOR { { p.SetState(3567) p.Fdw_option() } p.SetState(3570) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_fdw_optionsContext is an interface to support dynamic dispatch. type IOpt_fdw_optionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Fdw_options() IFdw_optionsContext // IsOpt_fdw_optionsContext differentiates from other interfaces. IsOpt_fdw_optionsContext() } type Opt_fdw_optionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_fdw_optionsContext() *Opt_fdw_optionsContext { var p = new(Opt_fdw_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_fdw_options return p } func InitEmptyOpt_fdw_optionsContext(p *Opt_fdw_optionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_fdw_options } func (*Opt_fdw_optionsContext) IsOpt_fdw_optionsContext() {} func NewOpt_fdw_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_fdw_optionsContext { var p = new(Opt_fdw_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_fdw_options return p } func (s *Opt_fdw_optionsContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_fdw_optionsContext) Fdw_options() IFdw_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFdw_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFdw_optionsContext) } func (s *Opt_fdw_optionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_fdw_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_fdw_optionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_fdw_options(s) } } func (s *Opt_fdw_optionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_fdw_options(s) } } func (s *Opt_fdw_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_fdw_options(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_fdw_options() (localctx IOpt_fdw_optionsContext) { localctx = NewOpt_fdw_optionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 336, PostgreSQLParserRULE_opt_fdw_options) p.SetState(3574) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserHANDLER, PostgreSQLParserNO, PostgreSQLParserVALIDATOR: p.EnterOuterAlt(localctx, 1) { p.SetState(3572) p.Fdw_options() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserOPTIONS, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterfdwstmtContext is an interface to support dynamic dispatch. type IAlterfdwstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode FOREIGN() antlr.TerminalNode DATA_P() antlr.TerminalNode WRAPPER() antlr.TerminalNode Name() INameContext Opt_fdw_options() IOpt_fdw_optionsContext Alter_generic_options() IAlter_generic_optionsContext Fdw_options() IFdw_optionsContext // IsAlterfdwstmtContext differentiates from other interfaces. IsAlterfdwstmtContext() } type AlterfdwstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterfdwstmtContext() *AlterfdwstmtContext { var p = new(AlterfdwstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterfdwstmt return p } func InitEmptyAlterfdwstmtContext(p *AlterfdwstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterfdwstmt } func (*AlterfdwstmtContext) IsAlterfdwstmtContext() {} func NewAlterfdwstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterfdwstmtContext { var p = new(AlterfdwstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterfdwstmt return p } func (s *AlterfdwstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterfdwstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterfdwstmtContext) FOREIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREIGN, 0) } func (s *AlterfdwstmtContext) DATA_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATA_P, 0) } func (s *AlterfdwstmtContext) WRAPPER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWRAPPER, 0) } func (s *AlterfdwstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *AlterfdwstmtContext) Opt_fdw_options() IOpt_fdw_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_fdw_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_fdw_optionsContext) } func (s *AlterfdwstmtContext) Alter_generic_options() IAlter_generic_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_generic_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlter_generic_optionsContext) } func (s *AlterfdwstmtContext) Fdw_options() IFdw_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFdw_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFdw_optionsContext) } func (s *AlterfdwstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterfdwstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterfdwstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterfdwstmt(s) } } func (s *AlterfdwstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterfdwstmt(s) } } func (s *AlterfdwstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterfdwstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterfdwstmt() (localctx IAlterfdwstmtContext) { localctx = NewAlterfdwstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 338, PostgreSQLParserRULE_alterfdwstmt) p.SetState(3591) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 156, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3576) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3577) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3578) p.Match(PostgreSQLParserDATA_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3579) p.Match(PostgreSQLParserWRAPPER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3580) p.Name() } { p.SetState(3581) p.Opt_fdw_options() } { p.SetState(3582) p.Alter_generic_options() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(3584) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3585) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3586) p.Match(PostgreSQLParserDATA_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3587) p.Match(PostgreSQLParserWRAPPER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3588) p.Name() } { p.SetState(3589) p.Fdw_options() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreate_generic_optionsContext is an interface to support dynamic dispatch. type ICreate_generic_optionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPTIONS() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Generic_option_list() IGeneric_option_listContext CLOSE_PAREN() antlr.TerminalNode // IsCreate_generic_optionsContext differentiates from other interfaces. IsCreate_generic_optionsContext() } type Create_generic_optionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreate_generic_optionsContext() *Create_generic_optionsContext { var p = new(Create_generic_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_create_generic_options return p } func InitEmptyCreate_generic_optionsContext(p *Create_generic_optionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_create_generic_options } func (*Create_generic_optionsContext) IsCreate_generic_optionsContext() {} func NewCreate_generic_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_generic_optionsContext { var p = new(Create_generic_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_create_generic_options return p } func (s *Create_generic_optionsContext) GetParser() antlr.Parser { return s.parser } func (s *Create_generic_optionsContext) OPTIONS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPTIONS, 0) } func (s *Create_generic_optionsContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Create_generic_optionsContext) Generic_option_list() IGeneric_option_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGeneric_option_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGeneric_option_listContext) } func (s *Create_generic_optionsContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Create_generic_optionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Create_generic_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Create_generic_optionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreate_generic_options(s) } } func (s *Create_generic_optionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreate_generic_options(s) } } func (s *Create_generic_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreate_generic_options(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Create_generic_options() (localctx ICreate_generic_optionsContext) { localctx = NewCreate_generic_optionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 340, PostgreSQLParserRULE_create_generic_options) p.SetState(3599) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPTIONS: p.EnterOuterAlt(localctx, 1) { p.SetState(3593) p.Match(PostgreSQLParserOPTIONS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3594) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3595) p.Generic_option_list() } { p.SetState(3596) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserDEFAULT, PostgreSQLParserDEFERRABLE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINITIALLY, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserPRIMARY, PostgreSQLParserREFERENCES, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUNIQUE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserGENERATED, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGeneric_option_listContext is an interface to support dynamic dispatch. type IGeneric_option_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllGeneric_option_elem() []IGeneric_option_elemContext Generic_option_elem(i int) IGeneric_option_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsGeneric_option_listContext differentiates from other interfaces. IsGeneric_option_listContext() } type Generic_option_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGeneric_option_listContext() *Generic_option_listContext { var p = new(Generic_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generic_option_list return p } func InitEmptyGeneric_option_listContext(p *Generic_option_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generic_option_list } func (*Generic_option_listContext) IsGeneric_option_listContext() {} func NewGeneric_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_option_listContext { var p = new(Generic_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_generic_option_list return p } func (s *Generic_option_listContext) GetParser() antlr.Parser { return s.parser } func (s *Generic_option_listContext) AllGeneric_option_elem() []IGeneric_option_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IGeneric_option_elemContext); ok { len++ } } tst := make([]IGeneric_option_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IGeneric_option_elemContext); ok { tst[i] = t.(IGeneric_option_elemContext) i++ } } return tst } func (s *Generic_option_listContext) Generic_option_elem(i int) IGeneric_option_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGeneric_option_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IGeneric_option_elemContext) } func (s *Generic_option_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Generic_option_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Generic_option_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Generic_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Generic_option_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGeneric_option_list(s) } } func (s *Generic_option_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGeneric_option_list(s) } } func (s *Generic_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGeneric_option_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Generic_option_list() (localctx IGeneric_option_listContext) { localctx = NewGeneric_option_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 342, PostgreSQLParserRULE_generic_option_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3601) p.Generic_option_elem() } p.SetState(3606) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(3602) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3603) p.Generic_option_elem() } p.SetState(3608) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlter_generic_optionsContext is an interface to support dynamic dispatch. type IAlter_generic_optionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPTIONS() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Alter_generic_option_list() IAlter_generic_option_listContext CLOSE_PAREN() antlr.TerminalNode // IsAlter_generic_optionsContext differentiates from other interfaces. IsAlter_generic_optionsContext() } type Alter_generic_optionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlter_generic_optionsContext() *Alter_generic_optionsContext { var p = new(Alter_generic_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_generic_options return p } func InitEmptyAlter_generic_optionsContext(p *Alter_generic_optionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_generic_options } func (*Alter_generic_optionsContext) IsAlter_generic_optionsContext() {} func NewAlter_generic_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_generic_optionsContext { var p = new(Alter_generic_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alter_generic_options return p } func (s *Alter_generic_optionsContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_generic_optionsContext) OPTIONS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPTIONS, 0) } func (s *Alter_generic_optionsContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Alter_generic_optionsContext) Alter_generic_option_list() IAlter_generic_option_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_generic_option_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlter_generic_option_listContext) } func (s *Alter_generic_optionsContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Alter_generic_optionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alter_generic_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alter_generic_optionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlter_generic_options(s) } } func (s *Alter_generic_optionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlter_generic_options(s) } } func (s *Alter_generic_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlter_generic_options(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alter_generic_options() (localctx IAlter_generic_optionsContext) { localctx = NewAlter_generic_optionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 344, PostgreSQLParserRULE_alter_generic_options) p.EnterOuterAlt(localctx, 1) { p.SetState(3609) p.Match(PostgreSQLParserOPTIONS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3610) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3611) p.Alter_generic_option_list() } { p.SetState(3612) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlter_generic_option_listContext is an interface to support dynamic dispatch. type IAlter_generic_option_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllAlter_generic_option_elem() []IAlter_generic_option_elemContext Alter_generic_option_elem(i int) IAlter_generic_option_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsAlter_generic_option_listContext differentiates from other interfaces. IsAlter_generic_option_listContext() } type Alter_generic_option_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlter_generic_option_listContext() *Alter_generic_option_listContext { var p = new(Alter_generic_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_generic_option_list return p } func InitEmptyAlter_generic_option_listContext(p *Alter_generic_option_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_generic_option_list } func (*Alter_generic_option_listContext) IsAlter_generic_option_listContext() {} func NewAlter_generic_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_generic_option_listContext { var p = new(Alter_generic_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alter_generic_option_list return p } func (s *Alter_generic_option_listContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_generic_option_listContext) AllAlter_generic_option_elem() []IAlter_generic_option_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAlter_generic_option_elemContext); ok { len++ } } tst := make([]IAlter_generic_option_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAlter_generic_option_elemContext); ok { tst[i] = t.(IAlter_generic_option_elemContext) i++ } } return tst } func (s *Alter_generic_option_listContext) Alter_generic_option_elem(i int) IAlter_generic_option_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_generic_option_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAlter_generic_option_elemContext) } func (s *Alter_generic_option_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Alter_generic_option_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Alter_generic_option_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alter_generic_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alter_generic_option_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlter_generic_option_list(s) } } func (s *Alter_generic_option_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlter_generic_option_list(s) } } func (s *Alter_generic_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlter_generic_option_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alter_generic_option_list() (localctx IAlter_generic_option_listContext) { localctx = NewAlter_generic_option_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 346, PostgreSQLParserRULE_alter_generic_option_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3614) p.Alter_generic_option_elem() } p.SetState(3619) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(3615) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3616) p.Alter_generic_option_elem() } p.SetState(3621) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlter_generic_option_elemContext is an interface to support dynamic dispatch. type IAlter_generic_option_elemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Generic_option_elem() IGeneric_option_elemContext SET() antlr.TerminalNode ADD_P() antlr.TerminalNode DROP() antlr.TerminalNode Generic_option_name() IGeneric_option_nameContext // IsAlter_generic_option_elemContext differentiates from other interfaces. IsAlter_generic_option_elemContext() } type Alter_generic_option_elemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlter_generic_option_elemContext() *Alter_generic_option_elemContext { var p = new(Alter_generic_option_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_generic_option_elem return p } func InitEmptyAlter_generic_option_elemContext(p *Alter_generic_option_elemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alter_generic_option_elem } func (*Alter_generic_option_elemContext) IsAlter_generic_option_elemContext() {} func NewAlter_generic_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_generic_option_elemContext { var p = new(Alter_generic_option_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alter_generic_option_elem return p } func (s *Alter_generic_option_elemContext) GetParser() antlr.Parser { return s.parser } func (s *Alter_generic_option_elemContext) Generic_option_elem() IGeneric_option_elemContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGeneric_option_elemContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGeneric_option_elemContext) } func (s *Alter_generic_option_elemContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *Alter_generic_option_elemContext) ADD_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserADD_P, 0) } func (s *Alter_generic_option_elemContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *Alter_generic_option_elemContext) Generic_option_name() IGeneric_option_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGeneric_option_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGeneric_option_nameContext) } func (s *Alter_generic_option_elemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alter_generic_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alter_generic_option_elemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlter_generic_option_elem(s) } } func (s *Alter_generic_option_elemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlter_generic_option_elem(s) } } func (s *Alter_generic_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlter_generic_option_elem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alter_generic_option_elem() (localctx IAlter_generic_option_elemContext) { localctx = NewAlter_generic_option_elemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 348, PostgreSQLParserRULE_alter_generic_option_elem) p.SetState(3629) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 160, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3622) p.Generic_option_elem() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(3623) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3624) p.Generic_option_elem() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(3625) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3626) p.Generic_option_elem() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(3627) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3628) p.Generic_option_name() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGeneric_option_elemContext is an interface to support dynamic dispatch. type IGeneric_option_elemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Generic_option_name() IGeneric_option_nameContext Generic_option_arg() IGeneric_option_argContext // IsGeneric_option_elemContext differentiates from other interfaces. IsGeneric_option_elemContext() } type Generic_option_elemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGeneric_option_elemContext() *Generic_option_elemContext { var p = new(Generic_option_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generic_option_elem return p } func InitEmptyGeneric_option_elemContext(p *Generic_option_elemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generic_option_elem } func (*Generic_option_elemContext) IsGeneric_option_elemContext() {} func NewGeneric_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_option_elemContext { var p = new(Generic_option_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_generic_option_elem return p } func (s *Generic_option_elemContext) GetParser() antlr.Parser { return s.parser } func (s *Generic_option_elemContext) Generic_option_name() IGeneric_option_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGeneric_option_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGeneric_option_nameContext) } func (s *Generic_option_elemContext) Generic_option_arg() IGeneric_option_argContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGeneric_option_argContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGeneric_option_argContext) } func (s *Generic_option_elemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Generic_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Generic_option_elemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGeneric_option_elem(s) } } func (s *Generic_option_elemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGeneric_option_elem(s) } } func (s *Generic_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGeneric_option_elem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Generic_option_elem() (localctx IGeneric_option_elemContext) { localctx = NewGeneric_option_elemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 350, PostgreSQLParserRULE_generic_option_elem) p.EnterOuterAlt(localctx, 1) { p.SetState(3631) p.Generic_option_name() } { p.SetState(3632) p.Generic_option_arg() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGeneric_option_nameContext is an interface to support dynamic dispatch. type IGeneric_option_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Collabel() ICollabelContext // IsGeneric_option_nameContext differentiates from other interfaces. IsGeneric_option_nameContext() } type Generic_option_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGeneric_option_nameContext() *Generic_option_nameContext { var p = new(Generic_option_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generic_option_name return p } func InitEmptyGeneric_option_nameContext(p *Generic_option_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generic_option_name } func (*Generic_option_nameContext) IsGeneric_option_nameContext() {} func NewGeneric_option_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_option_nameContext { var p = new(Generic_option_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_generic_option_name return p } func (s *Generic_option_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Generic_option_nameContext) Collabel() ICollabelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICollabelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICollabelContext) } func (s *Generic_option_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Generic_option_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Generic_option_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGeneric_option_name(s) } } func (s *Generic_option_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGeneric_option_name(s) } } func (s *Generic_option_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGeneric_option_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Generic_option_name() (localctx IGeneric_option_nameContext) { localctx = NewGeneric_option_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 352, PostgreSQLParserRULE_generic_option_name) p.EnterOuterAlt(localctx, 1) { p.SetState(3634) p.Collabel() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGeneric_option_argContext is an interface to support dynamic dispatch. type IGeneric_option_argContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sconst() ISconstContext // IsGeneric_option_argContext differentiates from other interfaces. IsGeneric_option_argContext() } type Generic_option_argContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGeneric_option_argContext() *Generic_option_argContext { var p = new(Generic_option_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generic_option_arg return p } func InitEmptyGeneric_option_argContext(p *Generic_option_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generic_option_arg } func (*Generic_option_argContext) IsGeneric_option_argContext() {} func NewGeneric_option_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_option_argContext { var p = new(Generic_option_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_generic_option_arg return p } func (s *Generic_option_argContext) GetParser() antlr.Parser { return s.parser } func (s *Generic_option_argContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Generic_option_argContext) GetRuleContext() antlr.RuleContext { return s } func (s *Generic_option_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Generic_option_argContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGeneric_option_arg(s) } } func (s *Generic_option_argContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGeneric_option_arg(s) } } func (s *Generic_option_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGeneric_option_arg(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Generic_option_arg() (localctx IGeneric_option_argContext) { localctx = NewGeneric_option_argContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 354, PostgreSQLParserRULE_generic_option_arg) p.EnterOuterAlt(localctx, 1) { p.SetState(3636) p.Sconst() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateforeignserverstmtContext is an interface to support dynamic dispatch. type ICreateforeignserverstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode SERVER() antlr.TerminalNode AllName() []INameContext Name(i int) INameContext Opt_type() IOpt_typeContext Opt_foreign_server_version() IOpt_foreign_server_versionContext FOREIGN() antlr.TerminalNode DATA_P() antlr.TerminalNode WRAPPER() antlr.TerminalNode Create_generic_options() ICreate_generic_optionsContext IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsCreateforeignserverstmtContext differentiates from other interfaces. IsCreateforeignserverstmtContext() } type CreateforeignserverstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateforeignserverstmtContext() *CreateforeignserverstmtContext { var p = new(CreateforeignserverstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createforeignserverstmt return p } func InitEmptyCreateforeignserverstmtContext(p *CreateforeignserverstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createforeignserverstmt } func (*CreateforeignserverstmtContext) IsCreateforeignserverstmtContext() {} func NewCreateforeignserverstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateforeignserverstmtContext { var p = new(CreateforeignserverstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createforeignserverstmt return p } func (s *CreateforeignserverstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateforeignserverstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateforeignserverstmtContext) SERVER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSERVER, 0) } func (s *CreateforeignserverstmtContext) AllName() []INameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(INameContext); ok { len++ } } tst := make([]INameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(INameContext); ok { tst[i] = t.(INameContext) i++ } } return tst } func (s *CreateforeignserverstmtContext) Name(i int) INameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(INameContext) } func (s *CreateforeignserverstmtContext) Opt_type() IOpt_typeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_typeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_typeContext) } func (s *CreateforeignserverstmtContext) Opt_foreign_server_version() IOpt_foreign_server_versionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_foreign_server_versionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_foreign_server_versionContext) } func (s *CreateforeignserverstmtContext) FOREIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREIGN, 0) } func (s *CreateforeignserverstmtContext) DATA_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATA_P, 0) } func (s *CreateforeignserverstmtContext) WRAPPER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWRAPPER, 0) } func (s *CreateforeignserverstmtContext) Create_generic_options() ICreate_generic_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreate_generic_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreate_generic_optionsContext) } func (s *CreateforeignserverstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *CreateforeignserverstmtContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *CreateforeignserverstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *CreateforeignserverstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateforeignserverstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateforeignserverstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateforeignserverstmt(s) } } func (s *CreateforeignserverstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateforeignserverstmt(s) } } func (s *CreateforeignserverstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateforeignserverstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createforeignserverstmt() (localctx ICreateforeignserverstmtContext) { localctx = NewCreateforeignserverstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 356, PostgreSQLParserRULE_createforeignserverstmt) p.SetState(3663) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 161, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3638) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3639) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3640) p.Name() } { p.SetState(3641) p.Opt_type() } { p.SetState(3642) p.Opt_foreign_server_version() } { p.SetState(3643) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3644) p.Match(PostgreSQLParserDATA_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3645) p.Match(PostgreSQLParserWRAPPER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3646) p.Name() } { p.SetState(3647) p.Create_generic_options() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(3649) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3650) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3651) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3652) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3653) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3654) p.Name() } { p.SetState(3655) p.Opt_type() } { p.SetState(3656) p.Opt_foreign_server_version() } { p.SetState(3657) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3658) p.Match(PostgreSQLParserDATA_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3659) p.Match(PostgreSQLParserWRAPPER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3660) p.Name() } { p.SetState(3661) p.Create_generic_options() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_typeContext is an interface to support dynamic dispatch. type IOpt_typeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TYPE_P() antlr.TerminalNode Sconst() ISconstContext // IsOpt_typeContext differentiates from other interfaces. IsOpt_typeContext() } type Opt_typeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_typeContext() *Opt_typeContext { var p = new(Opt_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_type return p } func InitEmptyOpt_typeContext(p *Opt_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_type } func (*Opt_typeContext) IsOpt_typeContext() {} func NewOpt_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_typeContext { var p = new(Opt_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_type return p } func (s *Opt_typeContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_typeContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *Opt_typeContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Opt_typeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_typeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_type(s) } } func (s *Opt_typeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_type(s) } } func (s *Opt_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_type(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_type() (localctx IOpt_typeContext) { localctx = NewOpt_typeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 358, PostgreSQLParserRULE_opt_type) p.SetState(3668) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserTYPE_P: p.EnterOuterAlt(localctx, 1) { p.SetState(3665) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3666) p.Sconst() } case PostgreSQLParserFOREIGN, PostgreSQLParserVERSION_P: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IForeign_server_versionContext is an interface to support dynamic dispatch. type IForeign_server_versionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures VERSION_P() antlr.TerminalNode Sconst() ISconstContext NULL_P() antlr.TerminalNode // IsForeign_server_versionContext differentiates from other interfaces. IsForeign_server_versionContext() } type Foreign_server_versionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyForeign_server_versionContext() *Foreign_server_versionContext { var p = new(Foreign_server_versionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_foreign_server_version return p } func InitEmptyForeign_server_versionContext(p *Foreign_server_versionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_foreign_server_version } func (*Foreign_server_versionContext) IsForeign_server_versionContext() {} func NewForeign_server_versionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_server_versionContext { var p = new(Foreign_server_versionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_foreign_server_version return p } func (s *Foreign_server_versionContext) GetParser() antlr.Parser { return s.parser } func (s *Foreign_server_versionContext) VERSION_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVERSION_P, 0) } func (s *Foreign_server_versionContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Foreign_server_versionContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *Foreign_server_versionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Foreign_server_versionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Foreign_server_versionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterForeign_server_version(s) } } func (s *Foreign_server_versionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitForeign_server_version(s) } } func (s *Foreign_server_versionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitForeign_server_version(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Foreign_server_version() (localctx IForeign_server_versionContext) { localctx = NewForeign_server_versionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 360, PostgreSQLParserRULE_foreign_server_version) p.EnterOuterAlt(localctx, 1) { p.SetState(3670) p.Match(PostgreSQLParserVERSION_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(3673) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: { p.SetState(3671) p.Sconst() } case PostgreSQLParserNULL_P: { p.SetState(3672) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_foreign_server_versionContext is an interface to support dynamic dispatch. type IOpt_foreign_server_versionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Foreign_server_version() IForeign_server_versionContext // IsOpt_foreign_server_versionContext differentiates from other interfaces. IsOpt_foreign_server_versionContext() } type Opt_foreign_server_versionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_foreign_server_versionContext() *Opt_foreign_server_versionContext { var p = new(Opt_foreign_server_versionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_foreign_server_version return p } func InitEmptyOpt_foreign_server_versionContext(p *Opt_foreign_server_versionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_foreign_server_version } func (*Opt_foreign_server_versionContext) IsOpt_foreign_server_versionContext() {} func NewOpt_foreign_server_versionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_foreign_server_versionContext { var p = new(Opt_foreign_server_versionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_foreign_server_version return p } func (s *Opt_foreign_server_versionContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_foreign_server_versionContext) Foreign_server_version() IForeign_server_versionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IForeign_server_versionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IForeign_server_versionContext) } func (s *Opt_foreign_server_versionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_foreign_server_versionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_foreign_server_versionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_foreign_server_version(s) } } func (s *Opt_foreign_server_versionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_foreign_server_version(s) } } func (s *Opt_foreign_server_versionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_foreign_server_version(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_foreign_server_version() (localctx IOpt_foreign_server_versionContext) { localctx = NewOpt_foreign_server_versionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 362, PostgreSQLParserRULE_opt_foreign_server_version) p.SetState(3677) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserVERSION_P: p.EnterOuterAlt(localctx, 1) { p.SetState(3675) p.Foreign_server_version() } case PostgreSQLParserFOREIGN: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterforeignserverstmtContext is an interface to support dynamic dispatch. type IAlterforeignserverstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode SERVER() antlr.TerminalNode Name() INameContext Alter_generic_options() IAlter_generic_optionsContext Foreign_server_version() IForeign_server_versionContext // IsAlterforeignserverstmtContext differentiates from other interfaces. IsAlterforeignserverstmtContext() } type AlterforeignserverstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterforeignserverstmtContext() *AlterforeignserverstmtContext { var p = new(AlterforeignserverstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterforeignserverstmt return p } func InitEmptyAlterforeignserverstmtContext(p *AlterforeignserverstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterforeignserverstmt } func (*AlterforeignserverstmtContext) IsAlterforeignserverstmtContext() {} func NewAlterforeignserverstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterforeignserverstmtContext { var p = new(AlterforeignserverstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterforeignserverstmt return p } func (s *AlterforeignserverstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterforeignserverstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterforeignserverstmtContext) SERVER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSERVER, 0) } func (s *AlterforeignserverstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *AlterforeignserverstmtContext) Alter_generic_options() IAlter_generic_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_generic_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlter_generic_optionsContext) } func (s *AlterforeignserverstmtContext) Foreign_server_version() IForeign_server_versionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IForeign_server_versionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IForeign_server_versionContext) } func (s *AlterforeignserverstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterforeignserverstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterforeignserverstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterforeignserverstmt(s) } } func (s *AlterforeignserverstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterforeignserverstmt(s) } } func (s *AlterforeignserverstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterforeignserverstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterforeignserverstmt() (localctx IAlterforeignserverstmtContext) { localctx = NewAlterforeignserverstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 364, PostgreSQLParserRULE_alterforeignserverstmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3679) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3680) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3681) p.Name() } p.SetState(3687) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPTIONS: { p.SetState(3682) p.Alter_generic_options() } case PostgreSQLParserVERSION_P: { p.SetState(3683) p.Foreign_server_version() } p.SetState(3685) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserOPTIONS { { p.SetState(3684) p.Alter_generic_options() } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateforeigntablestmtContext is an interface to support dynamic dispatch. type ICreateforeigntablestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode FOREIGN() antlr.TerminalNode TABLE() antlr.TerminalNode AllQualified_name() []IQualified_nameContext Qualified_name(i int) IQualified_nameContext OPEN_PAREN() antlr.TerminalNode Opttableelementlist() IOpttableelementlistContext CLOSE_PAREN() antlr.TerminalNode Optinherit() IOptinheritContext SERVER() antlr.TerminalNode Name() INameContext Create_generic_options() ICreate_generic_optionsContext IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode PARTITION() antlr.TerminalNode OF() antlr.TerminalNode Opttypedtableelementlist() IOpttypedtableelementlistContext Partitionboundspec() IPartitionboundspecContext // IsCreateforeigntablestmtContext differentiates from other interfaces. IsCreateforeigntablestmtContext() } type CreateforeigntablestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateforeigntablestmtContext() *CreateforeigntablestmtContext { var p = new(CreateforeigntablestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createforeigntablestmt return p } func InitEmptyCreateforeigntablestmtContext(p *CreateforeigntablestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createforeigntablestmt } func (*CreateforeigntablestmtContext) IsCreateforeigntablestmtContext() {} func NewCreateforeigntablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateforeigntablestmtContext { var p = new(CreateforeigntablestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createforeigntablestmt return p } func (s *CreateforeigntablestmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateforeigntablestmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateforeigntablestmtContext) FOREIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREIGN, 0) } func (s *CreateforeigntablestmtContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *CreateforeigntablestmtContext) AllQualified_name() []IQualified_nameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IQualified_nameContext); ok { len++ } } tst := make([]IQualified_nameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IQualified_nameContext); ok { tst[i] = t.(IQualified_nameContext) i++ } } return tst } func (s *CreateforeigntablestmtContext) Qualified_name(i int) IQualified_nameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *CreateforeigntablestmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *CreateforeigntablestmtContext) Opttableelementlist() IOpttableelementlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttableelementlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttableelementlistContext) } func (s *CreateforeigntablestmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *CreateforeigntablestmtContext) Optinherit() IOptinheritContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptinheritContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptinheritContext) } func (s *CreateforeigntablestmtContext) SERVER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSERVER, 0) } func (s *CreateforeigntablestmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreateforeigntablestmtContext) Create_generic_options() ICreate_generic_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreate_generic_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreate_generic_optionsContext) } func (s *CreateforeigntablestmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *CreateforeigntablestmtContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *CreateforeigntablestmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *CreateforeigntablestmtContext) PARTITION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARTITION, 0) } func (s *CreateforeigntablestmtContext) OF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOF, 0) } func (s *CreateforeigntablestmtContext) Opttypedtableelementlist() IOpttypedtableelementlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttypedtableelementlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttypedtableelementlistContext) } func (s *CreateforeigntablestmtContext) Partitionboundspec() IPartitionboundspecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPartitionboundspecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPartitionboundspecContext) } func (s *CreateforeigntablestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateforeigntablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateforeigntablestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateforeigntablestmt(s) } } func (s *CreateforeigntablestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateforeigntablestmt(s) } } func (s *CreateforeigntablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateforeigntablestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createforeigntablestmt() (localctx ICreateforeigntablestmtContext) { localctx = NewCreateforeigntablestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 366, PostgreSQLParserRULE_createforeigntablestmt) p.SetState(3745) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 167, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3689) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3690) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3691) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3692) p.Qualified_name() } { p.SetState(3693) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3694) p.Opttableelementlist() } { p.SetState(3695) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3696) p.Optinherit() } { p.SetState(3697) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3698) p.Name() } { p.SetState(3699) p.Create_generic_options() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(3701) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3702) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3703) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3704) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3705) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3706) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3707) p.Qualified_name() } { p.SetState(3708) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3709) p.Opttableelementlist() } { p.SetState(3710) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3711) p.Optinherit() } { p.SetState(3712) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3713) p.Name() } { p.SetState(3714) p.Create_generic_options() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(3716) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3717) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3718) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3719) p.Qualified_name() } { p.SetState(3720) p.Match(PostgreSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3721) p.Match(PostgreSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3722) p.Qualified_name() } { p.SetState(3723) p.Opttypedtableelementlist() } { p.SetState(3724) p.Partitionboundspec() } { p.SetState(3725) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3726) p.Name() } { p.SetState(3727) p.Create_generic_options() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(3729) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3730) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3731) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3732) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3733) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3734) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3735) p.Qualified_name() } { p.SetState(3736) p.Match(PostgreSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3737) p.Match(PostgreSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3738) p.Qualified_name() } { p.SetState(3739) p.Opttypedtableelementlist() } { p.SetState(3740) p.Partitionboundspec() } { p.SetState(3741) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3742) p.Name() } { p.SetState(3743) p.Create_generic_options() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IImportforeignschemastmtContext is an interface to support dynamic dispatch. type IImportforeignschemastmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures IMPORT_P() antlr.TerminalNode FOREIGN() antlr.TerminalNode SCHEMA() antlr.TerminalNode AllName() []INameContext Name(i int) INameContext Import_qualification() IImport_qualificationContext FROM() antlr.TerminalNode SERVER() antlr.TerminalNode INTO() antlr.TerminalNode Create_generic_options() ICreate_generic_optionsContext // IsImportforeignschemastmtContext differentiates from other interfaces. IsImportforeignschemastmtContext() } type ImportforeignschemastmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyImportforeignschemastmtContext() *ImportforeignschemastmtContext { var p = new(ImportforeignschemastmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_importforeignschemastmt return p } func InitEmptyImportforeignschemastmtContext(p *ImportforeignschemastmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_importforeignschemastmt } func (*ImportforeignschemastmtContext) IsImportforeignschemastmtContext() {} func NewImportforeignschemastmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportforeignschemastmtContext { var p = new(ImportforeignschemastmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_importforeignschemastmt return p } func (s *ImportforeignschemastmtContext) GetParser() antlr.Parser { return s.parser } func (s *ImportforeignschemastmtContext) IMPORT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIMPORT_P, 0) } func (s *ImportforeignschemastmtContext) FOREIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREIGN, 0) } func (s *ImportforeignschemastmtContext) SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMA, 0) } func (s *ImportforeignschemastmtContext) AllName() []INameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(INameContext); ok { len++ } } tst := make([]INameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(INameContext); ok { tst[i] = t.(INameContext) i++ } } return tst } func (s *ImportforeignschemastmtContext) Name(i int) INameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(INameContext) } func (s *ImportforeignschemastmtContext) Import_qualification() IImport_qualificationContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IImport_qualificationContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IImport_qualificationContext) } func (s *ImportforeignschemastmtContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *ImportforeignschemastmtContext) SERVER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSERVER, 0) } func (s *ImportforeignschemastmtContext) INTO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINTO, 0) } func (s *ImportforeignschemastmtContext) Create_generic_options() ICreate_generic_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreate_generic_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreate_generic_optionsContext) } func (s *ImportforeignschemastmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *ImportforeignschemastmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ImportforeignschemastmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterImportforeignschemastmt(s) } } func (s *ImportforeignschemastmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitImportforeignschemastmt(s) } } func (s *ImportforeignschemastmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitImportforeignschemastmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Importforeignschemastmt() (localctx IImportforeignschemastmtContext) { localctx = NewImportforeignschemastmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 368, PostgreSQLParserRULE_importforeignschemastmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3747) p.Match(PostgreSQLParserIMPORT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3748) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3749) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3750) p.Name() } { p.SetState(3751) p.Import_qualification() } { p.SetState(3752) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3753) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3754) p.Name() } { p.SetState(3755) p.Match(PostgreSQLParserINTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3756) p.Name() } { p.SetState(3757) p.Create_generic_options() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IImport_qualification_typeContext is an interface to support dynamic dispatch. type IImport_qualification_typeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures LIMIT() antlr.TerminalNode TO() antlr.TerminalNode EXCEPT() antlr.TerminalNode // IsImport_qualification_typeContext differentiates from other interfaces. IsImport_qualification_typeContext() } type Import_qualification_typeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyImport_qualification_typeContext() *Import_qualification_typeContext { var p = new(Import_qualification_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_import_qualification_type return p } func InitEmptyImport_qualification_typeContext(p *Import_qualification_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_import_qualification_type } func (*Import_qualification_typeContext) IsImport_qualification_typeContext() {} func NewImport_qualification_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Import_qualification_typeContext { var p = new(Import_qualification_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_import_qualification_type return p } func (s *Import_qualification_typeContext) GetParser() antlr.Parser { return s.parser } func (s *Import_qualification_typeContext) LIMIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLIMIT, 0) } func (s *Import_qualification_typeContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *Import_qualification_typeContext) EXCEPT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXCEPT, 0) } func (s *Import_qualification_typeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Import_qualification_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Import_qualification_typeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterImport_qualification_type(s) } } func (s *Import_qualification_typeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitImport_qualification_type(s) } } func (s *Import_qualification_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitImport_qualification_type(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Import_qualification_type() (localctx IImport_qualification_typeContext) { localctx = NewImport_qualification_typeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 370, PostgreSQLParserRULE_import_qualification_type) p.SetState(3762) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserLIMIT: p.EnterOuterAlt(localctx, 1) { p.SetState(3759) p.Match(PostgreSQLParserLIMIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3760) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEXCEPT: p.EnterOuterAlt(localctx, 2) { p.SetState(3761) p.Match(PostgreSQLParserEXCEPT) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IImport_qualificationContext is an interface to support dynamic dispatch. type IImport_qualificationContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Import_qualification_type() IImport_qualification_typeContext OPEN_PAREN() antlr.TerminalNode Relation_expr_list() IRelation_expr_listContext CLOSE_PAREN() antlr.TerminalNode // IsImport_qualificationContext differentiates from other interfaces. IsImport_qualificationContext() } type Import_qualificationContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyImport_qualificationContext() *Import_qualificationContext { var p = new(Import_qualificationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_import_qualification return p } func InitEmptyImport_qualificationContext(p *Import_qualificationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_import_qualification } func (*Import_qualificationContext) IsImport_qualificationContext() {} func NewImport_qualificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Import_qualificationContext { var p = new(Import_qualificationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_import_qualification return p } func (s *Import_qualificationContext) GetParser() antlr.Parser { return s.parser } func (s *Import_qualificationContext) Import_qualification_type() IImport_qualification_typeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IImport_qualification_typeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IImport_qualification_typeContext) } func (s *Import_qualificationContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Import_qualificationContext) Relation_expr_list() IRelation_expr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_expr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRelation_expr_listContext) } func (s *Import_qualificationContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Import_qualificationContext) GetRuleContext() antlr.RuleContext { return s } func (s *Import_qualificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Import_qualificationContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterImport_qualification(s) } } func (s *Import_qualificationContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitImport_qualification(s) } } func (s *Import_qualificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitImport_qualification(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Import_qualification() (localctx IImport_qualificationContext) { localctx = NewImport_qualificationContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 372, PostgreSQLParserRULE_import_qualification) p.SetState(3770) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserEXCEPT, PostgreSQLParserLIMIT: p.EnterOuterAlt(localctx, 1) { p.SetState(3764) p.Import_qualification_type() } { p.SetState(3765) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3766) p.Relation_expr_list() } { p.SetState(3767) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserFROM: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateusermappingstmtContext is an interface to support dynamic dispatch. type ICreateusermappingstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode USER() antlr.TerminalNode MAPPING() antlr.TerminalNode FOR() antlr.TerminalNode Auth_ident() IAuth_identContext SERVER() antlr.TerminalNode Name() INameContext Create_generic_options() ICreate_generic_optionsContext IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsCreateusermappingstmtContext differentiates from other interfaces. IsCreateusermappingstmtContext() } type CreateusermappingstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateusermappingstmtContext() *CreateusermappingstmtContext { var p = new(CreateusermappingstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createusermappingstmt return p } func InitEmptyCreateusermappingstmtContext(p *CreateusermappingstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createusermappingstmt } func (*CreateusermappingstmtContext) IsCreateusermappingstmtContext() {} func NewCreateusermappingstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateusermappingstmtContext { var p = new(CreateusermappingstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createusermappingstmt return p } func (s *CreateusermappingstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateusermappingstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateusermappingstmtContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *CreateusermappingstmtContext) MAPPING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMAPPING, 0) } func (s *CreateusermappingstmtContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *CreateusermappingstmtContext) Auth_ident() IAuth_identContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAuth_identContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAuth_identContext) } func (s *CreateusermappingstmtContext) SERVER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSERVER, 0) } func (s *CreateusermappingstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreateusermappingstmtContext) Create_generic_options() ICreate_generic_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreate_generic_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreate_generic_optionsContext) } func (s *CreateusermappingstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *CreateusermappingstmtContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *CreateusermappingstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *CreateusermappingstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateusermappingstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateusermappingstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateusermappingstmt(s) } } func (s *CreateusermappingstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateusermappingstmt(s) } } func (s *CreateusermappingstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateusermappingstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createusermappingstmt() (localctx ICreateusermappingstmtContext) { localctx = NewCreateusermappingstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 374, PostgreSQLParserRULE_createusermappingstmt) p.SetState(3793) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 170, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3772) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3773) p.Match(PostgreSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3774) p.Match(PostgreSQLParserMAPPING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3775) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3776) p.Auth_ident() } { p.SetState(3777) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3778) p.Name() } { p.SetState(3779) p.Create_generic_options() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(3781) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3782) p.Match(PostgreSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3783) p.Match(PostgreSQLParserMAPPING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3784) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3785) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3786) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3787) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3788) p.Auth_ident() } { p.SetState(3789) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3790) p.Name() } { p.SetState(3791) p.Create_generic_options() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAuth_identContext is an interface to support dynamic dispatch. type IAuth_identContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Rolespec() IRolespecContext USER() antlr.TerminalNode // IsAuth_identContext differentiates from other interfaces. IsAuth_identContext() } type Auth_identContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAuth_identContext() *Auth_identContext { var p = new(Auth_identContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_auth_ident return p } func InitEmptyAuth_identContext(p *Auth_identContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_auth_ident } func (*Auth_identContext) IsAuth_identContext() {} func NewAuth_identContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Auth_identContext { var p = new(Auth_identContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_auth_ident return p } func (s *Auth_identContext) GetParser() antlr.Parser { return s.parser } func (s *Auth_identContext) Rolespec() IRolespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRolespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRolespecContext) } func (s *Auth_identContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *Auth_identContext) GetRuleContext() antlr.RuleContext { return s } func (s *Auth_identContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Auth_identContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAuth_ident(s) } } func (s *Auth_identContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAuth_ident(s) } } func (s *Auth_identContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAuth_ident(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Auth_ident() (localctx IAuth_identContext) { localctx = NewAuth_identContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 376, PostgreSQLParserRULE_auth_ident) p.SetState(3797) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(3795) p.Rolespec() } case PostgreSQLParserUSER: p.EnterOuterAlt(localctx, 2) { p.SetState(3796) p.Match(PostgreSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDropusermappingstmtContext is an interface to support dynamic dispatch. type IDropusermappingstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DROP() antlr.TerminalNode USER() antlr.TerminalNode MAPPING() antlr.TerminalNode FOR() antlr.TerminalNode Auth_ident() IAuth_identContext SERVER() antlr.TerminalNode Name() INameContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsDropusermappingstmtContext differentiates from other interfaces. IsDropusermappingstmtContext() } type DropusermappingstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDropusermappingstmtContext() *DropusermappingstmtContext { var p = new(DropusermappingstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropusermappingstmt return p } func InitEmptyDropusermappingstmtContext(p *DropusermappingstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropusermappingstmt } func (*DropusermappingstmtContext) IsDropusermappingstmtContext() {} func NewDropusermappingstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropusermappingstmtContext { var p = new(DropusermappingstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_dropusermappingstmt return p } func (s *DropusermappingstmtContext) GetParser() antlr.Parser { return s.parser } func (s *DropusermappingstmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *DropusermappingstmtContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *DropusermappingstmtContext) MAPPING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMAPPING, 0) } func (s *DropusermappingstmtContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *DropusermappingstmtContext) Auth_ident() IAuth_identContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAuth_identContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAuth_identContext) } func (s *DropusermappingstmtContext) SERVER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSERVER, 0) } func (s *DropusermappingstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *DropusermappingstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *DropusermappingstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *DropusermappingstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DropusermappingstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DropusermappingstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDropusermappingstmt(s) } } func (s *DropusermappingstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDropusermappingstmt(s) } } func (s *DropusermappingstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDropusermappingstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Dropusermappingstmt() (localctx IDropusermappingstmtContext) { localctx = NewDropusermappingstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 378, PostgreSQLParserRULE_dropusermappingstmt) p.SetState(3817) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 172, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3799) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3800) p.Match(PostgreSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3801) p.Match(PostgreSQLParserMAPPING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3802) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3803) p.Auth_ident() } { p.SetState(3804) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3805) p.Name() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(3807) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3808) p.Match(PostgreSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3809) p.Match(PostgreSQLParserMAPPING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3810) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3811) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3812) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3813) p.Auth_ident() } { p.SetState(3814) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3815) p.Name() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterusermappingstmtContext is an interface to support dynamic dispatch. type IAlterusermappingstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode USER() antlr.TerminalNode MAPPING() antlr.TerminalNode FOR() antlr.TerminalNode Auth_ident() IAuth_identContext SERVER() antlr.TerminalNode Name() INameContext Alter_generic_options() IAlter_generic_optionsContext // IsAlterusermappingstmtContext differentiates from other interfaces. IsAlterusermappingstmtContext() } type AlterusermappingstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterusermappingstmtContext() *AlterusermappingstmtContext { var p = new(AlterusermappingstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterusermappingstmt return p } func InitEmptyAlterusermappingstmtContext(p *AlterusermappingstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterusermappingstmt } func (*AlterusermappingstmtContext) IsAlterusermappingstmtContext() {} func NewAlterusermappingstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterusermappingstmtContext { var p = new(AlterusermappingstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterusermappingstmt return p } func (s *AlterusermappingstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterusermappingstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterusermappingstmtContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *AlterusermappingstmtContext) MAPPING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMAPPING, 0) } func (s *AlterusermappingstmtContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *AlterusermappingstmtContext) Auth_ident() IAuth_identContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAuth_identContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAuth_identContext) } func (s *AlterusermappingstmtContext) SERVER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSERVER, 0) } func (s *AlterusermappingstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *AlterusermappingstmtContext) Alter_generic_options() IAlter_generic_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_generic_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlter_generic_optionsContext) } func (s *AlterusermappingstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterusermappingstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterusermappingstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterusermappingstmt(s) } } func (s *AlterusermappingstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterusermappingstmt(s) } } func (s *AlterusermappingstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterusermappingstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterusermappingstmt() (localctx IAlterusermappingstmtContext) { localctx = NewAlterusermappingstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 380, PostgreSQLParserRULE_alterusermappingstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3819) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3820) p.Match(PostgreSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3821) p.Match(PostgreSQLParserMAPPING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3822) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3823) p.Auth_ident() } { p.SetState(3824) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3825) p.Name() } { p.SetState(3826) p.Alter_generic_options() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatepolicystmtContext is an interface to support dynamic dispatch. type ICreatepolicystmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode POLICY() antlr.TerminalNode Name() INameContext ON() antlr.TerminalNode Qualified_name() IQualified_nameContext Rowsecuritydefaultpermissive() IRowsecuritydefaultpermissiveContext Rowsecuritydefaultforcmd() IRowsecuritydefaultforcmdContext Rowsecuritydefaulttorole() IRowsecuritydefaulttoroleContext Rowsecurityoptionalexpr() IRowsecurityoptionalexprContext Rowsecurityoptionalwithcheck() IRowsecurityoptionalwithcheckContext // IsCreatepolicystmtContext differentiates from other interfaces. IsCreatepolicystmtContext() } type CreatepolicystmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatepolicystmtContext() *CreatepolicystmtContext { var p = new(CreatepolicystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createpolicystmt return p } func InitEmptyCreatepolicystmtContext(p *CreatepolicystmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createpolicystmt } func (*CreatepolicystmtContext) IsCreatepolicystmtContext() {} func NewCreatepolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatepolicystmtContext { var p = new(CreatepolicystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createpolicystmt return p } func (s *CreatepolicystmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreatepolicystmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreatepolicystmtContext) POLICY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPOLICY, 0) } func (s *CreatepolicystmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreatepolicystmtContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *CreatepolicystmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *CreatepolicystmtContext) Rowsecuritydefaultpermissive() IRowsecuritydefaultpermissiveContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRowsecuritydefaultpermissiveContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRowsecuritydefaultpermissiveContext) } func (s *CreatepolicystmtContext) Rowsecuritydefaultforcmd() IRowsecuritydefaultforcmdContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRowsecuritydefaultforcmdContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRowsecuritydefaultforcmdContext) } func (s *CreatepolicystmtContext) Rowsecuritydefaulttorole() IRowsecuritydefaulttoroleContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRowsecuritydefaulttoroleContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRowsecuritydefaulttoroleContext) } func (s *CreatepolicystmtContext) Rowsecurityoptionalexpr() IRowsecurityoptionalexprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRowsecurityoptionalexprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRowsecurityoptionalexprContext) } func (s *CreatepolicystmtContext) Rowsecurityoptionalwithcheck() IRowsecurityoptionalwithcheckContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRowsecurityoptionalwithcheckContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRowsecurityoptionalwithcheckContext) } func (s *CreatepolicystmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreatepolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreatepolicystmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatepolicystmt(s) } } func (s *CreatepolicystmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatepolicystmt(s) } } func (s *CreatepolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatepolicystmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createpolicystmt() (localctx ICreatepolicystmtContext) { localctx = NewCreatepolicystmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 382, PostgreSQLParserRULE_createpolicystmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3828) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3829) p.Match(PostgreSQLParserPOLICY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3830) p.Name() } { p.SetState(3831) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3832) p.Qualified_name() } { p.SetState(3833) p.Rowsecuritydefaultpermissive() } { p.SetState(3834) p.Rowsecuritydefaultforcmd() } { p.SetState(3835) p.Rowsecuritydefaulttorole() } { p.SetState(3836) p.Rowsecurityoptionalexpr() } { p.SetState(3837) p.Rowsecurityoptionalwithcheck() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterpolicystmtContext is an interface to support dynamic dispatch. type IAlterpolicystmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode POLICY() antlr.TerminalNode Name() INameContext ON() antlr.TerminalNode Qualified_name() IQualified_nameContext Rowsecurityoptionaltorole() IRowsecurityoptionaltoroleContext Rowsecurityoptionalexpr() IRowsecurityoptionalexprContext Rowsecurityoptionalwithcheck() IRowsecurityoptionalwithcheckContext // IsAlterpolicystmtContext differentiates from other interfaces. IsAlterpolicystmtContext() } type AlterpolicystmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterpolicystmtContext() *AlterpolicystmtContext { var p = new(AlterpolicystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterpolicystmt return p } func InitEmptyAlterpolicystmtContext(p *AlterpolicystmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterpolicystmt } func (*AlterpolicystmtContext) IsAlterpolicystmtContext() {} func NewAlterpolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterpolicystmtContext { var p = new(AlterpolicystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterpolicystmt return p } func (s *AlterpolicystmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterpolicystmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterpolicystmtContext) POLICY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPOLICY, 0) } func (s *AlterpolicystmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *AlterpolicystmtContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *AlterpolicystmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *AlterpolicystmtContext) Rowsecurityoptionaltorole() IRowsecurityoptionaltoroleContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRowsecurityoptionaltoroleContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRowsecurityoptionaltoroleContext) } func (s *AlterpolicystmtContext) Rowsecurityoptionalexpr() IRowsecurityoptionalexprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRowsecurityoptionalexprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRowsecurityoptionalexprContext) } func (s *AlterpolicystmtContext) Rowsecurityoptionalwithcheck() IRowsecurityoptionalwithcheckContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRowsecurityoptionalwithcheckContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRowsecurityoptionalwithcheckContext) } func (s *AlterpolicystmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterpolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterpolicystmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterpolicystmt(s) } } func (s *AlterpolicystmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterpolicystmt(s) } } func (s *AlterpolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterpolicystmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterpolicystmt() (localctx IAlterpolicystmtContext) { localctx = NewAlterpolicystmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 384, PostgreSQLParserRULE_alterpolicystmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3839) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3840) p.Match(PostgreSQLParserPOLICY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3841) p.Name() } { p.SetState(3842) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3843) p.Qualified_name() } { p.SetState(3844) p.Rowsecurityoptionaltorole() } { p.SetState(3845) p.Rowsecurityoptionalexpr() } { p.SetState(3846) p.Rowsecurityoptionalwithcheck() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRowsecurityoptionalexprContext is an interface to support dynamic dispatch. type IRowsecurityoptionalexprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USING() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode A_expr() IA_exprContext CLOSE_PAREN() antlr.TerminalNode // IsRowsecurityoptionalexprContext differentiates from other interfaces. IsRowsecurityoptionalexprContext() } type RowsecurityoptionalexprContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRowsecurityoptionalexprContext() *RowsecurityoptionalexprContext { var p = new(RowsecurityoptionalexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionalexpr return p } func InitEmptyRowsecurityoptionalexprContext(p *RowsecurityoptionalexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionalexpr } func (*RowsecurityoptionalexprContext) IsRowsecurityoptionalexprContext() {} func NewRowsecurityoptionalexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecurityoptionalexprContext { var p = new(RowsecurityoptionalexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionalexpr return p } func (s *RowsecurityoptionalexprContext) GetParser() antlr.Parser { return s.parser } func (s *RowsecurityoptionalexprContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *RowsecurityoptionalexprContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *RowsecurityoptionalexprContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *RowsecurityoptionalexprContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *RowsecurityoptionalexprContext) GetRuleContext() antlr.RuleContext { return s } func (s *RowsecurityoptionalexprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RowsecurityoptionalexprContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRowsecurityoptionalexpr(s) } } func (s *RowsecurityoptionalexprContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRowsecurityoptionalexpr(s) } } func (s *RowsecurityoptionalexprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRowsecurityoptionalexpr(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Rowsecurityoptionalexpr() (localctx IRowsecurityoptionalexprContext) { localctx = NewRowsecurityoptionalexprContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 386, PostgreSQLParserRULE_rowsecurityoptionalexpr) p.SetState(3854) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 1) { p.SetState(3848) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3849) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3850) p.A_expr() } { p.SetState(3851) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRowsecurityoptionalwithcheckContext is an interface to support dynamic dispatch. type IRowsecurityoptionalwithcheckContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITH() antlr.TerminalNode CHECK() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode A_expr() IA_exprContext CLOSE_PAREN() antlr.TerminalNode // IsRowsecurityoptionalwithcheckContext differentiates from other interfaces. IsRowsecurityoptionalwithcheckContext() } type RowsecurityoptionalwithcheckContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRowsecurityoptionalwithcheckContext() *RowsecurityoptionalwithcheckContext { var p = new(RowsecurityoptionalwithcheckContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionalwithcheck return p } func InitEmptyRowsecurityoptionalwithcheckContext(p *RowsecurityoptionalwithcheckContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionalwithcheck } func (*RowsecurityoptionalwithcheckContext) IsRowsecurityoptionalwithcheckContext() {} func NewRowsecurityoptionalwithcheckContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecurityoptionalwithcheckContext { var p = new(RowsecurityoptionalwithcheckContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionalwithcheck return p } func (s *RowsecurityoptionalwithcheckContext) GetParser() antlr.Parser { return s.parser } func (s *RowsecurityoptionalwithcheckContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *RowsecurityoptionalwithcheckContext) CHECK() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHECK, 0) } func (s *RowsecurityoptionalwithcheckContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *RowsecurityoptionalwithcheckContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *RowsecurityoptionalwithcheckContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *RowsecurityoptionalwithcheckContext) GetRuleContext() antlr.RuleContext { return s } func (s *RowsecurityoptionalwithcheckContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RowsecurityoptionalwithcheckContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRowsecurityoptionalwithcheck(s) } } func (s *RowsecurityoptionalwithcheckContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRowsecurityoptionalwithcheck(s) } } func (s *RowsecurityoptionalwithcheckContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRowsecurityoptionalwithcheck(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Rowsecurityoptionalwithcheck() (localctx IRowsecurityoptionalwithcheckContext) { localctx = NewRowsecurityoptionalwithcheckContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 388, PostgreSQLParserRULE_rowsecurityoptionalwithcheck) p.SetState(3863) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 174, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3856) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3857) p.Match(PostgreSQLParserCHECK) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3858) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3859) p.A_expr() } { p.SetState(3860) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRowsecuritydefaulttoroleContext is an interface to support dynamic dispatch. type IRowsecuritydefaulttoroleContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TO() antlr.TerminalNode Role_list() IRole_listContext // IsRowsecuritydefaulttoroleContext differentiates from other interfaces. IsRowsecuritydefaulttoroleContext() } type RowsecuritydefaulttoroleContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRowsecuritydefaulttoroleContext() *RowsecuritydefaulttoroleContext { var p = new(RowsecuritydefaulttoroleContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaulttorole return p } func InitEmptyRowsecuritydefaulttoroleContext(p *RowsecuritydefaulttoroleContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaulttorole } func (*RowsecuritydefaulttoroleContext) IsRowsecuritydefaulttoroleContext() {} func NewRowsecuritydefaulttoroleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecuritydefaulttoroleContext { var p = new(RowsecuritydefaulttoroleContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaulttorole return p } func (s *RowsecuritydefaulttoroleContext) GetParser() antlr.Parser { return s.parser } func (s *RowsecuritydefaulttoroleContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *RowsecuritydefaulttoroleContext) Role_list() IRole_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRole_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRole_listContext) } func (s *RowsecuritydefaulttoroleContext) GetRuleContext() antlr.RuleContext { return s } func (s *RowsecuritydefaulttoroleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RowsecuritydefaulttoroleContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRowsecuritydefaulttorole(s) } } func (s *RowsecuritydefaulttoroleContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRowsecuritydefaulttorole(s) } } func (s *RowsecuritydefaulttoroleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRowsecuritydefaulttorole(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Rowsecuritydefaulttorole() (localctx IRowsecuritydefaulttoroleContext) { localctx = NewRowsecuritydefaulttoroleContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 390, PostgreSQLParserRULE_rowsecuritydefaulttorole) p.SetState(3868) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserTO: p.EnterOuterAlt(localctx, 1) { p.SetState(3865) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3866) p.Role_list() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUSING, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRowsecurityoptionaltoroleContext is an interface to support dynamic dispatch. type IRowsecurityoptionaltoroleContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TO() antlr.TerminalNode Role_list() IRole_listContext // IsRowsecurityoptionaltoroleContext differentiates from other interfaces. IsRowsecurityoptionaltoroleContext() } type RowsecurityoptionaltoroleContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRowsecurityoptionaltoroleContext() *RowsecurityoptionaltoroleContext { var p = new(RowsecurityoptionaltoroleContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionaltorole return p } func InitEmptyRowsecurityoptionaltoroleContext(p *RowsecurityoptionaltoroleContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionaltorole } func (*RowsecurityoptionaltoroleContext) IsRowsecurityoptionaltoroleContext() {} func NewRowsecurityoptionaltoroleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecurityoptionaltoroleContext { var p = new(RowsecurityoptionaltoroleContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_rowsecurityoptionaltorole return p } func (s *RowsecurityoptionaltoroleContext) GetParser() antlr.Parser { return s.parser } func (s *RowsecurityoptionaltoroleContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *RowsecurityoptionaltoroleContext) Role_list() IRole_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRole_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRole_listContext) } func (s *RowsecurityoptionaltoroleContext) GetRuleContext() antlr.RuleContext { return s } func (s *RowsecurityoptionaltoroleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RowsecurityoptionaltoroleContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRowsecurityoptionaltorole(s) } } func (s *RowsecurityoptionaltoroleContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRowsecurityoptionaltorole(s) } } func (s *RowsecurityoptionaltoroleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRowsecurityoptionaltorole(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Rowsecurityoptionaltorole() (localctx IRowsecurityoptionaltoroleContext) { localctx = NewRowsecurityoptionaltoroleContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 392, PostgreSQLParserRULE_rowsecurityoptionaltorole) p.SetState(3873) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserTO: p.EnterOuterAlt(localctx, 1) { p.SetState(3870) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3871) p.Role_list() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserUSING, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRowsecuritydefaultpermissiveContext is an interface to support dynamic dispatch. type IRowsecuritydefaultpermissiveContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AS() antlr.TerminalNode Identifier() IIdentifierContext // IsRowsecuritydefaultpermissiveContext differentiates from other interfaces. IsRowsecuritydefaultpermissiveContext() } type RowsecuritydefaultpermissiveContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRowsecuritydefaultpermissiveContext() *RowsecuritydefaultpermissiveContext { var p = new(RowsecuritydefaultpermissiveContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaultpermissive return p } func InitEmptyRowsecuritydefaultpermissiveContext(p *RowsecuritydefaultpermissiveContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaultpermissive } func (*RowsecuritydefaultpermissiveContext) IsRowsecuritydefaultpermissiveContext() {} func NewRowsecuritydefaultpermissiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecuritydefaultpermissiveContext { var p = new(RowsecuritydefaultpermissiveContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaultpermissive return p } func (s *RowsecuritydefaultpermissiveContext) GetParser() antlr.Parser { return s.parser } func (s *RowsecuritydefaultpermissiveContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *RowsecuritydefaultpermissiveContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *RowsecuritydefaultpermissiveContext) GetRuleContext() antlr.RuleContext { return s } func (s *RowsecuritydefaultpermissiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RowsecuritydefaultpermissiveContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRowsecuritydefaultpermissive(s) } } func (s *RowsecuritydefaultpermissiveContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRowsecuritydefaultpermissive(s) } } func (s *RowsecuritydefaultpermissiveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRowsecuritydefaultpermissive(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Rowsecuritydefaultpermissive() (localctx IRowsecuritydefaultpermissiveContext) { localctx = NewRowsecuritydefaultpermissiveContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 394, PostgreSQLParserRULE_rowsecuritydefaultpermissive) p.SetState(3878) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAS: p.EnterOuterAlt(localctx, 1) { p.SetState(3875) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3876) p.Identifier() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTO, PostgreSQLParserUSING, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRowsecuritydefaultforcmdContext is an interface to support dynamic dispatch. type IRowsecuritydefaultforcmdContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FOR() antlr.TerminalNode Row_security_cmd() IRow_security_cmdContext // IsRowsecuritydefaultforcmdContext differentiates from other interfaces. IsRowsecuritydefaultforcmdContext() } type RowsecuritydefaultforcmdContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRowsecuritydefaultforcmdContext() *RowsecuritydefaultforcmdContext { var p = new(RowsecuritydefaultforcmdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaultforcmd return p } func InitEmptyRowsecuritydefaultforcmdContext(p *RowsecuritydefaultforcmdContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaultforcmd } func (*RowsecuritydefaultforcmdContext) IsRowsecuritydefaultforcmdContext() {} func NewRowsecuritydefaultforcmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecuritydefaultforcmdContext { var p = new(RowsecuritydefaultforcmdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_rowsecuritydefaultforcmd return p } func (s *RowsecuritydefaultforcmdContext) GetParser() antlr.Parser { return s.parser } func (s *RowsecuritydefaultforcmdContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *RowsecuritydefaultforcmdContext) Row_security_cmd() IRow_security_cmdContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRow_security_cmdContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRow_security_cmdContext) } func (s *RowsecuritydefaultforcmdContext) GetRuleContext() antlr.RuleContext { return s } func (s *RowsecuritydefaultforcmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RowsecuritydefaultforcmdContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRowsecuritydefaultforcmd(s) } } func (s *RowsecuritydefaultforcmdContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRowsecuritydefaultforcmd(s) } } func (s *RowsecuritydefaultforcmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRowsecuritydefaultforcmd(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Rowsecuritydefaultforcmd() (localctx IRowsecuritydefaultforcmdContext) { localctx = NewRowsecuritydefaultforcmdContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 396, PostgreSQLParserRULE_rowsecuritydefaultforcmd) p.SetState(3883) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFOR: p.EnterOuterAlt(localctx, 1) { p.SetState(3880) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3881) p.Row_security_cmd() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTO, PostgreSQLParserUSING, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRow_security_cmdContext is an interface to support dynamic dispatch. type IRow_security_cmdContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALL() antlr.TerminalNode SELECT() antlr.TerminalNode INSERT() antlr.TerminalNode UPDATE() antlr.TerminalNode DELETE_P() antlr.TerminalNode // IsRow_security_cmdContext differentiates from other interfaces. IsRow_security_cmdContext() } type Row_security_cmdContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRow_security_cmdContext() *Row_security_cmdContext { var p = new(Row_security_cmdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_row_security_cmd return p } func InitEmptyRow_security_cmdContext(p *Row_security_cmdContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_row_security_cmd } func (*Row_security_cmdContext) IsRow_security_cmdContext() {} func NewRow_security_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_security_cmdContext { var p = new(Row_security_cmdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_row_security_cmd return p } func (s *Row_security_cmdContext) GetParser() antlr.Parser { return s.parser } func (s *Row_security_cmdContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *Row_security_cmdContext) SELECT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSELECT, 0) } func (s *Row_security_cmdContext) INSERT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINSERT, 0) } func (s *Row_security_cmdContext) UPDATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUPDATE, 0) } func (s *Row_security_cmdContext) DELETE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDELETE_P, 0) } func (s *Row_security_cmdContext) GetRuleContext() antlr.RuleContext { return s } func (s *Row_security_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Row_security_cmdContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRow_security_cmd(s) } } func (s *Row_security_cmdContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRow_security_cmd(s) } } func (s *Row_security_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRow_security_cmd(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Row_security_cmd() (localctx IRow_security_cmdContext) { localctx = NewRow_security_cmdContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 398, PostgreSQLParserRULE_row_security_cmd) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3885) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserALL || _la == PostgreSQLParserSELECT || _la == PostgreSQLParserDELETE_P || _la == PostgreSQLParserINSERT || _la == PostgreSQLParserUPDATE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateamstmtContext is an interface to support dynamic dispatch. type ICreateamstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode ACCESS() antlr.TerminalNode METHOD() antlr.TerminalNode Name() INameContext TYPE_P() antlr.TerminalNode Am_type() IAm_typeContext HANDLER() antlr.TerminalNode Handler_name() IHandler_nameContext // IsCreateamstmtContext differentiates from other interfaces. IsCreateamstmtContext() } type CreateamstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateamstmtContext() *CreateamstmtContext { var p = new(CreateamstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createamstmt return p } func InitEmptyCreateamstmtContext(p *CreateamstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createamstmt } func (*CreateamstmtContext) IsCreateamstmtContext() {} func NewCreateamstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateamstmtContext { var p = new(CreateamstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createamstmt return p } func (s *CreateamstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateamstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateamstmtContext) ACCESS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserACCESS, 0) } func (s *CreateamstmtContext) METHOD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMETHOD, 0) } func (s *CreateamstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreateamstmtContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *CreateamstmtContext) Am_type() IAm_typeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAm_typeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAm_typeContext) } func (s *CreateamstmtContext) HANDLER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserHANDLER, 0) } func (s *CreateamstmtContext) Handler_name() IHandler_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IHandler_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IHandler_nameContext) } func (s *CreateamstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateamstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateamstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateamstmt(s) } } func (s *CreateamstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateamstmt(s) } } func (s *CreateamstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateamstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createamstmt() (localctx ICreateamstmtContext) { localctx = NewCreateamstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 400, PostgreSQLParserRULE_createamstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(3887) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3888) p.Match(PostgreSQLParserACCESS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3889) p.Match(PostgreSQLParserMETHOD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3890) p.Name() } { p.SetState(3891) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3892) p.Am_type() } { p.SetState(3893) p.Match(PostgreSQLParserHANDLER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3894) p.Handler_name() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAm_typeContext is an interface to support dynamic dispatch. type IAm_typeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures INDEX() antlr.TerminalNode TABLE() antlr.TerminalNode // IsAm_typeContext differentiates from other interfaces. IsAm_typeContext() } type Am_typeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAm_typeContext() *Am_typeContext { var p = new(Am_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_am_type return p } func InitEmptyAm_typeContext(p *Am_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_am_type } func (*Am_typeContext) IsAm_typeContext() {} func NewAm_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Am_typeContext { var p = new(Am_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_am_type return p } func (s *Am_typeContext) GetParser() antlr.Parser { return s.parser } func (s *Am_typeContext) INDEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINDEX, 0) } func (s *Am_typeContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *Am_typeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Am_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Am_typeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAm_type(s) } } func (s *Am_typeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAm_type(s) } } func (s *Am_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAm_type(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Am_type() (localctx IAm_typeContext) { localctx = NewAm_typeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 402, PostgreSQLParserRULE_am_type) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3896) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserTABLE || _la == PostgreSQLParserINDEX) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatetrigstmtContext is an interface to support dynamic dispatch. type ICreatetrigstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode TRIGGER() antlr.TerminalNode Name() INameContext Triggeractiontime() ITriggeractiontimeContext Triggerevents() ITriggereventsContext ON() antlr.TerminalNode Qualified_name() IQualified_nameContext Triggerreferencing() ITriggerreferencingContext Triggerforspec() ITriggerforspecContext Triggerwhen() ITriggerwhenContext EXECUTE() antlr.TerminalNode Function_or_procedure() IFunction_or_procedureContext Func_name() IFunc_nameContext OPEN_PAREN() antlr.TerminalNode Triggerfuncargs() ITriggerfuncargsContext CLOSE_PAREN() antlr.TerminalNode CONSTRAINT() antlr.TerminalNode AFTER() antlr.TerminalNode Optconstrfromtable() IOptconstrfromtableContext Constraintattributespec() IConstraintattributespecContext FOR() antlr.TerminalNode EACH() antlr.TerminalNode ROW() antlr.TerminalNode // IsCreatetrigstmtContext differentiates from other interfaces. IsCreatetrigstmtContext() } type CreatetrigstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatetrigstmtContext() *CreatetrigstmtContext { var p = new(CreatetrigstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createtrigstmt return p } func InitEmptyCreatetrigstmtContext(p *CreatetrigstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createtrigstmt } func (*CreatetrigstmtContext) IsCreatetrigstmtContext() {} func NewCreatetrigstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatetrigstmtContext { var p = new(CreatetrigstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createtrigstmt return p } func (s *CreatetrigstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreatetrigstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreatetrigstmtContext) TRIGGER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRIGGER, 0) } func (s *CreatetrigstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreatetrigstmtContext) Triggeractiontime() ITriggeractiontimeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITriggeractiontimeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITriggeractiontimeContext) } func (s *CreatetrigstmtContext) Triggerevents() ITriggereventsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITriggereventsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITriggereventsContext) } func (s *CreatetrigstmtContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *CreatetrigstmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *CreatetrigstmtContext) Triggerreferencing() ITriggerreferencingContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITriggerreferencingContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITriggerreferencingContext) } func (s *CreatetrigstmtContext) Triggerforspec() ITriggerforspecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITriggerforspecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITriggerforspecContext) } func (s *CreatetrigstmtContext) Triggerwhen() ITriggerwhenContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITriggerwhenContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITriggerwhenContext) } func (s *CreatetrigstmtContext) EXECUTE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXECUTE, 0) } func (s *CreatetrigstmtContext) Function_or_procedure() IFunction_or_procedureContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_or_procedureContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunction_or_procedureContext) } func (s *CreatetrigstmtContext) Func_name() IFunc_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_nameContext) } func (s *CreatetrigstmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *CreatetrigstmtContext) Triggerfuncargs() ITriggerfuncargsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITriggerfuncargsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITriggerfuncargsContext) } func (s *CreatetrigstmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *CreatetrigstmtContext) CONSTRAINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTRAINT, 0) } func (s *CreatetrigstmtContext) AFTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAFTER, 0) } func (s *CreatetrigstmtContext) Optconstrfromtable() IOptconstrfromtableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOptconstrfromtableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOptconstrfromtableContext) } func (s *CreatetrigstmtContext) Constraintattributespec() IConstraintattributespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstraintattributespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstraintattributespecContext) } func (s *CreatetrigstmtContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *CreatetrigstmtContext) EACH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEACH, 0) } func (s *CreatetrigstmtContext) ROW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROW, 0) } func (s *CreatetrigstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreatetrigstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreatetrigstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatetrigstmt(s) } } func (s *CreatetrigstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatetrigstmt(s) } } func (s *CreatetrigstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatetrigstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createtrigstmt() (localctx ICreatetrigstmtContext) { localctx = NewCreatetrigstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 404, PostgreSQLParserRULE_createtrigstmt) p.SetState(3936) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 179, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3898) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3899) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3900) p.Name() } { p.SetState(3901) p.Triggeractiontime() } { p.SetState(3902) p.Triggerevents() } { p.SetState(3903) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3904) p.Qualified_name() } { p.SetState(3905) p.Triggerreferencing() } { p.SetState(3906) p.Triggerforspec() } { p.SetState(3907) p.Triggerwhen() } { p.SetState(3908) p.Match(PostgreSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3909) p.Function_or_procedure() } { p.SetState(3910) p.Func_name() } { p.SetState(3911) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3912) p.Triggerfuncargs() } { p.SetState(3913) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(3915) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3916) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3917) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3918) p.Name() } { p.SetState(3919) p.Match(PostgreSQLParserAFTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3920) p.Triggerevents() } { p.SetState(3921) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3922) p.Qualified_name() } { p.SetState(3923) p.Optconstrfromtable() } { p.SetState(3924) p.Constraintattributespec() } { p.SetState(3925) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3926) p.Match(PostgreSQLParserEACH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3927) p.Match(PostgreSQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3928) p.Triggerwhen() } { p.SetState(3929) p.Match(PostgreSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3930) p.Function_or_procedure() } { p.SetState(3931) p.Func_name() } { p.SetState(3932) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3933) p.Triggerfuncargs() } { p.SetState(3934) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITriggeractiontimeContext is an interface to support dynamic dispatch. type ITriggeractiontimeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures BEFORE() antlr.TerminalNode AFTER() antlr.TerminalNode INSTEAD() antlr.TerminalNode OF() antlr.TerminalNode // IsTriggeractiontimeContext differentiates from other interfaces. IsTriggeractiontimeContext() } type TriggeractiontimeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTriggeractiontimeContext() *TriggeractiontimeContext { var p = new(TriggeractiontimeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggeractiontime return p } func InitEmptyTriggeractiontimeContext(p *TriggeractiontimeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggeractiontime } func (*TriggeractiontimeContext) IsTriggeractiontimeContext() {} func NewTriggeractiontimeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggeractiontimeContext { var p = new(TriggeractiontimeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_triggeractiontime return p } func (s *TriggeractiontimeContext) GetParser() antlr.Parser { return s.parser } func (s *TriggeractiontimeContext) BEFORE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBEFORE, 0) } func (s *TriggeractiontimeContext) AFTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAFTER, 0) } func (s *TriggeractiontimeContext) INSTEAD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINSTEAD, 0) } func (s *TriggeractiontimeContext) OF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOF, 0) } func (s *TriggeractiontimeContext) GetRuleContext() antlr.RuleContext { return s } func (s *TriggeractiontimeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TriggeractiontimeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTriggeractiontime(s) } } func (s *TriggeractiontimeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTriggeractiontime(s) } } func (s *TriggeractiontimeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTriggeractiontime(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Triggeractiontime() (localctx ITriggeractiontimeContext) { localctx = NewTriggeractiontimeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 406, PostgreSQLParserRULE_triggeractiontime) p.SetState(3942) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserBEFORE: p.EnterOuterAlt(localctx, 1) { p.SetState(3938) p.Match(PostgreSQLParserBEFORE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserAFTER: p.EnterOuterAlt(localctx, 2) { p.SetState(3939) p.Match(PostgreSQLParserAFTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserINSTEAD: p.EnterOuterAlt(localctx, 3) { p.SetState(3940) p.Match(PostgreSQLParserINSTEAD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3941) p.Match(PostgreSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITriggereventsContext is an interface to support dynamic dispatch. type ITriggereventsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllTriggeroneevent() []ITriggeroneeventContext Triggeroneevent(i int) ITriggeroneeventContext AllOR() []antlr.TerminalNode OR(i int) antlr.TerminalNode // IsTriggereventsContext differentiates from other interfaces. IsTriggereventsContext() } type TriggereventsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTriggereventsContext() *TriggereventsContext { var p = new(TriggereventsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerevents return p } func InitEmptyTriggereventsContext(p *TriggereventsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerevents } func (*TriggereventsContext) IsTriggereventsContext() {} func NewTriggereventsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggereventsContext { var p = new(TriggereventsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_triggerevents return p } func (s *TriggereventsContext) GetParser() antlr.Parser { return s.parser } func (s *TriggereventsContext) AllTriggeroneevent() []ITriggeroneeventContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITriggeroneeventContext); ok { len++ } } tst := make([]ITriggeroneeventContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITriggeroneeventContext); ok { tst[i] = t.(ITriggeroneeventContext) i++ } } return tst } func (s *TriggereventsContext) Triggeroneevent(i int) ITriggeroneeventContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITriggeroneeventContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITriggeroneeventContext) } func (s *TriggereventsContext) AllOR() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserOR) } func (s *TriggereventsContext) OR(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserOR, i) } func (s *TriggereventsContext) GetRuleContext() antlr.RuleContext { return s } func (s *TriggereventsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TriggereventsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTriggerevents(s) } } func (s *TriggereventsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTriggerevents(s) } } func (s *TriggereventsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTriggerevents(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Triggerevents() (localctx ITriggereventsContext) { localctx = NewTriggereventsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 408, PostgreSQLParserRULE_triggerevents) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3944) p.Triggeroneevent() } p.SetState(3949) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserOR { { p.SetState(3945) p.Match(PostgreSQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3946) p.Triggeroneevent() } p.SetState(3951) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITriggeroneeventContext is an interface to support dynamic dispatch. type ITriggeroneeventContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures INSERT() antlr.TerminalNode DELETE_P() antlr.TerminalNode UPDATE() antlr.TerminalNode OF() antlr.TerminalNode Columnlist() IColumnlistContext TRUNCATE() antlr.TerminalNode // IsTriggeroneeventContext differentiates from other interfaces. IsTriggeroneeventContext() } type TriggeroneeventContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTriggeroneeventContext() *TriggeroneeventContext { var p = new(TriggeroneeventContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggeroneevent return p } func InitEmptyTriggeroneeventContext(p *TriggeroneeventContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggeroneevent } func (*TriggeroneeventContext) IsTriggeroneeventContext() {} func NewTriggeroneeventContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggeroneeventContext { var p = new(TriggeroneeventContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_triggeroneevent return p } func (s *TriggeroneeventContext) GetParser() antlr.Parser { return s.parser } func (s *TriggeroneeventContext) INSERT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINSERT, 0) } func (s *TriggeroneeventContext) DELETE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDELETE_P, 0) } func (s *TriggeroneeventContext) UPDATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUPDATE, 0) } func (s *TriggeroneeventContext) OF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOF, 0) } func (s *TriggeroneeventContext) Columnlist() IColumnlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColumnlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColumnlistContext) } func (s *TriggeroneeventContext) TRUNCATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRUNCATE, 0) } func (s *TriggeroneeventContext) GetRuleContext() antlr.RuleContext { return s } func (s *TriggeroneeventContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TriggeroneeventContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTriggeroneevent(s) } } func (s *TriggeroneeventContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTriggeroneevent(s) } } func (s *TriggeroneeventContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTriggeroneevent(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Triggeroneevent() (localctx ITriggeroneeventContext) { localctx = NewTriggeroneeventContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 410, PostgreSQLParserRULE_triggeroneevent) p.SetState(3959) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 182, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(3952) p.Match(PostgreSQLParserINSERT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(3953) p.Match(PostgreSQLParserDELETE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(3954) p.Match(PostgreSQLParserUPDATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(3955) p.Match(PostgreSQLParserUPDATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3956) p.Match(PostgreSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3957) p.Columnlist() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(3958) p.Match(PostgreSQLParserTRUNCATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITriggerreferencingContext is an interface to support dynamic dispatch. type ITriggerreferencingContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures REFERENCING() antlr.TerminalNode Triggertransitions() ITriggertransitionsContext // IsTriggerreferencingContext differentiates from other interfaces. IsTriggerreferencingContext() } type TriggerreferencingContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTriggerreferencingContext() *TriggerreferencingContext { var p = new(TriggerreferencingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerreferencing return p } func InitEmptyTriggerreferencingContext(p *TriggerreferencingContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerreferencing } func (*TriggerreferencingContext) IsTriggerreferencingContext() {} func NewTriggerreferencingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerreferencingContext { var p = new(TriggerreferencingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_triggerreferencing return p } func (s *TriggerreferencingContext) GetParser() antlr.Parser { return s.parser } func (s *TriggerreferencingContext) REFERENCING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREFERENCING, 0) } func (s *TriggerreferencingContext) Triggertransitions() ITriggertransitionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITriggertransitionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITriggertransitionsContext) } func (s *TriggerreferencingContext) GetRuleContext() antlr.RuleContext { return s } func (s *TriggerreferencingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TriggerreferencingContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTriggerreferencing(s) } } func (s *TriggerreferencingContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTriggerreferencing(s) } } func (s *TriggerreferencingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTriggerreferencing(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Triggerreferencing() (localctx ITriggerreferencingContext) { localctx = NewTriggerreferencingContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 412, PostgreSQLParserRULE_triggerreferencing) p.SetState(3964) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserREFERENCING: p.EnterOuterAlt(localctx, 1) { p.SetState(3961) p.Match(PostgreSQLParserREFERENCING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3962) p.Triggertransitions() } case PostgreSQLParserFOR, PostgreSQLParserWHEN, PostgreSQLParserEXECUTE: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITriggertransitionsContext is an interface to support dynamic dispatch. type ITriggertransitionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllTriggertransition() []ITriggertransitionContext Triggertransition(i int) ITriggertransitionContext // IsTriggertransitionsContext differentiates from other interfaces. IsTriggertransitionsContext() } type TriggertransitionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTriggertransitionsContext() *TriggertransitionsContext { var p = new(TriggertransitionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggertransitions return p } func InitEmptyTriggertransitionsContext(p *TriggertransitionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggertransitions } func (*TriggertransitionsContext) IsTriggertransitionsContext() {} func NewTriggertransitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggertransitionsContext { var p = new(TriggertransitionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_triggertransitions return p } func (s *TriggertransitionsContext) GetParser() antlr.Parser { return s.parser } func (s *TriggertransitionsContext) AllTriggertransition() []ITriggertransitionContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITriggertransitionContext); ok { len++ } } tst := make([]ITriggertransitionContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITriggertransitionContext); ok { tst[i] = t.(ITriggertransitionContext) i++ } } return tst } func (s *TriggertransitionsContext) Triggertransition(i int) ITriggertransitionContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITriggertransitionContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITriggertransitionContext) } func (s *TriggertransitionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *TriggertransitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TriggertransitionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTriggertransitions(s) } } func (s *TriggertransitionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTriggertransitions(s) } } func (s *TriggertransitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTriggertransitions(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Triggertransitions() (localctx ITriggertransitionsContext) { localctx = NewTriggertransitionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 414, PostgreSQLParserRULE_triggertransitions) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(3967) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ok := true; ok; ok = _la == PostgreSQLParserNEW || _la == PostgreSQLParserOLD { { p.SetState(3966) p.Triggertransition() } p.SetState(3969) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITriggertransitionContext is an interface to support dynamic dispatch. type ITriggertransitionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Transitionoldornew() ITransitionoldornewContext Transitionrowortable() ITransitionrowortableContext Opt_as() IOpt_asContext Transitionrelname() ITransitionrelnameContext // IsTriggertransitionContext differentiates from other interfaces. IsTriggertransitionContext() } type TriggertransitionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTriggertransitionContext() *TriggertransitionContext { var p = new(TriggertransitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggertransition return p } func InitEmptyTriggertransitionContext(p *TriggertransitionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggertransition } func (*TriggertransitionContext) IsTriggertransitionContext() {} func NewTriggertransitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggertransitionContext { var p = new(TriggertransitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_triggertransition return p } func (s *TriggertransitionContext) GetParser() antlr.Parser { return s.parser } func (s *TriggertransitionContext) Transitionoldornew() ITransitionoldornewContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITransitionoldornewContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITransitionoldornewContext) } func (s *TriggertransitionContext) Transitionrowortable() ITransitionrowortableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITransitionrowortableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITransitionrowortableContext) } func (s *TriggertransitionContext) Opt_as() IOpt_asContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_asContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_asContext) } func (s *TriggertransitionContext) Transitionrelname() ITransitionrelnameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITransitionrelnameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITransitionrelnameContext) } func (s *TriggertransitionContext) GetRuleContext() antlr.RuleContext { return s } func (s *TriggertransitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TriggertransitionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTriggertransition(s) } } func (s *TriggertransitionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTriggertransition(s) } } func (s *TriggertransitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTriggertransition(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Triggertransition() (localctx ITriggertransitionContext) { localctx = NewTriggertransitionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 416, PostgreSQLParserRULE_triggertransition) p.EnterOuterAlt(localctx, 1) { p.SetState(3971) p.Transitionoldornew() } { p.SetState(3972) p.Transitionrowortable() } { p.SetState(3973) p.Opt_as() } { p.SetState(3974) p.Transitionrelname() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITransitionoldornewContext is an interface to support dynamic dispatch. type ITransitionoldornewContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NEW() antlr.TerminalNode OLD() antlr.TerminalNode // IsTransitionoldornewContext differentiates from other interfaces. IsTransitionoldornewContext() } type TransitionoldornewContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTransitionoldornewContext() *TransitionoldornewContext { var p = new(TransitionoldornewContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transitionoldornew return p } func InitEmptyTransitionoldornewContext(p *TransitionoldornewContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transitionoldornew } func (*TransitionoldornewContext) IsTransitionoldornewContext() {} func NewTransitionoldornewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransitionoldornewContext { var p = new(TransitionoldornewContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_transitionoldornew return p } func (s *TransitionoldornewContext) GetParser() antlr.Parser { return s.parser } func (s *TransitionoldornewContext) NEW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNEW, 0) } func (s *TransitionoldornewContext) OLD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOLD, 0) } func (s *TransitionoldornewContext) GetRuleContext() antlr.RuleContext { return s } func (s *TransitionoldornewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TransitionoldornewContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTransitionoldornew(s) } } func (s *TransitionoldornewContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTransitionoldornew(s) } } func (s *TransitionoldornewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTransitionoldornew(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Transitionoldornew() (localctx ITransitionoldornewContext) { localctx = NewTransitionoldornewContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 418, PostgreSQLParserRULE_transitionoldornew) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3976) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserNEW || _la == PostgreSQLParserOLD) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITransitionrowortableContext is an interface to support dynamic dispatch. type ITransitionrowortableContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TABLE() antlr.TerminalNode ROW() antlr.TerminalNode // IsTransitionrowortableContext differentiates from other interfaces. IsTransitionrowortableContext() } type TransitionrowortableContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTransitionrowortableContext() *TransitionrowortableContext { var p = new(TransitionrowortableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transitionrowortable return p } func InitEmptyTransitionrowortableContext(p *TransitionrowortableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transitionrowortable } func (*TransitionrowortableContext) IsTransitionrowortableContext() {} func NewTransitionrowortableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransitionrowortableContext { var p = new(TransitionrowortableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_transitionrowortable return p } func (s *TransitionrowortableContext) GetParser() antlr.Parser { return s.parser } func (s *TransitionrowortableContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *TransitionrowortableContext) ROW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROW, 0) } func (s *TransitionrowortableContext) GetRuleContext() antlr.RuleContext { return s } func (s *TransitionrowortableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TransitionrowortableContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTransitionrowortable(s) } } func (s *TransitionrowortableContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTransitionrowortable(s) } } func (s *TransitionrowortableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTransitionrowortable(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Transitionrowortable() (localctx ITransitionrowortableContext) { localctx = NewTransitionrowortableContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 420, PostgreSQLParserRULE_transitionrowortable) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3978) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserTABLE || _la == PostgreSQLParserROW) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITransitionrelnameContext is an interface to support dynamic dispatch. type ITransitionrelnameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext // IsTransitionrelnameContext differentiates from other interfaces. IsTransitionrelnameContext() } type TransitionrelnameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTransitionrelnameContext() *TransitionrelnameContext { var p = new(TransitionrelnameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transitionrelname return p } func InitEmptyTransitionrelnameContext(p *TransitionrelnameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transitionrelname } func (*TransitionrelnameContext) IsTransitionrelnameContext() {} func NewTransitionrelnameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransitionrelnameContext { var p = new(TransitionrelnameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_transitionrelname return p } func (s *TransitionrelnameContext) GetParser() antlr.Parser { return s.parser } func (s *TransitionrelnameContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *TransitionrelnameContext) GetRuleContext() antlr.RuleContext { return s } func (s *TransitionrelnameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TransitionrelnameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTransitionrelname(s) } } func (s *TransitionrelnameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTransitionrelname(s) } } func (s *TransitionrelnameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTransitionrelname(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Transitionrelname() (localctx ITransitionrelnameContext) { localctx = NewTransitionrelnameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 422, PostgreSQLParserRULE_transitionrelname) p.EnterOuterAlt(localctx, 1) { p.SetState(3980) p.Colid() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITriggerforspecContext is an interface to support dynamic dispatch. type ITriggerforspecContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FOR() antlr.TerminalNode Triggerforopteach() ITriggerforopteachContext Triggerfortype() ITriggerfortypeContext // IsTriggerforspecContext differentiates from other interfaces. IsTriggerforspecContext() } type TriggerforspecContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTriggerforspecContext() *TriggerforspecContext { var p = new(TriggerforspecContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerforspec return p } func InitEmptyTriggerforspecContext(p *TriggerforspecContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerforspec } func (*TriggerforspecContext) IsTriggerforspecContext() {} func NewTriggerforspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerforspecContext { var p = new(TriggerforspecContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_triggerforspec return p } func (s *TriggerforspecContext) GetParser() antlr.Parser { return s.parser } func (s *TriggerforspecContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *TriggerforspecContext) Triggerforopteach() ITriggerforopteachContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITriggerforopteachContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITriggerforopteachContext) } func (s *TriggerforspecContext) Triggerfortype() ITriggerfortypeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITriggerfortypeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITriggerfortypeContext) } func (s *TriggerforspecContext) GetRuleContext() antlr.RuleContext { return s } func (s *TriggerforspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TriggerforspecContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTriggerforspec(s) } } func (s *TriggerforspecContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTriggerforspec(s) } } func (s *TriggerforspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTriggerforspec(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Triggerforspec() (localctx ITriggerforspecContext) { localctx = NewTriggerforspecContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 424, PostgreSQLParserRULE_triggerforspec) p.SetState(3987) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFOR: p.EnterOuterAlt(localctx, 1) { p.SetState(3982) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3983) p.Triggerforopteach() } { p.SetState(3984) p.Triggerfortype() } case PostgreSQLParserWHEN, PostgreSQLParserEXECUTE: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITriggerforopteachContext is an interface to support dynamic dispatch. type ITriggerforopteachContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures EACH() antlr.TerminalNode // IsTriggerforopteachContext differentiates from other interfaces. IsTriggerforopteachContext() } type TriggerforopteachContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTriggerforopteachContext() *TriggerforopteachContext { var p = new(TriggerforopteachContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerforopteach return p } func InitEmptyTriggerforopteachContext(p *TriggerforopteachContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerforopteach } func (*TriggerforopteachContext) IsTriggerforopteachContext() {} func NewTriggerforopteachContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerforopteachContext { var p = new(TriggerforopteachContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_triggerforopteach return p } func (s *TriggerforopteachContext) GetParser() antlr.Parser { return s.parser } func (s *TriggerforopteachContext) EACH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEACH, 0) } func (s *TriggerforopteachContext) GetRuleContext() antlr.RuleContext { return s } func (s *TriggerforopteachContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TriggerforopteachContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTriggerforopteach(s) } } func (s *TriggerforopteachContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTriggerforopteach(s) } } func (s *TriggerforopteachContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTriggerforopteach(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Triggerforopteach() (localctx ITriggerforopteachContext) { localctx = NewTriggerforopteachContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 426, PostgreSQLParserRULE_triggerforopteach) p.SetState(3991) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserEACH: p.EnterOuterAlt(localctx, 1) { p.SetState(3989) p.Match(PostgreSQLParserEACH) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSTATEMENT, PostgreSQLParserROW: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITriggerfortypeContext is an interface to support dynamic dispatch. type ITriggerfortypeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ROW() antlr.TerminalNode STATEMENT() antlr.TerminalNode // IsTriggerfortypeContext differentiates from other interfaces. IsTriggerfortypeContext() } type TriggerfortypeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTriggerfortypeContext() *TriggerfortypeContext { var p = new(TriggerfortypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerfortype return p } func InitEmptyTriggerfortypeContext(p *TriggerfortypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerfortype } func (*TriggerfortypeContext) IsTriggerfortypeContext() {} func NewTriggerfortypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerfortypeContext { var p = new(TriggerfortypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_triggerfortype return p } func (s *TriggerfortypeContext) GetParser() antlr.Parser { return s.parser } func (s *TriggerfortypeContext) ROW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROW, 0) } func (s *TriggerfortypeContext) STATEMENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTATEMENT, 0) } func (s *TriggerfortypeContext) GetRuleContext() antlr.RuleContext { return s } func (s *TriggerfortypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TriggerfortypeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTriggerfortype(s) } } func (s *TriggerfortypeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTriggerfortype(s) } } func (s *TriggerfortypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTriggerfortype(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Triggerfortype() (localctx ITriggerfortypeContext) { localctx = NewTriggerfortypeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 428, PostgreSQLParserRULE_triggerfortype) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3993) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserSTATEMENT || _la == PostgreSQLParserROW) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITriggerwhenContext is an interface to support dynamic dispatch. type ITriggerwhenContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WHEN() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode A_expr() IA_exprContext CLOSE_PAREN() antlr.TerminalNode // IsTriggerwhenContext differentiates from other interfaces. IsTriggerwhenContext() } type TriggerwhenContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTriggerwhenContext() *TriggerwhenContext { var p = new(TriggerwhenContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerwhen return p } func InitEmptyTriggerwhenContext(p *TriggerwhenContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerwhen } func (*TriggerwhenContext) IsTriggerwhenContext() {} func NewTriggerwhenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerwhenContext { var p = new(TriggerwhenContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_triggerwhen return p } func (s *TriggerwhenContext) GetParser() antlr.Parser { return s.parser } func (s *TriggerwhenContext) WHEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHEN, 0) } func (s *TriggerwhenContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *TriggerwhenContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *TriggerwhenContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *TriggerwhenContext) GetRuleContext() antlr.RuleContext { return s } func (s *TriggerwhenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TriggerwhenContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTriggerwhen(s) } } func (s *TriggerwhenContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTriggerwhen(s) } } func (s *TriggerwhenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTriggerwhen(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Triggerwhen() (localctx ITriggerwhenContext) { localctx = NewTriggerwhenContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 430, PostgreSQLParserRULE_triggerwhen) p.SetState(4001) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserWHEN: p.EnterOuterAlt(localctx, 1) { p.SetState(3995) p.Match(PostgreSQLParserWHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3996) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(3997) p.A_expr() } { p.SetState(3998) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEXECUTE: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunction_or_procedureContext is an interface to support dynamic dispatch. type IFunction_or_procedureContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FUNCTION() antlr.TerminalNode PROCEDURE() antlr.TerminalNode // IsFunction_or_procedureContext differentiates from other interfaces. IsFunction_or_procedureContext() } type Function_or_procedureContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunction_or_procedureContext() *Function_or_procedureContext { var p = new(Function_or_procedureContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_function_or_procedure return p } func InitEmptyFunction_or_procedureContext(p *Function_or_procedureContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_function_or_procedure } func (*Function_or_procedureContext) IsFunction_or_procedureContext() {} func NewFunction_or_procedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_or_procedureContext { var p = new(Function_or_procedureContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_function_or_procedure return p } func (s *Function_or_procedureContext) GetParser() antlr.Parser { return s.parser } func (s *Function_or_procedureContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *Function_or_procedureContext) PROCEDURE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURE, 0) } func (s *Function_or_procedureContext) GetRuleContext() antlr.RuleContext { return s } func (s *Function_or_procedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Function_or_procedureContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunction_or_procedure(s) } } func (s *Function_or_procedureContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunction_or_procedure(s) } } func (s *Function_or_procedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunction_or_procedure(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Function_or_procedure() (localctx IFunction_or_procedureContext) { localctx = NewFunction_or_procedureContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 432, PostgreSQLParserRULE_function_or_procedure) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4003) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserFUNCTION || _la == PostgreSQLParserPROCEDURE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITriggerfuncargsContext is an interface to support dynamic dispatch. type ITriggerfuncargsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllTriggerfuncarg() []ITriggerfuncargContext Triggerfuncarg(i int) ITriggerfuncargContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsTriggerfuncargsContext differentiates from other interfaces. IsTriggerfuncargsContext() } type TriggerfuncargsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTriggerfuncargsContext() *TriggerfuncargsContext { var p = new(TriggerfuncargsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerfuncargs return p } func InitEmptyTriggerfuncargsContext(p *TriggerfuncargsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerfuncargs } func (*TriggerfuncargsContext) IsTriggerfuncargsContext() {} func NewTriggerfuncargsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerfuncargsContext { var p = new(TriggerfuncargsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_triggerfuncargs return p } func (s *TriggerfuncargsContext) GetParser() antlr.Parser { return s.parser } func (s *TriggerfuncargsContext) AllTriggerfuncarg() []ITriggerfuncargContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITriggerfuncargContext); ok { len++ } } tst := make([]ITriggerfuncargContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITriggerfuncargContext); ok { tst[i] = t.(ITriggerfuncargContext) i++ } } return tst } func (s *TriggerfuncargsContext) Triggerfuncarg(i int) ITriggerfuncargContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITriggerfuncargContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITriggerfuncargContext) } func (s *TriggerfuncargsContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *TriggerfuncargsContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *TriggerfuncargsContext) GetRuleContext() antlr.RuleContext { return s } func (s *TriggerfuncargsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TriggerfuncargsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTriggerfuncargs(s) } } func (s *TriggerfuncargsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTriggerfuncargs(s) } } func (s *TriggerfuncargsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTriggerfuncargs(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Triggerfuncargs() (localctx ITriggerfuncargsContext) { localctx = NewTriggerfuncargsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 434, PostgreSQLParserRULE_triggerfuncargs) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(4007) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserALL, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserANY, PostgreSQLParserARRAY, PostgreSQLParserAS, PostgreSQLParserASC, PostgreSQLParserASYMMETRIC, PostgreSQLParserBOTH, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDEFERRABLE, PostgreSQLParserDESC, PostgreSQLParserDISTINCT, PostgreSQLParserDO, PostgreSQLParserELSE, PostgreSQLParserEXCEPT, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserFOREIGN, PostgreSQLParserFROM, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserIN_P, PostgreSQLParserINITIALLY, PostgreSQLParserINTERSECT, PostgreSQLParserLATERAL_P, PostgreSQLParserLEADING, PostgreSQLParserLIMIT, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserONLY, PostgreSQLParserOR, PostgreSQLParserORDER, PostgreSQLParserPLACING, PostgreSQLParserPRIMARY, PostgreSQLParserREFERENCES, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserSESSION_USER, PostgreSQLParserSOME, PostgreSQLParserSYMMETRIC, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserTO, PostgreSQLParserTRAILING, PostgreSQLParserTRUE_P, PostgreSQLParserUNION, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserUSING, PostgreSQLParserVARIADIC, PostgreSQLParserWHEN, PostgreSQLParserWHERE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: { p.SetState(4005) p.Triggerfuncarg() } case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA: default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.SetState(4013) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(4009) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4010) p.Triggerfuncarg() } p.SetState(4015) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITriggerfuncargContext is an interface to support dynamic dispatch. type ITriggerfuncargContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Iconst() IIconstContext Fconst() IFconstContext Sconst() ISconstContext Collabel() ICollabelContext // IsTriggerfuncargContext differentiates from other interfaces. IsTriggerfuncargContext() } type TriggerfuncargContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTriggerfuncargContext() *TriggerfuncargContext { var p = new(TriggerfuncargContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerfuncarg return p } func InitEmptyTriggerfuncargContext(p *TriggerfuncargContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_triggerfuncarg } func (*TriggerfuncargContext) IsTriggerfuncargContext() {} func NewTriggerfuncargContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerfuncargContext { var p = new(TriggerfuncargContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_triggerfuncarg return p } func (s *TriggerfuncargContext) GetParser() antlr.Parser { return s.parser } func (s *TriggerfuncargContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *TriggerfuncargContext) Fconst() IFconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFconstContext) } func (s *TriggerfuncargContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *TriggerfuncargContext) Collabel() ICollabelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICollabelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICollabelContext) } func (s *TriggerfuncargContext) GetRuleContext() antlr.RuleContext { return s } func (s *TriggerfuncargContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TriggerfuncargContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTriggerfuncarg(s) } } func (s *TriggerfuncargContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTriggerfuncarg(s) } } func (s *TriggerfuncargContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTriggerfuncarg(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Triggerfuncarg() (localctx ITriggerfuncargContext) { localctx = NewTriggerfuncargContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 436, PostgreSQLParserRULE_triggerfuncarg) p.SetState(4020) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserIntegral: p.EnterOuterAlt(localctx, 1) { p.SetState(4016) p.Iconst() } case PostgreSQLParserNumeric: p.EnterOuterAlt(localctx, 2) { p.SetState(4017) p.Fconst() } case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 3) { p.SetState(4018) p.Sconst() } case PostgreSQLParserALL, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserANY, PostgreSQLParserARRAY, PostgreSQLParserAS, PostgreSQLParserASC, PostgreSQLParserASYMMETRIC, PostgreSQLParserBOTH, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDEFERRABLE, PostgreSQLParserDESC, PostgreSQLParserDISTINCT, PostgreSQLParserDO, PostgreSQLParserELSE, PostgreSQLParserEXCEPT, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserFOREIGN, PostgreSQLParserFROM, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserIN_P, PostgreSQLParserINITIALLY, PostgreSQLParserINTERSECT, PostgreSQLParserLATERAL_P, PostgreSQLParserLEADING, PostgreSQLParserLIMIT, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserONLY, PostgreSQLParserOR, PostgreSQLParserORDER, PostgreSQLParserPLACING, PostgreSQLParserPRIMARY, PostgreSQLParserREFERENCES, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserSESSION_USER, PostgreSQLParserSOME, PostgreSQLParserSYMMETRIC, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserTO, PostgreSQLParserTRAILING, PostgreSQLParserTRUE_P, PostgreSQLParserUNION, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserUSING, PostgreSQLParserVARIADIC, PostgreSQLParserWHEN, PostgreSQLParserWHERE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 4) { p.SetState(4019) p.Collabel() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOptconstrfromtableContext is an interface to support dynamic dispatch. type IOptconstrfromtableContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FROM() antlr.TerminalNode Qualified_name() IQualified_nameContext // IsOptconstrfromtableContext differentiates from other interfaces. IsOptconstrfromtableContext() } type OptconstrfromtableContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOptconstrfromtableContext() *OptconstrfromtableContext { var p = new(OptconstrfromtableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optconstrfromtable return p } func InitEmptyOptconstrfromtableContext(p *OptconstrfromtableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_optconstrfromtable } func (*OptconstrfromtableContext) IsOptconstrfromtableContext() {} func NewOptconstrfromtableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptconstrfromtableContext { var p = new(OptconstrfromtableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_optconstrfromtable return p } func (s *OptconstrfromtableContext) GetParser() antlr.Parser { return s.parser } func (s *OptconstrfromtableContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *OptconstrfromtableContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *OptconstrfromtableContext) GetRuleContext() antlr.RuleContext { return s } func (s *OptconstrfromtableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OptconstrfromtableContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOptconstrfromtable(s) } } func (s *OptconstrfromtableContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOptconstrfromtable(s) } } func (s *OptconstrfromtableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOptconstrfromtable(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Optconstrfromtable() (localctx IOptconstrfromtableContext) { localctx = NewOptconstrfromtableContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 438, PostgreSQLParserRULE_optconstrfromtable) p.SetState(4025) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFROM: p.EnterOuterAlt(localctx, 1) { p.SetState(4022) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4023) p.Qualified_name() } case PostgreSQLParserDEFERRABLE, PostgreSQLParserFOR, PostgreSQLParserINITIALLY, PostgreSQLParserNOT, PostgreSQLParserNO: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IConstraintattributespecContext is an interface to support dynamic dispatch. type IConstraintattributespecContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllConstraintattributeElem() []IConstraintattributeElemContext ConstraintattributeElem(i int) IConstraintattributeElemContext // IsConstraintattributespecContext differentiates from other interfaces. IsConstraintattributespecContext() } type ConstraintattributespecContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyConstraintattributespecContext() *ConstraintattributespecContext { var p = new(ConstraintattributespecContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constraintattributespec return p } func InitEmptyConstraintattributespecContext(p *ConstraintattributespecContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constraintattributespec } func (*ConstraintattributespecContext) IsConstraintattributespecContext() {} func NewConstraintattributespecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintattributespecContext { var p = new(ConstraintattributespecContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_constraintattributespec return p } func (s *ConstraintattributespecContext) GetParser() antlr.Parser { return s.parser } func (s *ConstraintattributespecContext) AllConstraintattributeElem() []IConstraintattributeElemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IConstraintattributeElemContext); ok { len++ } } tst := make([]IConstraintattributeElemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IConstraintattributeElemContext); ok { tst[i] = t.(IConstraintattributeElemContext) i++ } } return tst } func (s *ConstraintattributespecContext) ConstraintattributeElem(i int) IConstraintattributeElemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstraintattributeElemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IConstraintattributeElemContext) } func (s *ConstraintattributespecContext) GetRuleContext() antlr.RuleContext { return s } func (s *ConstraintattributespecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ConstraintattributespecContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterConstraintattributespec(s) } } func (s *ConstraintattributespecContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitConstraintattributespec(s) } } func (s *ConstraintattributespecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitConstraintattributespec(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Constraintattributespec() (localctx IConstraintattributespecContext) { localctx = NewConstraintattributespecContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 440, PostgreSQLParserRULE_constraintattributespec) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(4030) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ((int64((_la-54)) & ^0x3f) == 0 && ((int64(1)<<(_la-54))&8421377) != 0) || _la == PostgreSQLParserNO { { p.SetState(4027) p.ConstraintattributeElem() } p.SetState(4032) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IConstraintattributeElemContext is an interface to support dynamic dispatch. type IConstraintattributeElemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NOT() antlr.TerminalNode DEFERRABLE() antlr.TerminalNode INITIALLY() antlr.TerminalNode IMMEDIATE() antlr.TerminalNode DEFERRED() antlr.TerminalNode VALID() antlr.TerminalNode NO() antlr.TerminalNode INHERIT() antlr.TerminalNode // IsConstraintattributeElemContext differentiates from other interfaces. IsConstraintattributeElemContext() } type ConstraintattributeElemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyConstraintattributeElemContext() *ConstraintattributeElemContext { var p = new(ConstraintattributeElemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constraintattributeElem return p } func InitEmptyConstraintattributeElemContext(p *ConstraintattributeElemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constraintattributeElem } func (*ConstraintattributeElemContext) IsConstraintattributeElemContext() {} func NewConstraintattributeElemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintattributeElemContext { var p = new(ConstraintattributeElemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_constraintattributeElem return p } func (s *ConstraintattributeElemContext) GetParser() antlr.Parser { return s.parser } func (s *ConstraintattributeElemContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *ConstraintattributeElemContext) DEFERRABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFERRABLE, 0) } func (s *ConstraintattributeElemContext) INITIALLY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINITIALLY, 0) } func (s *ConstraintattributeElemContext) IMMEDIATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIMMEDIATE, 0) } func (s *ConstraintattributeElemContext) DEFERRED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFERRED, 0) } func (s *ConstraintattributeElemContext) VALID() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALID, 0) } func (s *ConstraintattributeElemContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *ConstraintattributeElemContext) INHERIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINHERIT, 0) } func (s *ConstraintattributeElemContext) GetRuleContext() antlr.RuleContext { return s } func (s *ConstraintattributeElemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ConstraintattributeElemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterConstraintattributeElem(s) } } func (s *ConstraintattributeElemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitConstraintattributeElem(s) } } func (s *ConstraintattributeElemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitConstraintattributeElem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) ConstraintattributeElem() (localctx IConstraintattributeElemContext) { localctx = NewConstraintattributeElemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 442, PostgreSQLParserRULE_constraintattributeElem) p.SetState(4044) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 193, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4033) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4034) p.Match(PostgreSQLParserDEFERRABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4035) p.Match(PostgreSQLParserDEFERRABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(4036) p.Match(PostgreSQLParserINITIALLY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4037) p.Match(PostgreSQLParserIMMEDIATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(4038) p.Match(PostgreSQLParserINITIALLY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4039) p.Match(PostgreSQLParserDEFERRED) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(4040) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4041) p.Match(PostgreSQLParserVALID) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(4042) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4043) p.Match(PostgreSQLParserINHERIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateeventtrigstmtContext is an interface to support dynamic dispatch. type ICreateeventtrigstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode EVENT() antlr.TerminalNode TRIGGER() antlr.TerminalNode Name() INameContext ON() antlr.TerminalNode Collabel() ICollabelContext EXECUTE() antlr.TerminalNode Function_or_procedure() IFunction_or_procedureContext Func_name() IFunc_nameContext OPEN_PAREN() antlr.TerminalNode CLOSE_PAREN() antlr.TerminalNode WHEN() antlr.TerminalNode Event_trigger_when_list() IEvent_trigger_when_listContext // IsCreateeventtrigstmtContext differentiates from other interfaces. IsCreateeventtrigstmtContext() } type CreateeventtrigstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateeventtrigstmtContext() *CreateeventtrigstmtContext { var p = new(CreateeventtrigstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createeventtrigstmt return p } func InitEmptyCreateeventtrigstmtContext(p *CreateeventtrigstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createeventtrigstmt } func (*CreateeventtrigstmtContext) IsCreateeventtrigstmtContext() {} func NewCreateeventtrigstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateeventtrigstmtContext { var p = new(CreateeventtrigstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createeventtrigstmt return p } func (s *CreateeventtrigstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateeventtrigstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateeventtrigstmtContext) EVENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEVENT, 0) } func (s *CreateeventtrigstmtContext) TRIGGER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRIGGER, 0) } func (s *CreateeventtrigstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreateeventtrigstmtContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *CreateeventtrigstmtContext) Collabel() ICollabelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICollabelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICollabelContext) } func (s *CreateeventtrigstmtContext) EXECUTE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXECUTE, 0) } func (s *CreateeventtrigstmtContext) Function_or_procedure() IFunction_or_procedureContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_or_procedureContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunction_or_procedureContext) } func (s *CreateeventtrigstmtContext) Func_name() IFunc_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_nameContext) } func (s *CreateeventtrigstmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *CreateeventtrigstmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *CreateeventtrigstmtContext) WHEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHEN, 0) } func (s *CreateeventtrigstmtContext) Event_trigger_when_list() IEvent_trigger_when_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IEvent_trigger_when_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IEvent_trigger_when_listContext) } func (s *CreateeventtrigstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateeventtrigstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateeventtrigstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateeventtrigstmt(s) } } func (s *CreateeventtrigstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateeventtrigstmt(s) } } func (s *CreateeventtrigstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateeventtrigstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createeventtrigstmt() (localctx ICreateeventtrigstmtContext) { localctx = NewCreateeventtrigstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 444, PostgreSQLParserRULE_createeventtrigstmt) p.SetState(4072) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 194, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4046) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4047) p.Match(PostgreSQLParserEVENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4048) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4049) p.Name() } { p.SetState(4050) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4051) p.Collabel() } { p.SetState(4052) p.Match(PostgreSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4053) p.Function_or_procedure() } { p.SetState(4054) p.Func_name() } { p.SetState(4055) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4056) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4058) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4059) p.Match(PostgreSQLParserEVENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4060) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4061) p.Name() } { p.SetState(4062) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4063) p.Collabel() } { p.SetState(4064) p.Match(PostgreSQLParserWHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4065) p.Event_trigger_when_list() } { p.SetState(4066) p.Match(PostgreSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4067) p.Function_or_procedure() } { p.SetState(4068) p.Func_name() } { p.SetState(4069) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4070) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IEvent_trigger_when_listContext is an interface to support dynamic dispatch. type IEvent_trigger_when_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllEvent_trigger_when_item() []IEvent_trigger_when_itemContext Event_trigger_when_item(i int) IEvent_trigger_when_itemContext AllAND() []antlr.TerminalNode AND(i int) antlr.TerminalNode // IsEvent_trigger_when_listContext differentiates from other interfaces. IsEvent_trigger_when_listContext() } type Event_trigger_when_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyEvent_trigger_when_listContext() *Event_trigger_when_listContext { var p = new(Event_trigger_when_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_event_trigger_when_list return p } func InitEmptyEvent_trigger_when_listContext(p *Event_trigger_when_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_event_trigger_when_list } func (*Event_trigger_when_listContext) IsEvent_trigger_when_listContext() {} func NewEvent_trigger_when_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_trigger_when_listContext { var p = new(Event_trigger_when_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_event_trigger_when_list return p } func (s *Event_trigger_when_listContext) GetParser() antlr.Parser { return s.parser } func (s *Event_trigger_when_listContext) AllEvent_trigger_when_item() []IEvent_trigger_when_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IEvent_trigger_when_itemContext); ok { len++ } } tst := make([]IEvent_trigger_when_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IEvent_trigger_when_itemContext); ok { tst[i] = t.(IEvent_trigger_when_itemContext) i++ } } return tst } func (s *Event_trigger_when_listContext) Event_trigger_when_item(i int) IEvent_trigger_when_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IEvent_trigger_when_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IEvent_trigger_when_itemContext) } func (s *Event_trigger_when_listContext) AllAND() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserAND) } func (s *Event_trigger_when_listContext) AND(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserAND, i) } func (s *Event_trigger_when_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Event_trigger_when_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Event_trigger_when_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterEvent_trigger_when_list(s) } } func (s *Event_trigger_when_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitEvent_trigger_when_list(s) } } func (s *Event_trigger_when_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitEvent_trigger_when_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Event_trigger_when_list() (localctx IEvent_trigger_when_listContext) { localctx = NewEvent_trigger_when_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 446, PostgreSQLParserRULE_event_trigger_when_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4074) p.Event_trigger_when_item() } p.SetState(4079) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserAND { { p.SetState(4075) p.Match(PostgreSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4076) p.Event_trigger_when_item() } p.SetState(4081) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IEvent_trigger_when_itemContext is an interface to support dynamic dispatch. type IEvent_trigger_when_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext IN_P() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Event_trigger_value_list() IEvent_trigger_value_listContext CLOSE_PAREN() antlr.TerminalNode // IsEvent_trigger_when_itemContext differentiates from other interfaces. IsEvent_trigger_when_itemContext() } type Event_trigger_when_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyEvent_trigger_when_itemContext() *Event_trigger_when_itemContext { var p = new(Event_trigger_when_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_event_trigger_when_item return p } func InitEmptyEvent_trigger_when_itemContext(p *Event_trigger_when_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_event_trigger_when_item } func (*Event_trigger_when_itemContext) IsEvent_trigger_when_itemContext() {} func NewEvent_trigger_when_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_trigger_when_itemContext { var p = new(Event_trigger_when_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_event_trigger_when_item return p } func (s *Event_trigger_when_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Event_trigger_when_itemContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Event_trigger_when_itemContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *Event_trigger_when_itemContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Event_trigger_when_itemContext) Event_trigger_value_list() IEvent_trigger_value_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IEvent_trigger_value_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IEvent_trigger_value_listContext) } func (s *Event_trigger_when_itemContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Event_trigger_when_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Event_trigger_when_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Event_trigger_when_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterEvent_trigger_when_item(s) } } func (s *Event_trigger_when_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitEvent_trigger_when_item(s) } } func (s *Event_trigger_when_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitEvent_trigger_when_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Event_trigger_when_item() (localctx IEvent_trigger_when_itemContext) { localctx = NewEvent_trigger_when_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 448, PostgreSQLParserRULE_event_trigger_when_item) p.EnterOuterAlt(localctx, 1) { p.SetState(4082) p.Colid() } { p.SetState(4083) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4084) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4085) p.Event_trigger_value_list() } { p.SetState(4086) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IEvent_trigger_value_listContext is an interface to support dynamic dispatch. type IEvent_trigger_value_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllSconst() []ISconstContext Sconst(i int) ISconstContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsEvent_trigger_value_listContext differentiates from other interfaces. IsEvent_trigger_value_listContext() } type Event_trigger_value_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyEvent_trigger_value_listContext() *Event_trigger_value_listContext { var p = new(Event_trigger_value_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_event_trigger_value_list return p } func InitEmptyEvent_trigger_value_listContext(p *Event_trigger_value_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_event_trigger_value_list } func (*Event_trigger_value_listContext) IsEvent_trigger_value_listContext() {} func NewEvent_trigger_value_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_trigger_value_listContext { var p = new(Event_trigger_value_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_event_trigger_value_list return p } func (s *Event_trigger_value_listContext) GetParser() antlr.Parser { return s.parser } func (s *Event_trigger_value_listContext) AllSconst() []ISconstContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISconstContext); ok { len++ } } tst := make([]ISconstContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISconstContext); ok { tst[i] = t.(ISconstContext) i++ } } return tst } func (s *Event_trigger_value_listContext) Sconst(i int) ISconstContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISconstContext) } func (s *Event_trigger_value_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Event_trigger_value_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Event_trigger_value_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Event_trigger_value_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Event_trigger_value_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterEvent_trigger_value_list(s) } } func (s *Event_trigger_value_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitEvent_trigger_value_list(s) } } func (s *Event_trigger_value_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitEvent_trigger_value_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Event_trigger_value_list() (localctx IEvent_trigger_value_listContext) { localctx = NewEvent_trigger_value_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 450, PostgreSQLParserRULE_event_trigger_value_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4088) p.Sconst() } p.SetState(4093) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(4089) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4090) p.Sconst() } p.SetState(4095) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAltereventtrigstmtContext is an interface to support dynamic dispatch. type IAltereventtrigstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode EVENT() antlr.TerminalNode TRIGGER() antlr.TerminalNode Name() INameContext Enable_trigger() IEnable_triggerContext // IsAltereventtrigstmtContext differentiates from other interfaces. IsAltereventtrigstmtContext() } type AltereventtrigstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAltereventtrigstmtContext() *AltereventtrigstmtContext { var p = new(AltereventtrigstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altereventtrigstmt return p } func InitEmptyAltereventtrigstmtContext(p *AltereventtrigstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altereventtrigstmt } func (*AltereventtrigstmtContext) IsAltereventtrigstmtContext() {} func NewAltereventtrigstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltereventtrigstmtContext { var p = new(AltereventtrigstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_altereventtrigstmt return p } func (s *AltereventtrigstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AltereventtrigstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AltereventtrigstmtContext) EVENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEVENT, 0) } func (s *AltereventtrigstmtContext) TRIGGER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRIGGER, 0) } func (s *AltereventtrigstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *AltereventtrigstmtContext) Enable_trigger() IEnable_triggerContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IEnable_triggerContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IEnable_triggerContext) } func (s *AltereventtrigstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AltereventtrigstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AltereventtrigstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAltereventtrigstmt(s) } } func (s *AltereventtrigstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAltereventtrigstmt(s) } } func (s *AltereventtrigstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAltereventtrigstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Altereventtrigstmt() (localctx IAltereventtrigstmtContext) { localctx = NewAltereventtrigstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 452, PostgreSQLParserRULE_altereventtrigstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(4096) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4097) p.Match(PostgreSQLParserEVENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4098) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4099) p.Name() } { p.SetState(4100) p.Enable_trigger() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IEnable_triggerContext is an interface to support dynamic dispatch. type IEnable_triggerContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ENABLE_P() antlr.TerminalNode REPLICA() antlr.TerminalNode ALWAYS() antlr.TerminalNode DISABLE_P() antlr.TerminalNode // IsEnable_triggerContext differentiates from other interfaces. IsEnable_triggerContext() } type Enable_triggerContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyEnable_triggerContext() *Enable_triggerContext { var p = new(Enable_triggerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_enable_trigger return p } func InitEmptyEnable_triggerContext(p *Enable_triggerContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_enable_trigger } func (*Enable_triggerContext) IsEnable_triggerContext() {} func NewEnable_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enable_triggerContext { var p = new(Enable_triggerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_enable_trigger return p } func (s *Enable_triggerContext) GetParser() antlr.Parser { return s.parser } func (s *Enable_triggerContext) ENABLE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserENABLE_P, 0) } func (s *Enable_triggerContext) REPLICA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREPLICA, 0) } func (s *Enable_triggerContext) ALWAYS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALWAYS, 0) } func (s *Enable_triggerContext) DISABLE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDISABLE_P, 0) } func (s *Enable_triggerContext) GetRuleContext() antlr.RuleContext { return s } func (s *Enable_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Enable_triggerContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterEnable_trigger(s) } } func (s *Enable_triggerContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitEnable_trigger(s) } } func (s *Enable_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitEnable_trigger(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Enable_trigger() (localctx IEnable_triggerContext) { localctx = NewEnable_triggerContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 454, PostgreSQLParserRULE_enable_trigger) p.SetState(4108) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 197, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4102) p.Match(PostgreSQLParserENABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4103) p.Match(PostgreSQLParserENABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4104) p.Match(PostgreSQLParserREPLICA) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(4105) p.Match(PostgreSQLParserENABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4106) p.Match(PostgreSQLParserALWAYS) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(4107) p.Match(PostgreSQLParserDISABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateassertionstmtContext is an interface to support dynamic dispatch. type ICreateassertionstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode ASSERTION() antlr.TerminalNode Any_name() IAny_nameContext CHECK() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode A_expr() IA_exprContext CLOSE_PAREN() antlr.TerminalNode Constraintattributespec() IConstraintattributespecContext // IsCreateassertionstmtContext differentiates from other interfaces. IsCreateassertionstmtContext() } type CreateassertionstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateassertionstmtContext() *CreateassertionstmtContext { var p = new(CreateassertionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createassertionstmt return p } func InitEmptyCreateassertionstmtContext(p *CreateassertionstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createassertionstmt } func (*CreateassertionstmtContext) IsCreateassertionstmtContext() {} func NewCreateassertionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateassertionstmtContext { var p = new(CreateassertionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createassertionstmt return p } func (s *CreateassertionstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateassertionstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateassertionstmtContext) ASSERTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserASSERTION, 0) } func (s *CreateassertionstmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *CreateassertionstmtContext) CHECK() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHECK, 0) } func (s *CreateassertionstmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *CreateassertionstmtContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *CreateassertionstmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *CreateassertionstmtContext) Constraintattributespec() IConstraintattributespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstraintattributespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstraintattributespecContext) } func (s *CreateassertionstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateassertionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateassertionstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateassertionstmt(s) } } func (s *CreateassertionstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateassertionstmt(s) } } func (s *CreateassertionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateassertionstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createassertionstmt() (localctx ICreateassertionstmtContext) { localctx = NewCreateassertionstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 456, PostgreSQLParserRULE_createassertionstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(4110) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4111) p.Match(PostgreSQLParserASSERTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4112) p.Any_name() } { p.SetState(4113) p.Match(PostgreSQLParserCHECK) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4114) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4115) p.A_expr() } { p.SetState(4116) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4117) p.Constraintattributespec() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDefinestmtContext is an interface to support dynamic dispatch. type IDefinestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode Opt_or_replace() IOpt_or_replaceContext AGGREGATE() antlr.TerminalNode Func_name() IFunc_nameContext Aggr_args() IAggr_argsContext Definition() IDefinitionContext Old_aggr_definition() IOld_aggr_definitionContext OPERATOR() antlr.TerminalNode Any_operator() IAny_operatorContext TYPE_P() antlr.TerminalNode AllAny_name() []IAny_nameContext Any_name(i int) IAny_nameContext AS() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Opttablefuncelementlist() IOpttablefuncelementlistContext CLOSE_PAREN() antlr.TerminalNode ENUM_P() antlr.TerminalNode Opt_enum_val_list() IOpt_enum_val_listContext RANGE() antlr.TerminalNode TEXT_P() antlr.TerminalNode SEARCH() antlr.TerminalNode PARSER() antlr.TerminalNode DICTIONARY() antlr.TerminalNode TEMPLATE() antlr.TerminalNode CONFIGURATION() antlr.TerminalNode COLLATION() antlr.TerminalNode IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode FROM() antlr.TerminalNode // IsDefinestmtContext differentiates from other interfaces. IsDefinestmtContext() } type DefinestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDefinestmtContext() *DefinestmtContext { var p = new(DefinestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_definestmt return p } func InitEmptyDefinestmtContext(p *DefinestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_definestmt } func (*DefinestmtContext) IsDefinestmtContext() {} func NewDefinestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefinestmtContext { var p = new(DefinestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_definestmt return p } func (s *DefinestmtContext) GetParser() antlr.Parser { return s.parser } func (s *DefinestmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *DefinestmtContext) Opt_or_replace() IOpt_or_replaceContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_or_replaceContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_or_replaceContext) } func (s *DefinestmtContext) AGGREGATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAGGREGATE, 0) } func (s *DefinestmtContext) Func_name() IFunc_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_nameContext) } func (s *DefinestmtContext) Aggr_args() IAggr_argsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAggr_argsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAggr_argsContext) } func (s *DefinestmtContext) Definition() IDefinitionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDefinitionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDefinitionContext) } func (s *DefinestmtContext) Old_aggr_definition() IOld_aggr_definitionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOld_aggr_definitionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOld_aggr_definitionContext) } func (s *DefinestmtContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *DefinestmtContext) Any_operator() IAny_operatorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_operatorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_operatorContext) } func (s *DefinestmtContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *DefinestmtContext) AllAny_name() []IAny_nameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAny_nameContext); ok { len++ } } tst := make([]IAny_nameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAny_nameContext); ok { tst[i] = t.(IAny_nameContext) i++ } } return tst } func (s *DefinestmtContext) Any_name(i int) IAny_nameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *DefinestmtContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *DefinestmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *DefinestmtContext) Opttablefuncelementlist() IOpttablefuncelementlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttablefuncelementlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttablefuncelementlistContext) } func (s *DefinestmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *DefinestmtContext) ENUM_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserENUM_P, 0) } func (s *DefinestmtContext) Opt_enum_val_list() IOpt_enum_val_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_enum_val_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_enum_val_listContext) } func (s *DefinestmtContext) RANGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRANGE, 0) } func (s *DefinestmtContext) TEXT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEXT_P, 0) } func (s *DefinestmtContext) SEARCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEARCH, 0) } func (s *DefinestmtContext) PARSER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARSER, 0) } func (s *DefinestmtContext) DICTIONARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDICTIONARY, 0) } func (s *DefinestmtContext) TEMPLATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEMPLATE, 0) } func (s *DefinestmtContext) CONFIGURATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONFIGURATION, 0) } func (s *DefinestmtContext) COLLATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATION, 0) } func (s *DefinestmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *DefinestmtContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *DefinestmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *DefinestmtContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *DefinestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DefinestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DefinestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDefinestmt(s) } } func (s *DefinestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDefinestmt(s) } } func (s *DefinestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDefinestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Definestmt() (localctx IDefinestmtContext) { localctx = NewDefinestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 458, PostgreSQLParserRULE_definestmt) p.SetState(4225) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 198, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4119) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4120) p.Opt_or_replace() } { p.SetState(4121) p.Match(PostgreSQLParserAGGREGATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4122) p.Func_name() } { p.SetState(4123) p.Aggr_args() } { p.SetState(4124) p.Definition() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4126) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4127) p.Opt_or_replace() } { p.SetState(4128) p.Match(PostgreSQLParserAGGREGATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4129) p.Func_name() } { p.SetState(4130) p.Old_aggr_definition() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(4132) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4133) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4134) p.Any_operator() } { p.SetState(4135) p.Definition() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(4137) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4138) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4139) p.Any_name() } { p.SetState(4140) p.Definition() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(4142) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4143) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4144) p.Any_name() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(4145) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4146) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4147) p.Any_name() } { p.SetState(4148) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4149) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4150) p.Opttablefuncelementlist() } { p.SetState(4151) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(4153) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4154) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4155) p.Any_name() } { p.SetState(4156) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4157) p.Match(PostgreSQLParserENUM_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4158) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4159) p.Opt_enum_val_list() } { p.SetState(4160) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(4162) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4163) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4164) p.Any_name() } { p.SetState(4165) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4166) p.Match(PostgreSQLParserRANGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4167) p.Definition() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(4169) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4170) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4171) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4172) p.Match(PostgreSQLParserPARSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4173) p.Any_name() } { p.SetState(4174) p.Definition() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(4176) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4177) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4178) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4179) p.Match(PostgreSQLParserDICTIONARY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4180) p.Any_name() } { p.SetState(4181) p.Definition() } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(4183) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4184) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4185) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4186) p.Match(PostgreSQLParserTEMPLATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4187) p.Any_name() } { p.SetState(4188) p.Definition() } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(4190) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4191) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4192) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4193) p.Match(PostgreSQLParserCONFIGURATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4194) p.Any_name() } { p.SetState(4195) p.Definition() } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(4197) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4198) p.Match(PostgreSQLParserCOLLATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4199) p.Any_name() } { p.SetState(4200) p.Definition() } case 14: p.EnterOuterAlt(localctx, 14) { p.SetState(4202) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4203) p.Match(PostgreSQLParserCOLLATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4204) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4205) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4206) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4207) p.Any_name() } { p.SetState(4208) p.Definition() } case 15: p.EnterOuterAlt(localctx, 15) { p.SetState(4210) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4211) p.Match(PostgreSQLParserCOLLATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4212) p.Any_name() } { p.SetState(4213) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4214) p.Any_name() } case 16: p.EnterOuterAlt(localctx, 16) { p.SetState(4216) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4217) p.Match(PostgreSQLParserCOLLATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4218) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4219) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4220) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4221) p.Any_name() } { p.SetState(4222) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4223) p.Any_name() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDefinitionContext is an interface to support dynamic dispatch. type IDefinitionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Def_list() IDef_listContext CLOSE_PAREN() antlr.TerminalNode // IsDefinitionContext differentiates from other interfaces. IsDefinitionContext() } type DefinitionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDefinitionContext() *DefinitionContext { var p = new(DefinitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_definition return p } func InitEmptyDefinitionContext(p *DefinitionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_definition } func (*DefinitionContext) IsDefinitionContext() {} func NewDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefinitionContext { var p = new(DefinitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_definition return p } func (s *DefinitionContext) GetParser() antlr.Parser { return s.parser } func (s *DefinitionContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *DefinitionContext) Def_list() IDef_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDef_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDef_listContext) } func (s *DefinitionContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *DefinitionContext) GetRuleContext() antlr.RuleContext { return s } func (s *DefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DefinitionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDefinition(s) } } func (s *DefinitionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDefinition(s) } } func (s *DefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDefinition(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Definition() (localctx IDefinitionContext) { localctx = NewDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 460, PostgreSQLParserRULE_definition) p.EnterOuterAlt(localctx, 1) { p.SetState(4227) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4228) p.Def_list() } { p.SetState(4229) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDef_listContext is an interface to support dynamic dispatch. type IDef_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllDef_elem() []IDef_elemContext Def_elem(i int) IDef_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsDef_listContext differentiates from other interfaces. IsDef_listContext() } type Def_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDef_listContext() *Def_listContext { var p = new(Def_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_def_list return p } func InitEmptyDef_listContext(p *Def_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_def_list } func (*Def_listContext) IsDef_listContext() {} func NewDef_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Def_listContext { var p = new(Def_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_def_list return p } func (s *Def_listContext) GetParser() antlr.Parser { return s.parser } func (s *Def_listContext) AllDef_elem() []IDef_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IDef_elemContext); ok { len++ } } tst := make([]IDef_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IDef_elemContext); ok { tst[i] = t.(IDef_elemContext) i++ } } return tst } func (s *Def_listContext) Def_elem(i int) IDef_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDef_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IDef_elemContext) } func (s *Def_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Def_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Def_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Def_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Def_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDef_list(s) } } func (s *Def_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDef_list(s) } } func (s *Def_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDef_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Def_list() (localctx IDef_listContext) { localctx = NewDef_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 462, PostgreSQLParserRULE_def_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4231) p.Def_elem() } p.SetState(4236) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(4232) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4233) p.Def_elem() } p.SetState(4238) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDef_elemContext is an interface to support dynamic dispatch. type IDef_elemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Collabel() ICollabelContext EQUAL() antlr.TerminalNode Def_arg() IDef_argContext // IsDef_elemContext differentiates from other interfaces. IsDef_elemContext() } type Def_elemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDef_elemContext() *Def_elemContext { var p = new(Def_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_def_elem return p } func InitEmptyDef_elemContext(p *Def_elemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_def_elem } func (*Def_elemContext) IsDef_elemContext() {} func NewDef_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Def_elemContext { var p = new(Def_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_def_elem return p } func (s *Def_elemContext) GetParser() antlr.Parser { return s.parser } func (s *Def_elemContext) Collabel() ICollabelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICollabelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICollabelContext) } func (s *Def_elemContext) EQUAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEQUAL, 0) } func (s *Def_elemContext) Def_arg() IDef_argContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDef_argContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDef_argContext) } func (s *Def_elemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Def_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Def_elemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDef_elem(s) } } func (s *Def_elemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDef_elem(s) } } func (s *Def_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDef_elem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Def_elem() (localctx IDef_elemContext) { localctx = NewDef_elemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 464, PostgreSQLParserRULE_def_elem) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4239) p.Collabel() } p.SetState(4242) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserEQUAL { { p.SetState(4240) p.Match(PostgreSQLParserEQUAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4241) p.Def_arg() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDef_argContext is an interface to support dynamic dispatch. type IDef_argContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Func_type() IFunc_typeContext Reserved_keyword() IReserved_keywordContext Qual_all_op() IQual_all_opContext Numericonly() INumericonlyContext Sconst() ISconstContext NONE() antlr.TerminalNode // IsDef_argContext differentiates from other interfaces. IsDef_argContext() } type Def_argContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDef_argContext() *Def_argContext { var p = new(Def_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_def_arg return p } func InitEmptyDef_argContext(p *Def_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_def_arg } func (*Def_argContext) IsDef_argContext() {} func NewDef_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Def_argContext { var p = new(Def_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_def_arg return p } func (s *Def_argContext) GetParser() antlr.Parser { return s.parser } func (s *Def_argContext) Func_type() IFunc_typeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_typeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_typeContext) } func (s *Def_argContext) Reserved_keyword() IReserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReserved_keywordContext) } func (s *Def_argContext) Qual_all_op() IQual_all_opContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQual_all_opContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQual_all_opContext) } func (s *Def_argContext) Numericonly() INumericonlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericonlyContext) } func (s *Def_argContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Def_argContext) NONE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNONE, 0) } func (s *Def_argContext) GetRuleContext() antlr.RuleContext { return s } func (s *Def_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Def_argContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDef_arg(s) } } func (s *Def_argContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDef_arg(s) } } func (s *Def_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDef_arg(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Def_arg() (localctx IDef_argContext) { localctx = NewDef_argContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 466, PostgreSQLParserRULE_def_arg) p.SetState(4250) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 201, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4244) p.Func_type() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4245) p.Reserved_keyword() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(4246) p.Qual_all_op() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(4247) p.Numericonly() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(4248) p.Sconst() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(4249) p.Match(PostgreSQLParserNONE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOld_aggr_definitionContext is an interface to support dynamic dispatch. type IOld_aggr_definitionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Old_aggr_list() IOld_aggr_listContext CLOSE_PAREN() antlr.TerminalNode // IsOld_aggr_definitionContext differentiates from other interfaces. IsOld_aggr_definitionContext() } type Old_aggr_definitionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOld_aggr_definitionContext() *Old_aggr_definitionContext { var p = new(Old_aggr_definitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_old_aggr_definition return p } func InitEmptyOld_aggr_definitionContext(p *Old_aggr_definitionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_old_aggr_definition } func (*Old_aggr_definitionContext) IsOld_aggr_definitionContext() {} func NewOld_aggr_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Old_aggr_definitionContext { var p = new(Old_aggr_definitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_old_aggr_definition return p } func (s *Old_aggr_definitionContext) GetParser() antlr.Parser { return s.parser } func (s *Old_aggr_definitionContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Old_aggr_definitionContext) Old_aggr_list() IOld_aggr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOld_aggr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOld_aggr_listContext) } func (s *Old_aggr_definitionContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Old_aggr_definitionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Old_aggr_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Old_aggr_definitionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOld_aggr_definition(s) } } func (s *Old_aggr_definitionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOld_aggr_definition(s) } } func (s *Old_aggr_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOld_aggr_definition(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Old_aggr_definition() (localctx IOld_aggr_definitionContext) { localctx = NewOld_aggr_definitionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 468, PostgreSQLParserRULE_old_aggr_definition) p.EnterOuterAlt(localctx, 1) { p.SetState(4252) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4253) p.Old_aggr_list() } { p.SetState(4254) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOld_aggr_listContext is an interface to support dynamic dispatch. type IOld_aggr_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllOld_aggr_elem() []IOld_aggr_elemContext Old_aggr_elem(i int) IOld_aggr_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsOld_aggr_listContext differentiates from other interfaces. IsOld_aggr_listContext() } type Old_aggr_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOld_aggr_listContext() *Old_aggr_listContext { var p = new(Old_aggr_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_old_aggr_list return p } func InitEmptyOld_aggr_listContext(p *Old_aggr_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_old_aggr_list } func (*Old_aggr_listContext) IsOld_aggr_listContext() {} func NewOld_aggr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Old_aggr_listContext { var p = new(Old_aggr_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_old_aggr_list return p } func (s *Old_aggr_listContext) GetParser() antlr.Parser { return s.parser } func (s *Old_aggr_listContext) AllOld_aggr_elem() []IOld_aggr_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IOld_aggr_elemContext); ok { len++ } } tst := make([]IOld_aggr_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IOld_aggr_elemContext); ok { tst[i] = t.(IOld_aggr_elemContext) i++ } } return tst } func (s *Old_aggr_listContext) Old_aggr_elem(i int) IOld_aggr_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOld_aggr_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IOld_aggr_elemContext) } func (s *Old_aggr_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Old_aggr_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Old_aggr_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Old_aggr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Old_aggr_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOld_aggr_list(s) } } func (s *Old_aggr_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOld_aggr_list(s) } } func (s *Old_aggr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOld_aggr_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Old_aggr_list() (localctx IOld_aggr_listContext) { localctx = NewOld_aggr_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 470, PostgreSQLParserRULE_old_aggr_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4256) p.Old_aggr_elem() } p.SetState(4261) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(4257) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4258) p.Old_aggr_elem() } p.SetState(4263) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOld_aggr_elemContext is an interface to support dynamic dispatch. type IOld_aggr_elemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Identifier() IIdentifierContext EQUAL() antlr.TerminalNode Def_arg() IDef_argContext // IsOld_aggr_elemContext differentiates from other interfaces. IsOld_aggr_elemContext() } type Old_aggr_elemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOld_aggr_elemContext() *Old_aggr_elemContext { var p = new(Old_aggr_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_old_aggr_elem return p } func InitEmptyOld_aggr_elemContext(p *Old_aggr_elemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_old_aggr_elem } func (*Old_aggr_elemContext) IsOld_aggr_elemContext() {} func NewOld_aggr_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Old_aggr_elemContext { var p = new(Old_aggr_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_old_aggr_elem return p } func (s *Old_aggr_elemContext) GetParser() antlr.Parser { return s.parser } func (s *Old_aggr_elemContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *Old_aggr_elemContext) EQUAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEQUAL, 0) } func (s *Old_aggr_elemContext) Def_arg() IDef_argContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDef_argContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDef_argContext) } func (s *Old_aggr_elemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Old_aggr_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Old_aggr_elemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOld_aggr_elem(s) } } func (s *Old_aggr_elemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOld_aggr_elem(s) } } func (s *Old_aggr_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOld_aggr_elem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Old_aggr_elem() (localctx IOld_aggr_elemContext) { localctx = NewOld_aggr_elemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 472, PostgreSQLParserRULE_old_aggr_elem) p.EnterOuterAlt(localctx, 1) { p.SetState(4264) p.Identifier() } { p.SetState(4265) p.Match(PostgreSQLParserEQUAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4266) p.Def_arg() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_enum_val_listContext is an interface to support dynamic dispatch. type IOpt_enum_val_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Enum_val_list() IEnum_val_listContext // IsOpt_enum_val_listContext differentiates from other interfaces. IsOpt_enum_val_listContext() } type Opt_enum_val_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_enum_val_listContext() *Opt_enum_val_listContext { var p = new(Opt_enum_val_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_enum_val_list return p } func InitEmptyOpt_enum_val_listContext(p *Opt_enum_val_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_enum_val_list } func (*Opt_enum_val_listContext) IsOpt_enum_val_listContext() {} func NewOpt_enum_val_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_enum_val_listContext { var p = new(Opt_enum_val_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_enum_val_list return p } func (s *Opt_enum_val_listContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_enum_val_listContext) Enum_val_list() IEnum_val_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IEnum_val_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IEnum_val_listContext) } func (s *Opt_enum_val_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_enum_val_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_enum_val_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_enum_val_list(s) } } func (s *Opt_enum_val_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_enum_val_list(s) } } func (s *Opt_enum_val_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_enum_val_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_enum_val_list() (localctx IOpt_enum_val_listContext) { localctx = NewOpt_enum_val_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 474, PostgreSQLParserRULE_opt_enum_val_list) p.SetState(4270) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(4268) p.Enum_val_list() } case PostgreSQLParserCLOSE_PAREN: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IEnum_val_listContext is an interface to support dynamic dispatch. type IEnum_val_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllSconst() []ISconstContext Sconst(i int) ISconstContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsEnum_val_listContext differentiates from other interfaces. IsEnum_val_listContext() } type Enum_val_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyEnum_val_listContext() *Enum_val_listContext { var p = new(Enum_val_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_enum_val_list return p } func InitEmptyEnum_val_listContext(p *Enum_val_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_enum_val_list } func (*Enum_val_listContext) IsEnum_val_listContext() {} func NewEnum_val_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enum_val_listContext { var p = new(Enum_val_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_enum_val_list return p } func (s *Enum_val_listContext) GetParser() antlr.Parser { return s.parser } func (s *Enum_val_listContext) AllSconst() []ISconstContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISconstContext); ok { len++ } } tst := make([]ISconstContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISconstContext); ok { tst[i] = t.(ISconstContext) i++ } } return tst } func (s *Enum_val_listContext) Sconst(i int) ISconstContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISconstContext) } func (s *Enum_val_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Enum_val_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Enum_val_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Enum_val_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Enum_val_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterEnum_val_list(s) } } func (s *Enum_val_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitEnum_val_list(s) } } func (s *Enum_val_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitEnum_val_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Enum_val_list() (localctx IEnum_val_listContext) { localctx = NewEnum_val_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 476, PostgreSQLParserRULE_enum_val_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4272) p.Sconst() } p.SetState(4277) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(4273) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4274) p.Sconst() } p.SetState(4279) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterenumstmtContext is an interface to support dynamic dispatch. type IAlterenumstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode TYPE_P() antlr.TerminalNode Any_name() IAny_nameContext ADD_P() antlr.TerminalNode VALUE_P() antlr.TerminalNode Opt_if_not_exists() IOpt_if_not_existsContext AllSconst() []ISconstContext Sconst(i int) ISconstContext BEFORE() antlr.TerminalNode AFTER() antlr.TerminalNode RENAME() antlr.TerminalNode TO() antlr.TerminalNode // IsAlterenumstmtContext differentiates from other interfaces. IsAlterenumstmtContext() } type AlterenumstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterenumstmtContext() *AlterenumstmtContext { var p = new(AlterenumstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterenumstmt return p } func InitEmptyAlterenumstmtContext(p *AlterenumstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterenumstmt } func (*AlterenumstmtContext) IsAlterenumstmtContext() {} func NewAlterenumstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterenumstmtContext { var p = new(AlterenumstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterenumstmt return p } func (s *AlterenumstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterenumstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterenumstmtContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *AlterenumstmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *AlterenumstmtContext) ADD_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserADD_P, 0) } func (s *AlterenumstmtContext) VALUE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALUE_P, 0) } func (s *AlterenumstmtContext) Opt_if_not_exists() IOpt_if_not_existsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_if_not_existsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_if_not_existsContext) } func (s *AlterenumstmtContext) AllSconst() []ISconstContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISconstContext); ok { len++ } } tst := make([]ISconstContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISconstContext); ok { tst[i] = t.(ISconstContext) i++ } } return tst } func (s *AlterenumstmtContext) Sconst(i int) ISconstContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISconstContext) } func (s *AlterenumstmtContext) BEFORE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBEFORE, 0) } func (s *AlterenumstmtContext) AFTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAFTER, 0) } func (s *AlterenumstmtContext) RENAME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRENAME, 0) } func (s *AlterenumstmtContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *AlterenumstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterenumstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterenumstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterenumstmt(s) } } func (s *AlterenumstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterenumstmt(s) } } func (s *AlterenumstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterenumstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterenumstmt() (localctx IAlterenumstmtContext) { localctx = NewAlterenumstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 478, PostgreSQLParserRULE_alterenumstmt) p.SetState(4317) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 205, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4280) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4281) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4282) p.Any_name() } { p.SetState(4283) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4284) p.Match(PostgreSQLParserVALUE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4285) p.Opt_if_not_exists() } { p.SetState(4286) p.Sconst() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4288) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4289) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4290) p.Any_name() } { p.SetState(4291) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4292) p.Match(PostgreSQLParserVALUE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4293) p.Opt_if_not_exists() } { p.SetState(4294) p.Sconst() } { p.SetState(4295) p.Match(PostgreSQLParserBEFORE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4296) p.Sconst() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(4298) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4299) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4300) p.Any_name() } { p.SetState(4301) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4302) p.Match(PostgreSQLParserVALUE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4303) p.Opt_if_not_exists() } { p.SetState(4304) p.Sconst() } { p.SetState(4305) p.Match(PostgreSQLParserAFTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4306) p.Sconst() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(4308) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4309) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4310) p.Any_name() } { p.SetState(4311) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4312) p.Match(PostgreSQLParserVALUE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4313) p.Sconst() } { p.SetState(4314) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4315) p.Sconst() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_if_not_existsContext is an interface to support dynamic dispatch. type IOpt_if_not_existsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsOpt_if_not_existsContext differentiates from other interfaces. IsOpt_if_not_existsContext() } type Opt_if_not_existsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_if_not_existsContext() *Opt_if_not_existsContext { var p = new(Opt_if_not_existsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_if_not_exists return p } func InitEmptyOpt_if_not_existsContext(p *Opt_if_not_existsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_if_not_exists } func (*Opt_if_not_existsContext) IsOpt_if_not_existsContext() {} func NewOpt_if_not_existsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_if_not_existsContext { var p = new(Opt_if_not_existsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_if_not_exists return p } func (s *Opt_if_not_existsContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_if_not_existsContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *Opt_if_not_existsContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *Opt_if_not_existsContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *Opt_if_not_existsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_if_not_existsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_if_not_existsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_if_not_exists(s) } } func (s *Opt_if_not_existsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_if_not_exists(s) } } func (s *Opt_if_not_existsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_if_not_exists(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_if_not_exists() (localctx IOpt_if_not_existsContext) { localctx = NewOpt_if_not_existsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 480, PostgreSQLParserRULE_opt_if_not_exists) p.SetState(4323) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserIF_P: p.EnterOuterAlt(localctx, 1) { p.SetState(4319) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4320) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4321) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateopclassstmtContext is an interface to support dynamic dispatch. type ICreateopclassstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode OPERATOR() antlr.TerminalNode CLASS() antlr.TerminalNode Any_name() IAny_nameContext Opt_default() IOpt_defaultContext FOR() antlr.TerminalNode TYPE_P() antlr.TerminalNode Typename() ITypenameContext USING() antlr.TerminalNode Name() INameContext Opt_opfamily() IOpt_opfamilyContext AS() antlr.TerminalNode Opclass_item_list() IOpclass_item_listContext // IsCreateopclassstmtContext differentiates from other interfaces. IsCreateopclassstmtContext() } type CreateopclassstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateopclassstmtContext() *CreateopclassstmtContext { var p = new(CreateopclassstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createopclassstmt return p } func InitEmptyCreateopclassstmtContext(p *CreateopclassstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createopclassstmt } func (*CreateopclassstmtContext) IsCreateopclassstmtContext() {} func NewCreateopclassstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateopclassstmtContext { var p = new(CreateopclassstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createopclassstmt return p } func (s *CreateopclassstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateopclassstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateopclassstmtContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *CreateopclassstmtContext) CLASS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLASS, 0) } func (s *CreateopclassstmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *CreateopclassstmtContext) Opt_default() IOpt_defaultContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_defaultContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_defaultContext) } func (s *CreateopclassstmtContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *CreateopclassstmtContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *CreateopclassstmtContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *CreateopclassstmtContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *CreateopclassstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreateopclassstmtContext) Opt_opfamily() IOpt_opfamilyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_opfamilyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_opfamilyContext) } func (s *CreateopclassstmtContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *CreateopclassstmtContext) Opclass_item_list() IOpclass_item_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpclass_item_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpclass_item_listContext) } func (s *CreateopclassstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateopclassstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateopclassstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateopclassstmt(s) } } func (s *CreateopclassstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateopclassstmt(s) } } func (s *CreateopclassstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateopclassstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createopclassstmt() (localctx ICreateopclassstmtContext) { localctx = NewCreateopclassstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 482, PostgreSQLParserRULE_createopclassstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(4325) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4326) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4327) p.Match(PostgreSQLParserCLASS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4328) p.Any_name() } { p.SetState(4329) p.Opt_default() } { p.SetState(4330) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4331) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4332) p.Typename() } { p.SetState(4333) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4334) p.Name() } { p.SetState(4335) p.Opt_opfamily() } { p.SetState(4336) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4337) p.Opclass_item_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpclass_item_listContext is an interface to support dynamic dispatch. type IOpclass_item_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllOpclass_item() []IOpclass_itemContext Opclass_item(i int) IOpclass_itemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsOpclass_item_listContext differentiates from other interfaces. IsOpclass_item_listContext() } type Opclass_item_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpclass_item_listContext() *Opclass_item_listContext { var p = new(Opclass_item_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opclass_item_list return p } func InitEmptyOpclass_item_listContext(p *Opclass_item_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opclass_item_list } func (*Opclass_item_listContext) IsOpclass_item_listContext() {} func NewOpclass_item_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_item_listContext { var p = new(Opclass_item_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opclass_item_list return p } func (s *Opclass_item_listContext) GetParser() antlr.Parser { return s.parser } func (s *Opclass_item_listContext) AllOpclass_item() []IOpclass_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IOpclass_itemContext); ok { len++ } } tst := make([]IOpclass_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IOpclass_itemContext); ok { tst[i] = t.(IOpclass_itemContext) i++ } } return tst } func (s *Opclass_item_listContext) Opclass_item(i int) IOpclass_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpclass_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IOpclass_itemContext) } func (s *Opclass_item_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Opclass_item_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Opclass_item_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opclass_item_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opclass_item_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpclass_item_list(s) } } func (s *Opclass_item_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpclass_item_list(s) } } func (s *Opclass_item_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpclass_item_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opclass_item_list() (localctx IOpclass_item_listContext) { localctx = NewOpclass_item_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 484, PostgreSQLParserRULE_opclass_item_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4339) p.Opclass_item() } p.SetState(4344) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(4340) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4341) p.Opclass_item() } p.SetState(4346) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpclass_itemContext is an interface to support dynamic dispatch. type IOpclass_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPERATOR() antlr.TerminalNode Iconst() IIconstContext Any_operator() IAny_operatorContext Opclass_purpose() IOpclass_purposeContext Opt_recheck() IOpt_recheckContext Operator_with_argtypes() IOperator_with_argtypesContext FUNCTION() antlr.TerminalNode Function_with_argtypes() IFunction_with_argtypesContext OPEN_PAREN() antlr.TerminalNode Type_list() IType_listContext CLOSE_PAREN() antlr.TerminalNode STORAGE() antlr.TerminalNode Typename() ITypenameContext // IsOpclass_itemContext differentiates from other interfaces. IsOpclass_itemContext() } type Opclass_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpclass_itemContext() *Opclass_itemContext { var p = new(Opclass_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opclass_item return p } func InitEmptyOpclass_itemContext(p *Opclass_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opclass_item } func (*Opclass_itemContext) IsOpclass_itemContext() {} func NewOpclass_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_itemContext { var p = new(Opclass_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opclass_item return p } func (s *Opclass_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Opclass_itemContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *Opclass_itemContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *Opclass_itemContext) Any_operator() IAny_operatorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_operatorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_operatorContext) } func (s *Opclass_itemContext) Opclass_purpose() IOpclass_purposeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpclass_purposeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpclass_purposeContext) } func (s *Opclass_itemContext) Opt_recheck() IOpt_recheckContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_recheckContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_recheckContext) } func (s *Opclass_itemContext) Operator_with_argtypes() IOperator_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOperator_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOperator_with_argtypesContext) } func (s *Opclass_itemContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *Opclass_itemContext) Function_with_argtypes() IFunction_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunction_with_argtypesContext) } func (s *Opclass_itemContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Opclass_itemContext) Type_list() IType_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IType_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IType_listContext) } func (s *Opclass_itemContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Opclass_itemContext) STORAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTORAGE, 0) } func (s *Opclass_itemContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *Opclass_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opclass_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opclass_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpclass_item(s) } } func (s *Opclass_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpclass_item(s) } } func (s *Opclass_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpclass_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opclass_item() (localctx IOpclass_itemContext) { localctx = NewOpclass_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 486, PostgreSQLParserRULE_opclass_item) p.SetState(4372) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 208, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4347) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4348) p.Iconst() } { p.SetState(4349) p.Any_operator() } { p.SetState(4350) p.Opclass_purpose() } { p.SetState(4351) p.Opt_recheck() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4353) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4354) p.Iconst() } { p.SetState(4355) p.Operator_with_argtypes() } { p.SetState(4356) p.Opclass_purpose() } { p.SetState(4357) p.Opt_recheck() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(4359) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4360) p.Iconst() } { p.SetState(4361) p.Function_with_argtypes() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(4363) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4364) p.Iconst() } { p.SetState(4365) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4366) p.Type_list() } { p.SetState(4367) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4368) p.Function_with_argtypes() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(4370) p.Match(PostgreSQLParserSTORAGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4371) p.Typename() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_defaultContext is an interface to support dynamic dispatch. type IOpt_defaultContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DEFAULT() antlr.TerminalNode // IsOpt_defaultContext differentiates from other interfaces. IsOpt_defaultContext() } type Opt_defaultContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_defaultContext() *Opt_defaultContext { var p = new(Opt_defaultContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_default return p } func InitEmptyOpt_defaultContext(p *Opt_defaultContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_default } func (*Opt_defaultContext) IsOpt_defaultContext() {} func NewOpt_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_defaultContext { var p = new(Opt_defaultContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_default return p } func (s *Opt_defaultContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_defaultContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Opt_defaultContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_defaultContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_default(s) } } func (s *Opt_defaultContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_default(s) } } func (s *Opt_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_default(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_default() (localctx IOpt_defaultContext) { localctx = NewOpt_defaultContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 488, PostgreSQLParserRULE_opt_default) p.SetState(4376) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserDEFAULT: p.EnterOuterAlt(localctx, 1) { p.SetState(4374) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserFOR, PostgreSQLParserCONVERSION_P: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_opfamilyContext is an interface to support dynamic dispatch. type IOpt_opfamilyContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FAMILY() antlr.TerminalNode Any_name() IAny_nameContext // IsOpt_opfamilyContext differentiates from other interfaces. IsOpt_opfamilyContext() } type Opt_opfamilyContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_opfamilyContext() *Opt_opfamilyContext { var p = new(Opt_opfamilyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_opfamily return p } func InitEmptyOpt_opfamilyContext(p *Opt_opfamilyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_opfamily } func (*Opt_opfamilyContext) IsOpt_opfamilyContext() {} func NewOpt_opfamilyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_opfamilyContext { var p = new(Opt_opfamilyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_opfamily return p } func (s *Opt_opfamilyContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_opfamilyContext) FAMILY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFAMILY, 0) } func (s *Opt_opfamilyContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *Opt_opfamilyContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_opfamilyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_opfamilyContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_opfamily(s) } } func (s *Opt_opfamilyContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_opfamily(s) } } func (s *Opt_opfamilyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_opfamily(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_opfamily() (localctx IOpt_opfamilyContext) { localctx = NewOpt_opfamilyContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 490, PostgreSQLParserRULE_opt_opfamily) p.SetState(4381) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFAMILY: p.EnterOuterAlt(localctx, 1) { p.SetState(4378) p.Match(PostgreSQLParserFAMILY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4379) p.Any_name() } case PostgreSQLParserAS: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpclass_purposeContext is an interface to support dynamic dispatch. type IOpclass_purposeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FOR() antlr.TerminalNode SEARCH() antlr.TerminalNode ORDER() antlr.TerminalNode BY() antlr.TerminalNode Any_name() IAny_nameContext // IsOpclass_purposeContext differentiates from other interfaces. IsOpclass_purposeContext() } type Opclass_purposeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpclass_purposeContext() *Opclass_purposeContext { var p = new(Opclass_purposeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opclass_purpose return p } func InitEmptyOpclass_purposeContext(p *Opclass_purposeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opclass_purpose } func (*Opclass_purposeContext) IsOpclass_purposeContext() {} func NewOpclass_purposeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_purposeContext { var p = new(Opclass_purposeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opclass_purpose return p } func (s *Opclass_purposeContext) GetParser() antlr.Parser { return s.parser } func (s *Opclass_purposeContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *Opclass_purposeContext) SEARCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEARCH, 0) } func (s *Opclass_purposeContext) ORDER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserORDER, 0) } func (s *Opclass_purposeContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *Opclass_purposeContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *Opclass_purposeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opclass_purposeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opclass_purposeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpclass_purpose(s) } } func (s *Opclass_purposeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpclass_purpose(s) } } func (s *Opclass_purposeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpclass_purpose(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opclass_purpose() (localctx IOpclass_purposeContext) { localctx = NewOpclass_purposeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 492, PostgreSQLParserRULE_opclass_purpose) p.SetState(4390) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 211, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4383) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4384) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4385) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4386) p.Match(PostgreSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4387) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4388) p.Any_name() } case 3: p.EnterOuterAlt(localctx, 3) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_recheckContext is an interface to support dynamic dispatch. type IOpt_recheckContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures RECHECK() antlr.TerminalNode // IsOpt_recheckContext differentiates from other interfaces. IsOpt_recheckContext() } type Opt_recheckContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_recheckContext() *Opt_recheckContext { var p = new(Opt_recheckContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_recheck return p } func InitEmptyOpt_recheckContext(p *Opt_recheckContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_recheck } func (*Opt_recheckContext) IsOpt_recheckContext() {} func NewOpt_recheckContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_recheckContext { var p = new(Opt_recheckContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_recheck return p } func (s *Opt_recheckContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_recheckContext) RECHECK() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRECHECK, 0) } func (s *Opt_recheckContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_recheckContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_recheckContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_recheck(s) } } func (s *Opt_recheckContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_recheck(s) } } func (s *Opt_recheckContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_recheck(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_recheck() (localctx IOpt_recheckContext) { localctx = NewOpt_recheckContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 494, PostgreSQLParserRULE_opt_recheck) p.SetState(4394) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserRECHECK: p.EnterOuterAlt(localctx, 1) { p.SetState(4392) p.Match(PostgreSQLParserRECHECK) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateopfamilystmtContext is an interface to support dynamic dispatch. type ICreateopfamilystmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode OPERATOR() antlr.TerminalNode FAMILY() antlr.TerminalNode Any_name() IAny_nameContext USING() antlr.TerminalNode Name() INameContext // IsCreateopfamilystmtContext differentiates from other interfaces. IsCreateopfamilystmtContext() } type CreateopfamilystmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateopfamilystmtContext() *CreateopfamilystmtContext { var p = new(CreateopfamilystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createopfamilystmt return p } func InitEmptyCreateopfamilystmtContext(p *CreateopfamilystmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createopfamilystmt } func (*CreateopfamilystmtContext) IsCreateopfamilystmtContext() {} func NewCreateopfamilystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateopfamilystmtContext { var p = new(CreateopfamilystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createopfamilystmt return p } func (s *CreateopfamilystmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateopfamilystmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateopfamilystmtContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *CreateopfamilystmtContext) FAMILY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFAMILY, 0) } func (s *CreateopfamilystmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *CreateopfamilystmtContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *CreateopfamilystmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreateopfamilystmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateopfamilystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateopfamilystmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateopfamilystmt(s) } } func (s *CreateopfamilystmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateopfamilystmt(s) } } func (s *CreateopfamilystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateopfamilystmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createopfamilystmt() (localctx ICreateopfamilystmtContext) { localctx = NewCreateopfamilystmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 496, PostgreSQLParserRULE_createopfamilystmt) p.EnterOuterAlt(localctx, 1) { p.SetState(4396) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4397) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4398) p.Match(PostgreSQLParserFAMILY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4399) p.Any_name() } { p.SetState(4400) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4401) p.Name() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlteropfamilystmtContext is an interface to support dynamic dispatch. type IAlteropfamilystmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode OPERATOR() antlr.TerminalNode FAMILY() antlr.TerminalNode Any_name() IAny_nameContext USING() antlr.TerminalNode Name() INameContext ADD_P() antlr.TerminalNode Opclass_item_list() IOpclass_item_listContext DROP() antlr.TerminalNode Opclass_drop_list() IOpclass_drop_listContext // IsAlteropfamilystmtContext differentiates from other interfaces. IsAlteropfamilystmtContext() } type AlteropfamilystmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlteropfamilystmtContext() *AlteropfamilystmtContext { var p = new(AlteropfamilystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alteropfamilystmt return p } func InitEmptyAlteropfamilystmtContext(p *AlteropfamilystmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alteropfamilystmt } func (*AlteropfamilystmtContext) IsAlteropfamilystmtContext() {} func NewAlteropfamilystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteropfamilystmtContext { var p = new(AlteropfamilystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alteropfamilystmt return p } func (s *AlteropfamilystmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlteropfamilystmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlteropfamilystmtContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *AlteropfamilystmtContext) FAMILY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFAMILY, 0) } func (s *AlteropfamilystmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *AlteropfamilystmtContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *AlteropfamilystmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *AlteropfamilystmtContext) ADD_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserADD_P, 0) } func (s *AlteropfamilystmtContext) Opclass_item_list() IOpclass_item_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpclass_item_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpclass_item_listContext) } func (s *AlteropfamilystmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *AlteropfamilystmtContext) Opclass_drop_list() IOpclass_drop_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpclass_drop_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpclass_drop_listContext) } func (s *AlteropfamilystmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlteropfamilystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlteropfamilystmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlteropfamilystmt(s) } } func (s *AlteropfamilystmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlteropfamilystmt(s) } } func (s *AlteropfamilystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlteropfamilystmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alteropfamilystmt() (localctx IAlteropfamilystmtContext) { localctx = NewAlteropfamilystmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 498, PostgreSQLParserRULE_alteropfamilystmt) p.SetState(4421) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 213, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4403) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4404) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4405) p.Match(PostgreSQLParserFAMILY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4406) p.Any_name() } { p.SetState(4407) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4408) p.Name() } { p.SetState(4409) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4410) p.Opclass_item_list() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4412) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4413) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4414) p.Match(PostgreSQLParserFAMILY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4415) p.Any_name() } { p.SetState(4416) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4417) p.Name() } { p.SetState(4418) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4419) p.Opclass_drop_list() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpclass_drop_listContext is an interface to support dynamic dispatch. type IOpclass_drop_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllOpclass_drop() []IOpclass_dropContext Opclass_drop(i int) IOpclass_dropContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsOpclass_drop_listContext differentiates from other interfaces. IsOpclass_drop_listContext() } type Opclass_drop_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpclass_drop_listContext() *Opclass_drop_listContext { var p = new(Opclass_drop_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opclass_drop_list return p } func InitEmptyOpclass_drop_listContext(p *Opclass_drop_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opclass_drop_list } func (*Opclass_drop_listContext) IsOpclass_drop_listContext() {} func NewOpclass_drop_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_drop_listContext { var p = new(Opclass_drop_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opclass_drop_list return p } func (s *Opclass_drop_listContext) GetParser() antlr.Parser { return s.parser } func (s *Opclass_drop_listContext) AllOpclass_drop() []IOpclass_dropContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IOpclass_dropContext); ok { len++ } } tst := make([]IOpclass_dropContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IOpclass_dropContext); ok { tst[i] = t.(IOpclass_dropContext) i++ } } return tst } func (s *Opclass_drop_listContext) Opclass_drop(i int) IOpclass_dropContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpclass_dropContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IOpclass_dropContext) } func (s *Opclass_drop_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Opclass_drop_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Opclass_drop_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opclass_drop_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opclass_drop_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpclass_drop_list(s) } } func (s *Opclass_drop_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpclass_drop_list(s) } } func (s *Opclass_drop_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpclass_drop_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opclass_drop_list() (localctx IOpclass_drop_listContext) { localctx = NewOpclass_drop_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 500, PostgreSQLParserRULE_opclass_drop_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4423) p.Opclass_drop() } p.SetState(4428) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(4424) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4425) p.Opclass_drop() } p.SetState(4430) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpclass_dropContext is an interface to support dynamic dispatch. type IOpclass_dropContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPERATOR() antlr.TerminalNode Iconst() IIconstContext OPEN_PAREN() antlr.TerminalNode Type_list() IType_listContext CLOSE_PAREN() antlr.TerminalNode FUNCTION() antlr.TerminalNode // IsOpclass_dropContext differentiates from other interfaces. IsOpclass_dropContext() } type Opclass_dropContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpclass_dropContext() *Opclass_dropContext { var p = new(Opclass_dropContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opclass_drop return p } func InitEmptyOpclass_dropContext(p *Opclass_dropContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opclass_drop } func (*Opclass_dropContext) IsOpclass_dropContext() {} func NewOpclass_dropContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_dropContext { var p = new(Opclass_dropContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opclass_drop return p } func (s *Opclass_dropContext) GetParser() antlr.Parser { return s.parser } func (s *Opclass_dropContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *Opclass_dropContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *Opclass_dropContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Opclass_dropContext) Type_list() IType_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IType_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IType_listContext) } func (s *Opclass_dropContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Opclass_dropContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *Opclass_dropContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opclass_dropContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opclass_dropContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpclass_drop(s) } } func (s *Opclass_dropContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpclass_drop(s) } } func (s *Opclass_dropContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpclass_drop(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opclass_drop() (localctx IOpclass_dropContext) { localctx = NewOpclass_dropContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 502, PostgreSQLParserRULE_opclass_drop) p.SetState(4443) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPERATOR: p.EnterOuterAlt(localctx, 1) { p.SetState(4431) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4432) p.Iconst() } { p.SetState(4433) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4434) p.Type_list() } { p.SetState(4435) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserFUNCTION: p.EnterOuterAlt(localctx, 2) { p.SetState(4437) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4438) p.Iconst() } { p.SetState(4439) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4440) p.Type_list() } { p.SetState(4441) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDropopclassstmtContext is an interface to support dynamic dispatch. type IDropopclassstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DROP() antlr.TerminalNode OPERATOR() antlr.TerminalNode CLASS() antlr.TerminalNode Any_name() IAny_nameContext USING() antlr.TerminalNode Name() INameContext Opt_drop_behavior() IOpt_drop_behaviorContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsDropopclassstmtContext differentiates from other interfaces. IsDropopclassstmtContext() } type DropopclassstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDropopclassstmtContext() *DropopclassstmtContext { var p = new(DropopclassstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropopclassstmt return p } func InitEmptyDropopclassstmtContext(p *DropopclassstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropopclassstmt } func (*DropopclassstmtContext) IsDropopclassstmtContext() {} func NewDropopclassstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropopclassstmtContext { var p = new(DropopclassstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_dropopclassstmt return p } func (s *DropopclassstmtContext) GetParser() antlr.Parser { return s.parser } func (s *DropopclassstmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *DropopclassstmtContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *DropopclassstmtContext) CLASS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLASS, 0) } func (s *DropopclassstmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *DropopclassstmtContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *DropopclassstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *DropopclassstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *DropopclassstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *DropopclassstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *DropopclassstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DropopclassstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DropopclassstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDropopclassstmt(s) } } func (s *DropopclassstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDropopclassstmt(s) } } func (s *DropopclassstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDropopclassstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Dropopclassstmt() (localctx IDropopclassstmtContext) { localctx = NewDropopclassstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 504, PostgreSQLParserRULE_dropopclassstmt) p.SetState(4463) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 216, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4445) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4446) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4447) p.Match(PostgreSQLParserCLASS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4448) p.Any_name() } { p.SetState(4449) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4450) p.Name() } { p.SetState(4451) p.Opt_drop_behavior() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4453) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4454) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4455) p.Match(PostgreSQLParserCLASS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4456) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4457) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4458) p.Any_name() } { p.SetState(4459) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4460) p.Name() } { p.SetState(4461) p.Opt_drop_behavior() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDropopfamilystmtContext is an interface to support dynamic dispatch. type IDropopfamilystmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DROP() antlr.TerminalNode OPERATOR() antlr.TerminalNode FAMILY() antlr.TerminalNode Any_name() IAny_nameContext USING() antlr.TerminalNode Name() INameContext Opt_drop_behavior() IOpt_drop_behaviorContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsDropopfamilystmtContext differentiates from other interfaces. IsDropopfamilystmtContext() } type DropopfamilystmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDropopfamilystmtContext() *DropopfamilystmtContext { var p = new(DropopfamilystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropopfamilystmt return p } func InitEmptyDropopfamilystmtContext(p *DropopfamilystmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropopfamilystmt } func (*DropopfamilystmtContext) IsDropopfamilystmtContext() {} func NewDropopfamilystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropopfamilystmtContext { var p = new(DropopfamilystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_dropopfamilystmt return p } func (s *DropopfamilystmtContext) GetParser() antlr.Parser { return s.parser } func (s *DropopfamilystmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *DropopfamilystmtContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *DropopfamilystmtContext) FAMILY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFAMILY, 0) } func (s *DropopfamilystmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *DropopfamilystmtContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *DropopfamilystmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *DropopfamilystmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *DropopfamilystmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *DropopfamilystmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *DropopfamilystmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DropopfamilystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DropopfamilystmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDropopfamilystmt(s) } } func (s *DropopfamilystmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDropopfamilystmt(s) } } func (s *DropopfamilystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDropopfamilystmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Dropopfamilystmt() (localctx IDropopfamilystmtContext) { localctx = NewDropopfamilystmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 506, PostgreSQLParserRULE_dropopfamilystmt) p.SetState(4483) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 217, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4465) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4466) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4467) p.Match(PostgreSQLParserFAMILY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4468) p.Any_name() } { p.SetState(4469) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4470) p.Name() } { p.SetState(4471) p.Opt_drop_behavior() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4473) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4474) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4475) p.Match(PostgreSQLParserFAMILY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4476) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4477) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4478) p.Any_name() } { p.SetState(4479) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4480) p.Name() } { p.SetState(4481) p.Opt_drop_behavior() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDropownedstmtContext is an interface to support dynamic dispatch. type IDropownedstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DROP() antlr.TerminalNode OWNED() antlr.TerminalNode BY() antlr.TerminalNode Role_list() IRole_listContext Opt_drop_behavior() IOpt_drop_behaviorContext // IsDropownedstmtContext differentiates from other interfaces. IsDropownedstmtContext() } type DropownedstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDropownedstmtContext() *DropownedstmtContext { var p = new(DropownedstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropownedstmt return p } func InitEmptyDropownedstmtContext(p *DropownedstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropownedstmt } func (*DropownedstmtContext) IsDropownedstmtContext() {} func NewDropownedstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropownedstmtContext { var p = new(DropownedstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_dropownedstmt return p } func (s *DropownedstmtContext) GetParser() antlr.Parser { return s.parser } func (s *DropownedstmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *DropownedstmtContext) OWNED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOWNED, 0) } func (s *DropownedstmtContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *DropownedstmtContext) Role_list() IRole_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRole_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRole_listContext) } func (s *DropownedstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *DropownedstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DropownedstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DropownedstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDropownedstmt(s) } } func (s *DropownedstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDropownedstmt(s) } } func (s *DropownedstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDropownedstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Dropownedstmt() (localctx IDropownedstmtContext) { localctx = NewDropownedstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 508, PostgreSQLParserRULE_dropownedstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(4485) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4486) p.Match(PostgreSQLParserOWNED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4487) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4488) p.Role_list() } { p.SetState(4489) p.Opt_drop_behavior() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IReassignownedstmtContext is an interface to support dynamic dispatch. type IReassignownedstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures REASSIGN() antlr.TerminalNode OWNED() antlr.TerminalNode BY() antlr.TerminalNode Role_list() IRole_listContext TO() antlr.TerminalNode Rolespec() IRolespecContext // IsReassignownedstmtContext differentiates from other interfaces. IsReassignownedstmtContext() } type ReassignownedstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyReassignownedstmtContext() *ReassignownedstmtContext { var p = new(ReassignownedstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reassignownedstmt return p } func InitEmptyReassignownedstmtContext(p *ReassignownedstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reassignownedstmt } func (*ReassignownedstmtContext) IsReassignownedstmtContext() {} func NewReassignownedstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReassignownedstmtContext { var p = new(ReassignownedstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_reassignownedstmt return p } func (s *ReassignownedstmtContext) GetParser() antlr.Parser { return s.parser } func (s *ReassignownedstmtContext) REASSIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREASSIGN, 0) } func (s *ReassignownedstmtContext) OWNED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOWNED, 0) } func (s *ReassignownedstmtContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *ReassignownedstmtContext) Role_list() IRole_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRole_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRole_listContext) } func (s *ReassignownedstmtContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *ReassignownedstmtContext) Rolespec() IRolespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRolespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRolespecContext) } func (s *ReassignownedstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *ReassignownedstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ReassignownedstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterReassignownedstmt(s) } } func (s *ReassignownedstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitReassignownedstmt(s) } } func (s *ReassignownedstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitReassignownedstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Reassignownedstmt() (localctx IReassignownedstmtContext) { localctx = NewReassignownedstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 510, PostgreSQLParserRULE_reassignownedstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(4491) p.Match(PostgreSQLParserREASSIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4492) p.Match(PostgreSQLParserOWNED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4493) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4494) p.Role_list() } { p.SetState(4495) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4496) p.Rolespec() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDropstmtContext is an interface to support dynamic dispatch. type IDropstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DROP() antlr.TerminalNode Object_type_any_name() IObject_type_any_nameContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode Any_name_list() IAny_name_listContext Opt_drop_behavior() IOpt_drop_behaviorContext Drop_type_name() IDrop_type_nameContext Name_list() IName_listContext Object_type_name_on_any_name() IObject_type_name_on_any_nameContext Name() INameContext ON() antlr.TerminalNode Any_name() IAny_nameContext TYPE_P() antlr.TerminalNode Type_name_list() IType_name_listContext DOMAIN_P() antlr.TerminalNode INDEX() antlr.TerminalNode CONCURRENTLY() antlr.TerminalNode // IsDropstmtContext differentiates from other interfaces. IsDropstmtContext() } type DropstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDropstmtContext() *DropstmtContext { var p = new(DropstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropstmt return p } func InitEmptyDropstmtContext(p *DropstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropstmt } func (*DropstmtContext) IsDropstmtContext() {} func NewDropstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropstmtContext { var p = new(DropstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_dropstmt return p } func (s *DropstmtContext) GetParser() antlr.Parser { return s.parser } func (s *DropstmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *DropstmtContext) Object_type_any_name() IObject_type_any_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IObject_type_any_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IObject_type_any_nameContext) } func (s *DropstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *DropstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *DropstmtContext) Any_name_list() IAny_name_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_name_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_name_listContext) } func (s *DropstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *DropstmtContext) Drop_type_name() IDrop_type_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDrop_type_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDrop_type_nameContext) } func (s *DropstmtContext) Name_list() IName_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IName_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IName_listContext) } func (s *DropstmtContext) Object_type_name_on_any_name() IObject_type_name_on_any_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IObject_type_name_on_any_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IObject_type_name_on_any_nameContext) } func (s *DropstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *DropstmtContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *DropstmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *DropstmtContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *DropstmtContext) Type_name_list() IType_name_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IType_name_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IType_name_listContext) } func (s *DropstmtContext) DOMAIN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOMAIN_P, 0) } func (s *DropstmtContext) INDEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINDEX, 0) } func (s *DropstmtContext) CONCURRENTLY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONCURRENTLY, 0) } func (s *DropstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DropstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DropstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDropstmt(s) } } func (s *DropstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDropstmt(s) } } func (s *DropstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDropstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Dropstmt() (localctx IDropstmtContext) { localctx = NewDropstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 512, PostgreSQLParserRULE_dropstmt) p.SetState(4576) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 218, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4498) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4499) p.Object_type_any_name() } { p.SetState(4500) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4501) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4502) p.Any_name_list() } { p.SetState(4503) p.Opt_drop_behavior() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4505) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4506) p.Object_type_any_name() } { p.SetState(4507) p.Any_name_list() } { p.SetState(4508) p.Opt_drop_behavior() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(4510) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4511) p.Drop_type_name() } { p.SetState(4512) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4513) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4514) p.Name_list() } { p.SetState(4515) p.Opt_drop_behavior() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(4517) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4518) p.Drop_type_name() } { p.SetState(4519) p.Name_list() } { p.SetState(4520) p.Opt_drop_behavior() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(4522) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4523) p.Object_type_name_on_any_name() } { p.SetState(4524) p.Name() } { p.SetState(4525) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4526) p.Any_name() } { p.SetState(4527) p.Opt_drop_behavior() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(4529) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4530) p.Object_type_name_on_any_name() } { p.SetState(4531) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4532) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4533) p.Name() } { p.SetState(4534) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4535) p.Any_name() } { p.SetState(4536) p.Opt_drop_behavior() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(4538) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4539) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4540) p.Type_name_list() } { p.SetState(4541) p.Opt_drop_behavior() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(4543) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4544) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4545) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4546) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4547) p.Type_name_list() } { p.SetState(4548) p.Opt_drop_behavior() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(4550) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4551) p.Match(PostgreSQLParserDOMAIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4552) p.Type_name_list() } { p.SetState(4553) p.Opt_drop_behavior() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(4555) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4556) p.Match(PostgreSQLParserDOMAIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4557) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4558) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4559) p.Type_name_list() } { p.SetState(4560) p.Opt_drop_behavior() } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(4562) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4563) p.Match(PostgreSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4564) p.Match(PostgreSQLParserCONCURRENTLY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4565) p.Any_name_list() } { p.SetState(4566) p.Opt_drop_behavior() } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(4568) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4569) p.Match(PostgreSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4570) p.Match(PostgreSQLParserCONCURRENTLY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4571) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4572) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4573) p.Any_name_list() } { p.SetState(4574) p.Opt_drop_behavior() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IObject_type_any_nameContext is an interface to support dynamic dispatch. type IObject_type_any_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TABLE() antlr.TerminalNode SEQUENCE() antlr.TerminalNode VIEW() antlr.TerminalNode MATERIALIZED() antlr.TerminalNode INDEX() antlr.TerminalNode FOREIGN() antlr.TerminalNode COLLATION() antlr.TerminalNode CONVERSION_P() antlr.TerminalNode STATISTICS() antlr.TerminalNode TEXT_P() antlr.TerminalNode SEARCH() antlr.TerminalNode PARSER() antlr.TerminalNode DICTIONARY() antlr.TerminalNode TEMPLATE() antlr.TerminalNode CONFIGURATION() antlr.TerminalNode // IsObject_type_any_nameContext differentiates from other interfaces. IsObject_type_any_nameContext() } type Object_type_any_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyObject_type_any_nameContext() *Object_type_any_nameContext { var p = new(Object_type_any_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_object_type_any_name return p } func InitEmptyObject_type_any_nameContext(p *Object_type_any_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_object_type_any_name } func (*Object_type_any_nameContext) IsObject_type_any_nameContext() {} func NewObject_type_any_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_any_nameContext { var p = new(Object_type_any_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_object_type_any_name return p } func (s *Object_type_any_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Object_type_any_nameContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *Object_type_any_nameContext) SEQUENCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEQUENCE, 0) } func (s *Object_type_any_nameContext) VIEW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVIEW, 0) } func (s *Object_type_any_nameContext) MATERIALIZED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMATERIALIZED, 0) } func (s *Object_type_any_nameContext) INDEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINDEX, 0) } func (s *Object_type_any_nameContext) FOREIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREIGN, 0) } func (s *Object_type_any_nameContext) COLLATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATION, 0) } func (s *Object_type_any_nameContext) CONVERSION_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONVERSION_P, 0) } func (s *Object_type_any_nameContext) STATISTICS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTATISTICS, 0) } func (s *Object_type_any_nameContext) TEXT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEXT_P, 0) } func (s *Object_type_any_nameContext) SEARCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEARCH, 0) } func (s *Object_type_any_nameContext) PARSER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARSER, 0) } func (s *Object_type_any_nameContext) DICTIONARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDICTIONARY, 0) } func (s *Object_type_any_nameContext) TEMPLATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEMPLATE, 0) } func (s *Object_type_any_nameContext) CONFIGURATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONFIGURATION, 0) } func (s *Object_type_any_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Object_type_any_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Object_type_any_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterObject_type_any_name(s) } } func (s *Object_type_any_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitObject_type_any_name(s) } } func (s *Object_type_any_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitObject_type_any_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Object_type_any_name() (localctx IObject_type_any_nameContext) { localctx = NewObject_type_any_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 514, PostgreSQLParserRULE_object_type_any_name) p.SetState(4601) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 219, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4578) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4579) p.Match(PostgreSQLParserSEQUENCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(4580) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(4581) p.Match(PostgreSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4582) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(4583) p.Match(PostgreSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(4584) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4585) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(4586) p.Match(PostgreSQLParserCOLLATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(4587) p.Match(PostgreSQLParserCONVERSION_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(4588) p.Match(PostgreSQLParserSTATISTICS) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(4589) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4590) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4591) p.Match(PostgreSQLParserPARSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(4592) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4593) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4594) p.Match(PostgreSQLParserDICTIONARY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(4595) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4596) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4597) p.Match(PostgreSQLParserTEMPLATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(4598) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4599) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4600) p.Match(PostgreSQLParserCONFIGURATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IObject_type_nameContext is an interface to support dynamic dispatch. type IObject_type_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Drop_type_name() IDrop_type_nameContext DATABASE() antlr.TerminalNode ROLE() antlr.TerminalNode SUBSCRIPTION() antlr.TerminalNode TABLESPACE() antlr.TerminalNode // IsObject_type_nameContext differentiates from other interfaces. IsObject_type_nameContext() } type Object_type_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyObject_type_nameContext() *Object_type_nameContext { var p = new(Object_type_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_object_type_name return p } func InitEmptyObject_type_nameContext(p *Object_type_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_object_type_name } func (*Object_type_nameContext) IsObject_type_nameContext() {} func NewObject_type_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_nameContext { var p = new(Object_type_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_object_type_name return p } func (s *Object_type_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Object_type_nameContext) Drop_type_name() IDrop_type_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDrop_type_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDrop_type_nameContext) } func (s *Object_type_nameContext) DATABASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATABASE, 0) } func (s *Object_type_nameContext) ROLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLE, 0) } func (s *Object_type_nameContext) SUBSCRIPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSUBSCRIPTION, 0) } func (s *Object_type_nameContext) TABLESPACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, 0) } func (s *Object_type_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Object_type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Object_type_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterObject_type_name(s) } } func (s *Object_type_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitObject_type_name(s) } } func (s *Object_type_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitObject_type_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Object_type_name() (localctx IObject_type_nameContext) { localctx = NewObject_type_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 516, PostgreSQLParserRULE_object_type_name) p.SetState(4608) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFOREIGN, PostgreSQLParserACCESS, PostgreSQLParserEVENT, PostgreSQLParserEXTENSION, PostgreSQLParserLANGUAGE, PostgreSQLParserPROCEDURAL, PostgreSQLParserSCHEMA, PostgreSQLParserSERVER, PostgreSQLParserPUBLICATION: p.EnterOuterAlt(localctx, 1) { p.SetState(4603) p.Drop_type_name() } case PostgreSQLParserDATABASE: p.EnterOuterAlt(localctx, 2) { p.SetState(4604) p.Match(PostgreSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserROLE: p.EnterOuterAlt(localctx, 3) { p.SetState(4605) p.Match(PostgreSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSUBSCRIPTION: p.EnterOuterAlt(localctx, 4) { p.SetState(4606) p.Match(PostgreSQLParserSUBSCRIPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserTABLESPACE: p.EnterOuterAlt(localctx, 5) { p.SetState(4607) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDrop_type_nameContext is an interface to support dynamic dispatch. type IDrop_type_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ACCESS() antlr.TerminalNode METHOD() antlr.TerminalNode EVENT() antlr.TerminalNode TRIGGER() antlr.TerminalNode EXTENSION() antlr.TerminalNode FOREIGN() antlr.TerminalNode DATA_P() antlr.TerminalNode WRAPPER() antlr.TerminalNode Opt_procedural() IOpt_proceduralContext LANGUAGE() antlr.TerminalNode PUBLICATION() antlr.TerminalNode SCHEMA() antlr.TerminalNode SERVER() antlr.TerminalNode // IsDrop_type_nameContext differentiates from other interfaces. IsDrop_type_nameContext() } type Drop_type_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDrop_type_nameContext() *Drop_type_nameContext { var p = new(Drop_type_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_drop_type_name return p } func InitEmptyDrop_type_nameContext(p *Drop_type_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_drop_type_name } func (*Drop_type_nameContext) IsDrop_type_nameContext() {} func NewDrop_type_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_type_nameContext { var p = new(Drop_type_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_drop_type_name return p } func (s *Drop_type_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Drop_type_nameContext) ACCESS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserACCESS, 0) } func (s *Drop_type_nameContext) METHOD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMETHOD, 0) } func (s *Drop_type_nameContext) EVENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEVENT, 0) } func (s *Drop_type_nameContext) TRIGGER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRIGGER, 0) } func (s *Drop_type_nameContext) EXTENSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXTENSION, 0) } func (s *Drop_type_nameContext) FOREIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREIGN, 0) } func (s *Drop_type_nameContext) DATA_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATA_P, 0) } func (s *Drop_type_nameContext) WRAPPER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWRAPPER, 0) } func (s *Drop_type_nameContext) Opt_procedural() IOpt_proceduralContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_proceduralContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_proceduralContext) } func (s *Drop_type_nameContext) LANGUAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLANGUAGE, 0) } func (s *Drop_type_nameContext) PUBLICATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPUBLICATION, 0) } func (s *Drop_type_nameContext) SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMA, 0) } func (s *Drop_type_nameContext) SERVER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSERVER, 0) } func (s *Drop_type_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Drop_type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Drop_type_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDrop_type_name(s) } } func (s *Drop_type_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDrop_type_name(s) } } func (s *Drop_type_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDrop_type_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Drop_type_name() (localctx IDrop_type_nameContext) { localctx = NewDrop_type_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 518, PostgreSQLParserRULE_drop_type_name) p.SetState(4624) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserACCESS: p.EnterOuterAlt(localctx, 1) { p.SetState(4610) p.Match(PostgreSQLParserACCESS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4611) p.Match(PostgreSQLParserMETHOD) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEVENT: p.EnterOuterAlt(localctx, 2) { p.SetState(4612) p.Match(PostgreSQLParserEVENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4613) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEXTENSION: p.EnterOuterAlt(localctx, 3) { p.SetState(4614) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserFOREIGN: p.EnterOuterAlt(localctx, 4) { p.SetState(4615) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4616) p.Match(PostgreSQLParserDATA_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4617) p.Match(PostgreSQLParserWRAPPER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserLANGUAGE, PostgreSQLParserPROCEDURAL: p.EnterOuterAlt(localctx, 5) { p.SetState(4618) p.Opt_procedural() } { p.SetState(4619) p.Match(PostgreSQLParserLANGUAGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserPUBLICATION: p.EnterOuterAlt(localctx, 6) { p.SetState(4621) p.Match(PostgreSQLParserPUBLICATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSCHEMA: p.EnterOuterAlt(localctx, 7) { p.SetState(4622) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSERVER: p.EnterOuterAlt(localctx, 8) { p.SetState(4623) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IObject_type_name_on_any_nameContext is an interface to support dynamic dispatch. type IObject_type_name_on_any_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures POLICY() antlr.TerminalNode RULE() antlr.TerminalNode TRIGGER() antlr.TerminalNode // IsObject_type_name_on_any_nameContext differentiates from other interfaces. IsObject_type_name_on_any_nameContext() } type Object_type_name_on_any_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyObject_type_name_on_any_nameContext() *Object_type_name_on_any_nameContext { var p = new(Object_type_name_on_any_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_object_type_name_on_any_name return p } func InitEmptyObject_type_name_on_any_nameContext(p *Object_type_name_on_any_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_object_type_name_on_any_name } func (*Object_type_name_on_any_nameContext) IsObject_type_name_on_any_nameContext() {} func NewObject_type_name_on_any_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_name_on_any_nameContext { var p = new(Object_type_name_on_any_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_object_type_name_on_any_name return p } func (s *Object_type_name_on_any_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Object_type_name_on_any_nameContext) POLICY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPOLICY, 0) } func (s *Object_type_name_on_any_nameContext) RULE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRULE, 0) } func (s *Object_type_name_on_any_nameContext) TRIGGER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRIGGER, 0) } func (s *Object_type_name_on_any_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Object_type_name_on_any_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Object_type_name_on_any_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterObject_type_name_on_any_name(s) } } func (s *Object_type_name_on_any_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitObject_type_name_on_any_name(s) } } func (s *Object_type_name_on_any_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitObject_type_name_on_any_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Object_type_name_on_any_name() (localctx IObject_type_name_on_any_nameContext) { localctx = NewObject_type_name_on_any_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 520, PostgreSQLParserRULE_object_type_name_on_any_name) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4626) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserRULE || _la == PostgreSQLParserTRIGGER || _la == PostgreSQLParserPOLICY) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAny_name_listContext is an interface to support dynamic dispatch. type IAny_name_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllAny_name() []IAny_nameContext Any_name(i int) IAny_nameContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsAny_name_listContext differentiates from other interfaces. IsAny_name_listContext() } type Any_name_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAny_name_listContext() *Any_name_listContext { var p = new(Any_name_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_any_name_list return p } func InitEmptyAny_name_listContext(p *Any_name_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_any_name_list } func (*Any_name_listContext) IsAny_name_listContext() {} func NewAny_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_name_listContext { var p = new(Any_name_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_any_name_list return p } func (s *Any_name_listContext) GetParser() antlr.Parser { return s.parser } func (s *Any_name_listContext) AllAny_name() []IAny_nameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAny_nameContext); ok { len++ } } tst := make([]IAny_nameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAny_nameContext); ok { tst[i] = t.(IAny_nameContext) i++ } } return tst } func (s *Any_name_listContext) Any_name(i int) IAny_nameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *Any_name_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Any_name_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Any_name_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Any_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Any_name_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAny_name_list(s) } } func (s *Any_name_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAny_name_list(s) } } func (s *Any_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAny_name_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Any_name_list() (localctx IAny_name_listContext) { localctx = NewAny_name_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 522, PostgreSQLParserRULE_any_name_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4628) p.Any_name() } p.SetState(4633) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(4629) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4630) p.Any_name() } p.SetState(4635) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAny_nameContext is an interface to support dynamic dispatch. type IAny_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext Attrs() IAttrsContext // IsAny_nameContext differentiates from other interfaces. IsAny_nameContext() } type Any_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAny_nameContext() *Any_nameContext { var p = new(Any_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_any_name return p } func InitEmptyAny_nameContext(p *Any_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_any_name } func (*Any_nameContext) IsAny_nameContext() {} func NewAny_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_nameContext { var p = new(Any_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_any_name return p } func (s *Any_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Any_nameContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Any_nameContext) Attrs() IAttrsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAttrsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAttrsContext) } func (s *Any_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Any_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Any_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAny_name(s) } } func (s *Any_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAny_name(s) } } func (s *Any_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAny_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Any_name() (localctx IAny_nameContext) { localctx = NewAny_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 524, PostgreSQLParserRULE_any_name) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4636) p.Colid() } p.SetState(4638) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserDOT { { p.SetState(4637) p.Attrs() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAttrsContext is an interface to support dynamic dispatch. type IAttrsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllDOT() []antlr.TerminalNode DOT(i int) antlr.TerminalNode AllAttr_name() []IAttr_nameContext Attr_name(i int) IAttr_nameContext // IsAttrsContext differentiates from other interfaces. IsAttrsContext() } type AttrsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAttrsContext() *AttrsContext { var p = new(AttrsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_attrs return p } func InitEmptyAttrsContext(p *AttrsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_attrs } func (*AttrsContext) IsAttrsContext() {} func NewAttrsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AttrsContext { var p = new(AttrsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_attrs return p } func (s *AttrsContext) GetParser() antlr.Parser { return s.parser } func (s *AttrsContext) AllDOT() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserDOT) } func (s *AttrsContext) DOT(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOT, i) } func (s *AttrsContext) AllAttr_name() []IAttr_nameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAttr_nameContext); ok { len++ } } tst := make([]IAttr_nameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAttr_nameContext); ok { tst[i] = t.(IAttr_nameContext) i++ } } return tst } func (s *AttrsContext) Attr_name(i int) IAttr_nameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAttr_nameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAttr_nameContext) } func (s *AttrsContext) GetRuleContext() antlr.RuleContext { return s } func (s *AttrsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AttrsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAttrs(s) } } func (s *AttrsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAttrs(s) } } func (s *AttrsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAttrs(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Attrs() (localctx IAttrsContext) { localctx = NewAttrsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 526, PostgreSQLParserRULE_attrs) var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(4642) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = 1 for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { switch _alt { case 1: { p.SetState(4640) p.Match(PostgreSQLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4641) p.Attr_name() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.SetState(4644) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 224, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IType_name_listContext is an interface to support dynamic dispatch. type IType_name_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllTypename() []ITypenameContext Typename(i int) ITypenameContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsType_name_listContext differentiates from other interfaces. IsType_name_listContext() } type Type_name_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyType_name_listContext() *Type_name_listContext { var p = new(Type_name_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_type_name_list return p } func InitEmptyType_name_listContext(p *Type_name_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_type_name_list } func (*Type_name_listContext) IsType_name_listContext() {} func NewType_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_name_listContext { var p = new(Type_name_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_type_name_list return p } func (s *Type_name_listContext) GetParser() antlr.Parser { return s.parser } func (s *Type_name_listContext) AllTypename() []ITypenameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITypenameContext); ok { len++ } } tst := make([]ITypenameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITypenameContext); ok { tst[i] = t.(ITypenameContext) i++ } } return tst } func (s *Type_name_listContext) Typename(i int) ITypenameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITypenameContext) } func (s *Type_name_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Type_name_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Type_name_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Type_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Type_name_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterType_name_list(s) } } func (s *Type_name_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitType_name_list(s) } } func (s *Type_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitType_name_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Type_name_list() (localctx IType_name_listContext) { localctx = NewType_name_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 528, PostgreSQLParserRULE_type_name_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4646) p.Typename() } p.SetState(4651) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(4647) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4648) p.Typename() } p.SetState(4653) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITruncatestmtContext is an interface to support dynamic dispatch. type ITruncatestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TRUNCATE() antlr.TerminalNode Opt_table() IOpt_tableContext Relation_expr_list() IRelation_expr_listContext Opt_restart_seqs() IOpt_restart_seqsContext Opt_drop_behavior() IOpt_drop_behaviorContext // IsTruncatestmtContext differentiates from other interfaces. IsTruncatestmtContext() } type TruncatestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTruncatestmtContext() *TruncatestmtContext { var p = new(TruncatestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_truncatestmt return p } func InitEmptyTruncatestmtContext(p *TruncatestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_truncatestmt } func (*TruncatestmtContext) IsTruncatestmtContext() {} func NewTruncatestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TruncatestmtContext { var p = new(TruncatestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_truncatestmt return p } func (s *TruncatestmtContext) GetParser() antlr.Parser { return s.parser } func (s *TruncatestmtContext) TRUNCATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRUNCATE, 0) } func (s *TruncatestmtContext) Opt_table() IOpt_tableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_tableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_tableContext) } func (s *TruncatestmtContext) Relation_expr_list() IRelation_expr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_expr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRelation_expr_listContext) } func (s *TruncatestmtContext) Opt_restart_seqs() IOpt_restart_seqsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_restart_seqsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_restart_seqsContext) } func (s *TruncatestmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *TruncatestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *TruncatestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TruncatestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTruncatestmt(s) } } func (s *TruncatestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTruncatestmt(s) } } func (s *TruncatestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTruncatestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Truncatestmt() (localctx ITruncatestmtContext) { localctx = NewTruncatestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 530, PostgreSQLParserRULE_truncatestmt) p.EnterOuterAlt(localctx, 1) { p.SetState(4654) p.Match(PostgreSQLParserTRUNCATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4655) p.Opt_table() } { p.SetState(4656) p.Relation_expr_list() } { p.SetState(4657) p.Opt_restart_seqs() } { p.SetState(4658) p.Opt_drop_behavior() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_restart_seqsContext is an interface to support dynamic dispatch. type IOpt_restart_seqsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CONTINUE_P() antlr.TerminalNode IDENTITY_P() antlr.TerminalNode RESTART() antlr.TerminalNode // IsOpt_restart_seqsContext differentiates from other interfaces. IsOpt_restart_seqsContext() } type Opt_restart_seqsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_restart_seqsContext() *Opt_restart_seqsContext { var p = new(Opt_restart_seqsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_restart_seqs return p } func InitEmptyOpt_restart_seqsContext(p *Opt_restart_seqsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_restart_seqs } func (*Opt_restart_seqsContext) IsOpt_restart_seqsContext() {} func NewOpt_restart_seqsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_restart_seqsContext { var p = new(Opt_restart_seqsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_restart_seqs return p } func (s *Opt_restart_seqsContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_restart_seqsContext) CONTINUE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONTINUE_P, 0) } func (s *Opt_restart_seqsContext) IDENTITY_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIDENTITY_P, 0) } func (s *Opt_restart_seqsContext) RESTART() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESTART, 0) } func (s *Opt_restart_seqsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_restart_seqsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_restart_seqsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_restart_seqs(s) } } func (s *Opt_restart_seqsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_restart_seqs(s) } } func (s *Opt_restart_seqsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_restart_seqs(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_restart_seqs() (localctx IOpt_restart_seqsContext) { localctx = NewOpt_restart_seqsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 532, PostgreSQLParserRULE_opt_restart_seqs) p.SetState(4665) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCONTINUE_P: p.EnterOuterAlt(localctx, 1) { p.SetState(4660) p.Match(PostgreSQLParserCONTINUE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4661) p.Match(PostgreSQLParserIDENTITY_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserRESTART: p.EnterOuterAlt(localctx, 2) { p.SetState(4662) p.Match(PostgreSQLParserRESTART) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4663) p.Match(PostgreSQLParserIDENTITY_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCASCADE, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserRESTRICT, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 3) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICommentstmtContext is an interface to support dynamic dispatch. type ICommentstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures COMMENT() antlr.TerminalNode AllON() []antlr.TerminalNode ON(i int) antlr.TerminalNode Object_type_any_name() IObject_type_any_nameContext Any_name() IAny_nameContext IS() antlr.TerminalNode Comment_text() IComment_textContext COLUMN() antlr.TerminalNode Object_type_name() IObject_type_nameContext Name() INameContext TYPE_P() antlr.TerminalNode AllTypename() []ITypenameContext Typename(i int) ITypenameContext DOMAIN_P() antlr.TerminalNode AGGREGATE() antlr.TerminalNode Aggregate_with_argtypes() IAggregate_with_argtypesContext FUNCTION() antlr.TerminalNode Function_with_argtypes() IFunction_with_argtypesContext OPERATOR() antlr.TerminalNode Operator_with_argtypes() IOperator_with_argtypesContext CONSTRAINT() antlr.TerminalNode Object_type_name_on_any_name() IObject_type_name_on_any_nameContext PROCEDURE() antlr.TerminalNode ROUTINE() antlr.TerminalNode TRANSFORM() antlr.TerminalNode FOR() antlr.TerminalNode LANGUAGE() antlr.TerminalNode CLASS() antlr.TerminalNode USING() antlr.TerminalNode FAMILY() antlr.TerminalNode LARGE_P() antlr.TerminalNode OBJECT_P() antlr.TerminalNode Numericonly() INumericonlyContext CAST() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode AS() antlr.TerminalNode CLOSE_PAREN() antlr.TerminalNode // IsCommentstmtContext differentiates from other interfaces. IsCommentstmtContext() } type CommentstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCommentstmtContext() *CommentstmtContext { var p = new(CommentstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_commentstmt return p } func InitEmptyCommentstmtContext(p *CommentstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_commentstmt } func (*CommentstmtContext) IsCommentstmtContext() {} func NewCommentstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommentstmtContext { var p = new(CommentstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_commentstmt return p } func (s *CommentstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CommentstmtContext) COMMENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMENT, 0) } func (s *CommentstmtContext) AllON() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserON) } func (s *CommentstmtContext) ON(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, i) } func (s *CommentstmtContext) Object_type_any_name() IObject_type_any_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IObject_type_any_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IObject_type_any_nameContext) } func (s *CommentstmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *CommentstmtContext) IS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIS, 0) } func (s *CommentstmtContext) Comment_text() IComment_textContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IComment_textContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IComment_textContext) } func (s *CommentstmtContext) COLUMN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLUMN, 0) } func (s *CommentstmtContext) Object_type_name() IObject_type_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IObject_type_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IObject_type_nameContext) } func (s *CommentstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CommentstmtContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *CommentstmtContext) AllTypename() []ITypenameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITypenameContext); ok { len++ } } tst := make([]ITypenameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITypenameContext); ok { tst[i] = t.(ITypenameContext) i++ } } return tst } func (s *CommentstmtContext) Typename(i int) ITypenameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITypenameContext) } func (s *CommentstmtContext) DOMAIN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOMAIN_P, 0) } func (s *CommentstmtContext) AGGREGATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAGGREGATE, 0) } func (s *CommentstmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAggregate_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAggregate_with_argtypesContext) } func (s *CommentstmtContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *CommentstmtContext) Function_with_argtypes() IFunction_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunction_with_argtypesContext) } func (s *CommentstmtContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *CommentstmtContext) Operator_with_argtypes() IOperator_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOperator_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOperator_with_argtypesContext) } func (s *CommentstmtContext) CONSTRAINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTRAINT, 0) } func (s *CommentstmtContext) Object_type_name_on_any_name() IObject_type_name_on_any_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IObject_type_name_on_any_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IObject_type_name_on_any_nameContext) } func (s *CommentstmtContext) PROCEDURE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURE, 0) } func (s *CommentstmtContext) ROUTINE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUTINE, 0) } func (s *CommentstmtContext) TRANSFORM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSFORM, 0) } func (s *CommentstmtContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *CommentstmtContext) LANGUAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLANGUAGE, 0) } func (s *CommentstmtContext) CLASS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLASS, 0) } func (s *CommentstmtContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *CommentstmtContext) FAMILY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFAMILY, 0) } func (s *CommentstmtContext) LARGE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLARGE_P, 0) } func (s *CommentstmtContext) OBJECT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOBJECT_P, 0) } func (s *CommentstmtContext) Numericonly() INumericonlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericonlyContext) } func (s *CommentstmtContext) CAST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCAST, 0) } func (s *CommentstmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *CommentstmtContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *CommentstmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *CommentstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CommentstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CommentstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCommentstmt(s) } } func (s *CommentstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCommentstmt(s) } } func (s *CommentstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCommentstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Commentstmt() (localctx ICommentstmtContext) { localctx = NewCommentstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 534, PostgreSQLParserRULE_commentstmt) p.SetState(4814) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 227, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4667) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4668) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4669) p.Object_type_any_name() } { p.SetState(4670) p.Any_name() } { p.SetState(4671) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4672) p.Comment_text() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4674) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4675) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4676) p.Match(PostgreSQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4677) p.Any_name() } { p.SetState(4678) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4679) p.Comment_text() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(4681) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4682) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4683) p.Object_type_name() } { p.SetState(4684) p.Name() } { p.SetState(4685) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4686) p.Comment_text() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(4688) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4689) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4690) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4691) p.Typename() } { p.SetState(4692) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4693) p.Comment_text() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(4695) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4696) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4697) p.Match(PostgreSQLParserDOMAIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4698) p.Typename() } { p.SetState(4699) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4700) p.Comment_text() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(4702) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4703) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4704) p.Match(PostgreSQLParserAGGREGATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4705) p.Aggregate_with_argtypes() } { p.SetState(4706) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4707) p.Comment_text() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(4709) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4710) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4711) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4712) p.Function_with_argtypes() } { p.SetState(4713) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4714) p.Comment_text() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(4716) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4717) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4718) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4719) p.Operator_with_argtypes() } { p.SetState(4720) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4721) p.Comment_text() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(4723) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4724) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4725) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4726) p.Name() } { p.SetState(4727) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4728) p.Any_name() } { p.SetState(4729) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4730) p.Comment_text() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(4732) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4733) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4734) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4735) p.Name() } { p.SetState(4736) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4737) p.Match(PostgreSQLParserDOMAIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4738) p.Any_name() } { p.SetState(4739) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4740) p.Comment_text() } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(4742) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4743) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4744) p.Object_type_name_on_any_name() } { p.SetState(4745) p.Name() } { p.SetState(4746) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4747) p.Any_name() } { p.SetState(4748) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4749) p.Comment_text() } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(4751) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4752) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4753) p.Match(PostgreSQLParserPROCEDURE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4754) p.Function_with_argtypes() } { p.SetState(4755) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4756) p.Comment_text() } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(4758) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4759) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4760) p.Match(PostgreSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4761) p.Function_with_argtypes() } { p.SetState(4762) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4763) p.Comment_text() } case 14: p.EnterOuterAlt(localctx, 14) { p.SetState(4765) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4766) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4767) p.Match(PostgreSQLParserTRANSFORM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4768) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4769) p.Typename() } { p.SetState(4770) p.Match(PostgreSQLParserLANGUAGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4771) p.Name() } { p.SetState(4772) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4773) p.Comment_text() } case 15: p.EnterOuterAlt(localctx, 15) { p.SetState(4775) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4776) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4777) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4778) p.Match(PostgreSQLParserCLASS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4779) p.Any_name() } { p.SetState(4780) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4781) p.Name() } { p.SetState(4782) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4783) p.Comment_text() } case 16: p.EnterOuterAlt(localctx, 16) { p.SetState(4785) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4786) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4787) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4788) p.Match(PostgreSQLParserFAMILY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4789) p.Any_name() } { p.SetState(4790) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4791) p.Name() } { p.SetState(4792) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4793) p.Comment_text() } case 17: p.EnterOuterAlt(localctx, 17) { p.SetState(4795) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4796) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4797) p.Match(PostgreSQLParserLARGE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4798) p.Match(PostgreSQLParserOBJECT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4799) p.Numericonly() } { p.SetState(4800) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4801) p.Comment_text() } case 18: p.EnterOuterAlt(localctx, 18) { p.SetState(4803) p.Match(PostgreSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4804) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4805) p.Match(PostgreSQLParserCAST) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4806) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4807) p.Typename() } { p.SetState(4808) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4809) p.Typename() } { p.SetState(4810) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4811) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4812) p.Comment_text() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IComment_textContext is an interface to support dynamic dispatch. type IComment_textContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sconst() ISconstContext NULL_P() antlr.TerminalNode // IsComment_textContext differentiates from other interfaces. IsComment_textContext() } type Comment_textContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyComment_textContext() *Comment_textContext { var p = new(Comment_textContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_comment_text return p } func InitEmptyComment_textContext(p *Comment_textContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_comment_text } func (*Comment_textContext) IsComment_textContext() {} func NewComment_textContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comment_textContext { var p = new(Comment_textContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_comment_text return p } func (s *Comment_textContext) GetParser() antlr.Parser { return s.parser } func (s *Comment_textContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Comment_textContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *Comment_textContext) GetRuleContext() antlr.RuleContext { return s } func (s *Comment_textContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Comment_textContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterComment_text(s) } } func (s *Comment_textContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitComment_text(s) } } func (s *Comment_textContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitComment_text(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Comment_text() (localctx IComment_textContext) { localctx = NewComment_textContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 536, PostgreSQLParserRULE_comment_text) p.SetState(4818) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(4816) p.Sconst() } case PostgreSQLParserNULL_P: p.EnterOuterAlt(localctx, 2) { p.SetState(4817) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISeclabelstmtContext is an interface to support dynamic dispatch. type ISeclabelstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SECURITY() antlr.TerminalNode LABEL() antlr.TerminalNode Opt_provider() IOpt_providerContext ON() antlr.TerminalNode Object_type_any_name() IObject_type_any_nameContext Any_name() IAny_nameContext IS() antlr.TerminalNode Security_label() ISecurity_labelContext COLUMN() antlr.TerminalNode Object_type_name() IObject_type_nameContext Name() INameContext TYPE_P() antlr.TerminalNode Typename() ITypenameContext DOMAIN_P() antlr.TerminalNode AGGREGATE() antlr.TerminalNode Aggregate_with_argtypes() IAggregate_with_argtypesContext FUNCTION() antlr.TerminalNode Function_with_argtypes() IFunction_with_argtypesContext LARGE_P() antlr.TerminalNode OBJECT_P() antlr.TerminalNode Numericonly() INumericonlyContext PROCEDURE() antlr.TerminalNode ROUTINE() antlr.TerminalNode // IsSeclabelstmtContext differentiates from other interfaces. IsSeclabelstmtContext() } type SeclabelstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySeclabelstmtContext() *SeclabelstmtContext { var p = new(SeclabelstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_seclabelstmt return p } func InitEmptySeclabelstmtContext(p *SeclabelstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_seclabelstmt } func (*SeclabelstmtContext) IsSeclabelstmtContext() {} func NewSeclabelstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SeclabelstmtContext { var p = new(SeclabelstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_seclabelstmt return p } func (s *SeclabelstmtContext) GetParser() antlr.Parser { return s.parser } func (s *SeclabelstmtContext) SECURITY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSECURITY, 0) } func (s *SeclabelstmtContext) LABEL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLABEL, 0) } func (s *SeclabelstmtContext) Opt_provider() IOpt_providerContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_providerContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_providerContext) } func (s *SeclabelstmtContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *SeclabelstmtContext) Object_type_any_name() IObject_type_any_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IObject_type_any_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IObject_type_any_nameContext) } func (s *SeclabelstmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *SeclabelstmtContext) IS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIS, 0) } func (s *SeclabelstmtContext) Security_label() ISecurity_labelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISecurity_labelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISecurity_labelContext) } func (s *SeclabelstmtContext) COLUMN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLUMN, 0) } func (s *SeclabelstmtContext) Object_type_name() IObject_type_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IObject_type_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IObject_type_nameContext) } func (s *SeclabelstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *SeclabelstmtContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *SeclabelstmtContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *SeclabelstmtContext) DOMAIN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOMAIN_P, 0) } func (s *SeclabelstmtContext) AGGREGATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAGGREGATE, 0) } func (s *SeclabelstmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAggregate_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAggregate_with_argtypesContext) } func (s *SeclabelstmtContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *SeclabelstmtContext) Function_with_argtypes() IFunction_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunction_with_argtypesContext) } func (s *SeclabelstmtContext) LARGE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLARGE_P, 0) } func (s *SeclabelstmtContext) OBJECT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOBJECT_P, 0) } func (s *SeclabelstmtContext) Numericonly() INumericonlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericonlyContext) } func (s *SeclabelstmtContext) PROCEDURE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURE, 0) } func (s *SeclabelstmtContext) ROUTINE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUTINE, 0) } func (s *SeclabelstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *SeclabelstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SeclabelstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSeclabelstmt(s) } } func (s *SeclabelstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSeclabelstmt(s) } } func (s *SeclabelstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSeclabelstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Seclabelstmt() (localctx ISeclabelstmtContext) { localctx = NewSeclabelstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 538, PostgreSQLParserRULE_seclabelstmt) p.SetState(4911) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 229, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4820) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4821) p.Match(PostgreSQLParserLABEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4822) p.Opt_provider() } { p.SetState(4823) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4824) p.Object_type_any_name() } { p.SetState(4825) p.Any_name() } { p.SetState(4826) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4827) p.Security_label() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4829) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4830) p.Match(PostgreSQLParserLABEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4831) p.Opt_provider() } { p.SetState(4832) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4833) p.Match(PostgreSQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4834) p.Any_name() } { p.SetState(4835) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4836) p.Security_label() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(4838) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4839) p.Match(PostgreSQLParserLABEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4840) p.Opt_provider() } { p.SetState(4841) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4842) p.Object_type_name() } { p.SetState(4843) p.Name() } { p.SetState(4844) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4845) p.Security_label() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(4847) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4848) p.Match(PostgreSQLParserLABEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4849) p.Opt_provider() } { p.SetState(4850) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4851) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4852) p.Typename() } { p.SetState(4853) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4854) p.Security_label() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(4856) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4857) p.Match(PostgreSQLParserLABEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4858) p.Opt_provider() } { p.SetState(4859) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4860) p.Match(PostgreSQLParserDOMAIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4861) p.Typename() } { p.SetState(4862) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4863) p.Security_label() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(4865) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4866) p.Match(PostgreSQLParserLABEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4867) p.Opt_provider() } { p.SetState(4868) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4869) p.Match(PostgreSQLParserAGGREGATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4870) p.Aggregate_with_argtypes() } { p.SetState(4871) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4872) p.Security_label() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(4874) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4875) p.Match(PostgreSQLParserLABEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4876) p.Opt_provider() } { p.SetState(4877) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4878) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4879) p.Function_with_argtypes() } { p.SetState(4880) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4881) p.Security_label() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(4883) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4884) p.Match(PostgreSQLParserLABEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4885) p.Opt_provider() } { p.SetState(4886) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4887) p.Match(PostgreSQLParserLARGE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4888) p.Match(PostgreSQLParserOBJECT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4889) p.Numericonly() } { p.SetState(4890) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4891) p.Security_label() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(4893) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4894) p.Match(PostgreSQLParserLABEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4895) p.Opt_provider() } { p.SetState(4896) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4897) p.Match(PostgreSQLParserPROCEDURE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4898) p.Function_with_argtypes() } { p.SetState(4899) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4900) p.Security_label() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(4902) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4903) p.Match(PostgreSQLParserLABEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4904) p.Opt_provider() } { p.SetState(4905) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4906) p.Match(PostgreSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4907) p.Function_with_argtypes() } { p.SetState(4908) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4909) p.Security_label() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_providerContext is an interface to support dynamic dispatch. type IOpt_providerContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FOR() antlr.TerminalNode Nonreservedword_or_sconst() INonreservedword_or_sconstContext // IsOpt_providerContext differentiates from other interfaces. IsOpt_providerContext() } type Opt_providerContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_providerContext() *Opt_providerContext { var p = new(Opt_providerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_provider return p } func InitEmptyOpt_providerContext(p *Opt_providerContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_provider } func (*Opt_providerContext) IsOpt_providerContext() {} func NewOpt_providerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_providerContext { var p = new(Opt_providerContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_provider return p } func (s *Opt_providerContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_providerContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *Opt_providerContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INonreservedword_or_sconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INonreservedword_or_sconstContext) } func (s *Opt_providerContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_providerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_providerContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_provider(s) } } func (s *Opt_providerContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_provider(s) } } func (s *Opt_providerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_provider(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_provider() (localctx IOpt_providerContext) { localctx = NewOpt_providerContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 540, PostgreSQLParserRULE_opt_provider) p.SetState(4916) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFOR: p.EnterOuterAlt(localctx, 1) { p.SetState(4913) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4914) p.Nonreservedword_or_sconst() } case PostgreSQLParserON: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISecurity_labelContext is an interface to support dynamic dispatch. type ISecurity_labelContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sconst() ISconstContext NULL_P() antlr.TerminalNode // IsSecurity_labelContext differentiates from other interfaces. IsSecurity_labelContext() } type Security_labelContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySecurity_labelContext() *Security_labelContext { var p = new(Security_labelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_security_label return p } func InitEmptySecurity_labelContext(p *Security_labelContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_security_label } func (*Security_labelContext) IsSecurity_labelContext() {} func NewSecurity_labelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Security_labelContext { var p = new(Security_labelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_security_label return p } func (s *Security_labelContext) GetParser() antlr.Parser { return s.parser } func (s *Security_labelContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Security_labelContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *Security_labelContext) GetRuleContext() antlr.RuleContext { return s } func (s *Security_labelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Security_labelContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSecurity_label(s) } } func (s *Security_labelContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSecurity_label(s) } } func (s *Security_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSecurity_label(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Security_label() (localctx ISecurity_labelContext) { localctx = NewSecurity_labelContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 542, PostgreSQLParserRULE_security_label) p.SetState(4920) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(4918) p.Sconst() } case PostgreSQLParserNULL_P: p.EnterOuterAlt(localctx, 2) { p.SetState(4919) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFetchstmtContext is an interface to support dynamic dispatch. type IFetchstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FETCH() antlr.TerminalNode Fetch_args() IFetch_argsContext MOVE() antlr.TerminalNode // IsFetchstmtContext differentiates from other interfaces. IsFetchstmtContext() } type FetchstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFetchstmtContext() *FetchstmtContext { var p = new(FetchstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_fetchstmt return p } func InitEmptyFetchstmtContext(p *FetchstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_fetchstmt } func (*FetchstmtContext) IsFetchstmtContext() {} func NewFetchstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FetchstmtContext { var p = new(FetchstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_fetchstmt return p } func (s *FetchstmtContext) GetParser() antlr.Parser { return s.parser } func (s *FetchstmtContext) FETCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFETCH, 0) } func (s *FetchstmtContext) Fetch_args() IFetch_argsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFetch_argsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFetch_argsContext) } func (s *FetchstmtContext) MOVE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMOVE, 0) } func (s *FetchstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *FetchstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *FetchstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFetchstmt(s) } } func (s *FetchstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFetchstmt(s) } } func (s *FetchstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFetchstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Fetchstmt() (localctx IFetchstmtContext) { localctx = NewFetchstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 544, PostgreSQLParserRULE_fetchstmt) p.SetState(4926) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFETCH: p.EnterOuterAlt(localctx, 1) { p.SetState(4922) p.Match(PostgreSQLParserFETCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4923) p.Fetch_args() } case PostgreSQLParserMOVE: p.EnterOuterAlt(localctx, 2) { p.SetState(4924) p.Match(PostgreSQLParserMOVE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4925) p.Fetch_args() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFetch_argsContext is an interface to support dynamic dispatch. type IFetch_argsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Cursor_name() ICursor_nameContext From_in() IFrom_inContext NEXT() antlr.TerminalNode Opt_from_in() IOpt_from_inContext PRIOR() antlr.TerminalNode FIRST_P() antlr.TerminalNode LAST_P() antlr.TerminalNode ABSOLUTE_P() antlr.TerminalNode Signediconst() ISignediconstContext RELATIVE_P() antlr.TerminalNode ALL() antlr.TerminalNode FORWARD() antlr.TerminalNode BACKWARD() antlr.TerminalNode // IsFetch_argsContext differentiates from other interfaces. IsFetch_argsContext() } type Fetch_argsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFetch_argsContext() *Fetch_argsContext { var p = new(Fetch_argsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_fetch_args return p } func InitEmptyFetch_argsContext(p *Fetch_argsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_fetch_args } func (*Fetch_argsContext) IsFetch_argsContext() {} func NewFetch_argsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fetch_argsContext { var p = new(Fetch_argsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_fetch_args return p } func (s *Fetch_argsContext) GetParser() antlr.Parser { return s.parser } func (s *Fetch_argsContext) Cursor_name() ICursor_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICursor_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICursor_nameContext) } func (s *Fetch_argsContext) From_in() IFrom_inContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFrom_inContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFrom_inContext) } func (s *Fetch_argsContext) NEXT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNEXT, 0) } func (s *Fetch_argsContext) Opt_from_in() IOpt_from_inContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_from_inContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_from_inContext) } func (s *Fetch_argsContext) PRIOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRIOR, 0) } func (s *Fetch_argsContext) FIRST_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFIRST_P, 0) } func (s *Fetch_argsContext) LAST_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLAST_P, 0) } func (s *Fetch_argsContext) ABSOLUTE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserABSOLUTE_P, 0) } func (s *Fetch_argsContext) Signediconst() ISignediconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISignediconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISignediconstContext) } func (s *Fetch_argsContext) RELATIVE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRELATIVE_P, 0) } func (s *Fetch_argsContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *Fetch_argsContext) FORWARD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFORWARD, 0) } func (s *Fetch_argsContext) BACKWARD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBACKWARD, 0) } func (s *Fetch_argsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Fetch_argsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Fetch_argsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFetch_args(s) } } func (s *Fetch_argsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFetch_args(s) } } func (s *Fetch_argsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFetch_args(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Fetch_args() (localctx IFetch_argsContext) { localctx = NewFetch_argsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 546, PostgreSQLParserRULE_fetch_args) p.SetState(4994) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 233, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(4928) p.Cursor_name() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(4929) p.From_in() } { p.SetState(4930) p.Cursor_name() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(4932) p.Match(PostgreSQLParserNEXT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4933) p.Opt_from_in() } { p.SetState(4934) p.Cursor_name() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(4936) p.Match(PostgreSQLParserPRIOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4937) p.Opt_from_in() } { p.SetState(4938) p.Cursor_name() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(4940) p.Match(PostgreSQLParserFIRST_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4941) p.Opt_from_in() } { p.SetState(4942) p.Cursor_name() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(4944) p.Match(PostgreSQLParserLAST_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4945) p.Opt_from_in() } { p.SetState(4946) p.Cursor_name() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(4948) p.Match(PostgreSQLParserABSOLUTE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4949) p.Signediconst() } { p.SetState(4950) p.Opt_from_in() } { p.SetState(4951) p.Cursor_name() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(4953) p.Match(PostgreSQLParserRELATIVE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4954) p.Signediconst() } { p.SetState(4955) p.Opt_from_in() } { p.SetState(4956) p.Cursor_name() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(4958) p.Signediconst() } { p.SetState(4959) p.Opt_from_in() } { p.SetState(4960) p.Cursor_name() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(4962) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4963) p.Opt_from_in() } { p.SetState(4964) p.Cursor_name() } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(4966) p.Match(PostgreSQLParserFORWARD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4967) p.Opt_from_in() } { p.SetState(4968) p.Cursor_name() } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(4970) p.Match(PostgreSQLParserFORWARD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4971) p.Signediconst() } { p.SetState(4972) p.Opt_from_in() } { p.SetState(4973) p.Cursor_name() } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(4975) p.Match(PostgreSQLParserFORWARD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4976) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4977) p.Opt_from_in() } { p.SetState(4978) p.Cursor_name() } case 14: p.EnterOuterAlt(localctx, 14) { p.SetState(4980) p.Match(PostgreSQLParserBACKWARD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4981) p.Opt_from_in() } { p.SetState(4982) p.Cursor_name() } case 15: p.EnterOuterAlt(localctx, 15) { p.SetState(4984) p.Match(PostgreSQLParserBACKWARD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4985) p.Signediconst() } { p.SetState(4986) p.Opt_from_in() } { p.SetState(4987) p.Cursor_name() } case 16: p.EnterOuterAlt(localctx, 16) { p.SetState(4989) p.Match(PostgreSQLParserBACKWARD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4990) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(4991) p.Opt_from_in() } { p.SetState(4992) p.Cursor_name() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFrom_inContext is an interface to support dynamic dispatch. type IFrom_inContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FROM() antlr.TerminalNode IN_P() antlr.TerminalNode // IsFrom_inContext differentiates from other interfaces. IsFrom_inContext() } type From_inContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFrom_inContext() *From_inContext { var p = new(From_inContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_from_in return p } func InitEmptyFrom_inContext(p *From_inContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_from_in } func (*From_inContext) IsFrom_inContext() {} func NewFrom_inContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *From_inContext { var p = new(From_inContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_from_in return p } func (s *From_inContext) GetParser() antlr.Parser { return s.parser } func (s *From_inContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *From_inContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *From_inContext) GetRuleContext() antlr.RuleContext { return s } func (s *From_inContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *From_inContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFrom_in(s) } } func (s *From_inContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFrom_in(s) } } func (s *From_inContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFrom_in(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) From_in() (localctx IFrom_inContext) { localctx = NewFrom_inContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 548, PostgreSQLParserRULE_from_in) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4996) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserFROM || _la == PostgreSQLParserIN_P) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_from_inContext is an interface to support dynamic dispatch. type IOpt_from_inContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures From_in() IFrom_inContext // IsOpt_from_inContext differentiates from other interfaces. IsOpt_from_inContext() } type Opt_from_inContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_from_inContext() *Opt_from_inContext { var p = new(Opt_from_inContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_from_in return p } func InitEmptyOpt_from_inContext(p *Opt_from_inContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_from_in } func (*Opt_from_inContext) IsOpt_from_inContext() {} func NewOpt_from_inContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_from_inContext { var p = new(Opt_from_inContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_from_in return p } func (s *Opt_from_inContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_from_inContext) From_in() IFrom_inContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFrom_inContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFrom_inContext) } func (s *Opt_from_inContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_from_inContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_from_inContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_from_in(s) } } func (s *Opt_from_inContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_from_in(s) } } func (s *Opt_from_inContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_from_in(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_from_in() (localctx IOpt_from_inContext) { localctx = NewOpt_from_inContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 550, PostgreSQLParserRULE_opt_from_in) p.SetState(5000) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFROM, PostgreSQLParserIN_P: p.EnterOuterAlt(localctx, 1) { p.SetState(4998) p.From_in() } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGrantstmtContext is an interface to support dynamic dispatch. type IGrantstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures GRANT() antlr.TerminalNode Privileges() IPrivilegesContext ON() antlr.TerminalNode Privilege_target() IPrivilege_targetContext TO() antlr.TerminalNode Grantee_list() IGrantee_listContext Opt_grant_grant_option() IOpt_grant_grant_optionContext // IsGrantstmtContext differentiates from other interfaces. IsGrantstmtContext() } type GrantstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGrantstmtContext() *GrantstmtContext { var p = new(GrantstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_grantstmt return p } func InitEmptyGrantstmtContext(p *GrantstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_grantstmt } func (*GrantstmtContext) IsGrantstmtContext() {} func NewGrantstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantstmtContext { var p = new(GrantstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_grantstmt return p } func (s *GrantstmtContext) GetParser() antlr.Parser { return s.parser } func (s *GrantstmtContext) GRANT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGRANT, 0) } func (s *GrantstmtContext) Privileges() IPrivilegesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPrivilegesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPrivilegesContext) } func (s *GrantstmtContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *GrantstmtContext) Privilege_target() IPrivilege_targetContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPrivilege_targetContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPrivilege_targetContext) } func (s *GrantstmtContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *GrantstmtContext) Grantee_list() IGrantee_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGrantee_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGrantee_listContext) } func (s *GrantstmtContext) Opt_grant_grant_option() IOpt_grant_grant_optionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_grant_grant_optionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_grant_grant_optionContext) } func (s *GrantstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *GrantstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *GrantstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGrantstmt(s) } } func (s *GrantstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGrantstmt(s) } } func (s *GrantstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGrantstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Grantstmt() (localctx IGrantstmtContext) { localctx = NewGrantstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 552, PostgreSQLParserRULE_grantstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(5002) p.Match(PostgreSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5003) p.Privileges() } { p.SetState(5004) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5005) p.Privilege_target() } { p.SetState(5006) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5007) p.Grantee_list() } { p.SetState(5008) p.Opt_grant_grant_option() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRevokestmtContext is an interface to support dynamic dispatch. type IRevokestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures REVOKE() antlr.TerminalNode Privileges() IPrivilegesContext ON() antlr.TerminalNode Privilege_target() IPrivilege_targetContext FROM() antlr.TerminalNode Grantee_list() IGrantee_listContext Opt_drop_behavior() IOpt_drop_behaviorContext GRANT() antlr.TerminalNode OPTION() antlr.TerminalNode FOR() antlr.TerminalNode // IsRevokestmtContext differentiates from other interfaces. IsRevokestmtContext() } type RevokestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRevokestmtContext() *RevokestmtContext { var p = new(RevokestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_revokestmt return p } func InitEmptyRevokestmtContext(p *RevokestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_revokestmt } func (*RevokestmtContext) IsRevokestmtContext() {} func NewRevokestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RevokestmtContext { var p = new(RevokestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_revokestmt return p } func (s *RevokestmtContext) GetParser() antlr.Parser { return s.parser } func (s *RevokestmtContext) REVOKE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREVOKE, 0) } func (s *RevokestmtContext) Privileges() IPrivilegesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPrivilegesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPrivilegesContext) } func (s *RevokestmtContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *RevokestmtContext) Privilege_target() IPrivilege_targetContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPrivilege_targetContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPrivilege_targetContext) } func (s *RevokestmtContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *RevokestmtContext) Grantee_list() IGrantee_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGrantee_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGrantee_listContext) } func (s *RevokestmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *RevokestmtContext) GRANT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGRANT, 0) } func (s *RevokestmtContext) OPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPTION, 0) } func (s *RevokestmtContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *RevokestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *RevokestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RevokestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRevokestmt(s) } } func (s *RevokestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRevokestmt(s) } } func (s *RevokestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRevokestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Revokestmt() (localctx IRevokestmtContext) { localctx = NewRevokestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 554, PostgreSQLParserRULE_revokestmt) p.SetState(5029) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 235, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5010) p.Match(PostgreSQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5011) p.Privileges() } { p.SetState(5012) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5013) p.Privilege_target() } { p.SetState(5014) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5015) p.Grantee_list() } { p.SetState(5016) p.Opt_drop_behavior() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5018) p.Match(PostgreSQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5019) p.Match(PostgreSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5020) p.Match(PostgreSQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5021) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5022) p.Privileges() } { p.SetState(5023) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5024) p.Privilege_target() } { p.SetState(5025) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5026) p.Grantee_list() } { p.SetState(5027) p.Opt_drop_behavior() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPrivilegesContext is an interface to support dynamic dispatch. type IPrivilegesContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Privilege_list() IPrivilege_listContext ALL() antlr.TerminalNode PRIVILEGES() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Columnlist() IColumnlistContext CLOSE_PAREN() antlr.TerminalNode // IsPrivilegesContext differentiates from other interfaces. IsPrivilegesContext() } type PrivilegesContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPrivilegesContext() *PrivilegesContext { var p = new(PrivilegesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_privileges return p } func InitEmptyPrivilegesContext(p *PrivilegesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_privileges } func (*PrivilegesContext) IsPrivilegesContext() {} func NewPrivilegesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegesContext { var p = new(PrivilegesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_privileges return p } func (s *PrivilegesContext) GetParser() antlr.Parser { return s.parser } func (s *PrivilegesContext) Privilege_list() IPrivilege_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPrivilege_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPrivilege_listContext) } func (s *PrivilegesContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *PrivilegesContext) PRIVILEGES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRIVILEGES, 0) } func (s *PrivilegesContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *PrivilegesContext) Columnlist() IColumnlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColumnlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColumnlistContext) } func (s *PrivilegesContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *PrivilegesContext) GetRuleContext() antlr.RuleContext { return s } func (s *PrivilegesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *PrivilegesContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPrivileges(s) } } func (s *PrivilegesContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPrivileges(s) } } func (s *PrivilegesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPrivileges(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Privileges() (localctx IPrivilegesContext) { localctx = NewPrivilegesContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 556, PostgreSQLParserRULE_privileges) p.SetState(5046) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 236, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5031) p.Privilege_list() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5032) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(5033) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5034) p.Match(PostgreSQLParserPRIVILEGES) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(5035) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5036) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5037) p.Columnlist() } { p.SetState(5038) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(5040) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5041) p.Match(PostgreSQLParserPRIVILEGES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5042) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5043) p.Columnlist() } { p.SetState(5044) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPrivilege_listContext is an interface to support dynamic dispatch. type IPrivilege_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllPrivilege() []IPrivilegeContext Privilege(i int) IPrivilegeContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsPrivilege_listContext differentiates from other interfaces. IsPrivilege_listContext() } type Privilege_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPrivilege_listContext() *Privilege_listContext { var p = new(Privilege_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_privilege_list return p } func InitEmptyPrivilege_listContext(p *Privilege_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_privilege_list } func (*Privilege_listContext) IsPrivilege_listContext() {} func NewPrivilege_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Privilege_listContext { var p = new(Privilege_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_privilege_list return p } func (s *Privilege_listContext) GetParser() antlr.Parser { return s.parser } func (s *Privilege_listContext) AllPrivilege() []IPrivilegeContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IPrivilegeContext); ok { len++ } } tst := make([]IPrivilegeContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IPrivilegeContext); ok { tst[i] = t.(IPrivilegeContext) i++ } } return tst } func (s *Privilege_listContext) Privilege(i int) IPrivilegeContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPrivilegeContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IPrivilegeContext) } func (s *Privilege_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Privilege_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Privilege_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Privilege_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Privilege_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPrivilege_list(s) } } func (s *Privilege_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPrivilege_list(s) } } func (s *Privilege_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPrivilege_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Privilege_list() (localctx IPrivilege_listContext) { localctx = NewPrivilege_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 558, PostgreSQLParserRULE_privilege_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5048) p.Privilege() } p.SetState(5053) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(5049) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5050) p.Privilege() } p.SetState(5055) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPrivilegeContext is an interface to support dynamic dispatch. type IPrivilegeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SELECT() antlr.TerminalNode Opt_column_list() IOpt_column_listContext REFERENCES() antlr.TerminalNode CREATE() antlr.TerminalNode Colid() IColidContext // IsPrivilegeContext differentiates from other interfaces. IsPrivilegeContext() } type PrivilegeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPrivilegeContext() *PrivilegeContext { var p = new(PrivilegeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_privilege return p } func InitEmptyPrivilegeContext(p *PrivilegeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_privilege } func (*PrivilegeContext) IsPrivilegeContext() {} func NewPrivilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegeContext { var p = new(PrivilegeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_privilege return p } func (s *PrivilegeContext) GetParser() antlr.Parser { return s.parser } func (s *PrivilegeContext) SELECT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSELECT, 0) } func (s *PrivilegeContext) Opt_column_list() IOpt_column_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_column_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_column_listContext) } func (s *PrivilegeContext) REFERENCES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREFERENCES, 0) } func (s *PrivilegeContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *PrivilegeContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *PrivilegeContext) GetRuleContext() antlr.RuleContext { return s } func (s *PrivilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *PrivilegeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPrivilege(s) } } func (s *PrivilegeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPrivilege(s) } } func (s *PrivilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPrivilege(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Privilege() (localctx IPrivilegeContext) { localctx = NewPrivilegeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 560, PostgreSQLParserRULE_privilege) p.SetState(5065) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSELECT: p.EnterOuterAlt(localctx, 1) { p.SetState(5056) p.Match(PostgreSQLParserSELECT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5057) p.Opt_column_list() } case PostgreSQLParserREFERENCES: p.EnterOuterAlt(localctx, 2) { p.SetState(5058) p.Match(PostgreSQLParserREFERENCES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5059) p.Opt_column_list() } case PostgreSQLParserCREATE: p.EnterOuterAlt(localctx, 3) { p.SetState(5060) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5061) p.Opt_column_list() } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 4) { p.SetState(5062) p.Colid() } { p.SetState(5063) p.Opt_column_list() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPrivilege_targetContext is an interface to support dynamic dispatch. type IPrivilege_targetContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Qualified_name_list() IQualified_name_listContext TABLE() antlr.TerminalNode SEQUENCE() antlr.TerminalNode FOREIGN() antlr.TerminalNode DATA_P() antlr.TerminalNode WRAPPER() antlr.TerminalNode Name_list() IName_listContext SERVER() antlr.TerminalNode FUNCTION() antlr.TerminalNode Function_with_argtypes_list() IFunction_with_argtypes_listContext PROCEDURE() antlr.TerminalNode ROUTINE() antlr.TerminalNode DATABASE() antlr.TerminalNode DOMAIN_P() antlr.TerminalNode Any_name_list() IAny_name_listContext LANGUAGE() antlr.TerminalNode LARGE_P() antlr.TerminalNode OBJECT_P() antlr.TerminalNode Numericonly_list() INumericonly_listContext SCHEMA() antlr.TerminalNode TABLESPACE() antlr.TerminalNode TYPE_P() antlr.TerminalNode ALL() antlr.TerminalNode TABLES() antlr.TerminalNode IN_P() antlr.TerminalNode SEQUENCES() antlr.TerminalNode FUNCTIONS() antlr.TerminalNode PROCEDURES() antlr.TerminalNode ROUTINES() antlr.TerminalNode // IsPrivilege_targetContext differentiates from other interfaces. IsPrivilege_targetContext() } type Privilege_targetContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPrivilege_targetContext() *Privilege_targetContext { var p = new(Privilege_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_privilege_target return p } func InitEmptyPrivilege_targetContext(p *Privilege_targetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_privilege_target } func (*Privilege_targetContext) IsPrivilege_targetContext() {} func NewPrivilege_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Privilege_targetContext { var p = new(Privilege_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_privilege_target return p } func (s *Privilege_targetContext) GetParser() antlr.Parser { return s.parser } func (s *Privilege_targetContext) Qualified_name_list() IQualified_name_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_name_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_name_listContext) } func (s *Privilege_targetContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *Privilege_targetContext) SEQUENCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEQUENCE, 0) } func (s *Privilege_targetContext) FOREIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREIGN, 0) } func (s *Privilege_targetContext) DATA_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATA_P, 0) } func (s *Privilege_targetContext) WRAPPER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWRAPPER, 0) } func (s *Privilege_targetContext) Name_list() IName_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IName_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IName_listContext) } func (s *Privilege_targetContext) SERVER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSERVER, 0) } func (s *Privilege_targetContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *Privilege_targetContext) Function_with_argtypes_list() IFunction_with_argtypes_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_with_argtypes_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunction_with_argtypes_listContext) } func (s *Privilege_targetContext) PROCEDURE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURE, 0) } func (s *Privilege_targetContext) ROUTINE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUTINE, 0) } func (s *Privilege_targetContext) DATABASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATABASE, 0) } func (s *Privilege_targetContext) DOMAIN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOMAIN_P, 0) } func (s *Privilege_targetContext) Any_name_list() IAny_name_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_name_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_name_listContext) } func (s *Privilege_targetContext) LANGUAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLANGUAGE, 0) } func (s *Privilege_targetContext) LARGE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLARGE_P, 0) } func (s *Privilege_targetContext) OBJECT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOBJECT_P, 0) } func (s *Privilege_targetContext) Numericonly_list() INumericonly_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonly_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericonly_listContext) } func (s *Privilege_targetContext) SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMA, 0) } func (s *Privilege_targetContext) TABLESPACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, 0) } func (s *Privilege_targetContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *Privilege_targetContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *Privilege_targetContext) TABLES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLES, 0) } func (s *Privilege_targetContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *Privilege_targetContext) SEQUENCES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEQUENCES, 0) } func (s *Privilege_targetContext) FUNCTIONS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTIONS, 0) } func (s *Privilege_targetContext) PROCEDURES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURES, 0) } func (s *Privilege_targetContext) ROUTINES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUTINES, 0) } func (s *Privilege_targetContext) GetRuleContext() antlr.RuleContext { return s } func (s *Privilege_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Privilege_targetContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPrivilege_target(s) } } func (s *Privilege_targetContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPrivilege_target(s) } } func (s *Privilege_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPrivilege_target(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Privilege_target() (localctx IPrivilege_targetContext) { localctx = NewPrivilege_targetContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 562, PostgreSQLParserRULE_privilege_target) p.SetState(5125) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 239, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5067) p.Qualified_name_list() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5068) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5069) p.Qualified_name_list() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(5070) p.Match(PostgreSQLParserSEQUENCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5071) p.Qualified_name_list() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(5072) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5073) p.Match(PostgreSQLParserDATA_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5074) p.Match(PostgreSQLParserWRAPPER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5075) p.Name_list() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(5076) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5077) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5078) p.Name_list() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(5079) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5080) p.Function_with_argtypes_list() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(5081) p.Match(PostgreSQLParserPROCEDURE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5082) p.Function_with_argtypes_list() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(5083) p.Match(PostgreSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5084) p.Function_with_argtypes_list() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(5085) p.Match(PostgreSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5086) p.Name_list() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(5087) p.Match(PostgreSQLParserDOMAIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5088) p.Any_name_list() } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(5089) p.Match(PostgreSQLParserLANGUAGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5090) p.Name_list() } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(5091) p.Match(PostgreSQLParserLARGE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5092) p.Match(PostgreSQLParserOBJECT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5093) p.Numericonly_list() } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(5094) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5095) p.Name_list() } case 14: p.EnterOuterAlt(localctx, 14) { p.SetState(5096) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5097) p.Name_list() } case 15: p.EnterOuterAlt(localctx, 15) { p.SetState(5098) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5099) p.Any_name_list() } case 16: p.EnterOuterAlt(localctx, 16) { p.SetState(5100) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5101) p.Match(PostgreSQLParserTABLES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5102) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5103) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5104) p.Name_list() } case 17: p.EnterOuterAlt(localctx, 17) { p.SetState(5105) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5106) p.Match(PostgreSQLParserSEQUENCES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5107) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5108) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5109) p.Name_list() } case 18: p.EnterOuterAlt(localctx, 18) { p.SetState(5110) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5111) p.Match(PostgreSQLParserFUNCTIONS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5112) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5113) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5114) p.Name_list() } case 19: p.EnterOuterAlt(localctx, 19) { p.SetState(5115) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5116) p.Match(PostgreSQLParserPROCEDURES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5117) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5118) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5119) p.Name_list() } case 20: p.EnterOuterAlt(localctx, 20) { p.SetState(5120) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5121) p.Match(PostgreSQLParserROUTINES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5122) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5123) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5124) p.Name_list() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGrantee_listContext is an interface to support dynamic dispatch. type IGrantee_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllGrantee() []IGranteeContext Grantee(i int) IGranteeContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsGrantee_listContext differentiates from other interfaces. IsGrantee_listContext() } type Grantee_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGrantee_listContext() *Grantee_listContext { var p = new(Grantee_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_grantee_list return p } func InitEmptyGrantee_listContext(p *Grantee_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_grantee_list } func (*Grantee_listContext) IsGrantee_listContext() {} func NewGrantee_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grantee_listContext { var p = new(Grantee_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_grantee_list return p } func (s *Grantee_listContext) GetParser() antlr.Parser { return s.parser } func (s *Grantee_listContext) AllGrantee() []IGranteeContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IGranteeContext); ok { len++ } } tst := make([]IGranteeContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IGranteeContext); ok { tst[i] = t.(IGranteeContext) i++ } } return tst } func (s *Grantee_listContext) Grantee(i int) IGranteeContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGranteeContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IGranteeContext) } func (s *Grantee_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Grantee_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Grantee_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Grantee_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Grantee_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGrantee_list(s) } } func (s *Grantee_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGrantee_list(s) } } func (s *Grantee_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGrantee_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Grantee_list() (localctx IGrantee_listContext) { localctx = NewGrantee_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 564, PostgreSQLParserRULE_grantee_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5127) p.Grantee() } p.SetState(5132) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(5128) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5129) p.Grantee() } p.SetState(5134) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGranteeContext is an interface to support dynamic dispatch. type IGranteeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Rolespec() IRolespecContext GROUP_P() antlr.TerminalNode // IsGranteeContext differentiates from other interfaces. IsGranteeContext() } type GranteeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGranteeContext() *GranteeContext { var p = new(GranteeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_grantee return p } func InitEmptyGranteeContext(p *GranteeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_grantee } func (*GranteeContext) IsGranteeContext() {} func NewGranteeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GranteeContext { var p = new(GranteeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_grantee return p } func (s *GranteeContext) GetParser() antlr.Parser { return s.parser } func (s *GranteeContext) Rolespec() IRolespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRolespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRolespecContext) } func (s *GranteeContext) GROUP_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUP_P, 0) } func (s *GranteeContext) GetRuleContext() antlr.RuleContext { return s } func (s *GranteeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *GranteeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGrantee(s) } } func (s *GranteeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGrantee(s) } } func (s *GranteeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGrantee(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Grantee() (localctx IGranteeContext) { localctx = NewGranteeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 566, PostgreSQLParserRULE_grantee) p.SetState(5138) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(5135) p.Rolespec() } case PostgreSQLParserGROUP_P: p.EnterOuterAlt(localctx, 2) { p.SetState(5136) p.Match(PostgreSQLParserGROUP_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5137) p.Rolespec() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_grant_grant_optionContext is an interface to support dynamic dispatch. type IOpt_grant_grant_optionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITH() antlr.TerminalNode GRANT() antlr.TerminalNode OPTION() antlr.TerminalNode // IsOpt_grant_grant_optionContext differentiates from other interfaces. IsOpt_grant_grant_optionContext() } type Opt_grant_grant_optionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_grant_grant_optionContext() *Opt_grant_grant_optionContext { var p = new(Opt_grant_grant_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_grant_grant_option return p } func InitEmptyOpt_grant_grant_optionContext(p *Opt_grant_grant_optionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_grant_grant_option } func (*Opt_grant_grant_optionContext) IsOpt_grant_grant_optionContext() {} func NewOpt_grant_grant_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_grant_grant_optionContext { var p = new(Opt_grant_grant_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_grant_grant_option return p } func (s *Opt_grant_grant_optionContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_grant_grant_optionContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *Opt_grant_grant_optionContext) GRANT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGRANT, 0) } func (s *Opt_grant_grant_optionContext) OPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPTION, 0) } func (s *Opt_grant_grant_optionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_grant_grant_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_grant_grant_optionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_grant_grant_option(s) } } func (s *Opt_grant_grant_optionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_grant_grant_option(s) } } func (s *Opt_grant_grant_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_grant_grant_option(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_grant_grant_option() (localctx IOpt_grant_grant_optionContext) { localctx = NewOpt_grant_grant_optionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 568, PostgreSQLParserRULE_opt_grant_grant_option) p.SetState(5144) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 242, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5140) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5141) p.Match(PostgreSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5142) p.Match(PostgreSQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGrantrolestmtContext is an interface to support dynamic dispatch. type IGrantrolestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures GRANT() antlr.TerminalNode Privilege_list() IPrivilege_listContext TO() antlr.TerminalNode Role_list() IRole_listContext Opt_grant_admin_option() IOpt_grant_admin_optionContext Opt_granted_by() IOpt_granted_byContext // IsGrantrolestmtContext differentiates from other interfaces. IsGrantrolestmtContext() } type GrantrolestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGrantrolestmtContext() *GrantrolestmtContext { var p = new(GrantrolestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_grantrolestmt return p } func InitEmptyGrantrolestmtContext(p *GrantrolestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_grantrolestmt } func (*GrantrolestmtContext) IsGrantrolestmtContext() {} func NewGrantrolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantrolestmtContext { var p = new(GrantrolestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_grantrolestmt return p } func (s *GrantrolestmtContext) GetParser() antlr.Parser { return s.parser } func (s *GrantrolestmtContext) GRANT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGRANT, 0) } func (s *GrantrolestmtContext) Privilege_list() IPrivilege_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPrivilege_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPrivilege_listContext) } func (s *GrantrolestmtContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *GrantrolestmtContext) Role_list() IRole_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRole_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRole_listContext) } func (s *GrantrolestmtContext) Opt_grant_admin_option() IOpt_grant_admin_optionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_grant_admin_optionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_grant_admin_optionContext) } func (s *GrantrolestmtContext) Opt_granted_by() IOpt_granted_byContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_granted_byContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_granted_byContext) } func (s *GrantrolestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *GrantrolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *GrantrolestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGrantrolestmt(s) } } func (s *GrantrolestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGrantrolestmt(s) } } func (s *GrantrolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGrantrolestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Grantrolestmt() (localctx IGrantrolestmtContext) { localctx = NewGrantrolestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 570, PostgreSQLParserRULE_grantrolestmt) p.EnterOuterAlt(localctx, 1) { p.SetState(5146) p.Match(PostgreSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5147) p.Privilege_list() } { p.SetState(5148) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5149) p.Role_list() } { p.SetState(5150) p.Opt_grant_admin_option() } { p.SetState(5151) p.Opt_granted_by() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRevokerolestmtContext is an interface to support dynamic dispatch. type IRevokerolestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures REVOKE() antlr.TerminalNode Privilege_list() IPrivilege_listContext FROM() antlr.TerminalNode Role_list() IRole_listContext Opt_granted_by() IOpt_granted_byContext Opt_drop_behavior() IOpt_drop_behaviorContext ADMIN() antlr.TerminalNode OPTION() antlr.TerminalNode FOR() antlr.TerminalNode // IsRevokerolestmtContext differentiates from other interfaces. IsRevokerolestmtContext() } type RevokerolestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRevokerolestmtContext() *RevokerolestmtContext { var p = new(RevokerolestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_revokerolestmt return p } func InitEmptyRevokerolestmtContext(p *RevokerolestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_revokerolestmt } func (*RevokerolestmtContext) IsRevokerolestmtContext() {} func NewRevokerolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RevokerolestmtContext { var p = new(RevokerolestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_revokerolestmt return p } func (s *RevokerolestmtContext) GetParser() antlr.Parser { return s.parser } func (s *RevokerolestmtContext) REVOKE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREVOKE, 0) } func (s *RevokerolestmtContext) Privilege_list() IPrivilege_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPrivilege_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPrivilege_listContext) } func (s *RevokerolestmtContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *RevokerolestmtContext) Role_list() IRole_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRole_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRole_listContext) } func (s *RevokerolestmtContext) Opt_granted_by() IOpt_granted_byContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_granted_byContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_granted_byContext) } func (s *RevokerolestmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *RevokerolestmtContext) ADMIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserADMIN, 0) } func (s *RevokerolestmtContext) OPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPTION, 0) } func (s *RevokerolestmtContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *RevokerolestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *RevokerolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RevokerolestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRevokerolestmt(s) } } func (s *RevokerolestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRevokerolestmt(s) } } func (s *RevokerolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRevokerolestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Revokerolestmt() (localctx IRevokerolestmtContext) { localctx = NewRevokerolestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 572, PostgreSQLParserRULE_revokerolestmt) p.SetState(5170) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 243, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5153) p.Match(PostgreSQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5154) p.Privilege_list() } { p.SetState(5155) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5156) p.Role_list() } { p.SetState(5157) p.Opt_granted_by() } { p.SetState(5158) p.Opt_drop_behavior() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5160) p.Match(PostgreSQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5161) p.Match(PostgreSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5162) p.Match(PostgreSQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5163) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5164) p.Privilege_list() } { p.SetState(5165) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5166) p.Role_list() } { p.SetState(5167) p.Opt_granted_by() } { p.SetState(5168) p.Opt_drop_behavior() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_grant_admin_optionContext is an interface to support dynamic dispatch. type IOpt_grant_admin_optionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITH() antlr.TerminalNode ADMIN() antlr.TerminalNode OPTION() antlr.TerminalNode // IsOpt_grant_admin_optionContext differentiates from other interfaces. IsOpt_grant_admin_optionContext() } type Opt_grant_admin_optionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_grant_admin_optionContext() *Opt_grant_admin_optionContext { var p = new(Opt_grant_admin_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_grant_admin_option return p } func InitEmptyOpt_grant_admin_optionContext(p *Opt_grant_admin_optionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_grant_admin_option } func (*Opt_grant_admin_optionContext) IsOpt_grant_admin_optionContext() {} func NewOpt_grant_admin_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_grant_admin_optionContext { var p = new(Opt_grant_admin_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_grant_admin_option return p } func (s *Opt_grant_admin_optionContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_grant_admin_optionContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *Opt_grant_admin_optionContext) ADMIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserADMIN, 0) } func (s *Opt_grant_admin_optionContext) OPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPTION, 0) } func (s *Opt_grant_admin_optionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_grant_admin_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_grant_admin_optionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_grant_admin_option(s) } } func (s *Opt_grant_admin_optionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_grant_admin_option(s) } } func (s *Opt_grant_admin_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_grant_admin_option(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_grant_admin_option() (localctx IOpt_grant_admin_optionContext) { localctx = NewOpt_grant_admin_optionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 574, PostgreSQLParserRULE_opt_grant_admin_option) p.SetState(5176) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 244, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5172) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5173) p.Match(PostgreSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5174) p.Match(PostgreSQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_granted_byContext is an interface to support dynamic dispatch. type IOpt_granted_byContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures GRANTED() antlr.TerminalNode BY() antlr.TerminalNode Rolespec() IRolespecContext // IsOpt_granted_byContext differentiates from other interfaces. IsOpt_granted_byContext() } type Opt_granted_byContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_granted_byContext() *Opt_granted_byContext { var p = new(Opt_granted_byContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_granted_by return p } func InitEmptyOpt_granted_byContext(p *Opt_granted_byContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_granted_by } func (*Opt_granted_byContext) IsOpt_granted_byContext() {} func NewOpt_granted_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_granted_byContext { var p = new(Opt_granted_byContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_granted_by return p } func (s *Opt_granted_byContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_granted_byContext) GRANTED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGRANTED, 0) } func (s *Opt_granted_byContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *Opt_granted_byContext) Rolespec() IRolespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRolespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRolespecContext) } func (s *Opt_granted_byContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_granted_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_granted_byContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_granted_by(s) } } func (s *Opt_granted_byContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_granted_by(s) } } func (s *Opt_granted_byContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_granted_by(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_granted_by() (localctx IOpt_granted_byContext) { localctx = NewOpt_granted_byContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 576, PostgreSQLParserRULE_opt_granted_by) p.SetState(5182) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserGRANTED: p.EnterOuterAlt(localctx, 1) { p.SetState(5178) p.Match(PostgreSQLParserGRANTED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5179) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5180) p.Rolespec() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCASCADE, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserRESTRICT, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterdefaultprivilegesstmtContext is an interface to support dynamic dispatch. type IAlterdefaultprivilegesstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode DEFAULT() antlr.TerminalNode PRIVILEGES() antlr.TerminalNode Defacloptionlist() IDefacloptionlistContext Defaclaction() IDefaclactionContext // IsAlterdefaultprivilegesstmtContext differentiates from other interfaces. IsAlterdefaultprivilegesstmtContext() } type AlterdefaultprivilegesstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterdefaultprivilegesstmtContext() *AlterdefaultprivilegesstmtContext { var p = new(AlterdefaultprivilegesstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterdefaultprivilegesstmt return p } func InitEmptyAlterdefaultprivilegesstmtContext(p *AlterdefaultprivilegesstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterdefaultprivilegesstmt } func (*AlterdefaultprivilegesstmtContext) IsAlterdefaultprivilegesstmtContext() {} func NewAlterdefaultprivilegesstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterdefaultprivilegesstmtContext { var p = new(AlterdefaultprivilegesstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterdefaultprivilegesstmt return p } func (s *AlterdefaultprivilegesstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterdefaultprivilegesstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterdefaultprivilegesstmtContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *AlterdefaultprivilegesstmtContext) PRIVILEGES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRIVILEGES, 0) } func (s *AlterdefaultprivilegesstmtContext) Defacloptionlist() IDefacloptionlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDefacloptionlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDefacloptionlistContext) } func (s *AlterdefaultprivilegesstmtContext) Defaclaction() IDefaclactionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDefaclactionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDefaclactionContext) } func (s *AlterdefaultprivilegesstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterdefaultprivilegesstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterdefaultprivilegesstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterdefaultprivilegesstmt(s) } } func (s *AlterdefaultprivilegesstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterdefaultprivilegesstmt(s) } } func (s *AlterdefaultprivilegesstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterdefaultprivilegesstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterdefaultprivilegesstmt() (localctx IAlterdefaultprivilegesstmtContext) { localctx = NewAlterdefaultprivilegesstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 578, PostgreSQLParserRULE_alterdefaultprivilegesstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(5184) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5185) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5186) p.Match(PostgreSQLParserPRIVILEGES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5187) p.Defacloptionlist() } { p.SetState(5188) p.Defaclaction() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDefacloptionlistContext is an interface to support dynamic dispatch. type IDefacloptionlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllDefacloption() []IDefacloptionContext Defacloption(i int) IDefacloptionContext // IsDefacloptionlistContext differentiates from other interfaces. IsDefacloptionlistContext() } type DefacloptionlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDefacloptionlistContext() *DefacloptionlistContext { var p = new(DefacloptionlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_defacloptionlist return p } func InitEmptyDefacloptionlistContext(p *DefacloptionlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_defacloptionlist } func (*DefacloptionlistContext) IsDefacloptionlistContext() {} func NewDefacloptionlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefacloptionlistContext { var p = new(DefacloptionlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_defacloptionlist return p } func (s *DefacloptionlistContext) GetParser() antlr.Parser { return s.parser } func (s *DefacloptionlistContext) AllDefacloption() []IDefacloptionContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IDefacloptionContext); ok { len++ } } tst := make([]IDefacloptionContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IDefacloptionContext); ok { tst[i] = t.(IDefacloptionContext) i++ } } return tst } func (s *DefacloptionlistContext) Defacloption(i int) IDefacloptionContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDefacloptionContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IDefacloptionContext) } func (s *DefacloptionlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *DefacloptionlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DefacloptionlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDefacloptionlist(s) } } func (s *DefacloptionlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDefacloptionlist(s) } } func (s *DefacloptionlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDefacloptionlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Defacloptionlist() (localctx IDefacloptionlistContext) { localctx = NewDefacloptionlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 580, PostgreSQLParserRULE_defacloptionlist) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(5193) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserFOR || _la == PostgreSQLParserIN_P { { p.SetState(5190) p.Defacloption() } p.SetState(5195) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDefacloptionContext is an interface to support dynamic dispatch. type IDefacloptionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures IN_P() antlr.TerminalNode SCHEMA() antlr.TerminalNode Name_list() IName_listContext FOR() antlr.TerminalNode ROLE() antlr.TerminalNode Role_list() IRole_listContext USER() antlr.TerminalNode // IsDefacloptionContext differentiates from other interfaces. IsDefacloptionContext() } type DefacloptionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDefacloptionContext() *DefacloptionContext { var p = new(DefacloptionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_defacloption return p } func InitEmptyDefacloptionContext(p *DefacloptionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_defacloption } func (*DefacloptionContext) IsDefacloptionContext() {} func NewDefacloptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefacloptionContext { var p = new(DefacloptionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_defacloption return p } func (s *DefacloptionContext) GetParser() antlr.Parser { return s.parser } func (s *DefacloptionContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *DefacloptionContext) SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMA, 0) } func (s *DefacloptionContext) Name_list() IName_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IName_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IName_listContext) } func (s *DefacloptionContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *DefacloptionContext) ROLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLE, 0) } func (s *DefacloptionContext) Role_list() IRole_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRole_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRole_listContext) } func (s *DefacloptionContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *DefacloptionContext) GetRuleContext() antlr.RuleContext { return s } func (s *DefacloptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DefacloptionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDefacloption(s) } } func (s *DefacloptionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDefacloption(s) } } func (s *DefacloptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDefacloption(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Defacloption() (localctx IDefacloptionContext) { localctx = NewDefacloptionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 582, PostgreSQLParserRULE_defacloption) p.SetState(5205) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 247, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5196) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5197) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5198) p.Name_list() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5199) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5200) p.Match(PostgreSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5201) p.Role_list() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(5202) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5203) p.Match(PostgreSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5204) p.Role_list() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDefaclactionContext is an interface to support dynamic dispatch. type IDefaclactionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures GRANT() antlr.TerminalNode Privileges() IPrivilegesContext ON() antlr.TerminalNode Defacl_privilege_target() IDefacl_privilege_targetContext TO() antlr.TerminalNode Grantee_list() IGrantee_listContext Opt_grant_grant_option() IOpt_grant_grant_optionContext REVOKE() antlr.TerminalNode FROM() antlr.TerminalNode Opt_drop_behavior() IOpt_drop_behaviorContext OPTION() antlr.TerminalNode FOR() antlr.TerminalNode // IsDefaclactionContext differentiates from other interfaces. IsDefaclactionContext() } type DefaclactionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDefaclactionContext() *DefaclactionContext { var p = new(DefaclactionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_defaclaction return p } func InitEmptyDefaclactionContext(p *DefaclactionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_defaclaction } func (*DefaclactionContext) IsDefaclactionContext() {} func NewDefaclactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefaclactionContext { var p = new(DefaclactionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_defaclaction return p } func (s *DefaclactionContext) GetParser() antlr.Parser { return s.parser } func (s *DefaclactionContext) GRANT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGRANT, 0) } func (s *DefaclactionContext) Privileges() IPrivilegesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPrivilegesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPrivilegesContext) } func (s *DefaclactionContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *DefaclactionContext) Defacl_privilege_target() IDefacl_privilege_targetContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDefacl_privilege_targetContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDefacl_privilege_targetContext) } func (s *DefaclactionContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *DefaclactionContext) Grantee_list() IGrantee_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGrantee_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGrantee_listContext) } func (s *DefaclactionContext) Opt_grant_grant_option() IOpt_grant_grant_optionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_grant_grant_optionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_grant_grant_optionContext) } func (s *DefaclactionContext) REVOKE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREVOKE, 0) } func (s *DefaclactionContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *DefaclactionContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *DefaclactionContext) OPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPTION, 0) } func (s *DefaclactionContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *DefaclactionContext) GetRuleContext() antlr.RuleContext { return s } func (s *DefaclactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DefaclactionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDefaclaction(s) } } func (s *DefaclactionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDefaclaction(s) } } func (s *DefaclactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDefaclaction(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Defaclaction() (localctx IDefaclactionContext) { localctx = NewDefaclactionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 584, PostgreSQLParserRULE_defaclaction) p.SetState(5234) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 248, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5207) p.Match(PostgreSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5208) p.Privileges() } { p.SetState(5209) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5210) p.Defacl_privilege_target() } { p.SetState(5211) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5212) p.Grantee_list() } { p.SetState(5213) p.Opt_grant_grant_option() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5215) p.Match(PostgreSQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5216) p.Privileges() } { p.SetState(5217) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5218) p.Defacl_privilege_target() } { p.SetState(5219) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5220) p.Grantee_list() } { p.SetState(5221) p.Opt_drop_behavior() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(5223) p.Match(PostgreSQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5224) p.Match(PostgreSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5225) p.Match(PostgreSQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5226) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5227) p.Privileges() } { p.SetState(5228) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5229) p.Defacl_privilege_target() } { p.SetState(5230) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5231) p.Grantee_list() } { p.SetState(5232) p.Opt_drop_behavior() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDefacl_privilege_targetContext is an interface to support dynamic dispatch. type IDefacl_privilege_targetContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TABLES() antlr.TerminalNode FUNCTIONS() antlr.TerminalNode ROUTINES() antlr.TerminalNode SEQUENCES() antlr.TerminalNode TYPES_P() antlr.TerminalNode SCHEMAS() antlr.TerminalNode // IsDefacl_privilege_targetContext differentiates from other interfaces. IsDefacl_privilege_targetContext() } type Defacl_privilege_targetContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDefacl_privilege_targetContext() *Defacl_privilege_targetContext { var p = new(Defacl_privilege_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_defacl_privilege_target return p } func InitEmptyDefacl_privilege_targetContext(p *Defacl_privilege_targetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_defacl_privilege_target } func (*Defacl_privilege_targetContext) IsDefacl_privilege_targetContext() {} func NewDefacl_privilege_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Defacl_privilege_targetContext { var p = new(Defacl_privilege_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_defacl_privilege_target return p } func (s *Defacl_privilege_targetContext) GetParser() antlr.Parser { return s.parser } func (s *Defacl_privilege_targetContext) TABLES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLES, 0) } func (s *Defacl_privilege_targetContext) FUNCTIONS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTIONS, 0) } func (s *Defacl_privilege_targetContext) ROUTINES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUTINES, 0) } func (s *Defacl_privilege_targetContext) SEQUENCES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEQUENCES, 0) } func (s *Defacl_privilege_targetContext) TYPES_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPES_P, 0) } func (s *Defacl_privilege_targetContext) SCHEMAS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMAS, 0) } func (s *Defacl_privilege_targetContext) GetRuleContext() antlr.RuleContext { return s } func (s *Defacl_privilege_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Defacl_privilege_targetContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDefacl_privilege_target(s) } } func (s *Defacl_privilege_targetContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDefacl_privilege_target(s) } } func (s *Defacl_privilege_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDefacl_privilege_target(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Defacl_privilege_target() (localctx IDefacl_privilege_targetContext) { localctx = NewDefacl_privilege_targetContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 586, PostgreSQLParserRULE_defacl_privilege_target) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5236) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserFUNCTIONS || ((int64((_la-322)) & ^0x3f) == 0 && ((int64(1)<<(_la-322))&4297064449) != 0) || _la == PostgreSQLParserROUTINES || _la == PostgreSQLParserSCHEMAS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IIndexstmtContext is an interface to support dynamic dispatch. type IIndexstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode Opt_unique() IOpt_uniqueContext INDEX() antlr.TerminalNode Opt_concurrently() IOpt_concurrentlyContext Opt_index_name() IOpt_index_nameContext ON() antlr.TerminalNode Relation_expr() IRelation_exprContext Access_method_clause() IAccess_method_clauseContext OPEN_PAREN() antlr.TerminalNode Index_params() IIndex_paramsContext CLOSE_PAREN() antlr.TerminalNode Opt_include() IOpt_includeContext Opt_reloptions() IOpt_reloptionsContext Opttablespace() IOpttablespaceContext Where_clause() IWhere_clauseContext IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode Name() INameContext // IsIndexstmtContext differentiates from other interfaces. IsIndexstmtContext() } type IndexstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyIndexstmtContext() *IndexstmtContext { var p = new(IndexstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_indexstmt return p } func InitEmptyIndexstmtContext(p *IndexstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_indexstmt } func (*IndexstmtContext) IsIndexstmtContext() {} func NewIndexstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexstmtContext { var p = new(IndexstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_indexstmt return p } func (s *IndexstmtContext) GetParser() antlr.Parser { return s.parser } func (s *IndexstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *IndexstmtContext) Opt_unique() IOpt_uniqueContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_uniqueContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_uniqueContext) } func (s *IndexstmtContext) INDEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINDEX, 0) } func (s *IndexstmtContext) Opt_concurrently() IOpt_concurrentlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_concurrentlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_concurrentlyContext) } func (s *IndexstmtContext) Opt_index_name() IOpt_index_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_index_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_index_nameContext) } func (s *IndexstmtContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *IndexstmtContext) Relation_expr() IRelation_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRelation_exprContext) } func (s *IndexstmtContext) Access_method_clause() IAccess_method_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAccess_method_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAccess_method_clauseContext) } func (s *IndexstmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *IndexstmtContext) Index_params() IIndex_paramsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndex_paramsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIndex_paramsContext) } func (s *IndexstmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *IndexstmtContext) Opt_include() IOpt_includeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_includeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_includeContext) } func (s *IndexstmtContext) Opt_reloptions() IOpt_reloptionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_reloptionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_reloptionsContext) } func (s *IndexstmtContext) Opttablespace() IOpttablespaceContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttablespaceContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttablespaceContext) } func (s *IndexstmtContext) Where_clause() IWhere_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWhere_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWhere_clauseContext) } func (s *IndexstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *IndexstmtContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *IndexstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *IndexstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *IndexstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *IndexstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *IndexstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterIndexstmt(s) } } func (s *IndexstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitIndexstmt(s) } } func (s *IndexstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitIndexstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Indexstmt() (localctx IIndexstmtContext) { localctx = NewIndexstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 588, PostgreSQLParserRULE_indexstmt) p.SetState(5273) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 249, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5238) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5239) p.Opt_unique() } { p.SetState(5240) p.Match(PostgreSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5241) p.Opt_concurrently() } { p.SetState(5242) p.Opt_index_name() } { p.SetState(5243) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5244) p.Relation_expr() } { p.SetState(5245) p.Access_method_clause() } { p.SetState(5246) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5247) p.Index_params() } { p.SetState(5248) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5249) p.Opt_include() } { p.SetState(5250) p.Opt_reloptions() } { p.SetState(5251) p.Opttablespace() } { p.SetState(5252) p.Where_clause() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5254) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5255) p.Opt_unique() } { p.SetState(5256) p.Match(PostgreSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5257) p.Opt_concurrently() } { p.SetState(5258) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5259) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5260) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5261) p.Name() } { p.SetState(5262) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5263) p.Relation_expr() } { p.SetState(5264) p.Access_method_clause() } { p.SetState(5265) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5266) p.Index_params() } { p.SetState(5267) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5268) p.Opt_include() } { p.SetState(5269) p.Opt_reloptions() } { p.SetState(5270) p.Opttablespace() } { p.SetState(5271) p.Where_clause() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_uniqueContext is an interface to support dynamic dispatch. type IOpt_uniqueContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures UNIQUE() antlr.TerminalNode // IsOpt_uniqueContext differentiates from other interfaces. IsOpt_uniqueContext() } type Opt_uniqueContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_uniqueContext() *Opt_uniqueContext { var p = new(Opt_uniqueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_unique return p } func InitEmptyOpt_uniqueContext(p *Opt_uniqueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_unique } func (*Opt_uniqueContext) IsOpt_uniqueContext() {} func NewOpt_uniqueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_uniqueContext { var p = new(Opt_uniqueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_unique return p } func (s *Opt_uniqueContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_uniqueContext) UNIQUE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNIQUE, 0) } func (s *Opt_uniqueContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_uniqueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_uniqueContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_unique(s) } } func (s *Opt_uniqueContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_unique(s) } } func (s *Opt_uniqueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_unique(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_unique() (localctx IOpt_uniqueContext) { localctx = NewOpt_uniqueContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 590, PostgreSQLParserRULE_opt_unique) p.SetState(5277) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUNIQUE: p.EnterOuterAlt(localctx, 1) { p.SetState(5275) p.Match(PostgreSQLParserUNIQUE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserINDEX: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_concurrentlyContext is an interface to support dynamic dispatch. type IOpt_concurrentlyContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CONCURRENTLY() antlr.TerminalNode // IsOpt_concurrentlyContext differentiates from other interfaces. IsOpt_concurrentlyContext() } type Opt_concurrentlyContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_concurrentlyContext() *Opt_concurrentlyContext { var p = new(Opt_concurrentlyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_concurrently return p } func InitEmptyOpt_concurrentlyContext(p *Opt_concurrentlyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_concurrently } func (*Opt_concurrentlyContext) IsOpt_concurrentlyContext() {} func NewOpt_concurrentlyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_concurrentlyContext { var p = new(Opt_concurrentlyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_concurrently return p } func (s *Opt_concurrentlyContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_concurrentlyContext) CONCURRENTLY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONCURRENTLY, 0) } func (s *Opt_concurrentlyContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_concurrentlyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_concurrentlyContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_concurrently(s) } } func (s *Opt_concurrentlyContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_concurrently(s) } } func (s *Opt_concurrentlyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_concurrently(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_concurrently() (localctx IOpt_concurrentlyContext) { localctx = NewOpt_concurrentlyContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 592, PostgreSQLParserRULE_opt_concurrently) p.SetState(5281) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCONCURRENTLY: p.EnterOuterAlt(localctx, 1) { p.SetState(5279) p.Match(PostgreSQLParserCONCURRENTLY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserON, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_index_nameContext is an interface to support dynamic dispatch. type IOpt_index_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Name() INameContext // IsOpt_index_nameContext differentiates from other interfaces. IsOpt_index_nameContext() } type Opt_index_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_index_nameContext() *Opt_index_nameContext { var p = new(Opt_index_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_index_name return p } func InitEmptyOpt_index_nameContext(p *Opt_index_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_index_name } func (*Opt_index_nameContext) IsOpt_index_nameContext() {} func NewOpt_index_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_index_nameContext { var p = new(Opt_index_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_index_name return p } func (s *Opt_index_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_index_nameContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *Opt_index_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_index_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_index_name(s) } } func (s *Opt_index_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_index_name(s) } } func (s *Opt_index_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_index_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_index_name() (localctx IOpt_index_nameContext) { localctx = NewOpt_index_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 594, PostgreSQLParserRULE_opt_index_name) p.SetState(5285) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(5283) p.Name() } case PostgreSQLParserON: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAccess_method_clauseContext is an interface to support dynamic dispatch. type IAccess_method_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USING() antlr.TerminalNode Name() INameContext // IsAccess_method_clauseContext differentiates from other interfaces. IsAccess_method_clauseContext() } type Access_method_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAccess_method_clauseContext() *Access_method_clauseContext { var p = new(Access_method_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_access_method_clause return p } func InitEmptyAccess_method_clauseContext(p *Access_method_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_access_method_clause } func (*Access_method_clauseContext) IsAccess_method_clauseContext() {} func NewAccess_method_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Access_method_clauseContext { var p = new(Access_method_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_access_method_clause return p } func (s *Access_method_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Access_method_clauseContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *Access_method_clauseContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *Access_method_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Access_method_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Access_method_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAccess_method_clause(s) } } func (s *Access_method_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAccess_method_clause(s) } } func (s *Access_method_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAccess_method_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Access_method_clause() (localctx IAccess_method_clauseContext) { localctx = NewAccess_method_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 596, PostgreSQLParserRULE_access_method_clause) p.SetState(5290) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 1) { p.SetState(5287) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5288) p.Name() } case PostgreSQLParserOPEN_PAREN: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IIndex_paramsContext is an interface to support dynamic dispatch. type IIndex_paramsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllIndex_elem() []IIndex_elemContext Index_elem(i int) IIndex_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsIndex_paramsContext differentiates from other interfaces. IsIndex_paramsContext() } type Index_paramsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyIndex_paramsContext() *Index_paramsContext { var p = new(Index_paramsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_index_params return p } func InitEmptyIndex_paramsContext(p *Index_paramsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_index_params } func (*Index_paramsContext) IsIndex_paramsContext() {} func NewIndex_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_paramsContext { var p = new(Index_paramsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_index_params return p } func (s *Index_paramsContext) GetParser() antlr.Parser { return s.parser } func (s *Index_paramsContext) AllIndex_elem() []IIndex_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IIndex_elemContext); ok { len++ } } tst := make([]IIndex_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IIndex_elemContext); ok { tst[i] = t.(IIndex_elemContext) i++ } } return tst } func (s *Index_paramsContext) Index_elem(i int) IIndex_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndex_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IIndex_elemContext) } func (s *Index_paramsContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Index_paramsContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Index_paramsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Index_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Index_paramsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterIndex_params(s) } } func (s *Index_paramsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitIndex_params(s) } } func (s *Index_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitIndex_params(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Index_params() (localctx IIndex_paramsContext) { localctx = NewIndex_paramsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 598, PostgreSQLParserRULE_index_params) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5292) p.Index_elem() } p.SetState(5297) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(5293) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5294) p.Index_elem() } p.SetState(5299) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IIndex_elem_optionsContext is an interface to support dynamic dispatch. type IIndex_elem_optionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_collate() IOpt_collateContext Opt_class() IOpt_classContext Opt_asc_desc() IOpt_asc_descContext Opt_nulls_order() IOpt_nulls_orderContext Any_name() IAny_nameContext Reloptions() IReloptionsContext // IsIndex_elem_optionsContext differentiates from other interfaces. IsIndex_elem_optionsContext() } type Index_elem_optionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyIndex_elem_optionsContext() *Index_elem_optionsContext { var p = new(Index_elem_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_index_elem_options return p } func InitEmptyIndex_elem_optionsContext(p *Index_elem_optionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_index_elem_options } func (*Index_elem_optionsContext) IsIndex_elem_optionsContext() {} func NewIndex_elem_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_elem_optionsContext { var p = new(Index_elem_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_index_elem_options return p } func (s *Index_elem_optionsContext) GetParser() antlr.Parser { return s.parser } func (s *Index_elem_optionsContext) Opt_collate() IOpt_collateContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_collateContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_collateContext) } func (s *Index_elem_optionsContext) Opt_class() IOpt_classContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_classContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_classContext) } func (s *Index_elem_optionsContext) Opt_asc_desc() IOpt_asc_descContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_asc_descContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_asc_descContext) } func (s *Index_elem_optionsContext) Opt_nulls_order() IOpt_nulls_orderContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_nulls_orderContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_nulls_orderContext) } func (s *Index_elem_optionsContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *Index_elem_optionsContext) Reloptions() IReloptionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReloptionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReloptionsContext) } func (s *Index_elem_optionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Index_elem_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Index_elem_optionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterIndex_elem_options(s) } } func (s *Index_elem_optionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitIndex_elem_options(s) } } func (s *Index_elem_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitIndex_elem_options(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Index_elem_options() (localctx IIndex_elem_optionsContext) { localctx = NewIndex_elem_optionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 600, PostgreSQLParserRULE_index_elem_options) p.SetState(5311) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 255, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5300) p.Opt_collate() } { p.SetState(5301) p.Opt_class() } { p.SetState(5302) p.Opt_asc_desc() } { p.SetState(5303) p.Opt_nulls_order() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5305) p.Opt_collate() } { p.SetState(5306) p.Any_name() } { p.SetState(5307) p.Reloptions() } { p.SetState(5308) p.Opt_asc_desc() } { p.SetState(5309) p.Opt_nulls_order() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IIndex_elemContext is an interface to support dynamic dispatch. type IIndex_elemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext Index_elem_options() IIndex_elem_optionsContext Func_expr_windowless() IFunc_expr_windowlessContext OPEN_PAREN() antlr.TerminalNode A_expr() IA_exprContext CLOSE_PAREN() antlr.TerminalNode // IsIndex_elemContext differentiates from other interfaces. IsIndex_elemContext() } type Index_elemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyIndex_elemContext() *Index_elemContext { var p = new(Index_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_index_elem return p } func InitEmptyIndex_elemContext(p *Index_elemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_index_elem } func (*Index_elemContext) IsIndex_elemContext() {} func NewIndex_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_elemContext { var p = new(Index_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_index_elem return p } func (s *Index_elemContext) GetParser() antlr.Parser { return s.parser } func (s *Index_elemContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Index_elemContext) Index_elem_options() IIndex_elem_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndex_elem_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIndex_elem_optionsContext) } func (s *Index_elemContext) Func_expr_windowless() IFunc_expr_windowlessContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_expr_windowlessContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_expr_windowlessContext) } func (s *Index_elemContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Index_elemContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Index_elemContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Index_elemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Index_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Index_elemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterIndex_elem(s) } } func (s *Index_elemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitIndex_elem(s) } } func (s *Index_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitIndex_elem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Index_elem() (localctx IIndex_elemContext) { localctx = NewIndex_elemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 602, PostgreSQLParserRULE_index_elem) p.SetState(5324) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 256, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5313) p.Colid() } { p.SetState(5314) p.Index_elem_options() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5316) p.Func_expr_windowless() } { p.SetState(5317) p.Index_elem_options() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(5319) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5320) p.A_expr() } { p.SetState(5321) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5322) p.Index_elem_options() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_includeContext is an interface to support dynamic dispatch. type IOpt_includeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures INCLUDE() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Index_including_params() IIndex_including_paramsContext CLOSE_PAREN() antlr.TerminalNode // IsOpt_includeContext differentiates from other interfaces. IsOpt_includeContext() } type Opt_includeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_includeContext() *Opt_includeContext { var p = new(Opt_includeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_include return p } func InitEmptyOpt_includeContext(p *Opt_includeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_include } func (*Opt_includeContext) IsOpt_includeContext() {} func NewOpt_includeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_includeContext { var p = new(Opt_includeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_include return p } func (s *Opt_includeContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_includeContext) INCLUDE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINCLUDE, 0) } func (s *Opt_includeContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Opt_includeContext) Index_including_params() IIndex_including_paramsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndex_including_paramsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIndex_including_paramsContext) } func (s *Opt_includeContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Opt_includeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_includeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_includeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_include(s) } } func (s *Opt_includeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_include(s) } } func (s *Opt_includeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_include(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_include() (localctx IOpt_includeContext) { localctx = NewOpt_includeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 604, PostgreSQLParserRULE_opt_include) p.SetState(5332) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserINCLUDE: p.EnterOuterAlt(localctx, 1) { p.SetState(5326) p.Match(PostgreSQLParserINCLUDE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5327) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5328) p.Index_including_params() } { p.SetState(5329) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWHERE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTABLESPACE, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IIndex_including_paramsContext is an interface to support dynamic dispatch. type IIndex_including_paramsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllIndex_elem() []IIndex_elemContext Index_elem(i int) IIndex_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsIndex_including_paramsContext differentiates from other interfaces. IsIndex_including_paramsContext() } type Index_including_paramsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyIndex_including_paramsContext() *Index_including_paramsContext { var p = new(Index_including_paramsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_index_including_params return p } func InitEmptyIndex_including_paramsContext(p *Index_including_paramsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_index_including_params } func (*Index_including_paramsContext) IsIndex_including_paramsContext() {} func NewIndex_including_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_including_paramsContext { var p = new(Index_including_paramsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_index_including_params return p } func (s *Index_including_paramsContext) GetParser() antlr.Parser { return s.parser } func (s *Index_including_paramsContext) AllIndex_elem() []IIndex_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IIndex_elemContext); ok { len++ } } tst := make([]IIndex_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IIndex_elemContext); ok { tst[i] = t.(IIndex_elemContext) i++ } } return tst } func (s *Index_including_paramsContext) Index_elem(i int) IIndex_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndex_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IIndex_elemContext) } func (s *Index_including_paramsContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Index_including_paramsContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Index_including_paramsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Index_including_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Index_including_paramsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterIndex_including_params(s) } } func (s *Index_including_paramsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitIndex_including_params(s) } } func (s *Index_including_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitIndex_including_params(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Index_including_params() (localctx IIndex_including_paramsContext) { localctx = NewIndex_including_paramsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 606, PostgreSQLParserRULE_index_including_params) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5334) p.Index_elem() } p.SetState(5339) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(5335) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5336) p.Index_elem() } p.SetState(5341) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_collateContext is an interface to support dynamic dispatch. type IOpt_collateContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures COLLATE() antlr.TerminalNode Any_name() IAny_nameContext // IsOpt_collateContext differentiates from other interfaces. IsOpt_collateContext() } type Opt_collateContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_collateContext() *Opt_collateContext { var p = new(Opt_collateContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_collate return p } func InitEmptyOpt_collateContext(p *Opt_collateContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_collate } func (*Opt_collateContext) IsOpt_collateContext() {} func NewOpt_collateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_collateContext { var p = new(Opt_collateContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_collate return p } func (s *Opt_collateContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_collateContext) COLLATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATE, 0) } func (s *Opt_collateContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *Opt_collateContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_collateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_collateContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_collate(s) } } func (s *Opt_collateContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_collate(s) } } func (s *Opt_collateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_collate(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_collate() (localctx IOpt_collateContext) { localctx = NewOpt_collateContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 608, PostgreSQLParserRULE_opt_collate) p.SetState(5345) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 259, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5342) p.Match(PostgreSQLParserCOLLATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5343) p.Any_name() } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_classContext is an interface to support dynamic dispatch. type IOpt_classContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Any_name() IAny_nameContext // IsOpt_classContext differentiates from other interfaces. IsOpt_classContext() } type Opt_classContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_classContext() *Opt_classContext { var p = new(Opt_classContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_class return p } func InitEmptyOpt_classContext(p *Opt_classContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_class } func (*Opt_classContext) IsOpt_classContext() {} func NewOpt_classContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_classContext { var p = new(Opt_classContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_class return p } func (s *Opt_classContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_classContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *Opt_classContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_classContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_classContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_class(s) } } func (s *Opt_classContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_class(s) } } func (s *Opt_classContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_class(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_class() (localctx IOpt_classContext) { localctx = NewOpt_classContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 610, PostgreSQLParserRULE_opt_class) p.SetState(5349) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 260, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5347) p.Any_name() } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_asc_descContext is an interface to support dynamic dispatch. type IOpt_asc_descContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ASC() antlr.TerminalNode DESC() antlr.TerminalNode // IsOpt_asc_descContext differentiates from other interfaces. IsOpt_asc_descContext() } type Opt_asc_descContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_asc_descContext() *Opt_asc_descContext { var p = new(Opt_asc_descContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_asc_desc return p } func InitEmptyOpt_asc_descContext(p *Opt_asc_descContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_asc_desc } func (*Opt_asc_descContext) IsOpt_asc_descContext() {} func NewOpt_asc_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_asc_descContext { var p = new(Opt_asc_descContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_asc_desc return p } func (s *Opt_asc_descContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_asc_descContext) ASC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserASC, 0) } func (s *Opt_asc_descContext) DESC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDESC, 0) } func (s *Opt_asc_descContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_asc_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_asc_descContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_asc_desc(s) } } func (s *Opt_asc_descContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_asc_desc(s) } } func (s *Opt_asc_descContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_asc_desc(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_asc_desc() (localctx IOpt_asc_descContext) { localctx = NewOpt_asc_descContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 612, PostgreSQLParserRULE_opt_asc_desc) p.SetState(5354) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserASC: p.EnterOuterAlt(localctx, 1) { p.SetState(5351) p.Match(PostgreSQLParserASC) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserDESC: p.EnterOuterAlt(localctx, 2) { p.SetState(5352) p.Match(PostgreSQLParserDESC) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserNULLS_P, PostgreSQLParserPREPARE, PostgreSQLParserRANGE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserGROUPS, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 3) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_nulls_orderContext is an interface to support dynamic dispatch. type IOpt_nulls_orderContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NULLS_P() antlr.TerminalNode FIRST_P() antlr.TerminalNode LAST_P() antlr.TerminalNode // IsOpt_nulls_orderContext differentiates from other interfaces. IsOpt_nulls_orderContext() } type Opt_nulls_orderContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_nulls_orderContext() *Opt_nulls_orderContext { var p = new(Opt_nulls_orderContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_nulls_order return p } func InitEmptyOpt_nulls_orderContext(p *Opt_nulls_orderContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_nulls_order } func (*Opt_nulls_orderContext) IsOpt_nulls_orderContext() {} func NewOpt_nulls_orderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_nulls_orderContext { var p = new(Opt_nulls_orderContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_nulls_order return p } func (s *Opt_nulls_orderContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_nulls_orderContext) NULLS_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULLS_P, 0) } func (s *Opt_nulls_orderContext) FIRST_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFIRST_P, 0) } func (s *Opt_nulls_orderContext) LAST_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLAST_P, 0) } func (s *Opt_nulls_orderContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_nulls_orderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_nulls_orderContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_nulls_order(s) } } func (s *Opt_nulls_orderContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_nulls_order(s) } } func (s *Opt_nulls_orderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_nulls_order(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_nulls_order() (localctx IOpt_nulls_orderContext) { localctx = NewOpt_nulls_orderContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 614, PostgreSQLParserRULE_opt_nulls_order) p.SetState(5361) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 262, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5356) p.Match(PostgreSQLParserNULLS_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5357) p.Match(PostgreSQLParserFIRST_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5358) p.Match(PostgreSQLParserNULLS_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5359) p.Match(PostgreSQLParserLAST_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatefunctionstmtContext is an interface to support dynamic dispatch. type ICreatefunctionstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode Opt_or_replace() IOpt_or_replaceContext Func_name() IFunc_nameContext Func_args_with_defaults() IFunc_args_with_defaultsContext Createfunc_opt_list() ICreatefunc_opt_listContext FUNCTION() antlr.TerminalNode PROCEDURE() antlr.TerminalNode RETURNS() antlr.TerminalNode Func_return() IFunc_returnContext TABLE() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Table_func_column_list() ITable_func_column_listContext CLOSE_PAREN() antlr.TerminalNode // IsCreatefunctionstmtContext differentiates from other interfaces. IsCreatefunctionstmtContext() } type CreatefunctionstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatefunctionstmtContext() *CreatefunctionstmtContext { var p = new(CreatefunctionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createfunctionstmt return p } func InitEmptyCreatefunctionstmtContext(p *CreatefunctionstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createfunctionstmt } func (*CreatefunctionstmtContext) IsCreatefunctionstmtContext() {} func NewCreatefunctionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatefunctionstmtContext { var p = new(CreatefunctionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createfunctionstmt return p } func (s *CreatefunctionstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreatefunctionstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreatefunctionstmtContext) Opt_or_replace() IOpt_or_replaceContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_or_replaceContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_or_replaceContext) } func (s *CreatefunctionstmtContext) Func_name() IFunc_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_nameContext) } func (s *CreatefunctionstmtContext) Func_args_with_defaults() IFunc_args_with_defaultsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_args_with_defaultsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_args_with_defaultsContext) } func (s *CreatefunctionstmtContext) Createfunc_opt_list() ICreatefunc_opt_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatefunc_opt_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatefunc_opt_listContext) } func (s *CreatefunctionstmtContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *CreatefunctionstmtContext) PROCEDURE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURE, 0) } func (s *CreatefunctionstmtContext) RETURNS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRETURNS, 0) } func (s *CreatefunctionstmtContext) Func_return() IFunc_returnContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_returnContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_returnContext) } func (s *CreatefunctionstmtContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *CreatefunctionstmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *CreatefunctionstmtContext) Table_func_column_list() ITable_func_column_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITable_func_column_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITable_func_column_listContext) } func (s *CreatefunctionstmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *CreatefunctionstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreatefunctionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreatefunctionstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatefunctionstmt(s) } } func (s *CreatefunctionstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatefunctionstmt(s) } } func (s *CreatefunctionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatefunctionstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createfunctionstmt() (localctx ICreatefunctionstmtContext) { localctx = NewCreatefunctionstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 616, PostgreSQLParserRULE_createfunctionstmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5363) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5364) p.Opt_or_replace() } { p.SetState(5365) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserFUNCTION || _la == PostgreSQLParserPROCEDURE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(5366) p.Func_name() } { p.SetState(5367) p.Func_args_with_defaults() } p.SetState(5377) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 264, p.GetParserRuleContext()) == 1 { { p.SetState(5368) p.Match(PostgreSQLParserRETURNS) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(5375) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 263, p.GetParserRuleContext()) { case 1: { p.SetState(5369) p.Func_return() } case 2: { p.SetState(5370) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5371) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5372) p.Table_func_column_list() } { p.SetState(5373) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } } else if p.HasError() { // JIM goto errorExit } { p.SetState(5379) p.Createfunc_opt_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_or_replaceContext is an interface to support dynamic dispatch. type IOpt_or_replaceContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OR() antlr.TerminalNode REPLACE() antlr.TerminalNode // IsOpt_or_replaceContext differentiates from other interfaces. IsOpt_or_replaceContext() } type Opt_or_replaceContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_or_replaceContext() *Opt_or_replaceContext { var p = new(Opt_or_replaceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_or_replace return p } func InitEmptyOpt_or_replaceContext(p *Opt_or_replaceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_or_replace } func (*Opt_or_replaceContext) IsOpt_or_replaceContext() {} func NewOpt_or_replaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_or_replaceContext { var p = new(Opt_or_replaceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_or_replace return p } func (s *Opt_or_replaceContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_or_replaceContext) OR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOR, 0) } func (s *Opt_or_replaceContext) REPLACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREPLACE, 0) } func (s *Opt_or_replaceContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_or_replaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_or_replaceContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_or_replace(s) } } func (s *Opt_or_replaceContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_or_replace(s) } } func (s *Opt_or_replaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_or_replace(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_or_replace() (localctx IOpt_or_replaceContext) { localctx = NewOpt_or_replaceContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 618, PostgreSQLParserRULE_opt_or_replace) p.SetState(5384) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOR: p.EnterOuterAlt(localctx, 1) { p.SetState(5381) p.Match(PostgreSQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5382) p.Match(PostgreSQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserAGGREGATE, PostgreSQLParserFUNCTION, PostgreSQLParserLANGUAGE, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserRULE, PostgreSQLParserTRUSTED, PostgreSQLParserTRANSFORM: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_argsContext is an interface to support dynamic dispatch. type IFunc_argsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode CLOSE_PAREN() antlr.TerminalNode Func_args_list() IFunc_args_listContext // IsFunc_argsContext differentiates from other interfaces. IsFunc_argsContext() } type Func_argsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_argsContext() *Func_argsContext { var p = new(Func_argsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_args return p } func InitEmptyFunc_argsContext(p *Func_argsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_args } func (*Func_argsContext) IsFunc_argsContext() {} func NewFunc_argsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_argsContext { var p = new(Func_argsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_args return p } func (s *Func_argsContext) GetParser() antlr.Parser { return s.parser } func (s *Func_argsContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Func_argsContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Func_argsContext) Func_args_list() IFunc_args_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_args_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_args_listContext) } func (s *Func_argsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_argsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_argsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_args(s) } } func (s *Func_argsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_args(s) } } func (s *Func_argsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_args(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_args() (localctx IFunc_argsContext) { localctx = NewFunc_argsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 620, PostgreSQLParserRULE_func_args) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5386) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(5388) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&576460786949430277) != 0) || ((int64((_la-101)) & ^0x3f) == 0 && ((int64(1)<<(_la-101))&-31) != 0) || ((int64((_la-165)) & ^0x3f) == 0 && ((int64(1)<<(_la-165))&-1) != 0) || ((int64((_la-229)) & ^0x3f) == 0 && ((int64(1)<<(_la-229))&-18874369) != 0) || ((int64((_la-293)) & ^0x3f) == 0 && ((int64(1)<<(_la-293))&-1) != 0) || ((int64((_la-357)) & ^0x3f) == 0 && ((int64(1)<<(_la-357))&-1) != 0) || ((int64((_la-421)) & ^0x3f) == 0 && ((int64(1)<<(_la-421))&-8589934593) != 0) || ((int64((_la-485)) & ^0x3f) == 0 && ((int64(1)<<(_la-485))&-17181179905) != 0) || ((int64((_la-549)) & ^0x3f) == 0 && ((int64(1)<<(_la-549))&-1) != 0) || ((int64((_la-613)) & ^0x3f) == 0 && ((int64(1)<<(_la-613))&844425232121855) != 0) { { p.SetState(5387) p.Func_args_list() } } { p.SetState(5390) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_args_listContext is an interface to support dynamic dispatch. type IFunc_args_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllFunc_arg() []IFunc_argContext Func_arg(i int) IFunc_argContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsFunc_args_listContext differentiates from other interfaces. IsFunc_args_listContext() } type Func_args_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_args_listContext() *Func_args_listContext { var p = new(Func_args_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_args_list return p } func InitEmptyFunc_args_listContext(p *Func_args_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_args_list } func (*Func_args_listContext) IsFunc_args_listContext() {} func NewFunc_args_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_args_listContext { var p = new(Func_args_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_args_list return p } func (s *Func_args_listContext) GetParser() antlr.Parser { return s.parser } func (s *Func_args_listContext) AllFunc_arg() []IFunc_argContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IFunc_argContext); ok { len++ } } tst := make([]IFunc_argContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IFunc_argContext); ok { tst[i] = t.(IFunc_argContext) i++ } } return tst } func (s *Func_args_listContext) Func_arg(i int) IFunc_argContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_argContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IFunc_argContext) } func (s *Func_args_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Func_args_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Func_args_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_args_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_args_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_args_list(s) } } func (s *Func_args_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_args_list(s) } } func (s *Func_args_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_args_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_args_list() (localctx IFunc_args_listContext) { localctx = NewFunc_args_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 622, PostgreSQLParserRULE_func_args_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5392) p.Func_arg() } p.SetState(5397) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(5393) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5394) p.Func_arg() } p.SetState(5399) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunction_with_argtypes_listContext is an interface to support dynamic dispatch. type IFunction_with_argtypes_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllFunction_with_argtypes() []IFunction_with_argtypesContext Function_with_argtypes(i int) IFunction_with_argtypesContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsFunction_with_argtypes_listContext differentiates from other interfaces. IsFunction_with_argtypes_listContext() } type Function_with_argtypes_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunction_with_argtypes_listContext() *Function_with_argtypes_listContext { var p = new(Function_with_argtypes_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_function_with_argtypes_list return p } func InitEmptyFunction_with_argtypes_listContext(p *Function_with_argtypes_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_function_with_argtypes_list } func (*Function_with_argtypes_listContext) IsFunction_with_argtypes_listContext() {} func NewFunction_with_argtypes_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_with_argtypes_listContext { var p = new(Function_with_argtypes_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_function_with_argtypes_list return p } func (s *Function_with_argtypes_listContext) GetParser() antlr.Parser { return s.parser } func (s *Function_with_argtypes_listContext) AllFunction_with_argtypes() []IFunction_with_argtypesContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IFunction_with_argtypesContext); ok { len++ } } tst := make([]IFunction_with_argtypesContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IFunction_with_argtypesContext); ok { tst[i] = t.(IFunction_with_argtypesContext) i++ } } return tst } func (s *Function_with_argtypes_listContext) Function_with_argtypes(i int) IFunction_with_argtypesContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_with_argtypesContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IFunction_with_argtypesContext) } func (s *Function_with_argtypes_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Function_with_argtypes_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Function_with_argtypes_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Function_with_argtypes_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Function_with_argtypes_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunction_with_argtypes_list(s) } } func (s *Function_with_argtypes_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunction_with_argtypes_list(s) } } func (s *Function_with_argtypes_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunction_with_argtypes_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Function_with_argtypes_list() (localctx IFunction_with_argtypes_listContext) { localctx = NewFunction_with_argtypes_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 624, PostgreSQLParserRULE_function_with_argtypes_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5400) p.Function_with_argtypes() } p.SetState(5405) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(5401) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5402) p.Function_with_argtypes() } p.SetState(5407) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunction_with_argtypesContext is an interface to support dynamic dispatch. type IFunction_with_argtypesContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Func_name() IFunc_nameContext Func_args() IFunc_argsContext Type_func_name_keyword() IType_func_name_keywordContext Colid() IColidContext Indirection() IIndirectionContext // IsFunction_with_argtypesContext differentiates from other interfaces. IsFunction_with_argtypesContext() } type Function_with_argtypesContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunction_with_argtypesContext() *Function_with_argtypesContext { var p = new(Function_with_argtypesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_function_with_argtypes return p } func InitEmptyFunction_with_argtypesContext(p *Function_with_argtypesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_function_with_argtypes } func (*Function_with_argtypesContext) IsFunction_with_argtypesContext() {} func NewFunction_with_argtypesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_with_argtypesContext { var p = new(Function_with_argtypesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_function_with_argtypes return p } func (s *Function_with_argtypesContext) GetParser() antlr.Parser { return s.parser } func (s *Function_with_argtypesContext) Func_name() IFunc_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_nameContext) } func (s *Function_with_argtypesContext) Func_args() IFunc_argsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_argsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_argsContext) } func (s *Function_with_argtypesContext) Type_func_name_keyword() IType_func_name_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IType_func_name_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IType_func_name_keywordContext) } func (s *Function_with_argtypesContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Function_with_argtypesContext) Indirection() IIndirectionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndirectionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIndirectionContext) } func (s *Function_with_argtypesContext) GetRuleContext() antlr.RuleContext { return s } func (s *Function_with_argtypesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Function_with_argtypesContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunction_with_argtypes(s) } } func (s *Function_with_argtypesContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunction_with_argtypes(s) } } func (s *Function_with_argtypesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunction_with_argtypes(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Function_with_argtypes() (localctx IFunction_with_argtypesContext) { localctx = NewFunction_with_argtypesContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 626, PostgreSQLParserRULE_function_with_argtypes) var _la int p.SetState(5416) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 270, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5408) p.Func_name() } { p.SetState(5409) p.Func_args() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5411) p.Type_func_name_keyword() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(5412) p.Colid() } p.SetState(5414) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserOPEN_BRACKET || _la == PostgreSQLParserDOT { { p.SetState(5413) p.Indirection() } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_args_with_defaultsContext is an interface to support dynamic dispatch. type IFunc_args_with_defaultsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode CLOSE_PAREN() antlr.TerminalNode Func_args_with_defaults_list() IFunc_args_with_defaults_listContext // IsFunc_args_with_defaultsContext differentiates from other interfaces. IsFunc_args_with_defaultsContext() } type Func_args_with_defaultsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_args_with_defaultsContext() *Func_args_with_defaultsContext { var p = new(Func_args_with_defaultsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_args_with_defaults return p } func InitEmptyFunc_args_with_defaultsContext(p *Func_args_with_defaultsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_args_with_defaults } func (*Func_args_with_defaultsContext) IsFunc_args_with_defaultsContext() {} func NewFunc_args_with_defaultsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_args_with_defaultsContext { var p = new(Func_args_with_defaultsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_args_with_defaults return p } func (s *Func_args_with_defaultsContext) GetParser() antlr.Parser { return s.parser } func (s *Func_args_with_defaultsContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Func_args_with_defaultsContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Func_args_with_defaultsContext) Func_args_with_defaults_list() IFunc_args_with_defaults_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_args_with_defaults_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_args_with_defaults_listContext) } func (s *Func_args_with_defaultsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_args_with_defaultsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_args_with_defaultsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_args_with_defaults(s) } } func (s *Func_args_with_defaultsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_args_with_defaults(s) } } func (s *Func_args_with_defaultsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_args_with_defaults(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_args_with_defaults() (localctx IFunc_args_with_defaultsContext) { localctx = NewFunc_args_with_defaultsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 628, PostgreSQLParserRULE_func_args_with_defaults) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5418) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(5420) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&576460786949430277) != 0) || ((int64((_la-101)) & ^0x3f) == 0 && ((int64(1)<<(_la-101))&-31) != 0) || ((int64((_la-165)) & ^0x3f) == 0 && ((int64(1)<<(_la-165))&-1) != 0) || ((int64((_la-229)) & ^0x3f) == 0 && ((int64(1)<<(_la-229))&-18874369) != 0) || ((int64((_la-293)) & ^0x3f) == 0 && ((int64(1)<<(_la-293))&-1) != 0) || ((int64((_la-357)) & ^0x3f) == 0 && ((int64(1)<<(_la-357))&-1) != 0) || ((int64((_la-421)) & ^0x3f) == 0 && ((int64(1)<<(_la-421))&-8589934593) != 0) || ((int64((_la-485)) & ^0x3f) == 0 && ((int64(1)<<(_la-485))&-17181179905) != 0) || ((int64((_la-549)) & ^0x3f) == 0 && ((int64(1)<<(_la-549))&-1) != 0) || ((int64((_la-613)) & ^0x3f) == 0 && ((int64(1)<<(_la-613))&844425232121855) != 0) { { p.SetState(5419) p.Func_args_with_defaults_list() } } { p.SetState(5422) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_args_with_defaults_listContext is an interface to support dynamic dispatch. type IFunc_args_with_defaults_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllFunc_arg_with_default() []IFunc_arg_with_defaultContext Func_arg_with_default(i int) IFunc_arg_with_defaultContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsFunc_args_with_defaults_listContext differentiates from other interfaces. IsFunc_args_with_defaults_listContext() } type Func_args_with_defaults_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_args_with_defaults_listContext() *Func_args_with_defaults_listContext { var p = new(Func_args_with_defaults_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_args_with_defaults_list return p } func InitEmptyFunc_args_with_defaults_listContext(p *Func_args_with_defaults_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_args_with_defaults_list } func (*Func_args_with_defaults_listContext) IsFunc_args_with_defaults_listContext() {} func NewFunc_args_with_defaults_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_args_with_defaults_listContext { var p = new(Func_args_with_defaults_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_args_with_defaults_list return p } func (s *Func_args_with_defaults_listContext) GetParser() antlr.Parser { return s.parser } func (s *Func_args_with_defaults_listContext) AllFunc_arg_with_default() []IFunc_arg_with_defaultContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IFunc_arg_with_defaultContext); ok { len++ } } tst := make([]IFunc_arg_with_defaultContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IFunc_arg_with_defaultContext); ok { tst[i] = t.(IFunc_arg_with_defaultContext) i++ } } return tst } func (s *Func_args_with_defaults_listContext) Func_arg_with_default(i int) IFunc_arg_with_defaultContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_arg_with_defaultContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IFunc_arg_with_defaultContext) } func (s *Func_args_with_defaults_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Func_args_with_defaults_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Func_args_with_defaults_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_args_with_defaults_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_args_with_defaults_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_args_with_defaults_list(s) } } func (s *Func_args_with_defaults_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_args_with_defaults_list(s) } } func (s *Func_args_with_defaults_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_args_with_defaults_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_args_with_defaults_list() (localctx IFunc_args_with_defaults_listContext) { localctx = NewFunc_args_with_defaults_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 630, PostgreSQLParserRULE_func_args_with_defaults_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5424) p.Func_arg_with_default() } p.SetState(5429) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(5425) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5426) p.Func_arg_with_default() } p.SetState(5431) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_argContext is an interface to support dynamic dispatch. type IFunc_argContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Arg_class() IArg_classContext Func_type() IFunc_typeContext Param_name() IParam_nameContext // IsFunc_argContext differentiates from other interfaces. IsFunc_argContext() } type Func_argContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_argContext() *Func_argContext { var p = new(Func_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_arg return p } func InitEmptyFunc_argContext(p *Func_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_arg } func (*Func_argContext) IsFunc_argContext() {} func NewFunc_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_argContext { var p = new(Func_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_arg return p } func (s *Func_argContext) GetParser() antlr.Parser { return s.parser } func (s *Func_argContext) Arg_class() IArg_classContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IArg_classContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IArg_classContext) } func (s *Func_argContext) Func_type() IFunc_typeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_typeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_typeContext) } func (s *Func_argContext) Param_name() IParam_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IParam_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IParam_nameContext) } func (s *Func_argContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_argContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_arg(s) } } func (s *Func_argContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_arg(s) } } func (s *Func_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_arg(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_arg() (localctx IFunc_argContext) { localctx = NewFunc_argContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 632, PostgreSQLParserRULE_func_arg) p.SetState(5445) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 275, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5432) p.Arg_class() } p.SetState(5434) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 273, p.GetParserRuleContext()) == 1 { { p.SetState(5433) p.Param_name() } } else if p.HasError() { // JIM goto errorExit } { p.SetState(5436) p.Func_type() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5438) p.Param_name() } p.SetState(5440) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 274, p.GetParserRuleContext()) == 1 { { p.SetState(5439) p.Arg_class() } } else if p.HasError() { // JIM goto errorExit } { p.SetState(5442) p.Func_type() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(5444) p.Func_type() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IArg_classContext is an interface to support dynamic dispatch. type IArg_classContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures IN_P() antlr.TerminalNode OUT_P() antlr.TerminalNode INOUT() antlr.TerminalNode VARIADIC() antlr.TerminalNode // IsArg_classContext differentiates from other interfaces. IsArg_classContext() } type Arg_classContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyArg_classContext() *Arg_classContext { var p = new(Arg_classContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_arg_class return p } func InitEmptyArg_classContext(p *Arg_classContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_arg_class } func (*Arg_classContext) IsArg_classContext() {} func NewArg_classContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Arg_classContext { var p = new(Arg_classContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_arg_class return p } func (s *Arg_classContext) GetParser() antlr.Parser { return s.parser } func (s *Arg_classContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *Arg_classContext) OUT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOUT_P, 0) } func (s *Arg_classContext) INOUT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINOUT, 0) } func (s *Arg_classContext) VARIADIC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVARIADIC, 0) } func (s *Arg_classContext) GetRuleContext() antlr.RuleContext { return s } func (s *Arg_classContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Arg_classContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterArg_class(s) } } func (s *Arg_classContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitArg_class(s) } } func (s *Arg_classContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitArg_class(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Arg_class() (localctx IArg_classContext) { localctx = NewArg_classContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 634, PostgreSQLParserRULE_arg_class) p.SetState(5454) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserIN_P: p.EnterOuterAlt(localctx, 1) { p.SetState(5447) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(5449) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 276, p.GetParserRuleContext()) == 1 { { p.SetState(5448) p.Match(PostgreSQLParserOUT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } case PostgreSQLParserOUT_P: p.EnterOuterAlt(localctx, 2) { p.SetState(5451) p.Match(PostgreSQLParserOUT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserINOUT: p.EnterOuterAlt(localctx, 3) { p.SetState(5452) p.Match(PostgreSQLParserINOUT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserVARIADIC: p.EnterOuterAlt(localctx, 4) { p.SetState(5453) p.Match(PostgreSQLParserVARIADIC) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IParam_nameContext is an interface to support dynamic dispatch. type IParam_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Type_function_name() IType_function_nameContext Builtin_function_name() IBuiltin_function_nameContext LEFT() antlr.TerminalNode RIGHT() antlr.TerminalNode // IsParam_nameContext differentiates from other interfaces. IsParam_nameContext() } type Param_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyParam_nameContext() *Param_nameContext { var p = new(Param_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_param_name return p } func InitEmptyParam_nameContext(p *Param_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_param_name } func (*Param_nameContext) IsParam_nameContext() {} func NewParam_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Param_nameContext { var p = new(Param_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_param_name return p } func (s *Param_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Param_nameContext) Type_function_name() IType_function_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IType_function_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IType_function_nameContext) } func (s *Param_nameContext) Builtin_function_name() IBuiltin_function_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IBuiltin_function_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IBuiltin_function_nameContext) } func (s *Param_nameContext) LEFT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEFT, 0) } func (s *Param_nameContext) RIGHT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRIGHT, 0) } func (s *Param_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Param_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Param_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterParam_name(s) } } func (s *Param_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitParam_name(s) } } func (s *Param_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitParam_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Param_name() (localctx IParam_nameContext) { localctx = NewParam_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 636, PostgreSQLParserRULE_param_name) p.SetState(5460) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserCOLUMNS, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(5456) p.Type_function_name() } case PostgreSQLParserREPLACE, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserREVERSE, PostgreSQLParserLOG, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER: p.EnterOuterAlt(localctx, 2) { p.SetState(5457) p.Builtin_function_name() } case PostgreSQLParserLEFT: p.EnterOuterAlt(localctx, 3) { p.SetState(5458) p.Match(PostgreSQLParserLEFT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserRIGHT: p.EnterOuterAlt(localctx, 4) { p.SetState(5459) p.Match(PostgreSQLParserRIGHT) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_returnContext is an interface to support dynamic dispatch. type IFunc_returnContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Func_type() IFunc_typeContext // IsFunc_returnContext differentiates from other interfaces. IsFunc_returnContext() } type Func_returnContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_returnContext() *Func_returnContext { var p = new(Func_returnContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_return return p } func InitEmptyFunc_returnContext(p *Func_returnContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_return } func (*Func_returnContext) IsFunc_returnContext() {} func NewFunc_returnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_returnContext { var p = new(Func_returnContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_return return p } func (s *Func_returnContext) GetParser() antlr.Parser { return s.parser } func (s *Func_returnContext) Func_type() IFunc_typeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_typeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_typeContext) } func (s *Func_returnContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_returnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_returnContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_return(s) } } func (s *Func_returnContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_return(s) } } func (s *Func_returnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_return(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_return() (localctx IFunc_returnContext) { localctx = NewFunc_returnContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 638, PostgreSQLParserRULE_func_return) p.EnterOuterAlt(localctx, 1) { p.SetState(5462) p.Func_type() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_typeContext is an interface to support dynamic dispatch. type IFunc_typeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Typename() ITypenameContext Attrs() IAttrsContext PERCENT() antlr.TerminalNode TYPE_P() antlr.TerminalNode Builtin_function_name() IBuiltin_function_nameContext Type_function_name() IType_function_nameContext LEFT() antlr.TerminalNode RIGHT() antlr.TerminalNode SETOF() antlr.TerminalNode // IsFunc_typeContext differentiates from other interfaces. IsFunc_typeContext() } type Func_typeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_typeContext() *Func_typeContext { var p = new(Func_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_type return p } func InitEmptyFunc_typeContext(p *Func_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_type } func (*Func_typeContext) IsFunc_typeContext() {} func NewFunc_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_typeContext { var p = new(Func_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_type return p } func (s *Func_typeContext) GetParser() antlr.Parser { return s.parser } func (s *Func_typeContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *Func_typeContext) Attrs() IAttrsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAttrsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAttrsContext) } func (s *Func_typeContext) PERCENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPERCENT, 0) } func (s *Func_typeContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *Func_typeContext) Builtin_function_name() IBuiltin_function_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IBuiltin_function_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IBuiltin_function_nameContext) } func (s *Func_typeContext) Type_function_name() IType_function_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IType_function_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IType_function_nameContext) } func (s *Func_typeContext) LEFT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEFT, 0) } func (s *Func_typeContext) RIGHT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRIGHT, 0) } func (s *Func_typeContext) SETOF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSETOF, 0) } func (s *Func_typeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_typeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_type(s) } } func (s *Func_typeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_type(s) } } func (s *Func_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_type(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_type() (localctx IFunc_typeContext) { localctx = NewFunc_typeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 640, PostgreSQLParserRULE_func_type) var _la int p.SetState(5478) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 281, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5464) p.Typename() } case 2: p.EnterOuterAlt(localctx, 2) p.SetState(5466) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserSETOF { { p.SetState(5465) p.Match(PostgreSQLParserSETOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } } p.SetState(5472) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserREPLACE, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserREVERSE, PostgreSQLParserLOG, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER: { p.SetState(5468) p.Builtin_function_name() } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserCOLUMNS, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: { p.SetState(5469) p.Type_function_name() } case PostgreSQLParserLEFT: { p.SetState(5470) p.Match(PostgreSQLParserLEFT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserRIGHT: { p.SetState(5471) p.Match(PostgreSQLParserRIGHT) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } { p.SetState(5474) p.Attrs() } { p.SetState(5475) p.Match(PostgreSQLParserPERCENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5476) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_arg_with_defaultContext is an interface to support dynamic dispatch. type IFunc_arg_with_defaultContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Func_arg() IFunc_argContext A_expr() IA_exprContext DEFAULT() antlr.TerminalNode EQUAL() antlr.TerminalNode // IsFunc_arg_with_defaultContext differentiates from other interfaces. IsFunc_arg_with_defaultContext() } type Func_arg_with_defaultContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_arg_with_defaultContext() *Func_arg_with_defaultContext { var p = new(Func_arg_with_defaultContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_arg_with_default return p } func InitEmptyFunc_arg_with_defaultContext(p *Func_arg_with_defaultContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_arg_with_default } func (*Func_arg_with_defaultContext) IsFunc_arg_with_defaultContext() {} func NewFunc_arg_with_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_arg_with_defaultContext { var p = new(Func_arg_with_defaultContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_arg_with_default return p } func (s *Func_arg_with_defaultContext) GetParser() antlr.Parser { return s.parser } func (s *Func_arg_with_defaultContext) Func_arg() IFunc_argContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_argContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_argContext) } func (s *Func_arg_with_defaultContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Func_arg_with_defaultContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Func_arg_with_defaultContext) EQUAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEQUAL, 0) } func (s *Func_arg_with_defaultContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_arg_with_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_arg_with_defaultContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_arg_with_default(s) } } func (s *Func_arg_with_defaultContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_arg_with_default(s) } } func (s *Func_arg_with_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_arg_with_default(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_arg_with_default() (localctx IFunc_arg_with_defaultContext) { localctx = NewFunc_arg_with_defaultContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 642, PostgreSQLParserRULE_func_arg_with_default) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5480) p.Func_arg() } p.SetState(5483) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserEQUAL || _la == PostgreSQLParserDEFAULT { { p.SetState(5481) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserEQUAL || _la == PostgreSQLParserDEFAULT) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(5482) p.A_expr() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAggr_argContext is an interface to support dynamic dispatch. type IAggr_argContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Func_arg() IFunc_argContext // IsAggr_argContext differentiates from other interfaces. IsAggr_argContext() } type Aggr_argContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAggr_argContext() *Aggr_argContext { var p = new(Aggr_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_aggr_arg return p } func InitEmptyAggr_argContext(p *Aggr_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_aggr_arg } func (*Aggr_argContext) IsAggr_argContext() {} func NewAggr_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggr_argContext { var p = new(Aggr_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_aggr_arg return p } func (s *Aggr_argContext) GetParser() antlr.Parser { return s.parser } func (s *Aggr_argContext) Func_arg() IFunc_argContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_argContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_argContext) } func (s *Aggr_argContext) GetRuleContext() antlr.RuleContext { return s } func (s *Aggr_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Aggr_argContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAggr_arg(s) } } func (s *Aggr_argContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAggr_arg(s) } } func (s *Aggr_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAggr_arg(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Aggr_arg() (localctx IAggr_argContext) { localctx = NewAggr_argContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 644, PostgreSQLParserRULE_aggr_arg) p.EnterOuterAlt(localctx, 1) { p.SetState(5485) p.Func_arg() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAggr_argsContext is an interface to support dynamic dispatch. type IAggr_argsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode CLOSE_PAREN() antlr.TerminalNode STAR() antlr.TerminalNode AllAggr_args_list() []IAggr_args_listContext Aggr_args_list(i int) IAggr_args_listContext ORDER() antlr.TerminalNode BY() antlr.TerminalNode // IsAggr_argsContext differentiates from other interfaces. IsAggr_argsContext() } type Aggr_argsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAggr_argsContext() *Aggr_argsContext { var p = new(Aggr_argsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_aggr_args return p } func InitEmptyAggr_argsContext(p *Aggr_argsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_aggr_args } func (*Aggr_argsContext) IsAggr_argsContext() {} func NewAggr_argsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggr_argsContext { var p = new(Aggr_argsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_aggr_args return p } func (s *Aggr_argsContext) GetParser() antlr.Parser { return s.parser } func (s *Aggr_argsContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Aggr_argsContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Aggr_argsContext) STAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTAR, 0) } func (s *Aggr_argsContext) AllAggr_args_list() []IAggr_args_listContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAggr_args_listContext); ok { len++ } } tst := make([]IAggr_args_listContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAggr_args_listContext); ok { tst[i] = t.(IAggr_args_listContext) i++ } } return tst } func (s *Aggr_argsContext) Aggr_args_list(i int) IAggr_args_listContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAggr_args_listContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAggr_args_listContext) } func (s *Aggr_argsContext) ORDER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserORDER, 0) } func (s *Aggr_argsContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *Aggr_argsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Aggr_argsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Aggr_argsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAggr_args(s) } } func (s *Aggr_argsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAggr_args(s) } } func (s *Aggr_argsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAggr_args(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Aggr_args() (localctx IAggr_argsContext) { localctx = NewAggr_argsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 646, PostgreSQLParserRULE_aggr_args) p.EnterOuterAlt(localctx, 1) { p.SetState(5487) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(5498) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 283, p.GetParserRuleContext()) { case 1: { p.SetState(5488) p.Match(PostgreSQLParserSTAR) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: { p.SetState(5489) p.Aggr_args_list() } case 3: { p.SetState(5490) p.Match(PostgreSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5491) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5492) p.Aggr_args_list() } case 4: { p.SetState(5493) p.Aggr_args_list() } { p.SetState(5494) p.Match(PostgreSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5495) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5496) p.Aggr_args_list() } case antlr.ATNInvalidAltNumber: goto errorExit } { p.SetState(5500) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAggr_args_listContext is an interface to support dynamic dispatch. type IAggr_args_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllAggr_arg() []IAggr_argContext Aggr_arg(i int) IAggr_argContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsAggr_args_listContext differentiates from other interfaces. IsAggr_args_listContext() } type Aggr_args_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAggr_args_listContext() *Aggr_args_listContext { var p = new(Aggr_args_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_aggr_args_list return p } func InitEmptyAggr_args_listContext(p *Aggr_args_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_aggr_args_list } func (*Aggr_args_listContext) IsAggr_args_listContext() {} func NewAggr_args_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggr_args_listContext { var p = new(Aggr_args_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_aggr_args_list return p } func (s *Aggr_args_listContext) GetParser() antlr.Parser { return s.parser } func (s *Aggr_args_listContext) AllAggr_arg() []IAggr_argContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAggr_argContext); ok { len++ } } tst := make([]IAggr_argContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAggr_argContext); ok { tst[i] = t.(IAggr_argContext) i++ } } return tst } func (s *Aggr_args_listContext) Aggr_arg(i int) IAggr_argContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAggr_argContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAggr_argContext) } func (s *Aggr_args_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Aggr_args_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Aggr_args_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Aggr_args_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Aggr_args_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAggr_args_list(s) } } func (s *Aggr_args_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAggr_args_list(s) } } func (s *Aggr_args_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAggr_args_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Aggr_args_list() (localctx IAggr_args_listContext) { localctx = NewAggr_args_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 648, PostgreSQLParserRULE_aggr_args_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5502) p.Aggr_arg() } p.SetState(5507) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(5503) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5504) p.Aggr_arg() } p.SetState(5509) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAggregate_with_argtypesContext is an interface to support dynamic dispatch. type IAggregate_with_argtypesContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Func_name() IFunc_nameContext Aggr_args() IAggr_argsContext // IsAggregate_with_argtypesContext differentiates from other interfaces. IsAggregate_with_argtypesContext() } type Aggregate_with_argtypesContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAggregate_with_argtypesContext() *Aggregate_with_argtypesContext { var p = new(Aggregate_with_argtypesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_aggregate_with_argtypes return p } func InitEmptyAggregate_with_argtypesContext(p *Aggregate_with_argtypesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_aggregate_with_argtypes } func (*Aggregate_with_argtypesContext) IsAggregate_with_argtypesContext() {} func NewAggregate_with_argtypesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_with_argtypesContext { var p = new(Aggregate_with_argtypesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_aggregate_with_argtypes return p } func (s *Aggregate_with_argtypesContext) GetParser() antlr.Parser { return s.parser } func (s *Aggregate_with_argtypesContext) Func_name() IFunc_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_nameContext) } func (s *Aggregate_with_argtypesContext) Aggr_args() IAggr_argsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAggr_argsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAggr_argsContext) } func (s *Aggregate_with_argtypesContext) GetRuleContext() antlr.RuleContext { return s } func (s *Aggregate_with_argtypesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Aggregate_with_argtypesContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAggregate_with_argtypes(s) } } func (s *Aggregate_with_argtypesContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAggregate_with_argtypes(s) } } func (s *Aggregate_with_argtypesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAggregate_with_argtypes(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Aggregate_with_argtypes() (localctx IAggregate_with_argtypesContext) { localctx = NewAggregate_with_argtypesContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 650, PostgreSQLParserRULE_aggregate_with_argtypes) p.EnterOuterAlt(localctx, 1) { p.SetState(5510) p.Func_name() } { p.SetState(5511) p.Aggr_args() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAggregate_with_argtypes_listContext is an interface to support dynamic dispatch. type IAggregate_with_argtypes_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllAggregate_with_argtypes() []IAggregate_with_argtypesContext Aggregate_with_argtypes(i int) IAggregate_with_argtypesContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsAggregate_with_argtypes_listContext differentiates from other interfaces. IsAggregate_with_argtypes_listContext() } type Aggregate_with_argtypes_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAggregate_with_argtypes_listContext() *Aggregate_with_argtypes_listContext { var p = new(Aggregate_with_argtypes_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_aggregate_with_argtypes_list return p } func InitEmptyAggregate_with_argtypes_listContext(p *Aggregate_with_argtypes_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_aggregate_with_argtypes_list } func (*Aggregate_with_argtypes_listContext) IsAggregate_with_argtypes_listContext() {} func NewAggregate_with_argtypes_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_with_argtypes_listContext { var p = new(Aggregate_with_argtypes_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_aggregate_with_argtypes_list return p } func (s *Aggregate_with_argtypes_listContext) GetParser() antlr.Parser { return s.parser } func (s *Aggregate_with_argtypes_listContext) AllAggregate_with_argtypes() []IAggregate_with_argtypesContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAggregate_with_argtypesContext); ok { len++ } } tst := make([]IAggregate_with_argtypesContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAggregate_with_argtypesContext); ok { tst[i] = t.(IAggregate_with_argtypesContext) i++ } } return tst } func (s *Aggregate_with_argtypes_listContext) Aggregate_with_argtypes(i int) IAggregate_with_argtypesContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAggregate_with_argtypesContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAggregate_with_argtypesContext) } func (s *Aggregate_with_argtypes_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Aggregate_with_argtypes_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Aggregate_with_argtypes_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Aggregate_with_argtypes_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Aggregate_with_argtypes_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAggregate_with_argtypes_list(s) } } func (s *Aggregate_with_argtypes_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAggregate_with_argtypes_list(s) } } func (s *Aggregate_with_argtypes_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAggregate_with_argtypes_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Aggregate_with_argtypes_list() (localctx IAggregate_with_argtypes_listContext) { localctx = NewAggregate_with_argtypes_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 652, PostgreSQLParserRULE_aggregate_with_argtypes_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5513) p.Aggregate_with_argtypes() } p.SetState(5518) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(5514) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5515) p.Aggregate_with_argtypes() } p.SetState(5520) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatefunc_opt_listContext is an interface to support dynamic dispatch. type ICreatefunc_opt_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllCreatefunc_opt_item() []ICreatefunc_opt_itemContext Createfunc_opt_item(i int) ICreatefunc_opt_itemContext // IsCreatefunc_opt_listContext differentiates from other interfaces. IsCreatefunc_opt_listContext() } type Createfunc_opt_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatefunc_opt_listContext() *Createfunc_opt_listContext { var p = new(Createfunc_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createfunc_opt_list return p } func InitEmptyCreatefunc_opt_listContext(p *Createfunc_opt_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createfunc_opt_list } func (*Createfunc_opt_listContext) IsCreatefunc_opt_listContext() {} func NewCreatefunc_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createfunc_opt_listContext { var p = new(Createfunc_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createfunc_opt_list return p } func (s *Createfunc_opt_listContext) GetParser() antlr.Parser { return s.parser } func (s *Createfunc_opt_listContext) AllCreatefunc_opt_item() []ICreatefunc_opt_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ICreatefunc_opt_itemContext); ok { len++ } } tst := make([]ICreatefunc_opt_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ICreatefunc_opt_itemContext); ok { tst[i] = t.(ICreatefunc_opt_itemContext) i++ } } return tst } func (s *Createfunc_opt_listContext) Createfunc_opt_item(i int) ICreatefunc_opt_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatefunc_opt_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ICreatefunc_opt_itemContext) } func (s *Createfunc_opt_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Createfunc_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Createfunc_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatefunc_opt_list(s) } } func (s *Createfunc_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatefunc_opt_list(s) } } func (s *Createfunc_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatefunc_opt_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createfunc_opt_list() (localctx ICreatefunc_opt_listContext) { localctx = NewCreatefunc_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 654, PostgreSQLParserRULE_createfunc_opt_list) var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(5522) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = 1 for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { switch _alt { case 1: { p.SetState(5521) p.Createfunc_opt_item() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.SetState(5524) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 286, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } // ParseRoutineBody(_localctx) errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICommon_func_opt_itemContext is an interface to support dynamic dispatch. type ICommon_func_opt_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CALLED() antlr.TerminalNode ON() antlr.TerminalNode AllNULL_P() []antlr.TerminalNode NULL_P(i int) antlr.TerminalNode INPUT_P() antlr.TerminalNode RETURNS() antlr.TerminalNode STRICT_P() antlr.TerminalNode IMMUTABLE() antlr.TerminalNode STABLE() antlr.TerminalNode VOLATILE() antlr.TerminalNode EXTERNAL() antlr.TerminalNode SECURITY() antlr.TerminalNode DEFINER() antlr.TerminalNode INVOKER() antlr.TerminalNode LEAKPROOF() antlr.TerminalNode NOT() antlr.TerminalNode COST() antlr.TerminalNode Numericonly() INumericonlyContext ROWS() antlr.TerminalNode SUPPORT() antlr.TerminalNode Any_name() IAny_nameContext Functionsetresetclause() IFunctionsetresetclauseContext PARALLEL() antlr.TerminalNode Colid() IColidContext // IsCommon_func_opt_itemContext differentiates from other interfaces. IsCommon_func_opt_itemContext() } type Common_func_opt_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCommon_func_opt_itemContext() *Common_func_opt_itemContext { var p = new(Common_func_opt_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_common_func_opt_item return p } func InitEmptyCommon_func_opt_itemContext(p *Common_func_opt_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_common_func_opt_item } func (*Common_func_opt_itemContext) IsCommon_func_opt_itemContext() {} func NewCommon_func_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_func_opt_itemContext { var p = new(Common_func_opt_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_common_func_opt_item return p } func (s *Common_func_opt_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Common_func_opt_itemContext) CALLED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCALLED, 0) } func (s *Common_func_opt_itemContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *Common_func_opt_itemContext) AllNULL_P() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserNULL_P) } func (s *Common_func_opt_itemContext) NULL_P(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, i) } func (s *Common_func_opt_itemContext) INPUT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINPUT_P, 0) } func (s *Common_func_opt_itemContext) RETURNS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRETURNS, 0) } func (s *Common_func_opt_itemContext) STRICT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTRICT_P, 0) } func (s *Common_func_opt_itemContext) IMMUTABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIMMUTABLE, 0) } func (s *Common_func_opt_itemContext) STABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTABLE, 0) } func (s *Common_func_opt_itemContext) VOLATILE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVOLATILE, 0) } func (s *Common_func_opt_itemContext) EXTERNAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXTERNAL, 0) } func (s *Common_func_opt_itemContext) SECURITY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSECURITY, 0) } func (s *Common_func_opt_itemContext) DEFINER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFINER, 0) } func (s *Common_func_opt_itemContext) INVOKER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINVOKER, 0) } func (s *Common_func_opt_itemContext) LEAKPROOF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEAKPROOF, 0) } func (s *Common_func_opt_itemContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *Common_func_opt_itemContext) COST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOST, 0) } func (s *Common_func_opt_itemContext) Numericonly() INumericonlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericonlyContext) } func (s *Common_func_opt_itemContext) ROWS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROWS, 0) } func (s *Common_func_opt_itemContext) SUPPORT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSUPPORT, 0) } func (s *Common_func_opt_itemContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *Common_func_opt_itemContext) Functionsetresetclause() IFunctionsetresetclauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunctionsetresetclauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunctionsetresetclauseContext) } func (s *Common_func_opt_itemContext) PARALLEL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARALLEL, 0) } func (s *Common_func_opt_itemContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Common_func_opt_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Common_func_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Common_func_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCommon_func_opt_item(s) } } func (s *Common_func_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCommon_func_opt_item(s) } } func (s *Common_func_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCommon_func_opt_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Common_func_opt_item() (localctx ICommon_func_opt_itemContext) { localctx = NewCommon_func_opt_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 656, PostgreSQLParserRULE_common_func_opt_item) p.SetState(5563) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 287, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5528) p.Match(PostgreSQLParserCALLED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5529) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5530) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5531) p.Match(PostgreSQLParserINPUT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5532) p.Match(PostgreSQLParserRETURNS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5533) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5534) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5535) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5536) p.Match(PostgreSQLParserINPUT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(5537) p.Match(PostgreSQLParserSTRICT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(5538) p.Match(PostgreSQLParserIMMUTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(5539) p.Match(PostgreSQLParserSTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(5540) p.Match(PostgreSQLParserVOLATILE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(5541) p.Match(PostgreSQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5542) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5543) p.Match(PostgreSQLParserDEFINER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(5544) p.Match(PostgreSQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5545) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5546) p.Match(PostgreSQLParserINVOKER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(5547) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5548) p.Match(PostgreSQLParserDEFINER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(5549) p.Match(PostgreSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5550) p.Match(PostgreSQLParserINVOKER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(5551) p.Match(PostgreSQLParserLEAKPROOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(5552) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5553) p.Match(PostgreSQLParserLEAKPROOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(5554) p.Match(PostgreSQLParserCOST) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5555) p.Numericonly() } case 14: p.EnterOuterAlt(localctx, 14) { p.SetState(5556) p.Match(PostgreSQLParserROWS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5557) p.Numericonly() } case 15: p.EnterOuterAlt(localctx, 15) { p.SetState(5558) p.Match(PostgreSQLParserSUPPORT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5559) p.Any_name() } case 16: p.EnterOuterAlt(localctx, 16) { p.SetState(5560) p.Functionsetresetclause() } case 17: p.EnterOuterAlt(localctx, 17) { p.SetState(5561) p.Match(PostgreSQLParserPARALLEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5562) p.Colid() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatefunc_opt_itemContext is an interface to support dynamic dispatch. type ICreatefunc_opt_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AS() antlr.TerminalNode Func_as() IFunc_asContext LANGUAGE() antlr.TerminalNode Nonreservedword_or_sconst() INonreservedword_or_sconstContext TRANSFORM() antlr.TerminalNode Transform_type_list() ITransform_type_listContext WINDOW() antlr.TerminalNode Common_func_opt_item() ICommon_func_opt_itemContext // IsCreatefunc_opt_itemContext differentiates from other interfaces. IsCreatefunc_opt_itemContext() } type Createfunc_opt_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatefunc_opt_itemContext() *Createfunc_opt_itemContext { var p = new(Createfunc_opt_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createfunc_opt_item return p } func InitEmptyCreatefunc_opt_itemContext(p *Createfunc_opt_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createfunc_opt_item } func (*Createfunc_opt_itemContext) IsCreatefunc_opt_itemContext() {} func NewCreatefunc_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createfunc_opt_itemContext { var p = new(Createfunc_opt_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createfunc_opt_item return p } func (s *Createfunc_opt_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Createfunc_opt_itemContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Createfunc_opt_itemContext) Func_as() IFunc_asContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_asContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_asContext) } func (s *Createfunc_opt_itemContext) LANGUAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLANGUAGE, 0) } func (s *Createfunc_opt_itemContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INonreservedword_or_sconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INonreservedword_or_sconstContext) } func (s *Createfunc_opt_itemContext) TRANSFORM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSFORM, 0) } func (s *Createfunc_opt_itemContext) Transform_type_list() ITransform_type_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITransform_type_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITransform_type_listContext) } func (s *Createfunc_opt_itemContext) WINDOW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWINDOW, 0) } func (s *Createfunc_opt_itemContext) Common_func_opt_item() ICommon_func_opt_itemContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICommon_func_opt_itemContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICommon_func_opt_itemContext) } func (s *Createfunc_opt_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Createfunc_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Createfunc_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatefunc_opt_item(s) } } func (s *Createfunc_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatefunc_opt_item(s) } } func (s *Createfunc_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatefunc_opt_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createfunc_opt_item() (localctx ICreatefunc_opt_itemContext) { localctx = NewCreatefunc_opt_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 658, PostgreSQLParserRULE_createfunc_opt_item) p.SetState(5573) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAS: p.EnterOuterAlt(localctx, 1) { p.SetState(5565) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5566) p.Func_as() } case PostgreSQLParserLANGUAGE: p.EnterOuterAlt(localctx, 2) { p.SetState(5567) p.Match(PostgreSQLParserLANGUAGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5568) p.Nonreservedword_or_sconst() } case PostgreSQLParserTRANSFORM: p.EnterOuterAlt(localctx, 3) { p.SetState(5569) p.Match(PostgreSQLParserTRANSFORM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5570) p.Transform_type_list() } case PostgreSQLParserWINDOW: p.EnterOuterAlt(localctx, 4) { p.SetState(5571) p.Match(PostgreSQLParserWINDOW) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserNOT, PostgreSQLParserCALLED, PostgreSQLParserCOST, PostgreSQLParserEXTERNAL, PostgreSQLParserIMMUTABLE, PostgreSQLParserLEAKPROOF, PostgreSQLParserRESET, PostgreSQLParserRETURNS, PostgreSQLParserROWS, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSTABLE, PostgreSQLParserSTRICT_P, PostgreSQLParserVOLATILE, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL: p.EnterOuterAlt(localctx, 5) { p.SetState(5572) p.Common_func_opt_item() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_asContext is an interface to support dynamic dispatch. type IFunc_asContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // GetDef returns the def rule contexts. GetDef() ISconstContext // SetDef sets the def rule contexts. SetDef(ISconstContext) // GetDefinition returns the Definition attribute. GetDefinition() antlr.ParserRuleContext // SetDefinition sets the Definition attribute. SetDefinition(antlr.ParserRuleContext) // Getter signatures AllSconst() []ISconstContext Sconst(i int) ISconstContext COMMA() antlr.TerminalNode // IsFunc_asContext differentiates from other interfaces. IsFunc_asContext() } type Func_asContext struct { antlr.BaseParserRuleContext parser antlr.Parser Definition antlr.ParserRuleContext def ISconstContext } func NewEmptyFunc_asContext() *Func_asContext { var p = new(Func_asContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_as return p } func InitEmptyFunc_asContext(p *Func_asContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_as } func (*Func_asContext) IsFunc_asContext() {} func NewFunc_asContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_asContext { var p = new(Func_asContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_as return p } func (s *Func_asContext) GetParser() antlr.Parser { return s.parser } func (s *Func_asContext) GetDef() ISconstContext { return s.def } func (s *Func_asContext) SetDef(v ISconstContext) { s.def = v } func (s *Func_asContext) GetDefinition() antlr.ParserRuleContext { return s.Definition } func (s *Func_asContext) SetDefinition(v antlr.ParserRuleContext) { s.Definition = v } func (s *Func_asContext) AllSconst() []ISconstContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISconstContext); ok { len++ } } tst := make([]ISconstContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISconstContext); ok { tst[i] = t.(ISconstContext) i++ } } return tst } func (s *Func_asContext) Sconst(i int) ISconstContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISconstContext) } func (s *Func_asContext) COMMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, 0) } func (s *Func_asContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_asContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_asContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_as(s) } } func (s *Func_asContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_as(s) } } func (s *Func_asContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_as(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_as() (localctx IFunc_asContext) { localctx = NewFunc_asContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 660, PostgreSQLParserRULE_func_as) p.SetState(5580) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 289, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5575) var _x = p.Sconst() localctx.(*Func_asContext).def = _x } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5576) p.Sconst() } { p.SetState(5577) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5578) p.Sconst() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITransform_type_listContext is an interface to support dynamic dispatch. type ITransform_type_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllFOR() []antlr.TerminalNode FOR(i int) antlr.TerminalNode AllTYPE_P() []antlr.TerminalNode TYPE_P(i int) antlr.TerminalNode AllTypename() []ITypenameContext Typename(i int) ITypenameContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsTransform_type_listContext differentiates from other interfaces. IsTransform_type_listContext() } type Transform_type_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTransform_type_listContext() *Transform_type_listContext { var p = new(Transform_type_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transform_type_list return p } func InitEmptyTransform_type_listContext(p *Transform_type_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transform_type_list } func (*Transform_type_listContext) IsTransform_type_listContext() {} func NewTransform_type_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transform_type_listContext { var p = new(Transform_type_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_transform_type_list return p } func (s *Transform_type_listContext) GetParser() antlr.Parser { return s.parser } func (s *Transform_type_listContext) AllFOR() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserFOR) } func (s *Transform_type_listContext) FOR(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, i) } func (s *Transform_type_listContext) AllTYPE_P() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserTYPE_P) } func (s *Transform_type_listContext) TYPE_P(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, i) } func (s *Transform_type_listContext) AllTypename() []ITypenameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITypenameContext); ok { len++ } } tst := make([]ITypenameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITypenameContext); ok { tst[i] = t.(ITypenameContext) i++ } } return tst } func (s *Transform_type_listContext) Typename(i int) ITypenameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITypenameContext) } func (s *Transform_type_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Transform_type_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Transform_type_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Transform_type_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Transform_type_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTransform_type_list(s) } } func (s *Transform_type_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTransform_type_list(s) } } func (s *Transform_type_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTransform_type_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Transform_type_list() (localctx ITransform_type_listContext) { localctx = NewTransform_type_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 662, PostgreSQLParserRULE_transform_type_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5582) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5583) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5584) p.Typename() } p.SetState(5591) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(5585) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5586) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5587) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5588) p.Typename() } p.SetState(5593) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_definitionContext is an interface to support dynamic dispatch. type IOpt_definitionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITH() antlr.TerminalNode Definition() IDefinitionContext // IsOpt_definitionContext differentiates from other interfaces. IsOpt_definitionContext() } type Opt_definitionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_definitionContext() *Opt_definitionContext { var p = new(Opt_definitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_definition return p } func InitEmptyOpt_definitionContext(p *Opt_definitionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_definition } func (*Opt_definitionContext) IsOpt_definitionContext() {} func NewOpt_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_definitionContext { var p = new(Opt_definitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_definition return p } func (s *Opt_definitionContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_definitionContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *Opt_definitionContext) Definition() IDefinitionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDefinitionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDefinitionContext) } func (s *Opt_definitionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_definitionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_definition(s) } } func (s *Opt_definitionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_definition(s) } } func (s *Opt_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_definition(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_definition() (localctx IOpt_definitionContext) { localctx = NewOpt_definitionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 664, PostgreSQLParserRULE_opt_definition) p.SetState(5597) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 291, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5594) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5595) p.Definition() } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITable_func_columnContext is an interface to support dynamic dispatch. type ITable_func_columnContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Param_name() IParam_nameContext Func_type() IFunc_typeContext // IsTable_func_columnContext differentiates from other interfaces. IsTable_func_columnContext() } type Table_func_columnContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTable_func_columnContext() *Table_func_columnContext { var p = new(Table_func_columnContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_table_func_column return p } func InitEmptyTable_func_columnContext(p *Table_func_columnContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_table_func_column } func (*Table_func_columnContext) IsTable_func_columnContext() {} func NewTable_func_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_func_columnContext { var p = new(Table_func_columnContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_table_func_column return p } func (s *Table_func_columnContext) GetParser() antlr.Parser { return s.parser } func (s *Table_func_columnContext) Param_name() IParam_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IParam_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IParam_nameContext) } func (s *Table_func_columnContext) Func_type() IFunc_typeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_typeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_typeContext) } func (s *Table_func_columnContext) GetRuleContext() antlr.RuleContext { return s } func (s *Table_func_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Table_func_columnContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTable_func_column(s) } } func (s *Table_func_columnContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTable_func_column(s) } } func (s *Table_func_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTable_func_column(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Table_func_column() (localctx ITable_func_columnContext) { localctx = NewTable_func_columnContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 666, PostgreSQLParserRULE_table_func_column) p.EnterOuterAlt(localctx, 1) { p.SetState(5599) p.Param_name() } { p.SetState(5600) p.Func_type() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITable_func_column_listContext is an interface to support dynamic dispatch. type ITable_func_column_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllTable_func_column() []ITable_func_columnContext Table_func_column(i int) ITable_func_columnContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsTable_func_column_listContext differentiates from other interfaces. IsTable_func_column_listContext() } type Table_func_column_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTable_func_column_listContext() *Table_func_column_listContext { var p = new(Table_func_column_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_table_func_column_list return p } func InitEmptyTable_func_column_listContext(p *Table_func_column_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_table_func_column_list } func (*Table_func_column_listContext) IsTable_func_column_listContext() {} func NewTable_func_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_func_column_listContext { var p = new(Table_func_column_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_table_func_column_list return p } func (s *Table_func_column_listContext) GetParser() antlr.Parser { return s.parser } func (s *Table_func_column_listContext) AllTable_func_column() []ITable_func_columnContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITable_func_columnContext); ok { len++ } } tst := make([]ITable_func_columnContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITable_func_columnContext); ok { tst[i] = t.(ITable_func_columnContext) i++ } } return tst } func (s *Table_func_column_listContext) Table_func_column(i int) ITable_func_columnContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITable_func_columnContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITable_func_columnContext) } func (s *Table_func_column_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Table_func_column_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Table_func_column_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Table_func_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Table_func_column_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTable_func_column_list(s) } } func (s *Table_func_column_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTable_func_column_list(s) } } func (s *Table_func_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTable_func_column_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Table_func_column_list() (localctx ITable_func_column_listContext) { localctx = NewTable_func_column_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 668, PostgreSQLParserRULE_table_func_column_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5602) p.Table_func_column() } p.SetState(5607) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(5603) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5604) p.Table_func_column() } p.SetState(5609) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterfunctionstmtContext is an interface to support dynamic dispatch. type IAlterfunctionstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode Function_with_argtypes() IFunction_with_argtypesContext Alterfunc_opt_list() IAlterfunc_opt_listContext Opt_restrict() IOpt_restrictContext FUNCTION() antlr.TerminalNode PROCEDURE() antlr.TerminalNode ROUTINE() antlr.TerminalNode // IsAlterfunctionstmtContext differentiates from other interfaces. IsAlterfunctionstmtContext() } type AlterfunctionstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterfunctionstmtContext() *AlterfunctionstmtContext { var p = new(AlterfunctionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterfunctionstmt return p } func InitEmptyAlterfunctionstmtContext(p *AlterfunctionstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterfunctionstmt } func (*AlterfunctionstmtContext) IsAlterfunctionstmtContext() {} func NewAlterfunctionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterfunctionstmtContext { var p = new(AlterfunctionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterfunctionstmt return p } func (s *AlterfunctionstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterfunctionstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterfunctionstmtContext) Function_with_argtypes() IFunction_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunction_with_argtypesContext) } func (s *AlterfunctionstmtContext) Alterfunc_opt_list() IAlterfunc_opt_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlterfunc_opt_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlterfunc_opt_listContext) } func (s *AlterfunctionstmtContext) Opt_restrict() IOpt_restrictContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_restrictContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_restrictContext) } func (s *AlterfunctionstmtContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *AlterfunctionstmtContext) PROCEDURE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURE, 0) } func (s *AlterfunctionstmtContext) ROUTINE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUTINE, 0) } func (s *AlterfunctionstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterfunctionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterfunctionstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterfunctionstmt(s) } } func (s *AlterfunctionstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterfunctionstmt(s) } } func (s *AlterfunctionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterfunctionstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterfunctionstmt() (localctx IAlterfunctionstmtContext) { localctx = NewAlterfunctionstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 670, PostgreSQLParserRULE_alterfunctionstmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5610) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5611) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserFUNCTION || _la == PostgreSQLParserPROCEDURE || _la == PostgreSQLParserROUTINE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(5612) p.Function_with_argtypes() } { p.SetState(5613) p.Alterfunc_opt_list() } { p.SetState(5614) p.Opt_restrict() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterfunc_opt_listContext is an interface to support dynamic dispatch. type IAlterfunc_opt_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllCommon_func_opt_item() []ICommon_func_opt_itemContext Common_func_opt_item(i int) ICommon_func_opt_itemContext // IsAlterfunc_opt_listContext differentiates from other interfaces. IsAlterfunc_opt_listContext() } type Alterfunc_opt_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterfunc_opt_listContext() *Alterfunc_opt_listContext { var p = new(Alterfunc_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterfunc_opt_list return p } func InitEmptyAlterfunc_opt_listContext(p *Alterfunc_opt_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterfunc_opt_list } func (*Alterfunc_opt_listContext) IsAlterfunc_opt_listContext() {} func NewAlterfunc_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alterfunc_opt_listContext { var p = new(Alterfunc_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterfunc_opt_list return p } func (s *Alterfunc_opt_listContext) GetParser() antlr.Parser { return s.parser } func (s *Alterfunc_opt_listContext) AllCommon_func_opt_item() []ICommon_func_opt_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ICommon_func_opt_itemContext); ok { len++ } } tst := make([]ICommon_func_opt_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ICommon_func_opt_itemContext); ok { tst[i] = t.(ICommon_func_opt_itemContext) i++ } } return tst } func (s *Alterfunc_opt_listContext) Common_func_opt_item(i int) ICommon_func_opt_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICommon_func_opt_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ICommon_func_opt_itemContext) } func (s *Alterfunc_opt_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alterfunc_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alterfunc_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterfunc_opt_list(s) } } func (s *Alterfunc_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterfunc_opt_list(s) } } func (s *Alterfunc_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterfunc_opt_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterfunc_opt_list() (localctx IAlterfunc_opt_listContext) { localctx = NewAlterfunc_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 672, PostgreSQLParserRULE_alterfunc_opt_list) var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(5617) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = 1 for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { switch _alt { case 1: { p.SetState(5616) p.Common_func_opt_item() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.SetState(5619) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 293, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_restrictContext is an interface to support dynamic dispatch. type IOpt_restrictContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures RESTRICT() antlr.TerminalNode // IsOpt_restrictContext differentiates from other interfaces. IsOpt_restrictContext() } type Opt_restrictContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_restrictContext() *Opt_restrictContext { var p = new(Opt_restrictContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_restrict return p } func InitEmptyOpt_restrictContext(p *Opt_restrictContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_restrict } func (*Opt_restrictContext) IsOpt_restrictContext() {} func NewOpt_restrictContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_restrictContext { var p = new(Opt_restrictContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_restrict return p } func (s *Opt_restrictContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_restrictContext) RESTRICT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESTRICT, 0) } func (s *Opt_restrictContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_restrictContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_restrictContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_restrict(s) } } func (s *Opt_restrictContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_restrict(s) } } func (s *Opt_restrictContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_restrict(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_restrict() (localctx IOpt_restrictContext) { localctx = NewOpt_restrictContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 674, PostgreSQLParserRULE_opt_restrict) p.SetState(5623) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserRESTRICT: p.EnterOuterAlt(localctx, 1) { p.SetState(5621) p.Match(PostgreSQLParserRESTRICT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRemovefuncstmtContext is an interface to support dynamic dispatch. type IRemovefuncstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DROP() antlr.TerminalNode FUNCTION() antlr.TerminalNode Function_with_argtypes_list() IFunction_with_argtypes_listContext Opt_drop_behavior() IOpt_drop_behaviorContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode PROCEDURE() antlr.TerminalNode ROUTINE() antlr.TerminalNode // IsRemovefuncstmtContext differentiates from other interfaces. IsRemovefuncstmtContext() } type RemovefuncstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRemovefuncstmtContext() *RemovefuncstmtContext { var p = new(RemovefuncstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_removefuncstmt return p } func InitEmptyRemovefuncstmtContext(p *RemovefuncstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_removefuncstmt } func (*RemovefuncstmtContext) IsRemovefuncstmtContext() {} func NewRemovefuncstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RemovefuncstmtContext { var p = new(RemovefuncstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_removefuncstmt return p } func (s *RemovefuncstmtContext) GetParser() antlr.Parser { return s.parser } func (s *RemovefuncstmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *RemovefuncstmtContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *RemovefuncstmtContext) Function_with_argtypes_list() IFunction_with_argtypes_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_with_argtypes_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunction_with_argtypes_listContext) } func (s *RemovefuncstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *RemovefuncstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *RemovefuncstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *RemovefuncstmtContext) PROCEDURE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURE, 0) } func (s *RemovefuncstmtContext) ROUTINE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUTINE, 0) } func (s *RemovefuncstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *RemovefuncstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RemovefuncstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRemovefuncstmt(s) } } func (s *RemovefuncstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRemovefuncstmt(s) } } func (s *RemovefuncstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRemovefuncstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Removefuncstmt() (localctx IRemovefuncstmtContext) { localctx = NewRemovefuncstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 676, PostgreSQLParserRULE_removefuncstmt) p.SetState(5661) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 295, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5625) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5626) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5627) p.Function_with_argtypes_list() } { p.SetState(5628) p.Opt_drop_behavior() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5630) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5631) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5632) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5633) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5634) p.Function_with_argtypes_list() } { p.SetState(5635) p.Opt_drop_behavior() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(5637) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5638) p.Match(PostgreSQLParserPROCEDURE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5639) p.Function_with_argtypes_list() } { p.SetState(5640) p.Opt_drop_behavior() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(5642) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5643) p.Match(PostgreSQLParserPROCEDURE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5644) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5645) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5646) p.Function_with_argtypes_list() } { p.SetState(5647) p.Opt_drop_behavior() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(5649) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5650) p.Match(PostgreSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5651) p.Function_with_argtypes_list() } { p.SetState(5652) p.Opt_drop_behavior() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(5654) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5655) p.Match(PostgreSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5656) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5657) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5658) p.Function_with_argtypes_list() } { p.SetState(5659) p.Opt_drop_behavior() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRemoveaggrstmtContext is an interface to support dynamic dispatch. type IRemoveaggrstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DROP() antlr.TerminalNode AGGREGATE() antlr.TerminalNode Aggregate_with_argtypes_list() IAggregate_with_argtypes_listContext Opt_drop_behavior() IOpt_drop_behaviorContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsRemoveaggrstmtContext differentiates from other interfaces. IsRemoveaggrstmtContext() } type RemoveaggrstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRemoveaggrstmtContext() *RemoveaggrstmtContext { var p = new(RemoveaggrstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_removeaggrstmt return p } func InitEmptyRemoveaggrstmtContext(p *RemoveaggrstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_removeaggrstmt } func (*RemoveaggrstmtContext) IsRemoveaggrstmtContext() {} func NewRemoveaggrstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RemoveaggrstmtContext { var p = new(RemoveaggrstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_removeaggrstmt return p } func (s *RemoveaggrstmtContext) GetParser() antlr.Parser { return s.parser } func (s *RemoveaggrstmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *RemoveaggrstmtContext) AGGREGATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAGGREGATE, 0) } func (s *RemoveaggrstmtContext) Aggregate_with_argtypes_list() IAggregate_with_argtypes_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAggregate_with_argtypes_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAggregate_with_argtypes_listContext) } func (s *RemoveaggrstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *RemoveaggrstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *RemoveaggrstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *RemoveaggrstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *RemoveaggrstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RemoveaggrstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRemoveaggrstmt(s) } } func (s *RemoveaggrstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRemoveaggrstmt(s) } } func (s *RemoveaggrstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRemoveaggrstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Removeaggrstmt() (localctx IRemoveaggrstmtContext) { localctx = NewRemoveaggrstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 678, PostgreSQLParserRULE_removeaggrstmt) p.SetState(5675) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 296, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5663) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5664) p.Match(PostgreSQLParserAGGREGATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5665) p.Aggregate_with_argtypes_list() } { p.SetState(5666) p.Opt_drop_behavior() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5668) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5669) p.Match(PostgreSQLParserAGGREGATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5670) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5671) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5672) p.Aggregate_with_argtypes_list() } { p.SetState(5673) p.Opt_drop_behavior() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRemoveoperstmtContext is an interface to support dynamic dispatch. type IRemoveoperstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DROP() antlr.TerminalNode OPERATOR() antlr.TerminalNode Operator_with_argtypes_list() IOperator_with_argtypes_listContext Opt_drop_behavior() IOpt_drop_behaviorContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsRemoveoperstmtContext differentiates from other interfaces. IsRemoveoperstmtContext() } type RemoveoperstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRemoveoperstmtContext() *RemoveoperstmtContext { var p = new(RemoveoperstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_removeoperstmt return p } func InitEmptyRemoveoperstmtContext(p *RemoveoperstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_removeoperstmt } func (*RemoveoperstmtContext) IsRemoveoperstmtContext() {} func NewRemoveoperstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RemoveoperstmtContext { var p = new(RemoveoperstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_removeoperstmt return p } func (s *RemoveoperstmtContext) GetParser() antlr.Parser { return s.parser } func (s *RemoveoperstmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *RemoveoperstmtContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *RemoveoperstmtContext) Operator_with_argtypes_list() IOperator_with_argtypes_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOperator_with_argtypes_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOperator_with_argtypes_listContext) } func (s *RemoveoperstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *RemoveoperstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *RemoveoperstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *RemoveoperstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *RemoveoperstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RemoveoperstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRemoveoperstmt(s) } } func (s *RemoveoperstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRemoveoperstmt(s) } } func (s *RemoveoperstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRemoveoperstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Removeoperstmt() (localctx IRemoveoperstmtContext) { localctx = NewRemoveoperstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 680, PostgreSQLParserRULE_removeoperstmt) p.SetState(5689) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 297, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5677) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5678) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5679) p.Operator_with_argtypes_list() } { p.SetState(5680) p.Opt_drop_behavior() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5682) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5683) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5684) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5685) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5686) p.Operator_with_argtypes_list() } { p.SetState(5687) p.Opt_drop_behavior() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOper_argtypesContext is an interface to support dynamic dispatch. type IOper_argtypesContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode AllTypename() []ITypenameContext Typename(i int) ITypenameContext CLOSE_PAREN() antlr.TerminalNode COMMA() antlr.TerminalNode NONE() antlr.TerminalNode // IsOper_argtypesContext differentiates from other interfaces. IsOper_argtypesContext() } type Oper_argtypesContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOper_argtypesContext() *Oper_argtypesContext { var p = new(Oper_argtypesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_oper_argtypes return p } func InitEmptyOper_argtypesContext(p *Oper_argtypesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_oper_argtypes } func (*Oper_argtypesContext) IsOper_argtypesContext() {} func NewOper_argtypesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Oper_argtypesContext { var p = new(Oper_argtypesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_oper_argtypes return p } func (s *Oper_argtypesContext) GetParser() antlr.Parser { return s.parser } func (s *Oper_argtypesContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Oper_argtypesContext) AllTypename() []ITypenameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITypenameContext); ok { len++ } } tst := make([]ITypenameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITypenameContext); ok { tst[i] = t.(ITypenameContext) i++ } } return tst } func (s *Oper_argtypesContext) Typename(i int) ITypenameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITypenameContext) } func (s *Oper_argtypesContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Oper_argtypesContext) COMMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, 0) } func (s *Oper_argtypesContext) NONE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNONE, 0) } func (s *Oper_argtypesContext) GetRuleContext() antlr.RuleContext { return s } func (s *Oper_argtypesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Oper_argtypesContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOper_argtypes(s) } } func (s *Oper_argtypesContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOper_argtypes(s) } } func (s *Oper_argtypesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOper_argtypes(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Oper_argtypes() (localctx IOper_argtypesContext) { localctx = NewOper_argtypesContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 682, PostgreSQLParserRULE_oper_argtypes) p.SetState(5713) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 298, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5691) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5692) p.Typename() } { p.SetState(5693) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5695) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5696) p.Typename() } { p.SetState(5697) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5698) p.Typename() } { p.SetState(5699) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(5701) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5702) p.Match(PostgreSQLParserNONE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5703) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5704) p.Typename() } { p.SetState(5705) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(5707) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5708) p.Typename() } { p.SetState(5709) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5710) p.Match(PostgreSQLParserNONE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5711) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAny_operatorContext is an interface to support dynamic dispatch. type IAny_operatorContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures All_op() IAll_opContext AllColid() []IColidContext Colid(i int) IColidContext AllDOT() []antlr.TerminalNode DOT(i int) antlr.TerminalNode // IsAny_operatorContext differentiates from other interfaces. IsAny_operatorContext() } type Any_operatorContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAny_operatorContext() *Any_operatorContext { var p = new(Any_operatorContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_any_operator return p } func InitEmptyAny_operatorContext(p *Any_operatorContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_any_operator } func (*Any_operatorContext) IsAny_operatorContext() {} func NewAny_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_operatorContext { var p = new(Any_operatorContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_any_operator return p } func (s *Any_operatorContext) GetParser() antlr.Parser { return s.parser } func (s *Any_operatorContext) All_op() IAll_opContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAll_opContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAll_opContext) } func (s *Any_operatorContext) AllColid() []IColidContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IColidContext); ok { len++ } } tst := make([]IColidContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IColidContext); ok { tst[i] = t.(IColidContext) i++ } } return tst } func (s *Any_operatorContext) Colid(i int) IColidContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IColidContext) } func (s *Any_operatorContext) AllDOT() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserDOT) } func (s *Any_operatorContext) DOT(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOT, i) } func (s *Any_operatorContext) GetRuleContext() antlr.RuleContext { return s } func (s *Any_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Any_operatorContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAny_operator(s) } } func (s *Any_operatorContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAny_operator(s) } } func (s *Any_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAny_operator(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Any_operator() (localctx IAny_operatorContext) { localctx = NewAny_operatorContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 684, PostgreSQLParserRULE_any_operator) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(5720) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&2459027012145119232) != 0) || ((int64((_la-92)) & ^0x3f) == 0 && ((int64(1)<<(_la-92))&-113665638399) != 0) || ((int64((_la-156)) & ^0x3f) == 0 && ((int64(1)<<(_la-156))&-1) != 0) || ((int64((_la-220)) & ^0x3f) == 0 && ((int64(1)<<(_la-220))&-9663676417) != 0) || ((int64((_la-284)) & ^0x3f) == 0 && ((int64(1)<<(_la-284))&-1) != 0) || ((int64((_la-348)) & ^0x3f) == 0 && ((int64(1)<<(_la-348))&-1) != 0) || ((int64((_la-412)) & ^0x3f) == 0 && ((int64(1)<<(_la-412))&-1152925902653358081) != 0) || ((int64((_la-476)) & ^0x3f) == 0 && ((int64(1)<<(_la-476))&-8796764110849) != 0) || ((int64((_la-540)) & ^0x3f) == 0 && ((int64(1)<<(_la-540))&-1) != 0) || ((int64((_la-604)) & ^0x3f) == 0 && ((int64(1)<<(_la-604))&432345718846390271) != 0) { { p.SetState(5715) p.Colid() } { p.SetState(5716) p.Match(PostgreSQLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(5722) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } { p.SetState(5723) p.All_op() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOperator_with_argtypes_listContext is an interface to support dynamic dispatch. type IOperator_with_argtypes_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllOperator_with_argtypes() []IOperator_with_argtypesContext Operator_with_argtypes(i int) IOperator_with_argtypesContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsOperator_with_argtypes_listContext differentiates from other interfaces. IsOperator_with_argtypes_listContext() } type Operator_with_argtypes_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOperator_with_argtypes_listContext() *Operator_with_argtypes_listContext { var p = new(Operator_with_argtypes_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_operator_with_argtypes_list return p } func InitEmptyOperator_with_argtypes_listContext(p *Operator_with_argtypes_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_operator_with_argtypes_list } func (*Operator_with_argtypes_listContext) IsOperator_with_argtypes_listContext() {} func NewOperator_with_argtypes_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_with_argtypes_listContext { var p = new(Operator_with_argtypes_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_operator_with_argtypes_list return p } func (s *Operator_with_argtypes_listContext) GetParser() antlr.Parser { return s.parser } func (s *Operator_with_argtypes_listContext) AllOperator_with_argtypes() []IOperator_with_argtypesContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IOperator_with_argtypesContext); ok { len++ } } tst := make([]IOperator_with_argtypesContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IOperator_with_argtypesContext); ok { tst[i] = t.(IOperator_with_argtypesContext) i++ } } return tst } func (s *Operator_with_argtypes_listContext) Operator_with_argtypes(i int) IOperator_with_argtypesContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOperator_with_argtypesContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IOperator_with_argtypesContext) } func (s *Operator_with_argtypes_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Operator_with_argtypes_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Operator_with_argtypes_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Operator_with_argtypes_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Operator_with_argtypes_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOperator_with_argtypes_list(s) } } func (s *Operator_with_argtypes_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOperator_with_argtypes_list(s) } } func (s *Operator_with_argtypes_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOperator_with_argtypes_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Operator_with_argtypes_list() (localctx IOperator_with_argtypes_listContext) { localctx = NewOperator_with_argtypes_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 686, PostgreSQLParserRULE_operator_with_argtypes_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5725) p.Operator_with_argtypes() } p.SetState(5730) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(5726) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5727) p.Operator_with_argtypes() } p.SetState(5732) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOperator_with_argtypesContext is an interface to support dynamic dispatch. type IOperator_with_argtypesContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Any_operator() IAny_operatorContext Oper_argtypes() IOper_argtypesContext // IsOperator_with_argtypesContext differentiates from other interfaces. IsOperator_with_argtypesContext() } type Operator_with_argtypesContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOperator_with_argtypesContext() *Operator_with_argtypesContext { var p = new(Operator_with_argtypesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_operator_with_argtypes return p } func InitEmptyOperator_with_argtypesContext(p *Operator_with_argtypesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_operator_with_argtypes } func (*Operator_with_argtypesContext) IsOperator_with_argtypesContext() {} func NewOperator_with_argtypesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_with_argtypesContext { var p = new(Operator_with_argtypesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_operator_with_argtypes return p } func (s *Operator_with_argtypesContext) GetParser() antlr.Parser { return s.parser } func (s *Operator_with_argtypesContext) Any_operator() IAny_operatorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_operatorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_operatorContext) } func (s *Operator_with_argtypesContext) Oper_argtypes() IOper_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOper_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOper_argtypesContext) } func (s *Operator_with_argtypesContext) GetRuleContext() antlr.RuleContext { return s } func (s *Operator_with_argtypesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Operator_with_argtypesContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOperator_with_argtypes(s) } } func (s *Operator_with_argtypesContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOperator_with_argtypes(s) } } func (s *Operator_with_argtypesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOperator_with_argtypes(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Operator_with_argtypes() (localctx IOperator_with_argtypesContext) { localctx = NewOperator_with_argtypesContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 688, PostgreSQLParserRULE_operator_with_argtypes) p.EnterOuterAlt(localctx, 1) { p.SetState(5733) p.Any_operator() } { p.SetState(5734) p.Oper_argtypes() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDostmtContext is an interface to support dynamic dispatch. type IDostmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DO() antlr.TerminalNode Dostmt_opt_list() IDostmt_opt_listContext // IsDostmtContext differentiates from other interfaces. IsDostmtContext() } type DostmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDostmtContext() *DostmtContext { var p = new(DostmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dostmt return p } func InitEmptyDostmtContext(p *DostmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dostmt } func (*DostmtContext) IsDostmtContext() {} func NewDostmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DostmtContext { var p = new(DostmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_dostmt return p } func (s *DostmtContext) GetParser() antlr.Parser { return s.parser } func (s *DostmtContext) DO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDO, 0) } func (s *DostmtContext) Dostmt_opt_list() IDostmt_opt_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDostmt_opt_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDostmt_opt_listContext) } func (s *DostmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DostmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DostmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDostmt(s) } } func (s *DostmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDostmt(s) } } func (s *DostmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDostmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Dostmt() (localctx IDostmtContext) { localctx = NewDostmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 690, PostgreSQLParserRULE_dostmt) p.EnterOuterAlt(localctx, 1) { p.SetState(5736) p.Match(PostgreSQLParserDO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5737) p.Dostmt_opt_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDostmt_opt_listContext is an interface to support dynamic dispatch. type IDostmt_opt_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllDostmt_opt_item() []IDostmt_opt_itemContext Dostmt_opt_item(i int) IDostmt_opt_itemContext // IsDostmt_opt_listContext differentiates from other interfaces. IsDostmt_opt_listContext() } type Dostmt_opt_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDostmt_opt_listContext() *Dostmt_opt_listContext { var p = new(Dostmt_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dostmt_opt_list return p } func InitEmptyDostmt_opt_listContext(p *Dostmt_opt_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dostmt_opt_list } func (*Dostmt_opt_listContext) IsDostmt_opt_listContext() {} func NewDostmt_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dostmt_opt_listContext { var p = new(Dostmt_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_dostmt_opt_list return p } func (s *Dostmt_opt_listContext) GetParser() antlr.Parser { return s.parser } func (s *Dostmt_opt_listContext) AllDostmt_opt_item() []IDostmt_opt_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IDostmt_opt_itemContext); ok { len++ } } tst := make([]IDostmt_opt_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IDostmt_opt_itemContext); ok { tst[i] = t.(IDostmt_opt_itemContext) i++ } } return tst } func (s *Dostmt_opt_listContext) Dostmt_opt_item(i int) IDostmt_opt_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDostmt_opt_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IDostmt_opt_itemContext) } func (s *Dostmt_opt_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Dostmt_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Dostmt_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDostmt_opt_list(s) } } func (s *Dostmt_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDostmt_opt_list(s) } } func (s *Dostmt_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDostmt_opt_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Dostmt_opt_list() (localctx IDostmt_opt_listContext) { localctx = NewDostmt_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 692, PostgreSQLParserRULE_dostmt_opt_list) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(5740) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ok := true; ok; ok = _la == PostgreSQLParserLANGUAGE || ((int64((_la-645)) & ^0x3f) == 0 && ((int64(1)<<(_la-645))&67108885) != 0) { { p.SetState(5739) p.Dostmt_opt_item() } p.SetState(5742) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDostmt_opt_itemContext is an interface to support dynamic dispatch. type IDostmt_opt_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sconst() ISconstContext LANGUAGE() antlr.TerminalNode Nonreservedword_or_sconst() INonreservedword_or_sconstContext // IsDostmt_opt_itemContext differentiates from other interfaces. IsDostmt_opt_itemContext() } type Dostmt_opt_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDostmt_opt_itemContext() *Dostmt_opt_itemContext { var p = new(Dostmt_opt_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dostmt_opt_item return p } func InitEmptyDostmt_opt_itemContext(p *Dostmt_opt_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dostmt_opt_item } func (*Dostmt_opt_itemContext) IsDostmt_opt_itemContext() {} func NewDostmt_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dostmt_opt_itemContext { var p = new(Dostmt_opt_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_dostmt_opt_item return p } func (s *Dostmt_opt_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Dostmt_opt_itemContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Dostmt_opt_itemContext) LANGUAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLANGUAGE, 0) } func (s *Dostmt_opt_itemContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INonreservedword_or_sconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INonreservedword_or_sconstContext) } func (s *Dostmt_opt_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Dostmt_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Dostmt_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDostmt_opt_item(s) } } func (s *Dostmt_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDostmt_opt_item(s) } } func (s *Dostmt_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDostmt_opt_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Dostmt_opt_item() (localctx IDostmt_opt_itemContext) { localctx = NewDostmt_opt_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 694, PostgreSQLParserRULE_dostmt_opt_item) p.SetState(5747) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(5744) p.Sconst() } case PostgreSQLParserLANGUAGE: p.EnterOuterAlt(localctx, 2) { p.SetState(5745) p.Match(PostgreSQLParserLANGUAGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5746) p.Nonreservedword_or_sconst() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatecaststmtContext is an interface to support dynamic dispatch. type ICreatecaststmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode CAST() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode AllTypename() []ITypenameContext Typename(i int) ITypenameContext AS() antlr.TerminalNode CLOSE_PAREN() antlr.TerminalNode WITH() antlr.TerminalNode FUNCTION() antlr.TerminalNode Function_with_argtypes() IFunction_with_argtypesContext Cast_context() ICast_contextContext WITHOUT() antlr.TerminalNode INOUT() antlr.TerminalNode // IsCreatecaststmtContext differentiates from other interfaces. IsCreatecaststmtContext() } type CreatecaststmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatecaststmtContext() *CreatecaststmtContext { var p = new(CreatecaststmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createcaststmt return p } func InitEmptyCreatecaststmtContext(p *CreatecaststmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createcaststmt } func (*CreatecaststmtContext) IsCreatecaststmtContext() {} func NewCreatecaststmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatecaststmtContext { var p = new(CreatecaststmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createcaststmt return p } func (s *CreatecaststmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreatecaststmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreatecaststmtContext) CAST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCAST, 0) } func (s *CreatecaststmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *CreatecaststmtContext) AllTypename() []ITypenameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITypenameContext); ok { len++ } } tst := make([]ITypenameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITypenameContext); ok { tst[i] = t.(ITypenameContext) i++ } } return tst } func (s *CreatecaststmtContext) Typename(i int) ITypenameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITypenameContext) } func (s *CreatecaststmtContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *CreatecaststmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *CreatecaststmtContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *CreatecaststmtContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *CreatecaststmtContext) Function_with_argtypes() IFunction_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunction_with_argtypesContext) } func (s *CreatecaststmtContext) Cast_context() ICast_contextContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICast_contextContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICast_contextContext) } func (s *CreatecaststmtContext) WITHOUT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITHOUT, 0) } func (s *CreatecaststmtContext) INOUT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINOUT, 0) } func (s *CreatecaststmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreatecaststmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreatecaststmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatecaststmt(s) } } func (s *CreatecaststmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatecaststmt(s) } } func (s *CreatecaststmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatecaststmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createcaststmt() (localctx ICreatecaststmtContext) { localctx = NewCreatecaststmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 696, PostgreSQLParserRULE_createcaststmt) p.SetState(5783) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 303, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5749) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5750) p.Match(PostgreSQLParserCAST) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5751) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5752) p.Typename() } { p.SetState(5753) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5754) p.Typename() } { p.SetState(5755) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5756) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5757) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5758) p.Function_with_argtypes() } { p.SetState(5759) p.Cast_context() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5761) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5762) p.Match(PostgreSQLParserCAST) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5763) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5764) p.Typename() } { p.SetState(5765) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5766) p.Typename() } { p.SetState(5767) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5768) p.Match(PostgreSQLParserWITHOUT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5769) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5770) p.Cast_context() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(5772) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5773) p.Match(PostgreSQLParserCAST) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5774) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5775) p.Typename() } { p.SetState(5776) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5777) p.Typename() } { p.SetState(5778) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5779) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5780) p.Match(PostgreSQLParserINOUT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5781) p.Cast_context() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICast_contextContext is an interface to support dynamic dispatch. type ICast_contextContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AS() antlr.TerminalNode IMPLICIT_P() antlr.TerminalNode ASSIGNMENT() antlr.TerminalNode // IsCast_contextContext differentiates from other interfaces. IsCast_contextContext() } type Cast_contextContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCast_contextContext() *Cast_contextContext { var p = new(Cast_contextContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_cast_context return p } func InitEmptyCast_contextContext(p *Cast_contextContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_cast_context } func (*Cast_contextContext) IsCast_contextContext() {} func NewCast_contextContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cast_contextContext { var p = new(Cast_contextContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_cast_context return p } func (s *Cast_contextContext) GetParser() antlr.Parser { return s.parser } func (s *Cast_contextContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Cast_contextContext) IMPLICIT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIMPLICIT_P, 0) } func (s *Cast_contextContext) ASSIGNMENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserASSIGNMENT, 0) } func (s *Cast_contextContext) GetRuleContext() antlr.RuleContext { return s } func (s *Cast_contextContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Cast_contextContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCast_context(s) } } func (s *Cast_contextContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCast_context(s) } } func (s *Cast_contextContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCast_context(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Cast_context() (localctx ICast_contextContext) { localctx = NewCast_contextContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 698, PostgreSQLParserRULE_cast_context) p.SetState(5790) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 304, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5785) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5786) p.Match(PostgreSQLParserIMPLICIT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5787) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5788) p.Match(PostgreSQLParserASSIGNMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDropcaststmtContext is an interface to support dynamic dispatch. type IDropcaststmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DROP() antlr.TerminalNode CAST() antlr.TerminalNode Opt_if_exists() IOpt_if_existsContext OPEN_PAREN() antlr.TerminalNode AllTypename() []ITypenameContext Typename(i int) ITypenameContext AS() antlr.TerminalNode CLOSE_PAREN() antlr.TerminalNode Opt_drop_behavior() IOpt_drop_behaviorContext // IsDropcaststmtContext differentiates from other interfaces. IsDropcaststmtContext() } type DropcaststmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDropcaststmtContext() *DropcaststmtContext { var p = new(DropcaststmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropcaststmt return p } func InitEmptyDropcaststmtContext(p *DropcaststmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropcaststmt } func (*DropcaststmtContext) IsDropcaststmtContext() {} func NewDropcaststmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropcaststmtContext { var p = new(DropcaststmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_dropcaststmt return p } func (s *DropcaststmtContext) GetParser() antlr.Parser { return s.parser } func (s *DropcaststmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *DropcaststmtContext) CAST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCAST, 0) } func (s *DropcaststmtContext) Opt_if_exists() IOpt_if_existsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_if_existsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_if_existsContext) } func (s *DropcaststmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *DropcaststmtContext) AllTypename() []ITypenameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITypenameContext); ok { len++ } } tst := make([]ITypenameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITypenameContext); ok { tst[i] = t.(ITypenameContext) i++ } } return tst } func (s *DropcaststmtContext) Typename(i int) ITypenameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITypenameContext) } func (s *DropcaststmtContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *DropcaststmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *DropcaststmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *DropcaststmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DropcaststmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DropcaststmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDropcaststmt(s) } } func (s *DropcaststmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDropcaststmt(s) } } func (s *DropcaststmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDropcaststmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Dropcaststmt() (localctx IDropcaststmtContext) { localctx = NewDropcaststmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 700, PostgreSQLParserRULE_dropcaststmt) p.EnterOuterAlt(localctx, 1) { p.SetState(5792) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5793) p.Match(PostgreSQLParserCAST) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5794) p.Opt_if_exists() } { p.SetState(5795) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5796) p.Typename() } { p.SetState(5797) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5798) p.Typename() } { p.SetState(5799) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5800) p.Opt_drop_behavior() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_if_existsContext is an interface to support dynamic dispatch. type IOpt_if_existsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsOpt_if_existsContext differentiates from other interfaces. IsOpt_if_existsContext() } type Opt_if_existsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_if_existsContext() *Opt_if_existsContext { var p = new(Opt_if_existsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_if_exists return p } func InitEmptyOpt_if_existsContext(p *Opt_if_existsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_if_exists } func (*Opt_if_existsContext) IsOpt_if_existsContext() {} func NewOpt_if_existsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_if_existsContext { var p = new(Opt_if_existsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_if_exists return p } func (s *Opt_if_existsContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_if_existsContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *Opt_if_existsContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *Opt_if_existsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_if_existsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_if_existsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_if_exists(s) } } func (s *Opt_if_existsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_if_exists(s) } } func (s *Opt_if_existsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_if_exists(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_if_exists() (localctx IOpt_if_existsContext) { localctx = NewOpt_if_existsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 702, PostgreSQLParserRULE_opt_if_exists) p.SetState(5805) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserIF_P: p.EnterOuterAlt(localctx, 1) { p.SetState(5802) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5803) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserOPEN_PAREN, PostgreSQLParserFOR: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatetransformstmtContext is an interface to support dynamic dispatch. type ICreatetransformstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode Opt_or_replace() IOpt_or_replaceContext TRANSFORM() antlr.TerminalNode FOR() antlr.TerminalNode Typename() ITypenameContext LANGUAGE() antlr.TerminalNode Name() INameContext OPEN_PAREN() antlr.TerminalNode Transform_element_list() ITransform_element_listContext CLOSE_PAREN() antlr.TerminalNode // IsCreatetransformstmtContext differentiates from other interfaces. IsCreatetransformstmtContext() } type CreatetransformstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatetransformstmtContext() *CreatetransformstmtContext { var p = new(CreatetransformstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createtransformstmt return p } func InitEmptyCreatetransformstmtContext(p *CreatetransformstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createtransformstmt } func (*CreatetransformstmtContext) IsCreatetransformstmtContext() {} func NewCreatetransformstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatetransformstmtContext { var p = new(CreatetransformstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createtransformstmt return p } func (s *CreatetransformstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreatetransformstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreatetransformstmtContext) Opt_or_replace() IOpt_or_replaceContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_or_replaceContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_or_replaceContext) } func (s *CreatetransformstmtContext) TRANSFORM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSFORM, 0) } func (s *CreatetransformstmtContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *CreatetransformstmtContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *CreatetransformstmtContext) LANGUAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLANGUAGE, 0) } func (s *CreatetransformstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreatetransformstmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *CreatetransformstmtContext) Transform_element_list() ITransform_element_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITransform_element_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITransform_element_listContext) } func (s *CreatetransformstmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *CreatetransformstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreatetransformstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreatetransformstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatetransformstmt(s) } } func (s *CreatetransformstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatetransformstmt(s) } } func (s *CreatetransformstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatetransformstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createtransformstmt() (localctx ICreatetransformstmtContext) { localctx = NewCreatetransformstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 704, PostgreSQLParserRULE_createtransformstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(5807) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5808) p.Opt_or_replace() } { p.SetState(5809) p.Match(PostgreSQLParserTRANSFORM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5810) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5811) p.Typename() } { p.SetState(5812) p.Match(PostgreSQLParserLANGUAGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5813) p.Name() } { p.SetState(5814) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5815) p.Transform_element_list() } { p.SetState(5816) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITransform_element_listContext is an interface to support dynamic dispatch. type ITransform_element_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FROM() antlr.TerminalNode AllSQL_P() []antlr.TerminalNode SQL_P(i int) antlr.TerminalNode AllWITH() []antlr.TerminalNode WITH(i int) antlr.TerminalNode AllFUNCTION() []antlr.TerminalNode FUNCTION(i int) antlr.TerminalNode AllFunction_with_argtypes() []IFunction_with_argtypesContext Function_with_argtypes(i int) IFunction_with_argtypesContext COMMA() antlr.TerminalNode TO() antlr.TerminalNode // IsTransform_element_listContext differentiates from other interfaces. IsTransform_element_listContext() } type Transform_element_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTransform_element_listContext() *Transform_element_listContext { var p = new(Transform_element_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transform_element_list return p } func InitEmptyTransform_element_listContext(p *Transform_element_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transform_element_list } func (*Transform_element_listContext) IsTransform_element_listContext() {} func NewTransform_element_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transform_element_listContext { var p = new(Transform_element_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_transform_element_list return p } func (s *Transform_element_listContext) GetParser() antlr.Parser { return s.parser } func (s *Transform_element_listContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *Transform_element_listContext) AllSQL_P() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserSQL_P) } func (s *Transform_element_listContext) SQL_P(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserSQL_P, i) } func (s *Transform_element_listContext) AllWITH() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserWITH) } func (s *Transform_element_listContext) WITH(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, i) } func (s *Transform_element_listContext) AllFUNCTION() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserFUNCTION) } func (s *Transform_element_listContext) FUNCTION(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, i) } func (s *Transform_element_listContext) AllFunction_with_argtypes() []IFunction_with_argtypesContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IFunction_with_argtypesContext); ok { len++ } } tst := make([]IFunction_with_argtypesContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IFunction_with_argtypesContext); ok { tst[i] = t.(IFunction_with_argtypesContext) i++ } } return tst } func (s *Transform_element_listContext) Function_with_argtypes(i int) IFunction_with_argtypesContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_with_argtypesContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IFunction_with_argtypesContext) } func (s *Transform_element_listContext) COMMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, 0) } func (s *Transform_element_listContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *Transform_element_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Transform_element_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Transform_element_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTransform_element_list(s) } } func (s *Transform_element_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTransform_element_list(s) } } func (s *Transform_element_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTransform_element_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Transform_element_list() (localctx ITransform_element_listContext) { localctx = NewTransform_element_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 706, PostgreSQLParserRULE_transform_element_list) p.SetState(5852) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 306, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5818) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5819) p.Match(PostgreSQLParserSQL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5820) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5821) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5822) p.Function_with_argtypes() } { p.SetState(5823) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5824) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5825) p.Match(PostgreSQLParserSQL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5826) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5827) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5828) p.Function_with_argtypes() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5830) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5831) p.Match(PostgreSQLParserSQL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5832) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5833) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5834) p.Function_with_argtypes() } { p.SetState(5835) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5836) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5837) p.Match(PostgreSQLParserSQL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5838) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5839) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5840) p.Function_with_argtypes() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(5842) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5843) p.Match(PostgreSQLParserSQL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5844) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5845) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5846) p.Function_with_argtypes() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(5847) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5848) p.Match(PostgreSQLParserSQL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5849) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5850) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5851) p.Function_with_argtypes() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDroptransformstmtContext is an interface to support dynamic dispatch. type IDroptransformstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DROP() antlr.TerminalNode TRANSFORM() antlr.TerminalNode Opt_if_exists() IOpt_if_existsContext FOR() antlr.TerminalNode Typename() ITypenameContext LANGUAGE() antlr.TerminalNode Name() INameContext Opt_drop_behavior() IOpt_drop_behaviorContext // IsDroptransformstmtContext differentiates from other interfaces. IsDroptransformstmtContext() } type DroptransformstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDroptransformstmtContext() *DroptransformstmtContext { var p = new(DroptransformstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_droptransformstmt return p } func InitEmptyDroptransformstmtContext(p *DroptransformstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_droptransformstmt } func (*DroptransformstmtContext) IsDroptransformstmtContext() {} func NewDroptransformstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DroptransformstmtContext { var p = new(DroptransformstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_droptransformstmt return p } func (s *DroptransformstmtContext) GetParser() antlr.Parser { return s.parser } func (s *DroptransformstmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *DroptransformstmtContext) TRANSFORM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSFORM, 0) } func (s *DroptransformstmtContext) Opt_if_exists() IOpt_if_existsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_if_existsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_if_existsContext) } func (s *DroptransformstmtContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *DroptransformstmtContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *DroptransformstmtContext) LANGUAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLANGUAGE, 0) } func (s *DroptransformstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *DroptransformstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *DroptransformstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DroptransformstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DroptransformstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDroptransformstmt(s) } } func (s *DroptransformstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDroptransformstmt(s) } } func (s *DroptransformstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDroptransformstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Droptransformstmt() (localctx IDroptransformstmtContext) { localctx = NewDroptransformstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 708, PostgreSQLParserRULE_droptransformstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(5854) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5855) p.Match(PostgreSQLParserTRANSFORM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5856) p.Opt_if_exists() } { p.SetState(5857) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5858) p.Typename() } { p.SetState(5859) p.Match(PostgreSQLParserLANGUAGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5860) p.Name() } { p.SetState(5861) p.Opt_drop_behavior() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IReindexstmtContext is an interface to support dynamic dispatch. type IReindexstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures REINDEX() antlr.TerminalNode Reindex_target_type() IReindex_target_typeContext Opt_concurrently() IOpt_concurrentlyContext Qualified_name() IQualified_nameContext Reindex_target_multitable() IReindex_target_multitableContext Name() INameContext OPEN_PAREN() antlr.TerminalNode Reindex_option_list() IReindex_option_listContext CLOSE_PAREN() antlr.TerminalNode // IsReindexstmtContext differentiates from other interfaces. IsReindexstmtContext() } type ReindexstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyReindexstmtContext() *ReindexstmtContext { var p = new(ReindexstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reindexstmt return p } func InitEmptyReindexstmtContext(p *ReindexstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reindexstmt } func (*ReindexstmtContext) IsReindexstmtContext() {} func NewReindexstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReindexstmtContext { var p = new(ReindexstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_reindexstmt return p } func (s *ReindexstmtContext) GetParser() antlr.Parser { return s.parser } func (s *ReindexstmtContext) REINDEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREINDEX, 0) } func (s *ReindexstmtContext) Reindex_target_type() IReindex_target_typeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReindex_target_typeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReindex_target_typeContext) } func (s *ReindexstmtContext) Opt_concurrently() IOpt_concurrentlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_concurrentlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_concurrentlyContext) } func (s *ReindexstmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *ReindexstmtContext) Reindex_target_multitable() IReindex_target_multitableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReindex_target_multitableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReindex_target_multitableContext) } func (s *ReindexstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *ReindexstmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *ReindexstmtContext) Reindex_option_list() IReindex_option_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReindex_option_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReindex_option_listContext) } func (s *ReindexstmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *ReindexstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *ReindexstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ReindexstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterReindexstmt(s) } } func (s *ReindexstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitReindexstmt(s) } } func (s *ReindexstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitReindexstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Reindexstmt() (localctx IReindexstmtContext) { localctx = NewReindexstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 710, PostgreSQLParserRULE_reindexstmt) p.SetState(5889) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 307, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5863) p.Match(PostgreSQLParserREINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5864) p.Reindex_target_type() } { p.SetState(5865) p.Opt_concurrently() } { p.SetState(5866) p.Qualified_name() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5868) p.Match(PostgreSQLParserREINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5869) p.Reindex_target_multitable() } { p.SetState(5870) p.Opt_concurrently() } { p.SetState(5871) p.Name() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(5873) p.Match(PostgreSQLParserREINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5874) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5875) p.Reindex_option_list() } { p.SetState(5876) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5877) p.Reindex_target_type() } { p.SetState(5878) p.Opt_concurrently() } { p.SetState(5879) p.Qualified_name() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(5881) p.Match(PostgreSQLParserREINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5882) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5883) p.Reindex_option_list() } { p.SetState(5884) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5885) p.Reindex_target_multitable() } { p.SetState(5886) p.Opt_concurrently() } { p.SetState(5887) p.Name() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IReindex_target_typeContext is an interface to support dynamic dispatch. type IReindex_target_typeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures INDEX() antlr.TerminalNode TABLE() antlr.TerminalNode SCHEMA() antlr.TerminalNode DATABASE() antlr.TerminalNode SYSTEM_P() antlr.TerminalNode // IsReindex_target_typeContext differentiates from other interfaces. IsReindex_target_typeContext() } type Reindex_target_typeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyReindex_target_typeContext() *Reindex_target_typeContext { var p = new(Reindex_target_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reindex_target_type return p } func InitEmptyReindex_target_typeContext(p *Reindex_target_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reindex_target_type } func (*Reindex_target_typeContext) IsReindex_target_typeContext() {} func NewReindex_target_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_target_typeContext { var p = new(Reindex_target_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_reindex_target_type return p } func (s *Reindex_target_typeContext) GetParser() antlr.Parser { return s.parser } func (s *Reindex_target_typeContext) INDEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINDEX, 0) } func (s *Reindex_target_typeContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *Reindex_target_typeContext) SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMA, 0) } func (s *Reindex_target_typeContext) DATABASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATABASE, 0) } func (s *Reindex_target_typeContext) SYSTEM_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSYSTEM_P, 0) } func (s *Reindex_target_typeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Reindex_target_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Reindex_target_typeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterReindex_target_type(s) } } func (s *Reindex_target_typeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitReindex_target_type(s) } } func (s *Reindex_target_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitReindex_target_type(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Reindex_target_type() (localctx IReindex_target_typeContext) { localctx = NewReindex_target_typeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 712, PostgreSQLParserRULE_reindex_target_type) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5891) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserTABLE || _la == PostgreSQLParserDATABASE || _la == PostgreSQLParserINDEX || _la == PostgreSQLParserSCHEMA || _la == PostgreSQLParserSYSTEM_P) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IReindex_target_multitableContext is an interface to support dynamic dispatch. type IReindex_target_multitableContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SCHEMA() antlr.TerminalNode SYSTEM_P() antlr.TerminalNode DATABASE() antlr.TerminalNode // IsReindex_target_multitableContext differentiates from other interfaces. IsReindex_target_multitableContext() } type Reindex_target_multitableContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyReindex_target_multitableContext() *Reindex_target_multitableContext { var p = new(Reindex_target_multitableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reindex_target_multitable return p } func InitEmptyReindex_target_multitableContext(p *Reindex_target_multitableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reindex_target_multitable } func (*Reindex_target_multitableContext) IsReindex_target_multitableContext() {} func NewReindex_target_multitableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_target_multitableContext { var p = new(Reindex_target_multitableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_reindex_target_multitable return p } func (s *Reindex_target_multitableContext) GetParser() antlr.Parser { return s.parser } func (s *Reindex_target_multitableContext) SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMA, 0) } func (s *Reindex_target_multitableContext) SYSTEM_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSYSTEM_P, 0) } func (s *Reindex_target_multitableContext) DATABASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATABASE, 0) } func (s *Reindex_target_multitableContext) GetRuleContext() antlr.RuleContext { return s } func (s *Reindex_target_multitableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Reindex_target_multitableContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterReindex_target_multitable(s) } } func (s *Reindex_target_multitableContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitReindex_target_multitable(s) } } func (s *Reindex_target_multitableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitReindex_target_multitable(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Reindex_target_multitable() (localctx IReindex_target_multitableContext) { localctx = NewReindex_target_multitableContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 714, PostgreSQLParserRULE_reindex_target_multitable) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5893) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserDATABASE || _la == PostgreSQLParserSCHEMA || _la == PostgreSQLParserSYSTEM_P) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IReindex_option_listContext is an interface to support dynamic dispatch. type IReindex_option_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllReindex_option_elem() []IReindex_option_elemContext Reindex_option_elem(i int) IReindex_option_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsReindex_option_listContext differentiates from other interfaces. IsReindex_option_listContext() } type Reindex_option_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyReindex_option_listContext() *Reindex_option_listContext { var p = new(Reindex_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reindex_option_list return p } func InitEmptyReindex_option_listContext(p *Reindex_option_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reindex_option_list } func (*Reindex_option_listContext) IsReindex_option_listContext() {} func NewReindex_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_option_listContext { var p = new(Reindex_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_reindex_option_list return p } func (s *Reindex_option_listContext) GetParser() antlr.Parser { return s.parser } func (s *Reindex_option_listContext) AllReindex_option_elem() []IReindex_option_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IReindex_option_elemContext); ok { len++ } } tst := make([]IReindex_option_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IReindex_option_elemContext); ok { tst[i] = t.(IReindex_option_elemContext) i++ } } return tst } func (s *Reindex_option_listContext) Reindex_option_elem(i int) IReindex_option_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReindex_option_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IReindex_option_elemContext) } func (s *Reindex_option_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Reindex_option_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Reindex_option_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Reindex_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Reindex_option_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterReindex_option_list(s) } } func (s *Reindex_option_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitReindex_option_list(s) } } func (s *Reindex_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitReindex_option_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Reindex_option_list() (localctx IReindex_option_listContext) { localctx = NewReindex_option_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 716, PostgreSQLParserRULE_reindex_option_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5895) p.Reindex_option_elem() } p.SetState(5900) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(5896) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5897) p.Reindex_option_elem() } p.SetState(5902) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IReindex_option_elemContext is an interface to support dynamic dispatch. type IReindex_option_elemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures VERBOSE() antlr.TerminalNode TABLESPACE() antlr.TerminalNode CONCURRENTLY() antlr.TerminalNode // IsReindex_option_elemContext differentiates from other interfaces. IsReindex_option_elemContext() } type Reindex_option_elemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyReindex_option_elemContext() *Reindex_option_elemContext { var p = new(Reindex_option_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reindex_option_elem return p } func InitEmptyReindex_option_elemContext(p *Reindex_option_elemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reindex_option_elem } func (*Reindex_option_elemContext) IsReindex_option_elemContext() {} func NewReindex_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_option_elemContext { var p = new(Reindex_option_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_reindex_option_elem return p } func (s *Reindex_option_elemContext) GetParser() antlr.Parser { return s.parser } func (s *Reindex_option_elemContext) VERBOSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVERBOSE, 0) } func (s *Reindex_option_elemContext) TABLESPACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, 0) } func (s *Reindex_option_elemContext) CONCURRENTLY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONCURRENTLY, 0) } func (s *Reindex_option_elemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Reindex_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Reindex_option_elemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterReindex_option_elem(s) } } func (s *Reindex_option_elemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitReindex_option_elem(s) } } func (s *Reindex_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitReindex_option_elem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Reindex_option_elem() (localctx IReindex_option_elemContext) { localctx = NewReindex_option_elemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 718, PostgreSQLParserRULE_reindex_option_elem) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5903) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserCONCURRENTLY || _la == PostgreSQLParserVERBOSE || _la == PostgreSQLParserTABLESPACE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAltertblspcstmtContext is an interface to support dynamic dispatch. type IAltertblspcstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode TABLESPACE() antlr.TerminalNode Name() INameContext SET() antlr.TerminalNode Reloptions() IReloptionsContext RESET() antlr.TerminalNode // IsAltertblspcstmtContext differentiates from other interfaces. IsAltertblspcstmtContext() } type AltertblspcstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAltertblspcstmtContext() *AltertblspcstmtContext { var p = new(AltertblspcstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altertblspcstmt return p } func InitEmptyAltertblspcstmtContext(p *AltertblspcstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altertblspcstmt } func (*AltertblspcstmtContext) IsAltertblspcstmtContext() {} func NewAltertblspcstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertblspcstmtContext { var p = new(AltertblspcstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_altertblspcstmt return p } func (s *AltertblspcstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AltertblspcstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AltertblspcstmtContext) TABLESPACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, 0) } func (s *AltertblspcstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *AltertblspcstmtContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *AltertblspcstmtContext) Reloptions() IReloptionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReloptionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReloptionsContext) } func (s *AltertblspcstmtContext) RESET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESET, 0) } func (s *AltertblspcstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AltertblspcstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AltertblspcstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAltertblspcstmt(s) } } func (s *AltertblspcstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAltertblspcstmt(s) } } func (s *AltertblspcstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAltertblspcstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Altertblspcstmt() (localctx IAltertblspcstmtContext) { localctx = NewAltertblspcstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 720, PostgreSQLParserRULE_altertblspcstmt) p.SetState(5917) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 309, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5905) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5906) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5907) p.Name() } { p.SetState(5908) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5909) p.Reloptions() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5911) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5912) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5913) p.Name() } { p.SetState(5914) p.Match(PostgreSQLParserRESET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5915) p.Reloptions() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRenamestmtContext is an interface to support dynamic dispatch. type IRenamestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode AGGREGATE() antlr.TerminalNode Aggregate_with_argtypes() IAggregate_with_argtypesContext RENAME() antlr.TerminalNode TO() antlr.TerminalNode AllName() []INameContext Name(i int) INameContext COLLATION() antlr.TerminalNode Any_name() IAny_nameContext CONVERSION_P() antlr.TerminalNode DATABASE() antlr.TerminalNode DOMAIN_P() antlr.TerminalNode CONSTRAINT() antlr.TerminalNode FOREIGN() antlr.TerminalNode DATA_P() antlr.TerminalNode WRAPPER() antlr.TerminalNode FUNCTION() antlr.TerminalNode Function_with_argtypes() IFunction_with_argtypesContext GROUP_P() antlr.TerminalNode AllRoleid() []IRoleidContext Roleid(i int) IRoleidContext Opt_procedural() IOpt_proceduralContext LANGUAGE() antlr.TerminalNode OPERATOR() antlr.TerminalNode CLASS() antlr.TerminalNode USING() antlr.TerminalNode FAMILY() antlr.TerminalNode POLICY() antlr.TerminalNode ON() antlr.TerminalNode Qualified_name() IQualified_nameContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode PROCEDURE() antlr.TerminalNode PUBLICATION() antlr.TerminalNode ROUTINE() antlr.TerminalNode SCHEMA() antlr.TerminalNode SERVER() antlr.TerminalNode SUBSCRIPTION() antlr.TerminalNode TABLE() antlr.TerminalNode Relation_expr() IRelation_exprContext SEQUENCE() antlr.TerminalNode VIEW() antlr.TerminalNode MATERIALIZED() antlr.TerminalNode INDEX() antlr.TerminalNode Opt_column() IOpt_columnContext RULE() antlr.TerminalNode TRIGGER() antlr.TerminalNode EVENT() antlr.TerminalNode ROLE() antlr.TerminalNode USER() antlr.TerminalNode TABLESPACE() antlr.TerminalNode STATISTICS() antlr.TerminalNode TEXT_P() antlr.TerminalNode SEARCH() antlr.TerminalNode PARSER() antlr.TerminalNode DICTIONARY() antlr.TerminalNode TEMPLATE() antlr.TerminalNode CONFIGURATION() antlr.TerminalNode TYPE_P() antlr.TerminalNode ATTRIBUTE() antlr.TerminalNode Opt_drop_behavior() IOpt_drop_behaviorContext // IsRenamestmtContext differentiates from other interfaces. IsRenamestmtContext() } type RenamestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRenamestmtContext() *RenamestmtContext { var p = new(RenamestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_renamestmt return p } func InitEmptyRenamestmtContext(p *RenamestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_renamestmt } func (*RenamestmtContext) IsRenamestmtContext() {} func NewRenamestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RenamestmtContext { var p = new(RenamestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_renamestmt return p } func (s *RenamestmtContext) GetParser() antlr.Parser { return s.parser } func (s *RenamestmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *RenamestmtContext) AGGREGATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAGGREGATE, 0) } func (s *RenamestmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAggregate_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAggregate_with_argtypesContext) } func (s *RenamestmtContext) RENAME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRENAME, 0) } func (s *RenamestmtContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *RenamestmtContext) AllName() []INameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(INameContext); ok { len++ } } tst := make([]INameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(INameContext); ok { tst[i] = t.(INameContext) i++ } } return tst } func (s *RenamestmtContext) Name(i int) INameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(INameContext) } func (s *RenamestmtContext) COLLATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATION, 0) } func (s *RenamestmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *RenamestmtContext) CONVERSION_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONVERSION_P, 0) } func (s *RenamestmtContext) DATABASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATABASE, 0) } func (s *RenamestmtContext) DOMAIN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOMAIN_P, 0) } func (s *RenamestmtContext) CONSTRAINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTRAINT, 0) } func (s *RenamestmtContext) FOREIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREIGN, 0) } func (s *RenamestmtContext) DATA_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATA_P, 0) } func (s *RenamestmtContext) WRAPPER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWRAPPER, 0) } func (s *RenamestmtContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *RenamestmtContext) Function_with_argtypes() IFunction_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunction_with_argtypesContext) } func (s *RenamestmtContext) GROUP_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUP_P, 0) } func (s *RenamestmtContext) AllRoleid() []IRoleidContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IRoleidContext); ok { len++ } } tst := make([]IRoleidContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IRoleidContext); ok { tst[i] = t.(IRoleidContext) i++ } } return tst } func (s *RenamestmtContext) Roleid(i int) IRoleidContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRoleidContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IRoleidContext) } func (s *RenamestmtContext) Opt_procedural() IOpt_proceduralContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_proceduralContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_proceduralContext) } func (s *RenamestmtContext) LANGUAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLANGUAGE, 0) } func (s *RenamestmtContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *RenamestmtContext) CLASS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLASS, 0) } func (s *RenamestmtContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *RenamestmtContext) FAMILY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFAMILY, 0) } func (s *RenamestmtContext) POLICY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPOLICY, 0) } func (s *RenamestmtContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *RenamestmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *RenamestmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *RenamestmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *RenamestmtContext) PROCEDURE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURE, 0) } func (s *RenamestmtContext) PUBLICATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPUBLICATION, 0) } func (s *RenamestmtContext) ROUTINE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUTINE, 0) } func (s *RenamestmtContext) SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMA, 0) } func (s *RenamestmtContext) SERVER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSERVER, 0) } func (s *RenamestmtContext) SUBSCRIPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSUBSCRIPTION, 0) } func (s *RenamestmtContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *RenamestmtContext) Relation_expr() IRelation_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRelation_exprContext) } func (s *RenamestmtContext) SEQUENCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEQUENCE, 0) } func (s *RenamestmtContext) VIEW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVIEW, 0) } func (s *RenamestmtContext) MATERIALIZED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMATERIALIZED, 0) } func (s *RenamestmtContext) INDEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINDEX, 0) } func (s *RenamestmtContext) Opt_column() IOpt_columnContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_columnContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_columnContext) } func (s *RenamestmtContext) RULE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRULE, 0) } func (s *RenamestmtContext) TRIGGER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRIGGER, 0) } func (s *RenamestmtContext) EVENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEVENT, 0) } func (s *RenamestmtContext) ROLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLE, 0) } func (s *RenamestmtContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *RenamestmtContext) TABLESPACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, 0) } func (s *RenamestmtContext) STATISTICS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTATISTICS, 0) } func (s *RenamestmtContext) TEXT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEXT_P, 0) } func (s *RenamestmtContext) SEARCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEARCH, 0) } func (s *RenamestmtContext) PARSER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARSER, 0) } func (s *RenamestmtContext) DICTIONARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDICTIONARY, 0) } func (s *RenamestmtContext) TEMPLATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEMPLATE, 0) } func (s *RenamestmtContext) CONFIGURATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONFIGURATION, 0) } func (s *RenamestmtContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *RenamestmtContext) ATTRIBUTE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserATTRIBUTE, 0) } func (s *RenamestmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *RenamestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *RenamestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RenamestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRenamestmt(s) } } func (s *RenamestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRenamestmt(s) } } func (s *RenamestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRenamestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Renamestmt() (localctx IRenamestmtContext) { localctx = NewRenamestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 722, PostgreSQLParserRULE_renamestmt) p.SetState(6387) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 310, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(5919) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5920) p.Match(PostgreSQLParserAGGREGATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5921) p.Aggregate_with_argtypes() } { p.SetState(5922) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5923) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5924) p.Name() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(5926) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5927) p.Match(PostgreSQLParserCOLLATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5928) p.Any_name() } { p.SetState(5929) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5930) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5931) p.Name() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(5933) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5934) p.Match(PostgreSQLParserCONVERSION_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5935) p.Any_name() } { p.SetState(5936) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5937) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5938) p.Name() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(5940) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5941) p.Match(PostgreSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5942) p.Name() } { p.SetState(5943) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5944) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5945) p.Name() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(5947) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5948) p.Match(PostgreSQLParserDOMAIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5949) p.Any_name() } { p.SetState(5950) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5951) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5952) p.Name() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(5954) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5955) p.Match(PostgreSQLParserDOMAIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5956) p.Any_name() } { p.SetState(5957) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5958) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5959) p.Name() } { p.SetState(5960) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5961) p.Name() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(5963) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5964) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5965) p.Match(PostgreSQLParserDATA_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5966) p.Match(PostgreSQLParserWRAPPER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5967) p.Name() } { p.SetState(5968) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5969) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5970) p.Name() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(5972) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5973) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5974) p.Function_with_argtypes() } { p.SetState(5975) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5976) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5977) p.Name() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(5979) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5980) p.Match(PostgreSQLParserGROUP_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5981) p.Roleid() } { p.SetState(5982) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5983) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5984) p.Roleid() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(5986) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5987) p.Opt_procedural() } { p.SetState(5988) p.Match(PostgreSQLParserLANGUAGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5989) p.Name() } { p.SetState(5990) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5991) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5992) p.Name() } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(5994) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5995) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5996) p.Match(PostgreSQLParserCLASS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5997) p.Any_name() } { p.SetState(5998) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(5999) p.Name() } { p.SetState(6000) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6001) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6002) p.Name() } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(6004) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6005) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6006) p.Match(PostgreSQLParserFAMILY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6007) p.Any_name() } { p.SetState(6008) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6009) p.Name() } { p.SetState(6010) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6011) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6012) p.Name() } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(6014) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6015) p.Match(PostgreSQLParserPOLICY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6016) p.Name() } { p.SetState(6017) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6018) p.Qualified_name() } { p.SetState(6019) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6020) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6021) p.Name() } case 14: p.EnterOuterAlt(localctx, 14) { p.SetState(6023) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6024) p.Match(PostgreSQLParserPOLICY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6025) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6026) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6027) p.Name() } { p.SetState(6028) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6029) p.Qualified_name() } { p.SetState(6030) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6031) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6032) p.Name() } case 15: p.EnterOuterAlt(localctx, 15) { p.SetState(6034) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6035) p.Match(PostgreSQLParserPROCEDURE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6036) p.Function_with_argtypes() } { p.SetState(6037) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6038) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6039) p.Name() } case 16: p.EnterOuterAlt(localctx, 16) { p.SetState(6041) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6042) p.Match(PostgreSQLParserPUBLICATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6043) p.Name() } { p.SetState(6044) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6045) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6046) p.Name() } case 17: p.EnterOuterAlt(localctx, 17) { p.SetState(6048) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6049) p.Match(PostgreSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6050) p.Function_with_argtypes() } { p.SetState(6051) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6052) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6053) p.Name() } case 18: p.EnterOuterAlt(localctx, 18) { p.SetState(6055) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6056) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6057) p.Name() } { p.SetState(6058) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6059) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6060) p.Name() } case 19: p.EnterOuterAlt(localctx, 19) { p.SetState(6062) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6063) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6064) p.Name() } { p.SetState(6065) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6066) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6067) p.Name() } case 20: p.EnterOuterAlt(localctx, 20) { p.SetState(6069) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6070) p.Match(PostgreSQLParserSUBSCRIPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6071) p.Name() } { p.SetState(6072) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6073) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6074) p.Name() } case 21: p.EnterOuterAlt(localctx, 21) { p.SetState(6076) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6077) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6078) p.Relation_expr() } { p.SetState(6079) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6080) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6081) p.Name() } case 22: p.EnterOuterAlt(localctx, 22) { p.SetState(6083) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6084) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6085) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6086) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6087) p.Relation_expr() } { p.SetState(6088) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6089) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6090) p.Name() } case 23: p.EnterOuterAlt(localctx, 23) { p.SetState(6092) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6093) p.Match(PostgreSQLParserSEQUENCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6094) p.Qualified_name() } { p.SetState(6095) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6096) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6097) p.Name() } case 24: p.EnterOuterAlt(localctx, 24) { p.SetState(6099) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6100) p.Match(PostgreSQLParserSEQUENCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6101) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6102) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6103) p.Qualified_name() } { p.SetState(6104) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6105) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6106) p.Name() } case 25: p.EnterOuterAlt(localctx, 25) { p.SetState(6108) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6109) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6110) p.Qualified_name() } { p.SetState(6111) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6112) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6113) p.Name() } case 26: p.EnterOuterAlt(localctx, 26) { p.SetState(6115) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6116) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6117) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6118) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6119) p.Qualified_name() } { p.SetState(6120) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6121) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6122) p.Name() } case 27: p.EnterOuterAlt(localctx, 27) { p.SetState(6124) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6125) p.Match(PostgreSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6126) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6127) p.Qualified_name() } { p.SetState(6128) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6129) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6130) p.Name() } case 28: p.EnterOuterAlt(localctx, 28) { p.SetState(6132) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6133) p.Match(PostgreSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6134) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6135) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6136) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6137) p.Qualified_name() } { p.SetState(6138) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6139) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6140) p.Name() } case 29: p.EnterOuterAlt(localctx, 29) { p.SetState(6142) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6143) p.Match(PostgreSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6144) p.Qualified_name() } { p.SetState(6145) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6146) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6147) p.Name() } case 30: p.EnterOuterAlt(localctx, 30) { p.SetState(6149) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6150) p.Match(PostgreSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6151) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6152) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6153) p.Qualified_name() } { p.SetState(6154) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6155) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6156) p.Name() } case 31: p.EnterOuterAlt(localctx, 31) { p.SetState(6158) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6159) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6160) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6161) p.Relation_expr() } { p.SetState(6162) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6163) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6164) p.Name() } case 32: p.EnterOuterAlt(localctx, 32) { p.SetState(6166) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6167) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6168) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6169) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6170) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6171) p.Relation_expr() } { p.SetState(6172) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6173) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6174) p.Name() } case 33: p.EnterOuterAlt(localctx, 33) { p.SetState(6176) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6177) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6178) p.Relation_expr() } { p.SetState(6179) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6180) p.Opt_column() } { p.SetState(6181) p.Name() } { p.SetState(6182) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6183) p.Name() } case 34: p.EnterOuterAlt(localctx, 34) { p.SetState(6185) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6186) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6187) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6188) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6189) p.Relation_expr() } { p.SetState(6190) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6191) p.Opt_column() } { p.SetState(6192) p.Name() } { p.SetState(6193) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6194) p.Name() } case 35: p.EnterOuterAlt(localctx, 35) { p.SetState(6196) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6197) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6198) p.Qualified_name() } { p.SetState(6199) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6200) p.Opt_column() } { p.SetState(6201) p.Name() } { p.SetState(6202) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6203) p.Name() } case 36: p.EnterOuterAlt(localctx, 36) { p.SetState(6205) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6206) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6207) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6208) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6209) p.Qualified_name() } { p.SetState(6210) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6211) p.Opt_column() } { p.SetState(6212) p.Name() } { p.SetState(6213) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6214) p.Name() } case 37: p.EnterOuterAlt(localctx, 37) { p.SetState(6216) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6217) p.Match(PostgreSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6218) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6219) p.Qualified_name() } { p.SetState(6220) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6221) p.Opt_column() } { p.SetState(6222) p.Name() } { p.SetState(6223) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6224) p.Name() } case 38: p.EnterOuterAlt(localctx, 38) { p.SetState(6226) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6227) p.Match(PostgreSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6228) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6229) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6230) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6231) p.Qualified_name() } { p.SetState(6232) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6233) p.Opt_column() } { p.SetState(6234) p.Name() } { p.SetState(6235) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6236) p.Name() } case 39: p.EnterOuterAlt(localctx, 39) { p.SetState(6238) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6239) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6240) p.Relation_expr() } { p.SetState(6241) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6242) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6243) p.Name() } { p.SetState(6244) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6245) p.Name() } case 40: p.EnterOuterAlt(localctx, 40) { p.SetState(6247) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6248) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6249) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6250) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6251) p.Relation_expr() } { p.SetState(6252) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6253) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6254) p.Name() } { p.SetState(6255) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6256) p.Name() } case 41: p.EnterOuterAlt(localctx, 41) { p.SetState(6258) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6259) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6260) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6261) p.Relation_expr() } { p.SetState(6262) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6263) p.Opt_column() } { p.SetState(6264) p.Name() } { p.SetState(6265) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6266) p.Name() } case 42: p.EnterOuterAlt(localctx, 42) { p.SetState(6268) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6269) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6270) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6271) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6272) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6273) p.Relation_expr() } { p.SetState(6274) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6275) p.Opt_column() } { p.SetState(6276) p.Name() } { p.SetState(6277) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6278) p.Name() } case 43: p.EnterOuterAlt(localctx, 43) { p.SetState(6280) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6281) p.Match(PostgreSQLParserRULE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6282) p.Name() } { p.SetState(6283) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6284) p.Qualified_name() } { p.SetState(6285) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6286) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6287) p.Name() } case 44: p.EnterOuterAlt(localctx, 44) { p.SetState(6289) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6290) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6291) p.Name() } { p.SetState(6292) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6293) p.Qualified_name() } { p.SetState(6294) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6295) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6296) p.Name() } case 45: p.EnterOuterAlt(localctx, 45) { p.SetState(6298) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6299) p.Match(PostgreSQLParserEVENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6300) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6301) p.Name() } { p.SetState(6302) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6303) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6304) p.Name() } case 46: p.EnterOuterAlt(localctx, 46) { p.SetState(6306) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6307) p.Match(PostgreSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6308) p.Roleid() } { p.SetState(6309) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6310) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6311) p.Roleid() } case 47: p.EnterOuterAlt(localctx, 47) { p.SetState(6313) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6314) p.Match(PostgreSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6315) p.Roleid() } { p.SetState(6316) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6317) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6318) p.Roleid() } case 48: p.EnterOuterAlt(localctx, 48) { p.SetState(6320) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6321) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6322) p.Name() } { p.SetState(6323) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6324) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6325) p.Name() } case 49: p.EnterOuterAlt(localctx, 49) { p.SetState(6327) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6328) p.Match(PostgreSQLParserSTATISTICS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6329) p.Any_name() } { p.SetState(6330) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6331) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6332) p.Name() } case 50: p.EnterOuterAlt(localctx, 50) { p.SetState(6334) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6335) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6336) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6337) p.Match(PostgreSQLParserPARSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6338) p.Any_name() } { p.SetState(6339) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6340) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6341) p.Name() } case 51: p.EnterOuterAlt(localctx, 51) { p.SetState(6343) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6344) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6345) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6346) p.Match(PostgreSQLParserDICTIONARY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6347) p.Any_name() } { p.SetState(6348) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6349) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6350) p.Name() } case 52: p.EnterOuterAlt(localctx, 52) { p.SetState(6352) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6353) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6354) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6355) p.Match(PostgreSQLParserTEMPLATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6356) p.Any_name() } { p.SetState(6357) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6358) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6359) p.Name() } case 53: p.EnterOuterAlt(localctx, 53) { p.SetState(6361) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6362) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6363) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6364) p.Match(PostgreSQLParserCONFIGURATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6365) p.Any_name() } { p.SetState(6366) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6367) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6368) p.Name() } case 54: p.EnterOuterAlt(localctx, 54) { p.SetState(6370) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6371) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6372) p.Any_name() } { p.SetState(6373) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6374) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6375) p.Name() } case 55: p.EnterOuterAlt(localctx, 55) { p.SetState(6377) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6378) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6379) p.Any_name() } { p.SetState(6380) p.Match(PostgreSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6381) p.Match(PostgreSQLParserATTRIBUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6382) p.Name() } { p.SetState(6383) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6384) p.Name() } { p.SetState(6385) p.Opt_drop_behavior() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_columnContext is an interface to support dynamic dispatch. type IOpt_columnContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures COLUMN() antlr.TerminalNode // IsOpt_columnContext differentiates from other interfaces. IsOpt_columnContext() } type Opt_columnContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_columnContext() *Opt_columnContext { var p = new(Opt_columnContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_column return p } func InitEmptyOpt_columnContext(p *Opt_columnContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_column } func (*Opt_columnContext) IsOpt_columnContext() {} func NewOpt_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_columnContext { var p = new(Opt_columnContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_column return p } func (s *Opt_columnContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_columnContext) COLUMN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLUMN, 0) } func (s *Opt_columnContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_columnContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_column(s) } } func (s *Opt_columnContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_column(s) } } func (s *Opt_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_column(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_column() (localctx IOpt_columnContext) { localctx = NewOpt_columnContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 724, PostgreSQLParserRULE_opt_column) p.SetState(6391) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 311, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(6389) p.Match(PostgreSQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_set_dataContext is an interface to support dynamic dispatch. type IOpt_set_dataContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SET() antlr.TerminalNode DATA_P() antlr.TerminalNode // IsOpt_set_dataContext differentiates from other interfaces. IsOpt_set_dataContext() } type Opt_set_dataContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_set_dataContext() *Opt_set_dataContext { var p = new(Opt_set_dataContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_set_data return p } func InitEmptyOpt_set_dataContext(p *Opt_set_dataContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_set_data } func (*Opt_set_dataContext) IsOpt_set_dataContext() {} func NewOpt_set_dataContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_set_dataContext { var p = new(Opt_set_dataContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_set_data return p } func (s *Opt_set_dataContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_set_dataContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *Opt_set_dataContext) DATA_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATA_P, 0) } func (s *Opt_set_dataContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_set_dataContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_set_dataContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_set_data(s) } } func (s *Opt_set_dataContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_set_data(s) } } func (s *Opt_set_dataContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_set_data(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_set_data() (localctx IOpt_set_dataContext) { localctx = NewOpt_set_dataContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 726, PostgreSQLParserRULE_opt_set_data) p.SetState(6396) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSET: p.EnterOuterAlt(localctx, 1) { p.SetState(6393) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6394) p.Match(PostgreSQLParserDATA_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserTYPE_P: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterobjectdependsstmtContext is an interface to support dynamic dispatch. type IAlterobjectdependsstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode FUNCTION() antlr.TerminalNode Function_with_argtypes() IFunction_with_argtypesContext Opt_no() IOpt_noContext DEPENDS() antlr.TerminalNode AllON() []antlr.TerminalNode ON(i int) antlr.TerminalNode EXTENSION() antlr.TerminalNode AllName() []INameContext Name(i int) INameContext PROCEDURE() antlr.TerminalNode ROUTINE() antlr.TerminalNode TRIGGER() antlr.TerminalNode Qualified_name() IQualified_nameContext MATERIALIZED() antlr.TerminalNode VIEW() antlr.TerminalNode INDEX() antlr.TerminalNode // IsAlterobjectdependsstmtContext differentiates from other interfaces. IsAlterobjectdependsstmtContext() } type AlterobjectdependsstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterobjectdependsstmtContext() *AlterobjectdependsstmtContext { var p = new(AlterobjectdependsstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterobjectdependsstmt return p } func InitEmptyAlterobjectdependsstmtContext(p *AlterobjectdependsstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterobjectdependsstmt } func (*AlterobjectdependsstmtContext) IsAlterobjectdependsstmtContext() {} func NewAlterobjectdependsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterobjectdependsstmtContext { var p = new(AlterobjectdependsstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterobjectdependsstmt return p } func (s *AlterobjectdependsstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterobjectdependsstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterobjectdependsstmtContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *AlterobjectdependsstmtContext) Function_with_argtypes() IFunction_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunction_with_argtypesContext) } func (s *AlterobjectdependsstmtContext) Opt_no() IOpt_noContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_noContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_noContext) } func (s *AlterobjectdependsstmtContext) DEPENDS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEPENDS, 0) } func (s *AlterobjectdependsstmtContext) AllON() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserON) } func (s *AlterobjectdependsstmtContext) ON(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, i) } func (s *AlterobjectdependsstmtContext) EXTENSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXTENSION, 0) } func (s *AlterobjectdependsstmtContext) AllName() []INameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(INameContext); ok { len++ } } tst := make([]INameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(INameContext); ok { tst[i] = t.(INameContext) i++ } } return tst } func (s *AlterobjectdependsstmtContext) Name(i int) INameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(INameContext) } func (s *AlterobjectdependsstmtContext) PROCEDURE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURE, 0) } func (s *AlterobjectdependsstmtContext) ROUTINE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUTINE, 0) } func (s *AlterobjectdependsstmtContext) TRIGGER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRIGGER, 0) } func (s *AlterobjectdependsstmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *AlterobjectdependsstmtContext) MATERIALIZED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMATERIALIZED, 0) } func (s *AlterobjectdependsstmtContext) VIEW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVIEW, 0) } func (s *AlterobjectdependsstmtContext) INDEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINDEX, 0) } func (s *AlterobjectdependsstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterobjectdependsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterobjectdependsstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterobjectdependsstmt(s) } } func (s *AlterobjectdependsstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterobjectdependsstmt(s) } } func (s *AlterobjectdependsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterobjectdependsstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterobjectdependsstmt() (localctx IAlterobjectdependsstmtContext) { localctx = NewAlterobjectdependsstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 728, PostgreSQLParserRULE_alterobjectdependsstmt) p.SetState(6455) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 313, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(6398) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6399) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6400) p.Function_with_argtypes() } { p.SetState(6401) p.Opt_no() } { p.SetState(6402) p.Match(PostgreSQLParserDEPENDS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6403) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6404) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6405) p.Name() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(6407) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6408) p.Match(PostgreSQLParserPROCEDURE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6409) p.Function_with_argtypes() } { p.SetState(6410) p.Opt_no() } { p.SetState(6411) p.Match(PostgreSQLParserDEPENDS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6412) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6413) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6414) p.Name() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(6416) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6417) p.Match(PostgreSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6418) p.Function_with_argtypes() } { p.SetState(6419) p.Opt_no() } { p.SetState(6420) p.Match(PostgreSQLParserDEPENDS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6421) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6422) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6423) p.Name() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(6425) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6426) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6427) p.Name() } { p.SetState(6428) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6429) p.Qualified_name() } { p.SetState(6430) p.Opt_no() } { p.SetState(6431) p.Match(PostgreSQLParserDEPENDS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6432) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6433) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6434) p.Name() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(6436) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6437) p.Match(PostgreSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6438) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6439) p.Qualified_name() } { p.SetState(6440) p.Opt_no() } { p.SetState(6441) p.Match(PostgreSQLParserDEPENDS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6442) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6443) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6444) p.Name() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(6446) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6447) p.Match(PostgreSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6448) p.Qualified_name() } { p.SetState(6449) p.Opt_no() } { p.SetState(6450) p.Match(PostgreSQLParserDEPENDS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6451) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6452) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6453) p.Name() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_noContext is an interface to support dynamic dispatch. type IOpt_noContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NO() antlr.TerminalNode // IsOpt_noContext differentiates from other interfaces. IsOpt_noContext() } type Opt_noContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_noContext() *Opt_noContext { var p = new(Opt_noContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_no return p } func InitEmptyOpt_noContext(p *Opt_noContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_no } func (*Opt_noContext) IsOpt_noContext() {} func NewOpt_noContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_noContext { var p = new(Opt_noContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_no return p } func (s *Opt_noContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_noContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Opt_noContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_noContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_noContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_no(s) } } func (s *Opt_noContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_no(s) } } func (s *Opt_noContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_no(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_no() (localctx IOpt_noContext) { localctx = NewOpt_noContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 730, PostgreSQLParserRULE_opt_no) p.SetState(6459) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserNO: p.EnterOuterAlt(localctx, 1) { p.SetState(6457) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserDEPENDS: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterobjectschemastmtContext is an interface to support dynamic dispatch. type IAlterobjectschemastmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode AGGREGATE() antlr.TerminalNode Aggregate_with_argtypes() IAggregate_with_argtypesContext SET() antlr.TerminalNode SCHEMA() antlr.TerminalNode AllName() []INameContext Name(i int) INameContext COLLATION() antlr.TerminalNode Any_name() IAny_nameContext CONVERSION_P() antlr.TerminalNode DOMAIN_P() antlr.TerminalNode EXTENSION() antlr.TerminalNode FUNCTION() antlr.TerminalNode Function_with_argtypes() IFunction_with_argtypesContext OPERATOR() antlr.TerminalNode Operator_with_argtypes() IOperator_with_argtypesContext CLASS() antlr.TerminalNode USING() antlr.TerminalNode FAMILY() antlr.TerminalNode PROCEDURE() antlr.TerminalNode ROUTINE() antlr.TerminalNode TABLE() antlr.TerminalNode Relation_expr() IRelation_exprContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode STATISTICS() antlr.TerminalNode TEXT_P() antlr.TerminalNode SEARCH() antlr.TerminalNode PARSER() antlr.TerminalNode DICTIONARY() antlr.TerminalNode TEMPLATE() antlr.TerminalNode CONFIGURATION() antlr.TerminalNode SEQUENCE() antlr.TerminalNode Qualified_name() IQualified_nameContext VIEW() antlr.TerminalNode MATERIALIZED() antlr.TerminalNode FOREIGN() antlr.TerminalNode TYPE_P() antlr.TerminalNode // IsAlterobjectschemastmtContext differentiates from other interfaces. IsAlterobjectschemastmtContext() } type AlterobjectschemastmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterobjectschemastmtContext() *AlterobjectschemastmtContext { var p = new(AlterobjectschemastmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterobjectschemastmt return p } func InitEmptyAlterobjectschemastmtContext(p *AlterobjectschemastmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterobjectschemastmt } func (*AlterobjectschemastmtContext) IsAlterobjectschemastmtContext() {} func NewAlterobjectschemastmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterobjectschemastmtContext { var p = new(AlterobjectschemastmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterobjectschemastmt return p } func (s *AlterobjectschemastmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterobjectschemastmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterobjectschemastmtContext) AGGREGATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAGGREGATE, 0) } func (s *AlterobjectschemastmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAggregate_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAggregate_with_argtypesContext) } func (s *AlterobjectschemastmtContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *AlterobjectschemastmtContext) SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMA, 0) } func (s *AlterobjectschemastmtContext) AllName() []INameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(INameContext); ok { len++ } } tst := make([]INameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(INameContext); ok { tst[i] = t.(INameContext) i++ } } return tst } func (s *AlterobjectschemastmtContext) Name(i int) INameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(INameContext) } func (s *AlterobjectschemastmtContext) COLLATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATION, 0) } func (s *AlterobjectschemastmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *AlterobjectschemastmtContext) CONVERSION_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONVERSION_P, 0) } func (s *AlterobjectschemastmtContext) DOMAIN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOMAIN_P, 0) } func (s *AlterobjectschemastmtContext) EXTENSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXTENSION, 0) } func (s *AlterobjectschemastmtContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *AlterobjectschemastmtContext) Function_with_argtypes() IFunction_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunction_with_argtypesContext) } func (s *AlterobjectschemastmtContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *AlterobjectschemastmtContext) Operator_with_argtypes() IOperator_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOperator_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOperator_with_argtypesContext) } func (s *AlterobjectschemastmtContext) CLASS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLASS, 0) } func (s *AlterobjectschemastmtContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *AlterobjectschemastmtContext) FAMILY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFAMILY, 0) } func (s *AlterobjectschemastmtContext) PROCEDURE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURE, 0) } func (s *AlterobjectschemastmtContext) ROUTINE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUTINE, 0) } func (s *AlterobjectschemastmtContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *AlterobjectschemastmtContext) Relation_expr() IRelation_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRelation_exprContext) } func (s *AlterobjectschemastmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *AlterobjectschemastmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *AlterobjectschemastmtContext) STATISTICS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTATISTICS, 0) } func (s *AlterobjectschemastmtContext) TEXT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEXT_P, 0) } func (s *AlterobjectschemastmtContext) SEARCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEARCH, 0) } func (s *AlterobjectschemastmtContext) PARSER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARSER, 0) } func (s *AlterobjectschemastmtContext) DICTIONARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDICTIONARY, 0) } func (s *AlterobjectschemastmtContext) TEMPLATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEMPLATE, 0) } func (s *AlterobjectschemastmtContext) CONFIGURATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONFIGURATION, 0) } func (s *AlterobjectschemastmtContext) SEQUENCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEQUENCE, 0) } func (s *AlterobjectschemastmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *AlterobjectschemastmtContext) VIEW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVIEW, 0) } func (s *AlterobjectschemastmtContext) MATERIALIZED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMATERIALIZED, 0) } func (s *AlterobjectschemastmtContext) FOREIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREIGN, 0) } func (s *AlterobjectschemastmtContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *AlterobjectschemastmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterobjectschemastmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterobjectschemastmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterobjectschemastmt(s) } } func (s *AlterobjectschemastmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterobjectschemastmt(s) } } func (s *AlterobjectschemastmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterobjectschemastmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterobjectschemastmt() (localctx IAlterobjectschemastmtContext) { localctx = NewAlterobjectschemastmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 732, PostgreSQLParserRULE_alterobjectschemastmt) p.SetState(6678) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 315, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(6461) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6462) p.Match(PostgreSQLParserAGGREGATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6463) p.Aggregate_with_argtypes() } { p.SetState(6464) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6465) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6466) p.Name() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(6468) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6469) p.Match(PostgreSQLParserCOLLATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6470) p.Any_name() } { p.SetState(6471) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6472) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6473) p.Name() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(6475) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6476) p.Match(PostgreSQLParserCONVERSION_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6477) p.Any_name() } { p.SetState(6478) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6479) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6480) p.Name() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(6482) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6483) p.Match(PostgreSQLParserDOMAIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6484) p.Any_name() } { p.SetState(6485) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6486) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6487) p.Name() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(6489) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6490) p.Match(PostgreSQLParserEXTENSION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6491) p.Name() } { p.SetState(6492) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6493) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6494) p.Name() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(6496) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6497) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6498) p.Function_with_argtypes() } { p.SetState(6499) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6500) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6501) p.Name() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(6503) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6504) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6505) p.Operator_with_argtypes() } { p.SetState(6506) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6507) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6508) p.Name() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(6510) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6511) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6512) p.Match(PostgreSQLParserCLASS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6513) p.Any_name() } { p.SetState(6514) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6515) p.Name() } { p.SetState(6516) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6517) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6518) p.Name() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(6520) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6521) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6522) p.Match(PostgreSQLParserFAMILY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6523) p.Any_name() } { p.SetState(6524) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6525) p.Name() } { p.SetState(6526) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6527) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6528) p.Name() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(6530) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6531) p.Match(PostgreSQLParserPROCEDURE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6532) p.Function_with_argtypes() } { p.SetState(6533) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6534) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6535) p.Name() } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(6537) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6538) p.Match(PostgreSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6539) p.Function_with_argtypes() } { p.SetState(6540) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6541) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6542) p.Name() } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(6544) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6545) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6546) p.Relation_expr() } { p.SetState(6547) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6548) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6549) p.Name() } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(6551) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6552) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6553) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6554) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6555) p.Relation_expr() } { p.SetState(6556) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6557) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6558) p.Name() } case 14: p.EnterOuterAlt(localctx, 14) { p.SetState(6560) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6561) p.Match(PostgreSQLParserSTATISTICS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6562) p.Any_name() } { p.SetState(6563) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6564) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6565) p.Name() } case 15: p.EnterOuterAlt(localctx, 15) { p.SetState(6567) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6568) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6569) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6570) p.Match(PostgreSQLParserPARSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6571) p.Any_name() } { p.SetState(6572) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6573) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6574) p.Name() } case 16: p.EnterOuterAlt(localctx, 16) { p.SetState(6576) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6577) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6578) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6579) p.Match(PostgreSQLParserDICTIONARY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6580) p.Any_name() } { p.SetState(6581) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6582) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6583) p.Name() } case 17: p.EnterOuterAlt(localctx, 17) { p.SetState(6585) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6586) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6587) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6588) p.Match(PostgreSQLParserTEMPLATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6589) p.Any_name() } { p.SetState(6590) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6591) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6592) p.Name() } case 18: p.EnterOuterAlt(localctx, 18) { p.SetState(6594) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6595) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6596) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6597) p.Match(PostgreSQLParserCONFIGURATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6598) p.Any_name() } { p.SetState(6599) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6600) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6601) p.Name() } case 19: p.EnterOuterAlt(localctx, 19) { p.SetState(6603) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6604) p.Match(PostgreSQLParserSEQUENCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6605) p.Qualified_name() } { p.SetState(6606) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6607) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6608) p.Name() } case 20: p.EnterOuterAlt(localctx, 20) { p.SetState(6610) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6611) p.Match(PostgreSQLParserSEQUENCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6612) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6613) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6614) p.Qualified_name() } { p.SetState(6615) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6616) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6617) p.Name() } case 21: p.EnterOuterAlt(localctx, 21) { p.SetState(6619) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6620) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6621) p.Qualified_name() } { p.SetState(6622) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6623) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6624) p.Name() } case 22: p.EnterOuterAlt(localctx, 22) { p.SetState(6626) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6627) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6628) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6629) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6630) p.Qualified_name() } { p.SetState(6631) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6632) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6633) p.Name() } case 23: p.EnterOuterAlt(localctx, 23) { p.SetState(6635) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6636) p.Match(PostgreSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6637) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6638) p.Qualified_name() } { p.SetState(6639) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6640) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6641) p.Name() } case 24: p.EnterOuterAlt(localctx, 24) { p.SetState(6643) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6644) p.Match(PostgreSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6645) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6646) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6647) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6648) p.Qualified_name() } { p.SetState(6649) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6650) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6651) p.Name() } case 25: p.EnterOuterAlt(localctx, 25) { p.SetState(6653) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6654) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6655) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6656) p.Relation_expr() } { p.SetState(6657) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6658) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6659) p.Name() } case 26: p.EnterOuterAlt(localctx, 26) { p.SetState(6661) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6662) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6663) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6664) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6665) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6666) p.Relation_expr() } { p.SetState(6667) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6668) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6669) p.Name() } case 27: p.EnterOuterAlt(localctx, 27) { p.SetState(6671) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6672) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6673) p.Any_name() } { p.SetState(6674) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6675) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6676) p.Name() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlteroperatorstmtContext is an interface to support dynamic dispatch. type IAlteroperatorstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode OPERATOR() antlr.TerminalNode Operator_with_argtypes() IOperator_with_argtypesContext SET() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Operator_def_list() IOperator_def_listContext CLOSE_PAREN() antlr.TerminalNode // IsAlteroperatorstmtContext differentiates from other interfaces. IsAlteroperatorstmtContext() } type AlteroperatorstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlteroperatorstmtContext() *AlteroperatorstmtContext { var p = new(AlteroperatorstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alteroperatorstmt return p } func InitEmptyAlteroperatorstmtContext(p *AlteroperatorstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alteroperatorstmt } func (*AlteroperatorstmtContext) IsAlteroperatorstmtContext() {} func NewAlteroperatorstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteroperatorstmtContext { var p = new(AlteroperatorstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alteroperatorstmt return p } func (s *AlteroperatorstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlteroperatorstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlteroperatorstmtContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *AlteroperatorstmtContext) Operator_with_argtypes() IOperator_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOperator_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOperator_with_argtypesContext) } func (s *AlteroperatorstmtContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *AlteroperatorstmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *AlteroperatorstmtContext) Operator_def_list() IOperator_def_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOperator_def_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOperator_def_listContext) } func (s *AlteroperatorstmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *AlteroperatorstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlteroperatorstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlteroperatorstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlteroperatorstmt(s) } } func (s *AlteroperatorstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlteroperatorstmt(s) } } func (s *AlteroperatorstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlteroperatorstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alteroperatorstmt() (localctx IAlteroperatorstmtContext) { localctx = NewAlteroperatorstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 734, PostgreSQLParserRULE_alteroperatorstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(6680) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6681) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6682) p.Operator_with_argtypes() } { p.SetState(6683) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6684) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6685) p.Operator_def_list() } { p.SetState(6686) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOperator_def_listContext is an interface to support dynamic dispatch. type IOperator_def_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllOperator_def_elem() []IOperator_def_elemContext Operator_def_elem(i int) IOperator_def_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsOperator_def_listContext differentiates from other interfaces. IsOperator_def_listContext() } type Operator_def_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOperator_def_listContext() *Operator_def_listContext { var p = new(Operator_def_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_operator_def_list return p } func InitEmptyOperator_def_listContext(p *Operator_def_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_operator_def_list } func (*Operator_def_listContext) IsOperator_def_listContext() {} func NewOperator_def_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_def_listContext { var p = new(Operator_def_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_operator_def_list return p } func (s *Operator_def_listContext) GetParser() antlr.Parser { return s.parser } func (s *Operator_def_listContext) AllOperator_def_elem() []IOperator_def_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IOperator_def_elemContext); ok { len++ } } tst := make([]IOperator_def_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IOperator_def_elemContext); ok { tst[i] = t.(IOperator_def_elemContext) i++ } } return tst } func (s *Operator_def_listContext) Operator_def_elem(i int) IOperator_def_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOperator_def_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IOperator_def_elemContext) } func (s *Operator_def_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Operator_def_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Operator_def_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Operator_def_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Operator_def_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOperator_def_list(s) } } func (s *Operator_def_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOperator_def_list(s) } } func (s *Operator_def_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOperator_def_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Operator_def_list() (localctx IOperator_def_listContext) { localctx = NewOperator_def_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 736, PostgreSQLParserRULE_operator_def_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6688) p.Operator_def_elem() } p.SetState(6693) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(6689) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6690) p.Operator_def_elem() } p.SetState(6695) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOperator_def_elemContext is an interface to support dynamic dispatch. type IOperator_def_elemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Collabel() ICollabelContext EQUAL() antlr.TerminalNode NONE() antlr.TerminalNode Operator_def_arg() IOperator_def_argContext // IsOperator_def_elemContext differentiates from other interfaces. IsOperator_def_elemContext() } type Operator_def_elemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOperator_def_elemContext() *Operator_def_elemContext { var p = new(Operator_def_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_operator_def_elem return p } func InitEmptyOperator_def_elemContext(p *Operator_def_elemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_operator_def_elem } func (*Operator_def_elemContext) IsOperator_def_elemContext() {} func NewOperator_def_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_def_elemContext { var p = new(Operator_def_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_operator_def_elem return p } func (s *Operator_def_elemContext) GetParser() antlr.Parser { return s.parser } func (s *Operator_def_elemContext) Collabel() ICollabelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICollabelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICollabelContext) } func (s *Operator_def_elemContext) EQUAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEQUAL, 0) } func (s *Operator_def_elemContext) NONE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNONE, 0) } func (s *Operator_def_elemContext) Operator_def_arg() IOperator_def_argContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOperator_def_argContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOperator_def_argContext) } func (s *Operator_def_elemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Operator_def_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Operator_def_elemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOperator_def_elem(s) } } func (s *Operator_def_elemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOperator_def_elem(s) } } func (s *Operator_def_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOperator_def_elem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Operator_def_elem() (localctx IOperator_def_elemContext) { localctx = NewOperator_def_elemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 738, PostgreSQLParserRULE_operator_def_elem) p.SetState(6704) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 317, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(6696) p.Collabel() } { p.SetState(6697) p.Match(PostgreSQLParserEQUAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6698) p.Match(PostgreSQLParserNONE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(6700) p.Collabel() } { p.SetState(6701) p.Match(PostgreSQLParserEQUAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6702) p.Operator_def_arg() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOperator_def_argContext is an interface to support dynamic dispatch. type IOperator_def_argContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Func_type() IFunc_typeContext Reserved_keyword() IReserved_keywordContext Qual_all_op() IQual_all_opContext Numericonly() INumericonlyContext Sconst() ISconstContext // IsOperator_def_argContext differentiates from other interfaces. IsOperator_def_argContext() } type Operator_def_argContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOperator_def_argContext() *Operator_def_argContext { var p = new(Operator_def_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_operator_def_arg return p } func InitEmptyOperator_def_argContext(p *Operator_def_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_operator_def_arg } func (*Operator_def_argContext) IsOperator_def_argContext() {} func NewOperator_def_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_def_argContext { var p = new(Operator_def_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_operator_def_arg return p } func (s *Operator_def_argContext) GetParser() antlr.Parser { return s.parser } func (s *Operator_def_argContext) Func_type() IFunc_typeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_typeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_typeContext) } func (s *Operator_def_argContext) Reserved_keyword() IReserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReserved_keywordContext) } func (s *Operator_def_argContext) Qual_all_op() IQual_all_opContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQual_all_opContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQual_all_opContext) } func (s *Operator_def_argContext) Numericonly() INumericonlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericonlyContext) } func (s *Operator_def_argContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Operator_def_argContext) GetRuleContext() antlr.RuleContext { return s } func (s *Operator_def_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Operator_def_argContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOperator_def_arg(s) } } func (s *Operator_def_argContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOperator_def_arg(s) } } func (s *Operator_def_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOperator_def_arg(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Operator_def_arg() (localctx IOperator_def_argContext) { localctx = NewOperator_def_argContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 740, PostgreSQLParserRULE_operator_def_arg) p.SetState(6711) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 318, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(6706) p.Func_type() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(6707) p.Reserved_keyword() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(6708) p.Qual_all_op() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(6709) p.Numericonly() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(6710) p.Sconst() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAltertypestmtContext is an interface to support dynamic dispatch. type IAltertypestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode TYPE_P() antlr.TerminalNode Any_name() IAny_nameContext SET() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Operator_def_list() IOperator_def_listContext CLOSE_PAREN() antlr.TerminalNode // IsAltertypestmtContext differentiates from other interfaces. IsAltertypestmtContext() } type AltertypestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAltertypestmtContext() *AltertypestmtContext { var p = new(AltertypestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altertypestmt return p } func InitEmptyAltertypestmtContext(p *AltertypestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altertypestmt } func (*AltertypestmtContext) IsAltertypestmtContext() {} func NewAltertypestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertypestmtContext { var p = new(AltertypestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_altertypestmt return p } func (s *AltertypestmtContext) GetParser() antlr.Parser { return s.parser } func (s *AltertypestmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AltertypestmtContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *AltertypestmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *AltertypestmtContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *AltertypestmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *AltertypestmtContext) Operator_def_list() IOperator_def_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOperator_def_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOperator_def_listContext) } func (s *AltertypestmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *AltertypestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AltertypestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AltertypestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAltertypestmt(s) } } func (s *AltertypestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAltertypestmt(s) } } func (s *AltertypestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAltertypestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Altertypestmt() (localctx IAltertypestmtContext) { localctx = NewAltertypestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 742, PostgreSQLParserRULE_altertypestmt) p.EnterOuterAlt(localctx, 1) { p.SetState(6713) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6714) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6715) p.Any_name() } { p.SetState(6716) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6717) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6718) p.Operator_def_list() } { p.SetState(6719) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterownerstmtContext is an interface to support dynamic dispatch. type IAlterownerstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode AGGREGATE() antlr.TerminalNode Aggregate_with_argtypes() IAggregate_with_argtypesContext OWNER() antlr.TerminalNode TO() antlr.TerminalNode Rolespec() IRolespecContext COLLATION() antlr.TerminalNode Any_name() IAny_nameContext CONVERSION_P() antlr.TerminalNode DATABASE() antlr.TerminalNode Name() INameContext DOMAIN_P() antlr.TerminalNode FUNCTION() antlr.TerminalNode Function_with_argtypes() IFunction_with_argtypesContext Opt_procedural() IOpt_proceduralContext LANGUAGE() antlr.TerminalNode LARGE_P() antlr.TerminalNode OBJECT_P() antlr.TerminalNode Numericonly() INumericonlyContext OPERATOR() antlr.TerminalNode Operator_with_argtypes() IOperator_with_argtypesContext CLASS() antlr.TerminalNode USING() antlr.TerminalNode FAMILY() antlr.TerminalNode PROCEDURE() antlr.TerminalNode ROUTINE() antlr.TerminalNode SCHEMA() antlr.TerminalNode TYPE_P() antlr.TerminalNode TABLESPACE() antlr.TerminalNode STATISTICS() antlr.TerminalNode TEXT_P() antlr.TerminalNode SEARCH() antlr.TerminalNode DICTIONARY() antlr.TerminalNode CONFIGURATION() antlr.TerminalNode FOREIGN() antlr.TerminalNode DATA_P() antlr.TerminalNode WRAPPER() antlr.TerminalNode SERVER() antlr.TerminalNode EVENT() antlr.TerminalNode TRIGGER() antlr.TerminalNode PUBLICATION() antlr.TerminalNode SUBSCRIPTION() antlr.TerminalNode // IsAlterownerstmtContext differentiates from other interfaces. IsAlterownerstmtContext() } type AlterownerstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterownerstmtContext() *AlterownerstmtContext { var p = new(AlterownerstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterownerstmt return p } func InitEmptyAlterownerstmtContext(p *AlterownerstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterownerstmt } func (*AlterownerstmtContext) IsAlterownerstmtContext() {} func NewAlterownerstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterownerstmtContext { var p = new(AlterownerstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterownerstmt return p } func (s *AlterownerstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterownerstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterownerstmtContext) AGGREGATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAGGREGATE, 0) } func (s *AlterownerstmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAggregate_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAggregate_with_argtypesContext) } func (s *AlterownerstmtContext) OWNER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOWNER, 0) } func (s *AlterownerstmtContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *AlterownerstmtContext) Rolespec() IRolespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRolespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRolespecContext) } func (s *AlterownerstmtContext) COLLATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATION, 0) } func (s *AlterownerstmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *AlterownerstmtContext) CONVERSION_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONVERSION_P, 0) } func (s *AlterownerstmtContext) DATABASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATABASE, 0) } func (s *AlterownerstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *AlterownerstmtContext) DOMAIN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOMAIN_P, 0) } func (s *AlterownerstmtContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *AlterownerstmtContext) Function_with_argtypes() IFunction_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunction_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunction_with_argtypesContext) } func (s *AlterownerstmtContext) Opt_procedural() IOpt_proceduralContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_proceduralContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_proceduralContext) } func (s *AlterownerstmtContext) LANGUAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLANGUAGE, 0) } func (s *AlterownerstmtContext) LARGE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLARGE_P, 0) } func (s *AlterownerstmtContext) OBJECT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOBJECT_P, 0) } func (s *AlterownerstmtContext) Numericonly() INumericonlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericonlyContext) } func (s *AlterownerstmtContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *AlterownerstmtContext) Operator_with_argtypes() IOperator_with_argtypesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOperator_with_argtypesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOperator_with_argtypesContext) } func (s *AlterownerstmtContext) CLASS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLASS, 0) } func (s *AlterownerstmtContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *AlterownerstmtContext) FAMILY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFAMILY, 0) } func (s *AlterownerstmtContext) PROCEDURE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURE, 0) } func (s *AlterownerstmtContext) ROUTINE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUTINE, 0) } func (s *AlterownerstmtContext) SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMA, 0) } func (s *AlterownerstmtContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *AlterownerstmtContext) TABLESPACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, 0) } func (s *AlterownerstmtContext) STATISTICS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTATISTICS, 0) } func (s *AlterownerstmtContext) TEXT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEXT_P, 0) } func (s *AlterownerstmtContext) SEARCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEARCH, 0) } func (s *AlterownerstmtContext) DICTIONARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDICTIONARY, 0) } func (s *AlterownerstmtContext) CONFIGURATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONFIGURATION, 0) } func (s *AlterownerstmtContext) FOREIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREIGN, 0) } func (s *AlterownerstmtContext) DATA_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATA_P, 0) } func (s *AlterownerstmtContext) WRAPPER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWRAPPER, 0) } func (s *AlterownerstmtContext) SERVER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSERVER, 0) } func (s *AlterownerstmtContext) EVENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEVENT, 0) } func (s *AlterownerstmtContext) TRIGGER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRIGGER, 0) } func (s *AlterownerstmtContext) PUBLICATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPUBLICATION, 0) } func (s *AlterownerstmtContext) SUBSCRIPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSUBSCRIPTION, 0) } func (s *AlterownerstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterownerstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterownerstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterownerstmt(s) } } func (s *AlterownerstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterownerstmt(s) } } func (s *AlterownerstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterownerstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterownerstmt() (localctx IAlterownerstmtContext) { localctx = NewAlterownerstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 744, PostgreSQLParserRULE_alterownerstmt) p.SetState(6904) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 319, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(6721) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6722) p.Match(PostgreSQLParserAGGREGATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6723) p.Aggregate_with_argtypes() } { p.SetState(6724) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6725) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6726) p.Rolespec() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(6728) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6729) p.Match(PostgreSQLParserCOLLATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6730) p.Any_name() } { p.SetState(6731) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6732) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6733) p.Rolespec() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(6735) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6736) p.Match(PostgreSQLParserCONVERSION_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6737) p.Any_name() } { p.SetState(6738) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6739) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6740) p.Rolespec() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(6742) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6743) p.Match(PostgreSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6744) p.Name() } { p.SetState(6745) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6746) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6747) p.Rolespec() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(6749) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6750) p.Match(PostgreSQLParserDOMAIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6751) p.Any_name() } { p.SetState(6752) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6753) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6754) p.Rolespec() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(6756) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6757) p.Match(PostgreSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6758) p.Function_with_argtypes() } { p.SetState(6759) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6760) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6761) p.Rolespec() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(6763) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6764) p.Opt_procedural() } { p.SetState(6765) p.Match(PostgreSQLParserLANGUAGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6766) p.Name() } { p.SetState(6767) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6768) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6769) p.Rolespec() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(6771) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6772) p.Match(PostgreSQLParserLARGE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6773) p.Match(PostgreSQLParserOBJECT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6774) p.Numericonly() } { p.SetState(6775) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6776) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6777) p.Rolespec() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(6779) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6780) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6781) p.Operator_with_argtypes() } { p.SetState(6782) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6783) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6784) p.Rolespec() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(6786) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6787) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6788) p.Match(PostgreSQLParserCLASS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6789) p.Any_name() } { p.SetState(6790) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6791) p.Name() } { p.SetState(6792) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6793) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6794) p.Rolespec() } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(6796) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6797) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6798) p.Match(PostgreSQLParserFAMILY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6799) p.Any_name() } { p.SetState(6800) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6801) p.Name() } { p.SetState(6802) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6803) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6804) p.Rolespec() } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(6806) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6807) p.Match(PostgreSQLParserPROCEDURE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6808) p.Function_with_argtypes() } { p.SetState(6809) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6810) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6811) p.Rolespec() } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(6813) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6814) p.Match(PostgreSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6815) p.Function_with_argtypes() } { p.SetState(6816) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6817) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6818) p.Rolespec() } case 14: p.EnterOuterAlt(localctx, 14) { p.SetState(6820) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6821) p.Match(PostgreSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6822) p.Name() } { p.SetState(6823) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6824) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6825) p.Rolespec() } case 15: p.EnterOuterAlt(localctx, 15) { p.SetState(6827) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6828) p.Match(PostgreSQLParserTYPE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6829) p.Any_name() } { p.SetState(6830) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6831) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6832) p.Rolespec() } case 16: p.EnterOuterAlt(localctx, 16) { p.SetState(6834) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6835) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6836) p.Name() } { p.SetState(6837) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6838) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6839) p.Rolespec() } case 17: p.EnterOuterAlt(localctx, 17) { p.SetState(6841) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6842) p.Match(PostgreSQLParserSTATISTICS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6843) p.Any_name() } { p.SetState(6844) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6845) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6846) p.Rolespec() } case 18: p.EnterOuterAlt(localctx, 18) { p.SetState(6848) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6849) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6850) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6851) p.Match(PostgreSQLParserDICTIONARY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6852) p.Any_name() } { p.SetState(6853) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6854) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6855) p.Rolespec() } case 19: p.EnterOuterAlt(localctx, 19) { p.SetState(6857) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6858) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6859) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6860) p.Match(PostgreSQLParserCONFIGURATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6861) p.Any_name() } { p.SetState(6862) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6863) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6864) p.Rolespec() } case 20: p.EnterOuterAlt(localctx, 20) { p.SetState(6866) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6867) p.Match(PostgreSQLParserFOREIGN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6868) p.Match(PostgreSQLParserDATA_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6869) p.Match(PostgreSQLParserWRAPPER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6870) p.Name() } { p.SetState(6871) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6872) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6873) p.Rolespec() } case 21: p.EnterOuterAlt(localctx, 21) { p.SetState(6875) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6876) p.Match(PostgreSQLParserSERVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6877) p.Name() } { p.SetState(6878) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6879) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6880) p.Rolespec() } case 22: p.EnterOuterAlt(localctx, 22) { p.SetState(6882) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6883) p.Match(PostgreSQLParserEVENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6884) p.Match(PostgreSQLParserTRIGGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6885) p.Name() } { p.SetState(6886) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6887) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6888) p.Rolespec() } case 23: p.EnterOuterAlt(localctx, 23) { p.SetState(6890) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6891) p.Match(PostgreSQLParserPUBLICATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6892) p.Name() } { p.SetState(6893) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6894) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6895) p.Rolespec() } case 24: p.EnterOuterAlt(localctx, 24) { p.SetState(6897) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6898) p.Match(PostgreSQLParserSUBSCRIPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6899) p.Name() } { p.SetState(6900) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6901) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6902) p.Rolespec() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatepublicationstmtContext is an interface to support dynamic dispatch. type ICreatepublicationstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode PUBLICATION() antlr.TerminalNode Name() INameContext Opt_publication_for_tables() IOpt_publication_for_tablesContext Opt_definition() IOpt_definitionContext // IsCreatepublicationstmtContext differentiates from other interfaces. IsCreatepublicationstmtContext() } type CreatepublicationstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatepublicationstmtContext() *CreatepublicationstmtContext { var p = new(CreatepublicationstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createpublicationstmt return p } func InitEmptyCreatepublicationstmtContext(p *CreatepublicationstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createpublicationstmt } func (*CreatepublicationstmtContext) IsCreatepublicationstmtContext() {} func NewCreatepublicationstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatepublicationstmtContext { var p = new(CreatepublicationstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createpublicationstmt return p } func (s *CreatepublicationstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreatepublicationstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreatepublicationstmtContext) PUBLICATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPUBLICATION, 0) } func (s *CreatepublicationstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreatepublicationstmtContext) Opt_publication_for_tables() IOpt_publication_for_tablesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_publication_for_tablesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_publication_for_tablesContext) } func (s *CreatepublicationstmtContext) Opt_definition() IOpt_definitionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_definitionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_definitionContext) } func (s *CreatepublicationstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreatepublicationstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreatepublicationstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatepublicationstmt(s) } } func (s *CreatepublicationstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatepublicationstmt(s) } } func (s *CreatepublicationstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatepublicationstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createpublicationstmt() (localctx ICreatepublicationstmtContext) { localctx = NewCreatepublicationstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 746, PostgreSQLParserRULE_createpublicationstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(6906) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6907) p.Match(PostgreSQLParserPUBLICATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6908) p.Name() } { p.SetState(6909) p.Opt_publication_for_tables() } { p.SetState(6910) p.Opt_definition() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_publication_for_tablesContext is an interface to support dynamic dispatch. type IOpt_publication_for_tablesContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Publication_for_tables() IPublication_for_tablesContext // IsOpt_publication_for_tablesContext differentiates from other interfaces. IsOpt_publication_for_tablesContext() } type Opt_publication_for_tablesContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_publication_for_tablesContext() *Opt_publication_for_tablesContext { var p = new(Opt_publication_for_tablesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_publication_for_tables return p } func InitEmptyOpt_publication_for_tablesContext(p *Opt_publication_for_tablesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_publication_for_tables } func (*Opt_publication_for_tablesContext) IsOpt_publication_for_tablesContext() {} func NewOpt_publication_for_tablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_publication_for_tablesContext { var p = new(Opt_publication_for_tablesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_publication_for_tables return p } func (s *Opt_publication_for_tablesContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_publication_for_tablesContext) Publication_for_tables() IPublication_for_tablesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPublication_for_tablesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPublication_for_tablesContext) } func (s *Opt_publication_for_tablesContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_publication_for_tablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_publication_for_tablesContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_publication_for_tables(s) } } func (s *Opt_publication_for_tablesContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_publication_for_tables(s) } } func (s *Opt_publication_for_tablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_publication_for_tables(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_publication_for_tables() (localctx IOpt_publication_for_tablesContext) { localctx = NewOpt_publication_for_tablesContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 748, PostgreSQLParserRULE_opt_publication_for_tables) p.SetState(6914) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFOR: p.EnterOuterAlt(localctx, 1) { p.SetState(6912) p.Publication_for_tables() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPublication_for_tablesContext is an interface to support dynamic dispatch. type IPublication_for_tablesContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FOR() antlr.TerminalNode TABLE() antlr.TerminalNode Relation_expr_list() IRelation_expr_listContext ALL() antlr.TerminalNode TABLES() antlr.TerminalNode // IsPublication_for_tablesContext differentiates from other interfaces. IsPublication_for_tablesContext() } type Publication_for_tablesContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPublication_for_tablesContext() *Publication_for_tablesContext { var p = new(Publication_for_tablesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_publication_for_tables return p } func InitEmptyPublication_for_tablesContext(p *Publication_for_tablesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_publication_for_tables } func (*Publication_for_tablesContext) IsPublication_for_tablesContext() {} func NewPublication_for_tablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Publication_for_tablesContext { var p = new(Publication_for_tablesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_publication_for_tables return p } func (s *Publication_for_tablesContext) GetParser() antlr.Parser { return s.parser } func (s *Publication_for_tablesContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *Publication_for_tablesContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *Publication_for_tablesContext) Relation_expr_list() IRelation_expr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_expr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRelation_expr_listContext) } func (s *Publication_for_tablesContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *Publication_for_tablesContext) TABLES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLES, 0) } func (s *Publication_for_tablesContext) GetRuleContext() antlr.RuleContext { return s } func (s *Publication_for_tablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Publication_for_tablesContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPublication_for_tables(s) } } func (s *Publication_for_tablesContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPublication_for_tables(s) } } func (s *Publication_for_tablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPublication_for_tables(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Publication_for_tables() (localctx IPublication_for_tablesContext) { localctx = NewPublication_for_tablesContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 750, PostgreSQLParserRULE_publication_for_tables) p.SetState(6922) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 321, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(6916) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6917) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6918) p.Relation_expr_list() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(6919) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6920) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6921) p.Match(PostgreSQLParserTABLES) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterpublicationstmtContext is an interface to support dynamic dispatch. type IAlterpublicationstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode PUBLICATION() antlr.TerminalNode Name() INameContext SET() antlr.TerminalNode Definition() IDefinitionContext ADD_P() antlr.TerminalNode TABLE() antlr.TerminalNode Relation_expr_list() IRelation_expr_listContext DROP() antlr.TerminalNode // IsAlterpublicationstmtContext differentiates from other interfaces. IsAlterpublicationstmtContext() } type AlterpublicationstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterpublicationstmtContext() *AlterpublicationstmtContext { var p = new(AlterpublicationstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterpublicationstmt return p } func InitEmptyAlterpublicationstmtContext(p *AlterpublicationstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterpublicationstmt } func (*AlterpublicationstmtContext) IsAlterpublicationstmtContext() {} func NewAlterpublicationstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterpublicationstmtContext { var p = new(AlterpublicationstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterpublicationstmt return p } func (s *AlterpublicationstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterpublicationstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterpublicationstmtContext) PUBLICATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPUBLICATION, 0) } func (s *AlterpublicationstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *AlterpublicationstmtContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *AlterpublicationstmtContext) Definition() IDefinitionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDefinitionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDefinitionContext) } func (s *AlterpublicationstmtContext) ADD_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserADD_P, 0) } func (s *AlterpublicationstmtContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *AlterpublicationstmtContext) Relation_expr_list() IRelation_expr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_expr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRelation_expr_listContext) } func (s *AlterpublicationstmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *AlterpublicationstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterpublicationstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterpublicationstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterpublicationstmt(s) } } func (s *AlterpublicationstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterpublicationstmt(s) } } func (s *AlterpublicationstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterpublicationstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterpublicationstmt() (localctx IAlterpublicationstmtContext) { localctx = NewAlterpublicationstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 752, PostgreSQLParserRULE_alterpublicationstmt) p.SetState(6951) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 322, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(6924) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6925) p.Match(PostgreSQLParserPUBLICATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6926) p.Name() } { p.SetState(6927) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6928) p.Definition() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(6930) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6931) p.Match(PostgreSQLParserPUBLICATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6932) p.Name() } { p.SetState(6933) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6934) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6935) p.Relation_expr_list() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(6937) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6938) p.Match(PostgreSQLParserPUBLICATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6939) p.Name() } { p.SetState(6940) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6941) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6942) p.Relation_expr_list() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(6944) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6945) p.Match(PostgreSQLParserPUBLICATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6946) p.Name() } { p.SetState(6947) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6948) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6949) p.Relation_expr_list() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatesubscriptionstmtContext is an interface to support dynamic dispatch. type ICreatesubscriptionstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode SUBSCRIPTION() antlr.TerminalNode Name() INameContext CONNECTION() antlr.TerminalNode Sconst() ISconstContext PUBLICATION() antlr.TerminalNode Publication_name_list() IPublication_name_listContext Opt_definition() IOpt_definitionContext // IsCreatesubscriptionstmtContext differentiates from other interfaces. IsCreatesubscriptionstmtContext() } type CreatesubscriptionstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatesubscriptionstmtContext() *CreatesubscriptionstmtContext { var p = new(CreatesubscriptionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createsubscriptionstmt return p } func InitEmptyCreatesubscriptionstmtContext(p *CreatesubscriptionstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createsubscriptionstmt } func (*CreatesubscriptionstmtContext) IsCreatesubscriptionstmtContext() {} func NewCreatesubscriptionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatesubscriptionstmtContext { var p = new(CreatesubscriptionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createsubscriptionstmt return p } func (s *CreatesubscriptionstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreatesubscriptionstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreatesubscriptionstmtContext) SUBSCRIPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSUBSCRIPTION, 0) } func (s *CreatesubscriptionstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreatesubscriptionstmtContext) CONNECTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONNECTION, 0) } func (s *CreatesubscriptionstmtContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *CreatesubscriptionstmtContext) PUBLICATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPUBLICATION, 0) } func (s *CreatesubscriptionstmtContext) Publication_name_list() IPublication_name_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPublication_name_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPublication_name_listContext) } func (s *CreatesubscriptionstmtContext) Opt_definition() IOpt_definitionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_definitionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_definitionContext) } func (s *CreatesubscriptionstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreatesubscriptionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreatesubscriptionstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatesubscriptionstmt(s) } } func (s *CreatesubscriptionstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatesubscriptionstmt(s) } } func (s *CreatesubscriptionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatesubscriptionstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createsubscriptionstmt() (localctx ICreatesubscriptionstmtContext) { localctx = NewCreatesubscriptionstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 754, PostgreSQLParserRULE_createsubscriptionstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(6953) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6954) p.Match(PostgreSQLParserSUBSCRIPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6955) p.Name() } { p.SetState(6956) p.Match(PostgreSQLParserCONNECTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6957) p.Sconst() } { p.SetState(6958) p.Match(PostgreSQLParserPUBLICATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6959) p.Publication_name_list() } { p.SetState(6960) p.Opt_definition() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPublication_name_listContext is an interface to support dynamic dispatch. type IPublication_name_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllPublication_name_item() []IPublication_name_itemContext Publication_name_item(i int) IPublication_name_itemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsPublication_name_listContext differentiates from other interfaces. IsPublication_name_listContext() } type Publication_name_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPublication_name_listContext() *Publication_name_listContext { var p = new(Publication_name_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_publication_name_list return p } func InitEmptyPublication_name_listContext(p *Publication_name_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_publication_name_list } func (*Publication_name_listContext) IsPublication_name_listContext() {} func NewPublication_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Publication_name_listContext { var p = new(Publication_name_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_publication_name_list return p } func (s *Publication_name_listContext) GetParser() antlr.Parser { return s.parser } func (s *Publication_name_listContext) AllPublication_name_item() []IPublication_name_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IPublication_name_itemContext); ok { len++ } } tst := make([]IPublication_name_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IPublication_name_itemContext); ok { tst[i] = t.(IPublication_name_itemContext) i++ } } return tst } func (s *Publication_name_listContext) Publication_name_item(i int) IPublication_name_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPublication_name_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IPublication_name_itemContext) } func (s *Publication_name_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Publication_name_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Publication_name_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Publication_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Publication_name_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPublication_name_list(s) } } func (s *Publication_name_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPublication_name_list(s) } } func (s *Publication_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPublication_name_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Publication_name_list() (localctx IPublication_name_listContext) { localctx = NewPublication_name_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 756, PostgreSQLParserRULE_publication_name_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6962) p.Publication_name_item() } p.SetState(6967) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(6963) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6964) p.Publication_name_item() } p.SetState(6969) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPublication_name_itemContext is an interface to support dynamic dispatch. type IPublication_name_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Collabel() ICollabelContext // IsPublication_name_itemContext differentiates from other interfaces. IsPublication_name_itemContext() } type Publication_name_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPublication_name_itemContext() *Publication_name_itemContext { var p = new(Publication_name_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_publication_name_item return p } func InitEmptyPublication_name_itemContext(p *Publication_name_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_publication_name_item } func (*Publication_name_itemContext) IsPublication_name_itemContext() {} func NewPublication_name_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Publication_name_itemContext { var p = new(Publication_name_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_publication_name_item return p } func (s *Publication_name_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Publication_name_itemContext) Collabel() ICollabelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICollabelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICollabelContext) } func (s *Publication_name_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Publication_name_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Publication_name_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPublication_name_item(s) } } func (s *Publication_name_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPublication_name_item(s) } } func (s *Publication_name_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPublication_name_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Publication_name_item() (localctx IPublication_name_itemContext) { localctx = NewPublication_name_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 758, PostgreSQLParserRULE_publication_name_item) p.EnterOuterAlt(localctx, 1) { p.SetState(6970) p.Collabel() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAltersubscriptionstmtContext is an interface to support dynamic dispatch. type IAltersubscriptionstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode SUBSCRIPTION() antlr.TerminalNode Name() INameContext SET() antlr.TerminalNode Definition() IDefinitionContext CONNECTION() antlr.TerminalNode Sconst() ISconstContext REFRESH() antlr.TerminalNode PUBLICATION() antlr.TerminalNode Opt_definition() IOpt_definitionContext Publication_name_list() IPublication_name_listContext ENABLE_P() antlr.TerminalNode DISABLE_P() antlr.TerminalNode // IsAltersubscriptionstmtContext differentiates from other interfaces. IsAltersubscriptionstmtContext() } type AltersubscriptionstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAltersubscriptionstmtContext() *AltersubscriptionstmtContext { var p = new(AltersubscriptionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altersubscriptionstmt return p } func InitEmptyAltersubscriptionstmtContext(p *AltersubscriptionstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altersubscriptionstmt } func (*AltersubscriptionstmtContext) IsAltersubscriptionstmtContext() {} func NewAltersubscriptionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltersubscriptionstmtContext { var p = new(AltersubscriptionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_altersubscriptionstmt return p } func (s *AltersubscriptionstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AltersubscriptionstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AltersubscriptionstmtContext) SUBSCRIPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSUBSCRIPTION, 0) } func (s *AltersubscriptionstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *AltersubscriptionstmtContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *AltersubscriptionstmtContext) Definition() IDefinitionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDefinitionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDefinitionContext) } func (s *AltersubscriptionstmtContext) CONNECTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONNECTION, 0) } func (s *AltersubscriptionstmtContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *AltersubscriptionstmtContext) REFRESH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREFRESH, 0) } func (s *AltersubscriptionstmtContext) PUBLICATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPUBLICATION, 0) } func (s *AltersubscriptionstmtContext) Opt_definition() IOpt_definitionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_definitionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_definitionContext) } func (s *AltersubscriptionstmtContext) Publication_name_list() IPublication_name_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPublication_name_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPublication_name_listContext) } func (s *AltersubscriptionstmtContext) ENABLE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserENABLE_P, 0) } func (s *AltersubscriptionstmtContext) DISABLE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDISABLE_P, 0) } func (s *AltersubscriptionstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AltersubscriptionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AltersubscriptionstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAltersubscriptionstmt(s) } } func (s *AltersubscriptionstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAltersubscriptionstmt(s) } } func (s *AltersubscriptionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAltersubscriptionstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Altersubscriptionstmt() (localctx IAltersubscriptionstmtContext) { localctx = NewAltersubscriptionstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 760, PostgreSQLParserRULE_altersubscriptionstmt) p.SetState(7009) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 324, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(6972) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6973) p.Match(PostgreSQLParserSUBSCRIPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6974) p.Name() } { p.SetState(6975) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6976) p.Definition() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(6978) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6979) p.Match(PostgreSQLParserSUBSCRIPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6980) p.Name() } { p.SetState(6981) p.Match(PostgreSQLParserCONNECTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6982) p.Sconst() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(6984) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6985) p.Match(PostgreSQLParserSUBSCRIPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6986) p.Name() } { p.SetState(6987) p.Match(PostgreSQLParserREFRESH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6988) p.Match(PostgreSQLParserPUBLICATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6989) p.Opt_definition() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(6991) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6992) p.Match(PostgreSQLParserSUBSCRIPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6993) p.Name() } { p.SetState(6994) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6995) p.Match(PostgreSQLParserPUBLICATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(6996) p.Publication_name_list() } { p.SetState(6997) p.Opt_definition() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(6999) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7000) p.Match(PostgreSQLParserSUBSCRIPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7001) p.Name() } { p.SetState(7002) p.Match(PostgreSQLParserENABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(7004) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7005) p.Match(PostgreSQLParserSUBSCRIPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7006) p.Name() } { p.SetState(7007) p.Match(PostgreSQLParserDISABLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDropsubscriptionstmtContext is an interface to support dynamic dispatch. type IDropsubscriptionstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DROP() antlr.TerminalNode SUBSCRIPTION() antlr.TerminalNode Name() INameContext Opt_drop_behavior() IOpt_drop_behaviorContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsDropsubscriptionstmtContext differentiates from other interfaces. IsDropsubscriptionstmtContext() } type DropsubscriptionstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDropsubscriptionstmtContext() *DropsubscriptionstmtContext { var p = new(DropsubscriptionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropsubscriptionstmt return p } func InitEmptyDropsubscriptionstmtContext(p *DropsubscriptionstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropsubscriptionstmt } func (*DropsubscriptionstmtContext) IsDropsubscriptionstmtContext() {} func NewDropsubscriptionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropsubscriptionstmtContext { var p = new(DropsubscriptionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_dropsubscriptionstmt return p } func (s *DropsubscriptionstmtContext) GetParser() antlr.Parser { return s.parser } func (s *DropsubscriptionstmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *DropsubscriptionstmtContext) SUBSCRIPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSUBSCRIPTION, 0) } func (s *DropsubscriptionstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *DropsubscriptionstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *DropsubscriptionstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *DropsubscriptionstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *DropsubscriptionstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DropsubscriptionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DropsubscriptionstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDropsubscriptionstmt(s) } } func (s *DropsubscriptionstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDropsubscriptionstmt(s) } } func (s *DropsubscriptionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDropsubscriptionstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Dropsubscriptionstmt() (localctx IDropsubscriptionstmtContext) { localctx = NewDropsubscriptionstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 762, PostgreSQLParserRULE_dropsubscriptionstmt) p.SetState(7023) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 325, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7011) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7012) p.Match(PostgreSQLParserSUBSCRIPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7013) p.Name() } { p.SetState(7014) p.Opt_drop_behavior() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7016) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7017) p.Match(PostgreSQLParserSUBSCRIPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7018) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7019) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7020) p.Name() } { p.SetState(7021) p.Opt_drop_behavior() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRulestmtContext is an interface to support dynamic dispatch. type IRulestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode Opt_or_replace() IOpt_or_replaceContext RULE() antlr.TerminalNode Name() INameContext AS() antlr.TerminalNode ON() antlr.TerminalNode Event() IEventContext TO() antlr.TerminalNode Qualified_name() IQualified_nameContext Where_clause() IWhere_clauseContext DO() antlr.TerminalNode Opt_instead() IOpt_insteadContext Ruleactionlist() IRuleactionlistContext // IsRulestmtContext differentiates from other interfaces. IsRulestmtContext() } type RulestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRulestmtContext() *RulestmtContext { var p = new(RulestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rulestmt return p } func InitEmptyRulestmtContext(p *RulestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rulestmt } func (*RulestmtContext) IsRulestmtContext() {} func NewRulestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RulestmtContext { var p = new(RulestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_rulestmt return p } func (s *RulestmtContext) GetParser() antlr.Parser { return s.parser } func (s *RulestmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *RulestmtContext) Opt_or_replace() IOpt_or_replaceContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_or_replaceContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_or_replaceContext) } func (s *RulestmtContext) RULE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRULE, 0) } func (s *RulestmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *RulestmtContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *RulestmtContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *RulestmtContext) Event() IEventContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IEventContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IEventContext) } func (s *RulestmtContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *RulestmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *RulestmtContext) Where_clause() IWhere_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWhere_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWhere_clauseContext) } func (s *RulestmtContext) DO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDO, 0) } func (s *RulestmtContext) Opt_instead() IOpt_insteadContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_insteadContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_insteadContext) } func (s *RulestmtContext) Ruleactionlist() IRuleactionlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRuleactionlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRuleactionlistContext) } func (s *RulestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *RulestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RulestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRulestmt(s) } } func (s *RulestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRulestmt(s) } } func (s *RulestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRulestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Rulestmt() (localctx IRulestmtContext) { localctx = NewRulestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 764, PostgreSQLParserRULE_rulestmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7025) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7026) p.Opt_or_replace() } { p.SetState(7027) p.Match(PostgreSQLParserRULE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7028) p.Name() } { p.SetState(7029) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7030) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7031) p.Event() } { p.SetState(7032) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7033) p.Qualified_name() } { p.SetState(7034) p.Where_clause() } { p.SetState(7035) p.Match(PostgreSQLParserDO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7036) p.Opt_instead() } { p.SetState(7037) p.Ruleactionlist() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRuleactionlistContext is an interface to support dynamic dispatch. type IRuleactionlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NOTHING() antlr.TerminalNode Ruleactionstmt() IRuleactionstmtContext OPEN_PAREN() antlr.TerminalNode Ruleactionmulti() IRuleactionmultiContext CLOSE_PAREN() antlr.TerminalNode // IsRuleactionlistContext differentiates from other interfaces. IsRuleactionlistContext() } type RuleactionlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRuleactionlistContext() *RuleactionlistContext { var p = new(RuleactionlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_ruleactionlist return p } func InitEmptyRuleactionlistContext(p *RuleactionlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_ruleactionlist } func (*RuleactionlistContext) IsRuleactionlistContext() {} func NewRuleactionlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleactionlistContext { var p = new(RuleactionlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_ruleactionlist return p } func (s *RuleactionlistContext) GetParser() antlr.Parser { return s.parser } func (s *RuleactionlistContext) NOTHING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOTHING, 0) } func (s *RuleactionlistContext) Ruleactionstmt() IRuleactionstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRuleactionstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRuleactionstmtContext) } func (s *RuleactionlistContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *RuleactionlistContext) Ruleactionmulti() IRuleactionmultiContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRuleactionmultiContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRuleactionmultiContext) } func (s *RuleactionlistContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *RuleactionlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *RuleactionlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RuleactionlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRuleactionlist(s) } } func (s *RuleactionlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRuleactionlist(s) } } func (s *RuleactionlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRuleactionlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Ruleactionlist() (localctx IRuleactionlistContext) { localctx = NewRuleactionlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 766, PostgreSQLParserRULE_ruleactionlist) p.SetState(7045) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 326, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7039) p.Match(PostgreSQLParserNOTHING) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7040) p.Ruleactionstmt() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(7041) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7042) p.Ruleactionmulti() } { p.SetState(7043) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRuleactionmultiContext is an interface to support dynamic dispatch. type IRuleactionmultiContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllRuleactionstmtOrEmpty() []IRuleactionstmtOrEmptyContext RuleactionstmtOrEmpty(i int) IRuleactionstmtOrEmptyContext AllSEMI() []antlr.TerminalNode SEMI(i int) antlr.TerminalNode // IsRuleactionmultiContext differentiates from other interfaces. IsRuleactionmultiContext() } type RuleactionmultiContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRuleactionmultiContext() *RuleactionmultiContext { var p = new(RuleactionmultiContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_ruleactionmulti return p } func InitEmptyRuleactionmultiContext(p *RuleactionmultiContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_ruleactionmulti } func (*RuleactionmultiContext) IsRuleactionmultiContext() {} func NewRuleactionmultiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleactionmultiContext { var p = new(RuleactionmultiContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_ruleactionmulti return p } func (s *RuleactionmultiContext) GetParser() antlr.Parser { return s.parser } func (s *RuleactionmultiContext) AllRuleactionstmtOrEmpty() []IRuleactionstmtOrEmptyContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IRuleactionstmtOrEmptyContext); ok { len++ } } tst := make([]IRuleactionstmtOrEmptyContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IRuleactionstmtOrEmptyContext); ok { tst[i] = t.(IRuleactionstmtOrEmptyContext) i++ } } return tst } func (s *RuleactionmultiContext) RuleactionstmtOrEmpty(i int) IRuleactionstmtOrEmptyContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRuleactionstmtOrEmptyContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IRuleactionstmtOrEmptyContext) } func (s *RuleactionmultiContext) AllSEMI() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserSEMI) } func (s *RuleactionmultiContext) SEMI(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, i) } func (s *RuleactionmultiContext) GetRuleContext() antlr.RuleContext { return s } func (s *RuleactionmultiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RuleactionmultiContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRuleactionmulti(s) } } func (s *RuleactionmultiContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRuleactionmulti(s) } } func (s *RuleactionmultiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRuleactionmulti(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Ruleactionmulti() (localctx IRuleactionmultiContext) { localctx = NewRuleactionmultiContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 768, PostgreSQLParserRULE_ruleactionmulti) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7047) p.RuleactionstmtOrEmpty() } p.SetState(7052) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserSEMI { { p.SetState(7048) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7049) p.RuleactionstmtOrEmpty() } p.SetState(7054) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRuleactionstmtContext is an interface to support dynamic dispatch. type IRuleactionstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Selectstmt() ISelectstmtContext Insertstmt() IInsertstmtContext Updatestmt() IUpdatestmtContext Deletestmt() IDeletestmtContext Notifystmt() INotifystmtContext // IsRuleactionstmtContext differentiates from other interfaces. IsRuleactionstmtContext() } type RuleactionstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRuleactionstmtContext() *RuleactionstmtContext { var p = new(RuleactionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_ruleactionstmt return p } func InitEmptyRuleactionstmtContext(p *RuleactionstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_ruleactionstmt } func (*RuleactionstmtContext) IsRuleactionstmtContext() {} func NewRuleactionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleactionstmtContext { var p = new(RuleactionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_ruleactionstmt return p } func (s *RuleactionstmtContext) GetParser() antlr.Parser { return s.parser } func (s *RuleactionstmtContext) Selectstmt() ISelectstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectstmtContext) } func (s *RuleactionstmtContext) Insertstmt() IInsertstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInsertstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IInsertstmtContext) } func (s *RuleactionstmtContext) Updatestmt() IUpdatestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUpdatestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUpdatestmtContext) } func (s *RuleactionstmtContext) Deletestmt() IDeletestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDeletestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDeletestmtContext) } func (s *RuleactionstmtContext) Notifystmt() INotifystmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INotifystmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INotifystmtContext) } func (s *RuleactionstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *RuleactionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RuleactionstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRuleactionstmt(s) } } func (s *RuleactionstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRuleactionstmt(s) } } func (s *RuleactionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRuleactionstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Ruleactionstmt() (localctx IRuleactionstmtContext) { localctx = NewRuleactionstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 770, PostgreSQLParserRULE_ruleactionstmt) p.SetState(7060) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 328, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7055) p.Selectstmt() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7056) p.Insertstmt() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(7057) p.Updatestmt() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(7058) p.Deletestmt() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(7059) p.Notifystmt() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRuleactionstmtOrEmptyContext is an interface to support dynamic dispatch. type IRuleactionstmtOrEmptyContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Ruleactionstmt() IRuleactionstmtContext // IsRuleactionstmtOrEmptyContext differentiates from other interfaces. IsRuleactionstmtOrEmptyContext() } type RuleactionstmtOrEmptyContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRuleactionstmtOrEmptyContext() *RuleactionstmtOrEmptyContext { var p = new(RuleactionstmtOrEmptyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_ruleactionstmtOrEmpty return p } func InitEmptyRuleactionstmtOrEmptyContext(p *RuleactionstmtOrEmptyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_ruleactionstmtOrEmpty } func (*RuleactionstmtOrEmptyContext) IsRuleactionstmtOrEmptyContext() {} func NewRuleactionstmtOrEmptyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleactionstmtOrEmptyContext { var p = new(RuleactionstmtOrEmptyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_ruleactionstmtOrEmpty return p } func (s *RuleactionstmtOrEmptyContext) GetParser() antlr.Parser { return s.parser } func (s *RuleactionstmtOrEmptyContext) Ruleactionstmt() IRuleactionstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRuleactionstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRuleactionstmtContext) } func (s *RuleactionstmtOrEmptyContext) GetRuleContext() antlr.RuleContext { return s } func (s *RuleactionstmtOrEmptyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RuleactionstmtOrEmptyContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRuleactionstmtOrEmpty(s) } } func (s *RuleactionstmtOrEmptyContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRuleactionstmtOrEmpty(s) } } func (s *RuleactionstmtOrEmptyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRuleactionstmtOrEmpty(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) RuleactionstmtOrEmpty() (localctx IRuleactionstmtOrEmptyContext) { localctx = NewRuleactionstmtOrEmptyContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 772, PostgreSQLParserRULE_ruleactionstmtOrEmpty) p.SetState(7064) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserDELETE_P, PostgreSQLParserINSERT, PostgreSQLParserNOTIFY, PostgreSQLParserUPDATE, PostgreSQLParserVALUES: p.EnterOuterAlt(localctx, 1) { p.SetState(7062) p.Ruleactionstmt() } case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IEventContext is an interface to support dynamic dispatch. type IEventContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SELECT() antlr.TerminalNode UPDATE() antlr.TerminalNode DELETE_P() antlr.TerminalNode INSERT() antlr.TerminalNode // IsEventContext differentiates from other interfaces. IsEventContext() } type EventContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyEventContext() *EventContext { var p = new(EventContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_event return p } func InitEmptyEventContext(p *EventContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_event } func (*EventContext) IsEventContext() {} func NewEventContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EventContext { var p = new(EventContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_event return p } func (s *EventContext) GetParser() antlr.Parser { return s.parser } func (s *EventContext) SELECT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSELECT, 0) } func (s *EventContext) UPDATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUPDATE, 0) } func (s *EventContext) DELETE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDELETE_P, 0) } func (s *EventContext) INSERT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINSERT, 0) } func (s *EventContext) GetRuleContext() antlr.RuleContext { return s } func (s *EventContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *EventContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterEvent(s) } } func (s *EventContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitEvent(s) } } func (s *EventContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitEvent(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Event() (localctx IEventContext) { localctx = NewEventContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 774, PostgreSQLParserRULE_event) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7066) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserSELECT || _la == PostgreSQLParserDELETE_P || _la == PostgreSQLParserINSERT || _la == PostgreSQLParserUPDATE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_insteadContext is an interface to support dynamic dispatch. type IOpt_insteadContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures INSTEAD() antlr.TerminalNode ALSO() antlr.TerminalNode // IsOpt_insteadContext differentiates from other interfaces. IsOpt_insteadContext() } type Opt_insteadContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_insteadContext() *Opt_insteadContext { var p = new(Opt_insteadContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_instead return p } func InitEmptyOpt_insteadContext(p *Opt_insteadContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_instead } func (*Opt_insteadContext) IsOpt_insteadContext() {} func NewOpt_insteadContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_insteadContext { var p = new(Opt_insteadContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_instead return p } func (s *Opt_insteadContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_insteadContext) INSTEAD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINSTEAD, 0) } func (s *Opt_insteadContext) ALSO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALSO, 0) } func (s *Opt_insteadContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_insteadContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_insteadContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_instead(s) } } func (s *Opt_insteadContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_instead(s) } } func (s *Opt_insteadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_instead(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_instead() (localctx IOpt_insteadContext) { localctx = NewOpt_insteadContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 776, PostgreSQLParserRULE_opt_instead) p.SetState(7071) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserINSTEAD: p.EnterOuterAlt(localctx, 1) { p.SetState(7068) p.Match(PostgreSQLParserINSTEAD) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserALSO: p.EnterOuterAlt(localctx, 2) { p.SetState(7069) p.Match(PostgreSQLParserALSO) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserOPEN_PAREN, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserDELETE_P, PostgreSQLParserINSERT, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserUPDATE, PostgreSQLParserVALUES: p.EnterOuterAlt(localctx, 3) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // INotifystmtContext is an interface to support dynamic dispatch. type INotifystmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NOTIFY() antlr.TerminalNode Colid() IColidContext Notify_payload() INotify_payloadContext // IsNotifystmtContext differentiates from other interfaces. IsNotifystmtContext() } type NotifystmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyNotifystmtContext() *NotifystmtContext { var p = new(NotifystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_notifystmt return p } func InitEmptyNotifystmtContext(p *NotifystmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_notifystmt } func (*NotifystmtContext) IsNotifystmtContext() {} func NewNotifystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NotifystmtContext { var p = new(NotifystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_notifystmt return p } func (s *NotifystmtContext) GetParser() antlr.Parser { return s.parser } func (s *NotifystmtContext) NOTIFY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOTIFY, 0) } func (s *NotifystmtContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *NotifystmtContext) Notify_payload() INotify_payloadContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INotify_payloadContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INotify_payloadContext) } func (s *NotifystmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *NotifystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *NotifystmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterNotifystmt(s) } } func (s *NotifystmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitNotifystmt(s) } } func (s *NotifystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitNotifystmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Notifystmt() (localctx INotifystmtContext) { localctx = NewNotifystmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 778, PostgreSQLParserRULE_notifystmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7073) p.Match(PostgreSQLParserNOTIFY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7074) p.Colid() } { p.SetState(7075) p.Notify_payload() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // INotify_payloadContext is an interface to support dynamic dispatch. type INotify_payloadContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures COMMA() antlr.TerminalNode Sconst() ISconstContext // IsNotify_payloadContext differentiates from other interfaces. IsNotify_payloadContext() } type Notify_payloadContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyNotify_payloadContext() *Notify_payloadContext { var p = new(Notify_payloadContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_notify_payload return p } func InitEmptyNotify_payloadContext(p *Notify_payloadContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_notify_payload } func (*Notify_payloadContext) IsNotify_payloadContext() {} func NewNotify_payloadContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Notify_payloadContext { var p = new(Notify_payloadContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_notify_payload return p } func (s *Notify_payloadContext) GetParser() antlr.Parser { return s.parser } func (s *Notify_payloadContext) COMMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, 0) } func (s *Notify_payloadContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Notify_payloadContext) GetRuleContext() antlr.RuleContext { return s } func (s *Notify_payloadContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Notify_payloadContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterNotify_payload(s) } } func (s *Notify_payloadContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitNotify_payload(s) } } func (s *Notify_payloadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitNotify_payload(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Notify_payload() (localctx INotify_payloadContext) { localctx = NewNotify_payloadContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 780, PostgreSQLParserRULE_notify_payload) p.SetState(7080) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCOMMA: p.EnterOuterAlt(localctx, 1) { p.SetState(7077) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7078) p.Sconst() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IListenstmtContext is an interface to support dynamic dispatch. type IListenstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures LISTEN() antlr.TerminalNode Colid() IColidContext // IsListenstmtContext differentiates from other interfaces. IsListenstmtContext() } type ListenstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyListenstmtContext() *ListenstmtContext { var p = new(ListenstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_listenstmt return p } func InitEmptyListenstmtContext(p *ListenstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_listenstmt } func (*ListenstmtContext) IsListenstmtContext() {} func NewListenstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ListenstmtContext { var p = new(ListenstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_listenstmt return p } func (s *ListenstmtContext) GetParser() antlr.Parser { return s.parser } func (s *ListenstmtContext) LISTEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLISTEN, 0) } func (s *ListenstmtContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *ListenstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *ListenstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ListenstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterListenstmt(s) } } func (s *ListenstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitListenstmt(s) } } func (s *ListenstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitListenstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Listenstmt() (localctx IListenstmtContext) { localctx = NewListenstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 782, PostgreSQLParserRULE_listenstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7082) p.Match(PostgreSQLParserLISTEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7083) p.Colid() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IUnlistenstmtContext is an interface to support dynamic dispatch. type IUnlistenstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures UNLISTEN() antlr.TerminalNode Colid() IColidContext STAR() antlr.TerminalNode // IsUnlistenstmtContext differentiates from other interfaces. IsUnlistenstmtContext() } type UnlistenstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyUnlistenstmtContext() *UnlistenstmtContext { var p = new(UnlistenstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_unlistenstmt return p } func InitEmptyUnlistenstmtContext(p *UnlistenstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_unlistenstmt } func (*UnlistenstmtContext) IsUnlistenstmtContext() {} func NewUnlistenstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnlistenstmtContext { var p = new(UnlistenstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_unlistenstmt return p } func (s *UnlistenstmtContext) GetParser() antlr.Parser { return s.parser } func (s *UnlistenstmtContext) UNLISTEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNLISTEN, 0) } func (s *UnlistenstmtContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *UnlistenstmtContext) STAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTAR, 0) } func (s *UnlistenstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *UnlistenstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *UnlistenstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterUnlistenstmt(s) } } func (s *UnlistenstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitUnlistenstmt(s) } } func (s *UnlistenstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitUnlistenstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Unlistenstmt() (localctx IUnlistenstmtContext) { localctx = NewUnlistenstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 784, PostgreSQLParserRULE_unlistenstmt) p.SetState(7089) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 332, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7085) p.Match(PostgreSQLParserUNLISTEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7086) p.Colid() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7087) p.Match(PostgreSQLParserUNLISTEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7088) p.Match(PostgreSQLParserSTAR) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITransactionstmtContext is an interface to support dynamic dispatch. type ITransactionstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ABORT_P() antlr.TerminalNode Opt_transaction() IOpt_transactionContext Opt_transaction_chain() IOpt_transaction_chainContext BEGIN_P() antlr.TerminalNode Transaction_mode_list_or_empty() ITransaction_mode_list_or_emptyContext START() antlr.TerminalNode TRANSACTION() antlr.TerminalNode COMMIT() antlr.TerminalNode END_P() antlr.TerminalNode ROLLBACK() antlr.TerminalNode SAVEPOINT() antlr.TerminalNode Colid() IColidContext RELEASE() antlr.TerminalNode TO() antlr.TerminalNode PREPARE() antlr.TerminalNode Sconst() ISconstContext PREPARED() antlr.TerminalNode // IsTransactionstmtContext differentiates from other interfaces. IsTransactionstmtContext() } type TransactionstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTransactionstmtContext() *TransactionstmtContext { var p = new(TransactionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transactionstmt return p } func InitEmptyTransactionstmtContext(p *TransactionstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transactionstmt } func (*TransactionstmtContext) IsTransactionstmtContext() {} func NewTransactionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionstmtContext { var p = new(TransactionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_transactionstmt return p } func (s *TransactionstmtContext) GetParser() antlr.Parser { return s.parser } func (s *TransactionstmtContext) ABORT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserABORT_P, 0) } func (s *TransactionstmtContext) Opt_transaction() IOpt_transactionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_transactionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_transactionContext) } func (s *TransactionstmtContext) Opt_transaction_chain() IOpt_transaction_chainContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_transaction_chainContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_transaction_chainContext) } func (s *TransactionstmtContext) BEGIN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBEGIN_P, 0) } func (s *TransactionstmtContext) Transaction_mode_list_or_empty() ITransaction_mode_list_or_emptyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITransaction_mode_list_or_emptyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITransaction_mode_list_or_emptyContext) } func (s *TransactionstmtContext) START() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTART, 0) } func (s *TransactionstmtContext) TRANSACTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSACTION, 0) } func (s *TransactionstmtContext) COMMIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMIT, 0) } func (s *TransactionstmtContext) END_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEND_P, 0) } func (s *TransactionstmtContext) ROLLBACK() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLLBACK, 0) } func (s *TransactionstmtContext) SAVEPOINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSAVEPOINT, 0) } func (s *TransactionstmtContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *TransactionstmtContext) RELEASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRELEASE, 0) } func (s *TransactionstmtContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *TransactionstmtContext) PREPARE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPREPARE, 0) } func (s *TransactionstmtContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *TransactionstmtContext) PREPARED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPREPARED, 0) } func (s *TransactionstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *TransactionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TransactionstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTransactionstmt(s) } } func (s *TransactionstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTransactionstmt(s) } } func (s *TransactionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTransactionstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Transactionstmt() (localctx ITransactionstmtContext) { localctx = NewTransactionstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 786, PostgreSQLParserRULE_transactionstmt) p.SetState(7141) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 333, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7091) p.Match(PostgreSQLParserABORT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7092) p.Opt_transaction() } { p.SetState(7093) p.Opt_transaction_chain() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7095) p.Match(PostgreSQLParserBEGIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7096) p.Opt_transaction() } { p.SetState(7097) p.Transaction_mode_list_or_empty() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(7099) p.Match(PostgreSQLParserSTART) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7100) p.Match(PostgreSQLParserTRANSACTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7101) p.Transaction_mode_list_or_empty() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(7102) p.Match(PostgreSQLParserCOMMIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7103) p.Opt_transaction() } { p.SetState(7104) p.Opt_transaction_chain() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(7106) p.Match(PostgreSQLParserEND_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7107) p.Opt_transaction() } { p.SetState(7108) p.Opt_transaction_chain() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(7110) p.Match(PostgreSQLParserROLLBACK) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7111) p.Opt_transaction() } { p.SetState(7112) p.Opt_transaction_chain() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(7114) p.Match(PostgreSQLParserSAVEPOINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7115) p.Colid() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(7116) p.Match(PostgreSQLParserRELEASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7117) p.Match(PostgreSQLParserSAVEPOINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7118) p.Colid() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(7119) p.Match(PostgreSQLParserRELEASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7120) p.Colid() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(7121) p.Match(PostgreSQLParserROLLBACK) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7122) p.Opt_transaction() } { p.SetState(7123) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7124) p.Match(PostgreSQLParserSAVEPOINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7125) p.Colid() } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(7127) p.Match(PostgreSQLParserROLLBACK) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7128) p.Opt_transaction() } { p.SetState(7129) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7130) p.Colid() } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(7132) p.Match(PostgreSQLParserPREPARE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7133) p.Match(PostgreSQLParserTRANSACTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7134) p.Sconst() } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(7135) p.Match(PostgreSQLParserCOMMIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7136) p.Match(PostgreSQLParserPREPARED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7137) p.Sconst() } case 14: p.EnterOuterAlt(localctx, 14) { p.SetState(7138) p.Match(PostgreSQLParserROLLBACK) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7139) p.Match(PostgreSQLParserPREPARED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7140) p.Sconst() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_transactionContext is an interface to support dynamic dispatch. type IOpt_transactionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WORK() antlr.TerminalNode TRANSACTION() antlr.TerminalNode // IsOpt_transactionContext differentiates from other interfaces. IsOpt_transactionContext() } type Opt_transactionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_transactionContext() *Opt_transactionContext { var p = new(Opt_transactionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_transaction return p } func InitEmptyOpt_transactionContext(p *Opt_transactionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_transaction } func (*Opt_transactionContext) IsOpt_transactionContext() {} func NewOpt_transactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_transactionContext { var p = new(Opt_transactionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_transaction return p } func (s *Opt_transactionContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_transactionContext) WORK() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWORK, 0) } func (s *Opt_transactionContext) TRANSACTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSACTION, 0) } func (s *Opt_transactionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_transactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_transactionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_transaction(s) } } func (s *Opt_transactionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_transaction(s) } } func (s *Opt_transactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_transaction(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_transaction() (localctx IOpt_transactionContext) { localctx = NewOpt_transactionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 788, PostgreSQLParserRULE_opt_transaction) p.SetState(7146) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserWORK: p.EnterOuterAlt(localctx, 1) { p.SetState(7143) p.Match(PostgreSQLParserWORK) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserTRANSACTION: p.EnterOuterAlt(localctx, 2) { p.SetState(7144) p.Match(PostgreSQLParserTRANSACTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserCREATE, PostgreSQLParserDEFERRABLE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserNOT, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTO, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserISOLATION, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 3) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITransaction_mode_itemContext is an interface to support dynamic dispatch. type ITransaction_mode_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ISOLATION() antlr.TerminalNode LEVEL() antlr.TerminalNode Iso_level() IIso_levelContext READ() antlr.TerminalNode ONLY() antlr.TerminalNode WRITE() antlr.TerminalNode DEFERRABLE() antlr.TerminalNode NOT() antlr.TerminalNode // IsTransaction_mode_itemContext differentiates from other interfaces. IsTransaction_mode_itemContext() } type Transaction_mode_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTransaction_mode_itemContext() *Transaction_mode_itemContext { var p = new(Transaction_mode_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transaction_mode_item return p } func InitEmptyTransaction_mode_itemContext(p *Transaction_mode_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transaction_mode_item } func (*Transaction_mode_itemContext) IsTransaction_mode_itemContext() {} func NewTransaction_mode_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_mode_itemContext { var p = new(Transaction_mode_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_transaction_mode_item return p } func (s *Transaction_mode_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Transaction_mode_itemContext) ISOLATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserISOLATION, 0) } func (s *Transaction_mode_itemContext) LEVEL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEVEL, 0) } func (s *Transaction_mode_itemContext) Iso_level() IIso_levelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIso_levelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIso_levelContext) } func (s *Transaction_mode_itemContext) READ() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREAD, 0) } func (s *Transaction_mode_itemContext) ONLY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserONLY, 0) } func (s *Transaction_mode_itemContext) WRITE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWRITE, 0) } func (s *Transaction_mode_itemContext) DEFERRABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFERRABLE, 0) } func (s *Transaction_mode_itemContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *Transaction_mode_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Transaction_mode_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Transaction_mode_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTransaction_mode_item(s) } } func (s *Transaction_mode_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTransaction_mode_item(s) } } func (s *Transaction_mode_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTransaction_mode_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Transaction_mode_item() (localctx ITransaction_mode_itemContext) { localctx = NewTransaction_mode_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 790, PostgreSQLParserRULE_transaction_mode_item) p.SetState(7158) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 335, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7148) p.Match(PostgreSQLParserISOLATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7149) p.Match(PostgreSQLParserLEVEL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7150) p.Iso_level() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7151) p.Match(PostgreSQLParserREAD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7152) p.Match(PostgreSQLParserONLY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(7153) p.Match(PostgreSQLParserREAD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7154) p.Match(PostgreSQLParserWRITE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(7155) p.Match(PostgreSQLParserDEFERRABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(7156) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7157) p.Match(PostgreSQLParserDEFERRABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITransaction_mode_listContext is an interface to support dynamic dispatch. type ITransaction_mode_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllTransaction_mode_item() []ITransaction_mode_itemContext Transaction_mode_item(i int) ITransaction_mode_itemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsTransaction_mode_listContext differentiates from other interfaces. IsTransaction_mode_listContext() } type Transaction_mode_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTransaction_mode_listContext() *Transaction_mode_listContext { var p = new(Transaction_mode_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transaction_mode_list return p } func InitEmptyTransaction_mode_listContext(p *Transaction_mode_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transaction_mode_list } func (*Transaction_mode_listContext) IsTransaction_mode_listContext() {} func NewTransaction_mode_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_mode_listContext { var p = new(Transaction_mode_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_transaction_mode_list return p } func (s *Transaction_mode_listContext) GetParser() antlr.Parser { return s.parser } func (s *Transaction_mode_listContext) AllTransaction_mode_item() []ITransaction_mode_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITransaction_mode_itemContext); ok { len++ } } tst := make([]ITransaction_mode_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITransaction_mode_itemContext); ok { tst[i] = t.(ITransaction_mode_itemContext) i++ } } return tst } func (s *Transaction_mode_listContext) Transaction_mode_item(i int) ITransaction_mode_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITransaction_mode_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITransaction_mode_itemContext) } func (s *Transaction_mode_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Transaction_mode_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Transaction_mode_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Transaction_mode_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Transaction_mode_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTransaction_mode_list(s) } } func (s *Transaction_mode_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTransaction_mode_list(s) } } func (s *Transaction_mode_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTransaction_mode_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Transaction_mode_list() (localctx ITransaction_mode_listContext) { localctx = NewTransaction_mode_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 792, PostgreSQLParserRULE_transaction_mode_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7160) p.Transaction_mode_item() } p.SetState(7167) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA || _la == PostgreSQLParserDEFERRABLE || _la == PostgreSQLParserNOT || _la == PostgreSQLParserISOLATION || _la == PostgreSQLParserREAD { p.SetState(7162) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserCOMMA { { p.SetState(7161) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(7164) p.Transaction_mode_item() } p.SetState(7169) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITransaction_mode_list_or_emptyContext is an interface to support dynamic dispatch. type ITransaction_mode_list_or_emptyContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Transaction_mode_list() ITransaction_mode_listContext // IsTransaction_mode_list_or_emptyContext differentiates from other interfaces. IsTransaction_mode_list_or_emptyContext() } type Transaction_mode_list_or_emptyContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTransaction_mode_list_or_emptyContext() *Transaction_mode_list_or_emptyContext { var p = new(Transaction_mode_list_or_emptyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transaction_mode_list_or_empty return p } func InitEmptyTransaction_mode_list_or_emptyContext(p *Transaction_mode_list_or_emptyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_transaction_mode_list_or_empty } func (*Transaction_mode_list_or_emptyContext) IsTransaction_mode_list_or_emptyContext() {} func NewTransaction_mode_list_or_emptyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_mode_list_or_emptyContext { var p = new(Transaction_mode_list_or_emptyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_transaction_mode_list_or_empty return p } func (s *Transaction_mode_list_or_emptyContext) GetParser() antlr.Parser { return s.parser } func (s *Transaction_mode_list_or_emptyContext) Transaction_mode_list() ITransaction_mode_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITransaction_mode_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITransaction_mode_listContext) } func (s *Transaction_mode_list_or_emptyContext) GetRuleContext() antlr.RuleContext { return s } func (s *Transaction_mode_list_or_emptyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Transaction_mode_list_or_emptyContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTransaction_mode_list_or_empty(s) } } func (s *Transaction_mode_list_or_emptyContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTransaction_mode_list_or_empty(s) } } func (s *Transaction_mode_list_or_emptyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTransaction_mode_list_or_empty(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Transaction_mode_list_or_empty() (localctx ITransaction_mode_list_or_emptyContext) { localctx = NewTransaction_mode_list_or_emptyContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 794, PostgreSQLParserRULE_transaction_mode_list_or_empty) p.SetState(7172) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserDEFERRABLE, PostgreSQLParserNOT, PostgreSQLParserISOLATION, PostgreSQLParserREAD: p.EnterOuterAlt(localctx, 1) { p.SetState(7170) p.Transaction_mode_list() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_transaction_chainContext is an interface to support dynamic dispatch. type IOpt_transaction_chainContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AND() antlr.TerminalNode CHAIN() antlr.TerminalNode NO() antlr.TerminalNode // IsOpt_transaction_chainContext differentiates from other interfaces. IsOpt_transaction_chainContext() } type Opt_transaction_chainContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_transaction_chainContext() *Opt_transaction_chainContext { var p = new(Opt_transaction_chainContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_transaction_chain return p } func InitEmptyOpt_transaction_chainContext(p *Opt_transaction_chainContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_transaction_chain } func (*Opt_transaction_chainContext) IsOpt_transaction_chainContext() {} func NewOpt_transaction_chainContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_transaction_chainContext { var p = new(Opt_transaction_chainContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_transaction_chain return p } func (s *Opt_transaction_chainContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_transaction_chainContext) AND() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAND, 0) } func (s *Opt_transaction_chainContext) CHAIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHAIN, 0) } func (s *Opt_transaction_chainContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Opt_transaction_chainContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_transaction_chainContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_transaction_chainContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_transaction_chain(s) } } func (s *Opt_transaction_chainContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_transaction_chain(s) } } func (s *Opt_transaction_chainContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_transaction_chain(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_transaction_chain() (localctx IOpt_transaction_chainContext) { localctx = NewOpt_transaction_chainContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 796, PostgreSQLParserRULE_opt_transaction_chain) var _la int p.SetState(7180) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND: p.EnterOuterAlt(localctx, 1) { p.SetState(7174) p.Match(PostgreSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7176) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserNO { { p.SetState(7175) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(7178) p.Match(PostgreSQLParserCHAIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IViewstmtContext is an interface to support dynamic dispatch. type IViewstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode Opttemp() IOpttempContext AS() antlr.TerminalNode Selectstmt() ISelectstmtContext Opt_check_option() IOpt_check_optionContext VIEW() antlr.TerminalNode Qualified_name() IQualified_nameContext Opt_column_list() IOpt_column_listContext Opt_reloptions() IOpt_reloptionsContext RECURSIVE() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Columnlist() IColumnlistContext CLOSE_PAREN() antlr.TerminalNode OR() antlr.TerminalNode REPLACE() antlr.TerminalNode // IsViewstmtContext differentiates from other interfaces. IsViewstmtContext() } type ViewstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyViewstmtContext() *ViewstmtContext { var p = new(ViewstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_viewstmt return p } func InitEmptyViewstmtContext(p *ViewstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_viewstmt } func (*ViewstmtContext) IsViewstmtContext() {} func NewViewstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ViewstmtContext { var p = new(ViewstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_viewstmt return p } func (s *ViewstmtContext) GetParser() antlr.Parser { return s.parser } func (s *ViewstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *ViewstmtContext) Opttemp() IOpttempContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttempContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttempContext) } func (s *ViewstmtContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *ViewstmtContext) Selectstmt() ISelectstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectstmtContext) } func (s *ViewstmtContext) Opt_check_option() IOpt_check_optionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_check_optionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_check_optionContext) } func (s *ViewstmtContext) VIEW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVIEW, 0) } func (s *ViewstmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *ViewstmtContext) Opt_column_list() IOpt_column_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_column_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_column_listContext) } func (s *ViewstmtContext) Opt_reloptions() IOpt_reloptionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_reloptionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_reloptionsContext) } func (s *ViewstmtContext) RECURSIVE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRECURSIVE, 0) } func (s *ViewstmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *ViewstmtContext) Columnlist() IColumnlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColumnlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColumnlistContext) } func (s *ViewstmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *ViewstmtContext) OR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOR, 0) } func (s *ViewstmtContext) REPLACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREPLACE, 0) } func (s *ViewstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *ViewstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ViewstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterViewstmt(s) } } func (s *ViewstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitViewstmt(s) } } func (s *ViewstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitViewstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Viewstmt() (localctx IViewstmtContext) { localctx = NewViewstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 798, PostgreSQLParserRULE_viewstmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7182) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7185) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserOR { { p.SetState(7183) p.Match(PostgreSQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7184) p.Match(PostgreSQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(7187) p.Opttemp() } p.SetState(7201) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserVIEW: { p.SetState(7188) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7189) p.Qualified_name() } { p.SetState(7190) p.Opt_column_list() } { p.SetState(7191) p.Opt_reloptions() } case PostgreSQLParserRECURSIVE: { p.SetState(7193) p.Match(PostgreSQLParserRECURSIVE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7194) p.Match(PostgreSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7195) p.Qualified_name() } { p.SetState(7196) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7197) p.Columnlist() } { p.SetState(7198) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7199) p.Opt_reloptions() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } { p.SetState(7203) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7204) p.Selectstmt() } { p.SetState(7205) p.Opt_check_option() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_check_optionContext is an interface to support dynamic dispatch. type IOpt_check_optionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITH() antlr.TerminalNode CHECK() antlr.TerminalNode OPTION() antlr.TerminalNode CASCADED() antlr.TerminalNode LOCAL() antlr.TerminalNode // IsOpt_check_optionContext differentiates from other interfaces. IsOpt_check_optionContext() } type Opt_check_optionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_check_optionContext() *Opt_check_optionContext { var p = new(Opt_check_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_check_option return p } func InitEmptyOpt_check_optionContext(p *Opt_check_optionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_check_option } func (*Opt_check_optionContext) IsOpt_check_optionContext() {} func NewOpt_check_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_check_optionContext { var p = new(Opt_check_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_check_option return p } func (s *Opt_check_optionContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_check_optionContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *Opt_check_optionContext) CHECK() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHECK, 0) } func (s *Opt_check_optionContext) OPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPTION, 0) } func (s *Opt_check_optionContext) CASCADED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCASCADED, 0) } func (s *Opt_check_optionContext) LOCAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCAL, 0) } func (s *Opt_check_optionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_check_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_check_optionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_check_option(s) } } func (s *Opt_check_optionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_check_option(s) } } func (s *Opt_check_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_check_option(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_check_option() (localctx IOpt_check_optionContext) { localctx = NewOpt_check_optionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 800, PostgreSQLParserRULE_opt_check_option) var _la int p.SetState(7214) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 344, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7207) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7209) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserCASCADED || _la == PostgreSQLParserLOCAL { { p.SetState(7208) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserCASCADED || _la == PostgreSQLParserLOCAL) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } } { p.SetState(7211) p.Match(PostgreSQLParserCHECK) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7212) p.Match(PostgreSQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ILoadstmtContext is an interface to support dynamic dispatch. type ILoadstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures LOAD() antlr.TerminalNode File_name() IFile_nameContext // IsLoadstmtContext differentiates from other interfaces. IsLoadstmtContext() } type LoadstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyLoadstmtContext() *LoadstmtContext { var p = new(LoadstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_loadstmt return p } func InitEmptyLoadstmtContext(p *LoadstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_loadstmt } func (*LoadstmtContext) IsLoadstmtContext() {} func NewLoadstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoadstmtContext { var p = new(LoadstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_loadstmt return p } func (s *LoadstmtContext) GetParser() antlr.Parser { return s.parser } func (s *LoadstmtContext) LOAD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOAD, 0) } func (s *LoadstmtContext) File_name() IFile_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFile_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFile_nameContext) } func (s *LoadstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *LoadstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *LoadstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterLoadstmt(s) } } func (s *LoadstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitLoadstmt(s) } } func (s *LoadstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitLoadstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Loadstmt() (localctx ILoadstmtContext) { localctx = NewLoadstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 802, PostgreSQLParserRULE_loadstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7216) p.Match(PostgreSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7217) p.File_name() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatedbstmtContext is an interface to support dynamic dispatch. type ICreatedbstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode DATABASE() antlr.TerminalNode Name() INameContext Opt_with() IOpt_withContext Createdb_opt_list() ICreatedb_opt_listContext // IsCreatedbstmtContext differentiates from other interfaces. IsCreatedbstmtContext() } type CreatedbstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatedbstmtContext() *CreatedbstmtContext { var p = new(CreatedbstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createdbstmt return p } func InitEmptyCreatedbstmtContext(p *CreatedbstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createdbstmt } func (*CreatedbstmtContext) IsCreatedbstmtContext() {} func NewCreatedbstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatedbstmtContext { var p = new(CreatedbstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createdbstmt return p } func (s *CreatedbstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreatedbstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreatedbstmtContext) DATABASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATABASE, 0) } func (s *CreatedbstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *CreatedbstmtContext) Opt_with() IOpt_withContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_withContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_withContext) } func (s *CreatedbstmtContext) Createdb_opt_list() ICreatedb_opt_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatedb_opt_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatedb_opt_listContext) } func (s *CreatedbstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreatedbstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreatedbstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatedbstmt(s) } } func (s *CreatedbstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatedbstmt(s) } } func (s *CreatedbstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatedbstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createdbstmt() (localctx ICreatedbstmtContext) { localctx = NewCreatedbstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 804, PostgreSQLParserRULE_createdbstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7219) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7220) p.Match(PostgreSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7221) p.Name() } { p.SetState(7222) p.Opt_with() } { p.SetState(7223) p.Createdb_opt_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatedb_opt_listContext is an interface to support dynamic dispatch. type ICreatedb_opt_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Createdb_opt_items() ICreatedb_opt_itemsContext // IsCreatedb_opt_listContext differentiates from other interfaces. IsCreatedb_opt_listContext() } type Createdb_opt_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatedb_opt_listContext() *Createdb_opt_listContext { var p = new(Createdb_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createdb_opt_list return p } func InitEmptyCreatedb_opt_listContext(p *Createdb_opt_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createdb_opt_list } func (*Createdb_opt_listContext) IsCreatedb_opt_listContext() {} func NewCreatedb_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createdb_opt_listContext { var p = new(Createdb_opt_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createdb_opt_list return p } func (s *Createdb_opt_listContext) GetParser() antlr.Parser { return s.parser } func (s *Createdb_opt_listContext) Createdb_opt_items() ICreatedb_opt_itemsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatedb_opt_itemsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatedb_opt_itemsContext) } func (s *Createdb_opt_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Createdb_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Createdb_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatedb_opt_list(s) } } func (s *Createdb_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatedb_opt_list(s) } } func (s *Createdb_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatedb_opt_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createdb_opt_list() (localctx ICreatedb_opt_listContext) { localctx = NewCreatedb_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 806, PostgreSQLParserRULE_createdb_opt_list) p.SetState(7227) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 345, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7225) p.Createdb_opt_items() } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatedb_opt_itemsContext is an interface to support dynamic dispatch. type ICreatedb_opt_itemsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllCreatedb_opt_item() []ICreatedb_opt_itemContext Createdb_opt_item(i int) ICreatedb_opt_itemContext // IsCreatedb_opt_itemsContext differentiates from other interfaces. IsCreatedb_opt_itemsContext() } type Createdb_opt_itemsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatedb_opt_itemsContext() *Createdb_opt_itemsContext { var p = new(Createdb_opt_itemsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createdb_opt_items return p } func InitEmptyCreatedb_opt_itemsContext(p *Createdb_opt_itemsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createdb_opt_items } func (*Createdb_opt_itemsContext) IsCreatedb_opt_itemsContext() {} func NewCreatedb_opt_itemsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createdb_opt_itemsContext { var p = new(Createdb_opt_itemsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createdb_opt_items return p } func (s *Createdb_opt_itemsContext) GetParser() antlr.Parser { return s.parser } func (s *Createdb_opt_itemsContext) AllCreatedb_opt_item() []ICreatedb_opt_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ICreatedb_opt_itemContext); ok { len++ } } tst := make([]ICreatedb_opt_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ICreatedb_opt_itemContext); ok { tst[i] = t.(ICreatedb_opt_itemContext) i++ } } return tst } func (s *Createdb_opt_itemsContext) Createdb_opt_item(i int) ICreatedb_opt_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatedb_opt_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ICreatedb_opt_itemContext) } func (s *Createdb_opt_itemsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Createdb_opt_itemsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Createdb_opt_itemsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatedb_opt_items(s) } } func (s *Createdb_opt_itemsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatedb_opt_items(s) } } func (s *Createdb_opt_itemsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatedb_opt_items(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createdb_opt_items() (localctx ICreatedb_opt_itemsContext) { localctx = NewCreatedb_opt_itemsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 808, PostgreSQLParserRULE_createdb_opt_items) var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(7230) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = 1 for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { switch _alt { case 1: { p.SetState(7229) p.Createdb_opt_item() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.SetState(7232) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 346, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatedb_opt_itemContext is an interface to support dynamic dispatch. type ICreatedb_opt_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Createdb_opt_name() ICreatedb_opt_nameContext Opt_equal() IOpt_equalContext Signediconst() ISignediconstContext Opt_boolean_or_string() IOpt_boolean_or_stringContext DEFAULT() antlr.TerminalNode // IsCreatedb_opt_itemContext differentiates from other interfaces. IsCreatedb_opt_itemContext() } type Createdb_opt_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatedb_opt_itemContext() *Createdb_opt_itemContext { var p = new(Createdb_opt_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createdb_opt_item return p } func InitEmptyCreatedb_opt_itemContext(p *Createdb_opt_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createdb_opt_item } func (*Createdb_opt_itemContext) IsCreatedb_opt_itemContext() {} func NewCreatedb_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createdb_opt_itemContext { var p = new(Createdb_opt_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createdb_opt_item return p } func (s *Createdb_opt_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Createdb_opt_itemContext) Createdb_opt_name() ICreatedb_opt_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatedb_opt_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatedb_opt_nameContext) } func (s *Createdb_opt_itemContext) Opt_equal() IOpt_equalContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_equalContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_equalContext) } func (s *Createdb_opt_itemContext) Signediconst() ISignediconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISignediconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISignediconstContext) } func (s *Createdb_opt_itemContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_boolean_or_stringContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_boolean_or_stringContext) } func (s *Createdb_opt_itemContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Createdb_opt_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Createdb_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Createdb_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatedb_opt_item(s) } } func (s *Createdb_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatedb_opt_item(s) } } func (s *Createdb_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatedb_opt_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createdb_opt_item() (localctx ICreatedb_opt_itemContext) { localctx = NewCreatedb_opt_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 810, PostgreSQLParserRULE_createdb_opt_item) p.EnterOuterAlt(localctx, 1) { p.SetState(7234) p.Createdb_opt_name() } { p.SetState(7235) p.Opt_equal() } p.SetState(7239) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 347, p.GetParserRuleContext()) { case 1: { p.SetState(7236) p.Signediconst() } case 2: { p.SetState(7237) p.Opt_boolean_or_string() } case 3: { p.SetState(7238) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatedb_opt_nameContext is an interface to support dynamic dispatch. type ICreatedb_opt_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Identifier() IIdentifierContext CONNECTION() antlr.TerminalNode LIMIT() antlr.TerminalNode ENCODING() antlr.TerminalNode LOCATION() antlr.TerminalNode OWNER() antlr.TerminalNode TABLESPACE() antlr.TerminalNode TEMPLATE() antlr.TerminalNode // IsCreatedb_opt_nameContext differentiates from other interfaces. IsCreatedb_opt_nameContext() } type Createdb_opt_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatedb_opt_nameContext() *Createdb_opt_nameContext { var p = new(Createdb_opt_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createdb_opt_name return p } func InitEmptyCreatedb_opt_nameContext(p *Createdb_opt_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createdb_opt_name } func (*Createdb_opt_nameContext) IsCreatedb_opt_nameContext() {} func NewCreatedb_opt_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createdb_opt_nameContext { var p = new(Createdb_opt_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createdb_opt_name return p } func (s *Createdb_opt_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Createdb_opt_nameContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *Createdb_opt_nameContext) CONNECTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONNECTION, 0) } func (s *Createdb_opt_nameContext) LIMIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLIMIT, 0) } func (s *Createdb_opt_nameContext) ENCODING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserENCODING, 0) } func (s *Createdb_opt_nameContext) LOCATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCATION, 0) } func (s *Createdb_opt_nameContext) OWNER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOWNER, 0) } func (s *Createdb_opt_nameContext) TABLESPACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, 0) } func (s *Createdb_opt_nameContext) TEMPLATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEMPLATE, 0) } func (s *Createdb_opt_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Createdb_opt_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Createdb_opt_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatedb_opt_name(s) } } func (s *Createdb_opt_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatedb_opt_name(s) } } func (s *Createdb_opt_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatedb_opt_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createdb_opt_name() (localctx ICreatedb_opt_nameContext) { localctx = NewCreatedb_opt_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 812, PostgreSQLParserRULE_createdb_opt_name) p.SetState(7249) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserOUTER_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserBACKWARD, PostgreSQLParserCHAIN, PostgreSQLParserCLOSE, PostgreSQLParserCOMMIT, PostgreSQLParserCONTINUE_P, PostgreSQLParserCURSOR, PostgreSQLParserFIRST_P, PostgreSQLParserFORWARD, PostgreSQLParserINSERT, PostgreSQLParserLAST_P, PostgreSQLParserMOVE, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserOPTION, PostgreSQLParserPRIOR, PostgreSQLParserRELATIVE_P, PostgreSQLParserRESET, PostgreSQLParserROLLBACK, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSET, PostgreSQLParserTYPE_P, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserROWTYPE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(7241) p.Identifier() } case PostgreSQLParserCONNECTION: p.EnterOuterAlt(localctx, 2) { p.SetState(7242) p.Match(PostgreSQLParserCONNECTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7243) p.Match(PostgreSQLParserLIMIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserENCODING: p.EnterOuterAlt(localctx, 3) { p.SetState(7244) p.Match(PostgreSQLParserENCODING) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserLOCATION: p.EnterOuterAlt(localctx, 4) { p.SetState(7245) p.Match(PostgreSQLParserLOCATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserOWNER: p.EnterOuterAlt(localctx, 5) { p.SetState(7246) p.Match(PostgreSQLParserOWNER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserTABLESPACE: p.EnterOuterAlt(localctx, 6) { p.SetState(7247) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserTEMPLATE: p.EnterOuterAlt(localctx, 7) { p.SetState(7248) p.Match(PostgreSQLParserTEMPLATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_equalContext is an interface to support dynamic dispatch. type IOpt_equalContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures EQUAL() antlr.TerminalNode // IsOpt_equalContext differentiates from other interfaces. IsOpt_equalContext() } type Opt_equalContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_equalContext() *Opt_equalContext { var p = new(Opt_equalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_equal return p } func InitEmptyOpt_equalContext(p *Opt_equalContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_equal } func (*Opt_equalContext) IsOpt_equalContext() {} func NewOpt_equalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_equalContext { var p = new(Opt_equalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_equal return p } func (s *Opt_equalContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_equalContext) EQUAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEQUAL, 0) } func (s *Opt_equalContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_equalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_equalContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_equal(s) } } func (s *Opt_equalContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_equal(s) } } func (s *Opt_equalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_equal(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_equal() (localctx IOpt_equalContext) { localctx = NewOpt_equalContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 814, PostgreSQLParserRULE_opt_equal) p.SetState(7253) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserEQUAL: p.EnterOuterAlt(localctx, 1) { p.SetState(7251) p.Match(PostgreSQLParserEQUAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserON, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserIntegral, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterdatabasestmtContext is an interface to support dynamic dispatch. type IAlterdatabasestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode DATABASE() antlr.TerminalNode AllName() []INameContext Name(i int) INameContext WITH() antlr.TerminalNode Createdb_opt_list() ICreatedb_opt_listContext SET() antlr.TerminalNode TABLESPACE() antlr.TerminalNode // IsAlterdatabasestmtContext differentiates from other interfaces. IsAlterdatabasestmtContext() } type AlterdatabasestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterdatabasestmtContext() *AlterdatabasestmtContext { var p = new(AlterdatabasestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterdatabasestmt return p } func InitEmptyAlterdatabasestmtContext(p *AlterdatabasestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterdatabasestmt } func (*AlterdatabasestmtContext) IsAlterdatabasestmtContext() {} func NewAlterdatabasestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterdatabasestmtContext { var p = new(AlterdatabasestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterdatabasestmt return p } func (s *AlterdatabasestmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterdatabasestmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterdatabasestmtContext) DATABASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATABASE, 0) } func (s *AlterdatabasestmtContext) AllName() []INameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(INameContext); ok { len++ } } tst := make([]INameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(INameContext); ok { tst[i] = t.(INameContext) i++ } } return tst } func (s *AlterdatabasestmtContext) Name(i int) INameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(INameContext) } func (s *AlterdatabasestmtContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *AlterdatabasestmtContext) Createdb_opt_list() ICreatedb_opt_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatedb_opt_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatedb_opt_listContext) } func (s *AlterdatabasestmtContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *AlterdatabasestmtContext) TABLESPACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, 0) } func (s *AlterdatabasestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterdatabasestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterdatabasestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterdatabasestmt(s) } } func (s *AlterdatabasestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterdatabasestmt(s) } } func (s *AlterdatabasestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterdatabasestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterdatabasestmt() (localctx IAlterdatabasestmtContext) { localctx = NewAlterdatabasestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 816, PostgreSQLParserRULE_alterdatabasestmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7255) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7256) p.Match(PostgreSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7257) p.Name() } p.SetState(7264) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 350, p.GetParserRuleContext()) { case 1: { p.SetState(7258) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7259) p.Createdb_opt_list() } case 2: { p.SetState(7260) p.Createdb_opt_list() } case 3: { p.SetState(7261) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7262) p.Match(PostgreSQLParserTABLESPACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7263) p.Name() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterdatabasesetstmtContext is an interface to support dynamic dispatch. type IAlterdatabasesetstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode DATABASE() antlr.TerminalNode Name() INameContext Setresetclause() ISetresetclauseContext // IsAlterdatabasesetstmtContext differentiates from other interfaces. IsAlterdatabasesetstmtContext() } type AlterdatabasesetstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterdatabasesetstmtContext() *AlterdatabasesetstmtContext { var p = new(AlterdatabasesetstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterdatabasesetstmt return p } func InitEmptyAlterdatabasesetstmtContext(p *AlterdatabasesetstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterdatabasesetstmt } func (*AlterdatabasesetstmtContext) IsAlterdatabasesetstmtContext() {} func NewAlterdatabasesetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterdatabasesetstmtContext { var p = new(AlterdatabasesetstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterdatabasesetstmt return p } func (s *AlterdatabasesetstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterdatabasesetstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterdatabasesetstmtContext) DATABASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATABASE, 0) } func (s *AlterdatabasesetstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *AlterdatabasesetstmtContext) Setresetclause() ISetresetclauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISetresetclauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISetresetclauseContext) } func (s *AlterdatabasesetstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterdatabasesetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterdatabasesetstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterdatabasesetstmt(s) } } func (s *AlterdatabasesetstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterdatabasesetstmt(s) } } func (s *AlterdatabasesetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterdatabasesetstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterdatabasesetstmt() (localctx IAlterdatabasesetstmtContext) { localctx = NewAlterdatabasesetstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 818, PostgreSQLParserRULE_alterdatabasesetstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7266) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7267) p.Match(PostgreSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7268) p.Name() } { p.SetState(7269) p.Setresetclause() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDropdbstmtContext is an interface to support dynamic dispatch. type IDropdbstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DROP() antlr.TerminalNode DATABASE() antlr.TerminalNode Name() INameContext IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode Opt_with() IOpt_withContext OPEN_PAREN() antlr.TerminalNode Drop_option_list() IDrop_option_listContext CLOSE_PAREN() antlr.TerminalNode // IsDropdbstmtContext differentiates from other interfaces. IsDropdbstmtContext() } type DropdbstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDropdbstmtContext() *DropdbstmtContext { var p = new(DropdbstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropdbstmt return p } func InitEmptyDropdbstmtContext(p *DropdbstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_dropdbstmt } func (*DropdbstmtContext) IsDropdbstmtContext() {} func NewDropdbstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropdbstmtContext { var p = new(DropdbstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_dropdbstmt return p } func (s *DropdbstmtContext) GetParser() antlr.Parser { return s.parser } func (s *DropdbstmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *DropdbstmtContext) DATABASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATABASE, 0) } func (s *DropdbstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *DropdbstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *DropdbstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *DropdbstmtContext) Opt_with() IOpt_withContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_withContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_withContext) } func (s *DropdbstmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *DropdbstmtContext) Drop_option_list() IDrop_option_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDrop_option_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDrop_option_listContext) } func (s *DropdbstmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *DropdbstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DropdbstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DropdbstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDropdbstmt(s) } } func (s *DropdbstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDropdbstmt(s) } } func (s *DropdbstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDropdbstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Dropdbstmt() (localctx IDropdbstmtContext) { localctx = NewDropdbstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 820, PostgreSQLParserRULE_dropdbstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7271) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7272) p.Match(PostgreSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7275) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 351, p.GetParserRuleContext()) == 1 { { p.SetState(7273) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7274) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(7277) p.Name() } p.SetState(7283) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 352, p.GetParserRuleContext()) == 1 { { p.SetState(7278) p.Opt_with() } { p.SetState(7279) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7280) p.Drop_option_list() } { p.SetState(7281) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDrop_option_listContext is an interface to support dynamic dispatch. type IDrop_option_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllDrop_option() []IDrop_optionContext Drop_option(i int) IDrop_optionContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsDrop_option_listContext differentiates from other interfaces. IsDrop_option_listContext() } type Drop_option_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDrop_option_listContext() *Drop_option_listContext { var p = new(Drop_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_drop_option_list return p } func InitEmptyDrop_option_listContext(p *Drop_option_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_drop_option_list } func (*Drop_option_listContext) IsDrop_option_listContext() {} func NewDrop_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_option_listContext { var p = new(Drop_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_drop_option_list return p } func (s *Drop_option_listContext) GetParser() antlr.Parser { return s.parser } func (s *Drop_option_listContext) AllDrop_option() []IDrop_optionContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IDrop_optionContext); ok { len++ } } tst := make([]IDrop_optionContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IDrop_optionContext); ok { tst[i] = t.(IDrop_optionContext) i++ } } return tst } func (s *Drop_option_listContext) Drop_option(i int) IDrop_optionContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDrop_optionContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IDrop_optionContext) } func (s *Drop_option_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Drop_option_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Drop_option_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Drop_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Drop_option_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDrop_option_list(s) } } func (s *Drop_option_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDrop_option_list(s) } } func (s *Drop_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDrop_option_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Drop_option_list() (localctx IDrop_option_listContext) { localctx = NewDrop_option_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 822, PostgreSQLParserRULE_drop_option_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7285) p.Drop_option() } p.SetState(7290) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(7286) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7287) p.Drop_option() } p.SetState(7292) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDrop_optionContext is an interface to support dynamic dispatch. type IDrop_optionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FORCE() antlr.TerminalNode // IsDrop_optionContext differentiates from other interfaces. IsDrop_optionContext() } type Drop_optionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDrop_optionContext() *Drop_optionContext { var p = new(Drop_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_drop_option return p } func InitEmptyDrop_optionContext(p *Drop_optionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_drop_option } func (*Drop_optionContext) IsDrop_optionContext() {} func NewDrop_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_optionContext { var p = new(Drop_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_drop_option return p } func (s *Drop_optionContext) GetParser() antlr.Parser { return s.parser } func (s *Drop_optionContext) FORCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFORCE, 0) } func (s *Drop_optionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Drop_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Drop_optionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDrop_option(s) } } func (s *Drop_optionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDrop_option(s) } } func (s *Drop_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDrop_option(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Drop_option() (localctx IDrop_optionContext) { localctx = NewDrop_optionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 824, PostgreSQLParserRULE_drop_option) p.EnterOuterAlt(localctx, 1) { p.SetState(7293) p.Match(PostgreSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAltercollationstmtContext is an interface to support dynamic dispatch. type IAltercollationstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode COLLATION() antlr.TerminalNode Any_name() IAny_nameContext REFRESH() antlr.TerminalNode VERSION_P() antlr.TerminalNode // IsAltercollationstmtContext differentiates from other interfaces. IsAltercollationstmtContext() } type AltercollationstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAltercollationstmtContext() *AltercollationstmtContext { var p = new(AltercollationstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altercollationstmt return p } func InitEmptyAltercollationstmtContext(p *AltercollationstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altercollationstmt } func (*AltercollationstmtContext) IsAltercollationstmtContext() {} func NewAltercollationstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltercollationstmtContext { var p = new(AltercollationstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_altercollationstmt return p } func (s *AltercollationstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AltercollationstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AltercollationstmtContext) COLLATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATION, 0) } func (s *AltercollationstmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *AltercollationstmtContext) REFRESH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREFRESH, 0) } func (s *AltercollationstmtContext) VERSION_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVERSION_P, 0) } func (s *AltercollationstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AltercollationstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AltercollationstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAltercollationstmt(s) } } func (s *AltercollationstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAltercollationstmt(s) } } func (s *AltercollationstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAltercollationstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Altercollationstmt() (localctx IAltercollationstmtContext) { localctx = NewAltercollationstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 826, PostgreSQLParserRULE_altercollationstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7295) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7296) p.Match(PostgreSQLParserCOLLATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7297) p.Any_name() } { p.SetState(7298) p.Match(PostgreSQLParserREFRESH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7299) p.Match(PostgreSQLParserVERSION_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAltersystemstmtContext is an interface to support dynamic dispatch. type IAltersystemstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode SYSTEM_P() antlr.TerminalNode Generic_set() IGeneric_setContext SET() antlr.TerminalNode RESET() antlr.TerminalNode // IsAltersystemstmtContext differentiates from other interfaces. IsAltersystemstmtContext() } type AltersystemstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAltersystemstmtContext() *AltersystemstmtContext { var p = new(AltersystemstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altersystemstmt return p } func InitEmptyAltersystemstmtContext(p *AltersystemstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altersystemstmt } func (*AltersystemstmtContext) IsAltersystemstmtContext() {} func NewAltersystemstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltersystemstmtContext { var p = new(AltersystemstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_altersystemstmt return p } func (s *AltersystemstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AltersystemstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AltersystemstmtContext) SYSTEM_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSYSTEM_P, 0) } func (s *AltersystemstmtContext) Generic_set() IGeneric_setContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGeneric_setContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGeneric_setContext) } func (s *AltersystemstmtContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *AltersystemstmtContext) RESET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESET, 0) } func (s *AltersystemstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AltersystemstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AltersystemstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAltersystemstmt(s) } } func (s *AltersystemstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAltersystemstmt(s) } } func (s *AltersystemstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAltersystemstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Altersystemstmt() (localctx IAltersystemstmtContext) { localctx = NewAltersystemstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 828, PostgreSQLParserRULE_altersystemstmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7301) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7302) p.Match(PostgreSQLParserSYSTEM_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7303) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserRESET || _la == PostgreSQLParserSET) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(7304) p.Generic_set() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreatedomainstmtContext is an interface to support dynamic dispatch. type ICreatedomainstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode DOMAIN_P() antlr.TerminalNode Any_name() IAny_nameContext Opt_as() IOpt_asContext Typename() ITypenameContext Colquallist() IColquallistContext // IsCreatedomainstmtContext differentiates from other interfaces. IsCreatedomainstmtContext() } type CreatedomainstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreatedomainstmtContext() *CreatedomainstmtContext { var p = new(CreatedomainstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createdomainstmt return p } func InitEmptyCreatedomainstmtContext(p *CreatedomainstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createdomainstmt } func (*CreatedomainstmtContext) IsCreatedomainstmtContext() {} func NewCreatedomainstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatedomainstmtContext { var p = new(CreatedomainstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createdomainstmt return p } func (s *CreatedomainstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreatedomainstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreatedomainstmtContext) DOMAIN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOMAIN_P, 0) } func (s *CreatedomainstmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *CreatedomainstmtContext) Opt_as() IOpt_asContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_asContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_asContext) } func (s *CreatedomainstmtContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *CreatedomainstmtContext) Colquallist() IColquallistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColquallistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColquallistContext) } func (s *CreatedomainstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreatedomainstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreatedomainstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreatedomainstmt(s) } } func (s *CreatedomainstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreatedomainstmt(s) } } func (s *CreatedomainstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreatedomainstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createdomainstmt() (localctx ICreatedomainstmtContext) { localctx = NewCreatedomainstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 830, PostgreSQLParserRULE_createdomainstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7306) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7307) p.Match(PostgreSQLParserDOMAIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7308) p.Any_name() } { p.SetState(7309) p.Opt_as() } { p.SetState(7310) p.Typename() } { p.SetState(7311) p.Colquallist() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlterdomainstmtContext is an interface to support dynamic dispatch. type IAlterdomainstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode DOMAIN_P() antlr.TerminalNode Any_name() IAny_nameContext Alter_column_default() IAlter_column_defaultContext DROP() antlr.TerminalNode NOT() antlr.TerminalNode NULL_P() antlr.TerminalNode SET() antlr.TerminalNode ADD_P() antlr.TerminalNode Tableconstraint() ITableconstraintContext CONSTRAINT() antlr.TerminalNode Name() INameContext Opt_drop_behavior() IOpt_drop_behaviorContext VALIDATE() antlr.TerminalNode IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsAlterdomainstmtContext differentiates from other interfaces. IsAlterdomainstmtContext() } type AlterdomainstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlterdomainstmtContext() *AlterdomainstmtContext { var p = new(AlterdomainstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterdomainstmt return p } func InitEmptyAlterdomainstmtContext(p *AlterdomainstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alterdomainstmt } func (*AlterdomainstmtContext) IsAlterdomainstmtContext() {} func NewAlterdomainstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterdomainstmtContext { var p = new(AlterdomainstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alterdomainstmt return p } func (s *AlterdomainstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AlterdomainstmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AlterdomainstmtContext) DOMAIN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOMAIN_P, 0) } func (s *AlterdomainstmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *AlterdomainstmtContext) Alter_column_default() IAlter_column_defaultContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlter_column_defaultContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlter_column_defaultContext) } func (s *AlterdomainstmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *AlterdomainstmtContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *AlterdomainstmtContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *AlterdomainstmtContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *AlterdomainstmtContext) ADD_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserADD_P, 0) } func (s *AlterdomainstmtContext) Tableconstraint() ITableconstraintContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITableconstraintContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITableconstraintContext) } func (s *AlterdomainstmtContext) CONSTRAINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTRAINT, 0) } func (s *AlterdomainstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *AlterdomainstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_drop_behaviorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_drop_behaviorContext) } func (s *AlterdomainstmtContext) VALIDATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALIDATE, 0) } func (s *AlterdomainstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *AlterdomainstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *AlterdomainstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AlterdomainstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AlterdomainstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlterdomainstmt(s) } } func (s *AlterdomainstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlterdomainstmt(s) } } func (s *AlterdomainstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlterdomainstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alterdomainstmt() (localctx IAlterdomainstmtContext) { localctx = NewAlterdomainstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 832, PostgreSQLParserRULE_alterdomainstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7313) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7314) p.Match(PostgreSQLParserDOMAIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7315) p.Any_name() } p.SetState(7337) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 355, p.GetParserRuleContext()) { case 1: { p.SetState(7316) p.Alter_column_default() } case 2: { p.SetState(7317) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7318) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7319) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: { p.SetState(7320) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7321) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7322) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: { p.SetState(7323) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7324) p.Tableconstraint() } case 5: { p.SetState(7325) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7326) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7329) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 354, p.GetParserRuleContext()) == 1 { { p.SetState(7327) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7328) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(7331) p.Name() } { p.SetState(7332) p.Opt_drop_behavior() } case 6: { p.SetState(7334) p.Match(PostgreSQLParserVALIDATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7335) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7336) p.Name() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_asContext is an interface to support dynamic dispatch. type IOpt_asContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AS() antlr.TerminalNode // IsOpt_asContext differentiates from other interfaces. IsOpt_asContext() } type Opt_asContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_asContext() *Opt_asContext { var p = new(Opt_asContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_as return p } func InitEmptyOpt_asContext(p *Opt_asContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_as } func (*Opt_asContext) IsOpt_asContext() {} func NewOpt_asContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_asContext { var p = new(Opt_asContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_as return p } func (s *Opt_asContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_asContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Opt_asContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_asContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_asContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_as(s) } } func (s *Opt_asContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_as(s) } } func (s *Opt_asContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_as(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_as() (localctx IOpt_asContext) { localctx = NewOpt_asContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 834, PostgreSQLParserRULE_opt_as) p.SetState(7341) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAS: p.EnterOuterAlt(localctx, 1) { p.SetState(7339) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAltertsdictionarystmtContext is an interface to support dynamic dispatch. type IAltertsdictionarystmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALTER() antlr.TerminalNode TEXT_P() antlr.TerminalNode SEARCH() antlr.TerminalNode DICTIONARY() antlr.TerminalNode Any_name() IAny_nameContext Definition() IDefinitionContext // IsAltertsdictionarystmtContext differentiates from other interfaces. IsAltertsdictionarystmtContext() } type AltertsdictionarystmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAltertsdictionarystmtContext() *AltertsdictionarystmtContext { var p = new(AltertsdictionarystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altertsdictionarystmt return p } func InitEmptyAltertsdictionarystmtContext(p *AltertsdictionarystmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altertsdictionarystmt } func (*AltertsdictionarystmtContext) IsAltertsdictionarystmtContext() {} func NewAltertsdictionarystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertsdictionarystmtContext { var p = new(AltertsdictionarystmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_altertsdictionarystmt return p } func (s *AltertsdictionarystmtContext) GetParser() antlr.Parser { return s.parser } func (s *AltertsdictionarystmtContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *AltertsdictionarystmtContext) TEXT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEXT_P, 0) } func (s *AltertsdictionarystmtContext) SEARCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEARCH, 0) } func (s *AltertsdictionarystmtContext) DICTIONARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDICTIONARY, 0) } func (s *AltertsdictionarystmtContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *AltertsdictionarystmtContext) Definition() IDefinitionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDefinitionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDefinitionContext) } func (s *AltertsdictionarystmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AltertsdictionarystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AltertsdictionarystmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAltertsdictionarystmt(s) } } func (s *AltertsdictionarystmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAltertsdictionarystmt(s) } } func (s *AltertsdictionarystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAltertsdictionarystmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Altertsdictionarystmt() (localctx IAltertsdictionarystmtContext) { localctx = NewAltertsdictionarystmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 836, PostgreSQLParserRULE_altertsdictionarystmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7343) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7344) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7345) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7346) p.Match(PostgreSQLParserDICTIONARY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7347) p.Any_name() } { p.SetState(7348) p.Definition() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAltertsconfigurationstmtContext is an interface to support dynamic dispatch. type IAltertsconfigurationstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllALTER() []antlr.TerminalNode ALTER(i int) antlr.TerminalNode TEXT_P() antlr.TerminalNode SEARCH() antlr.TerminalNode CONFIGURATION() antlr.TerminalNode AllAny_name() []IAny_nameContext Any_name(i int) IAny_nameContext ADD_P() antlr.TerminalNode MAPPING() antlr.TerminalNode FOR() antlr.TerminalNode Name_list() IName_listContext Any_with() IAny_withContext Any_name_list() IAny_name_listContext REPLACE() antlr.TerminalNode DROP() antlr.TerminalNode IF_P() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsAltertsconfigurationstmtContext differentiates from other interfaces. IsAltertsconfigurationstmtContext() } type AltertsconfigurationstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAltertsconfigurationstmtContext() *AltertsconfigurationstmtContext { var p = new(AltertsconfigurationstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altertsconfigurationstmt return p } func InitEmptyAltertsconfigurationstmtContext(p *AltertsconfigurationstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_altertsconfigurationstmt } func (*AltertsconfigurationstmtContext) IsAltertsconfigurationstmtContext() {} func NewAltertsconfigurationstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertsconfigurationstmtContext { var p = new(AltertsconfigurationstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_altertsconfigurationstmt return p } func (s *AltertsconfigurationstmtContext) GetParser() antlr.Parser { return s.parser } func (s *AltertsconfigurationstmtContext) AllALTER() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserALTER) } func (s *AltertsconfigurationstmtContext) ALTER(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, i) } func (s *AltertsconfigurationstmtContext) TEXT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEXT_P, 0) } func (s *AltertsconfigurationstmtContext) SEARCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEARCH, 0) } func (s *AltertsconfigurationstmtContext) CONFIGURATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONFIGURATION, 0) } func (s *AltertsconfigurationstmtContext) AllAny_name() []IAny_nameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAny_nameContext); ok { len++ } } tst := make([]IAny_nameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAny_nameContext); ok { tst[i] = t.(IAny_nameContext) i++ } } return tst } func (s *AltertsconfigurationstmtContext) Any_name(i int) IAny_nameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *AltertsconfigurationstmtContext) ADD_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserADD_P, 0) } func (s *AltertsconfigurationstmtContext) MAPPING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMAPPING, 0) } func (s *AltertsconfigurationstmtContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *AltertsconfigurationstmtContext) Name_list() IName_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IName_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IName_listContext) } func (s *AltertsconfigurationstmtContext) Any_with() IAny_withContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_withContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_withContext) } func (s *AltertsconfigurationstmtContext) Any_name_list() IAny_name_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_name_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_name_listContext) } func (s *AltertsconfigurationstmtContext) REPLACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREPLACE, 0) } func (s *AltertsconfigurationstmtContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *AltertsconfigurationstmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *AltertsconfigurationstmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *AltertsconfigurationstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AltertsconfigurationstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AltertsconfigurationstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAltertsconfigurationstmt(s) } } func (s *AltertsconfigurationstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAltertsconfigurationstmt(s) } } func (s *AltertsconfigurationstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAltertsconfigurationstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Altertsconfigurationstmt() (localctx IAltertsconfigurationstmtContext) { localctx = NewAltertsconfigurationstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 838, PostgreSQLParserRULE_altertsconfigurationstmt) p.SetState(7422) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 357, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7350) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7351) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7352) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7353) p.Match(PostgreSQLParserCONFIGURATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7354) p.Any_name() } { p.SetState(7355) p.Match(PostgreSQLParserADD_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7356) p.Match(PostgreSQLParserMAPPING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7357) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7358) p.Name_list() } { p.SetState(7359) p.Any_with() } { p.SetState(7360) p.Any_name_list() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7362) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7363) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7364) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7365) p.Match(PostgreSQLParserCONFIGURATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7366) p.Any_name() } { p.SetState(7367) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7368) p.Match(PostgreSQLParserMAPPING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7369) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7370) p.Name_list() } { p.SetState(7371) p.Any_with() } { p.SetState(7372) p.Any_name_list() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(7374) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7375) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7376) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7377) p.Match(PostgreSQLParserCONFIGURATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7378) p.Any_name() } { p.SetState(7379) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7380) p.Match(PostgreSQLParserMAPPING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7381) p.Match(PostgreSQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7382) p.Any_name() } { p.SetState(7383) p.Any_with() } { p.SetState(7384) p.Any_name() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(7386) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7387) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7388) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7389) p.Match(PostgreSQLParserCONFIGURATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7390) p.Any_name() } { p.SetState(7391) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7392) p.Match(PostgreSQLParserMAPPING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7393) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7394) p.Name_list() } { p.SetState(7395) p.Match(PostgreSQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7396) p.Any_name() } { p.SetState(7397) p.Any_with() } { p.SetState(7398) p.Any_name() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(7400) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7401) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7402) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7403) p.Match(PostgreSQLParserCONFIGURATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7404) p.Any_name() } { p.SetState(7405) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7406) p.Match(PostgreSQLParserMAPPING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7407) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7408) p.Name_list() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(7410) p.Match(PostgreSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7411) p.Match(PostgreSQLParserTEXT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7412) p.Match(PostgreSQLParserSEARCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7413) p.Match(PostgreSQLParserCONFIGURATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7414) p.Any_name() } { p.SetState(7415) p.Match(PostgreSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7416) p.Match(PostgreSQLParserMAPPING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7417) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7418) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7419) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7420) p.Name_list() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAny_withContext is an interface to support dynamic dispatch. type IAny_withContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITH() antlr.TerminalNode // IsAny_withContext differentiates from other interfaces. IsAny_withContext() } type Any_withContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAny_withContext() *Any_withContext { var p = new(Any_withContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_any_with return p } func InitEmptyAny_withContext(p *Any_withContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_any_with } func (*Any_withContext) IsAny_withContext() {} func NewAny_withContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_withContext { var p = new(Any_withContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_any_with return p } func (s *Any_withContext) GetParser() antlr.Parser { return s.parser } func (s *Any_withContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *Any_withContext) GetRuleContext() antlr.RuleContext { return s } func (s *Any_withContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Any_withContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAny_with(s) } } func (s *Any_withContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAny_with(s) } } func (s *Any_withContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAny_with(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Any_with() (localctx IAny_withContext) { localctx = NewAny_withContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 840, PostgreSQLParserRULE_any_with) p.EnterOuterAlt(localctx, 1) { p.SetState(7424) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICreateconversionstmtContext is an interface to support dynamic dispatch. type ICreateconversionstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CREATE() antlr.TerminalNode Opt_default() IOpt_defaultContext CONVERSION_P() antlr.TerminalNode AllAny_name() []IAny_nameContext Any_name(i int) IAny_nameContext FOR() antlr.TerminalNode AllSconst() []ISconstContext Sconst(i int) ISconstContext TO() antlr.TerminalNode FROM() antlr.TerminalNode // IsCreateconversionstmtContext differentiates from other interfaces. IsCreateconversionstmtContext() } type CreateconversionstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCreateconversionstmtContext() *CreateconversionstmtContext { var p = new(CreateconversionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createconversionstmt return p } func InitEmptyCreateconversionstmtContext(p *CreateconversionstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_createconversionstmt } func (*CreateconversionstmtContext) IsCreateconversionstmtContext() {} func NewCreateconversionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateconversionstmtContext { var p = new(CreateconversionstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_createconversionstmt return p } func (s *CreateconversionstmtContext) GetParser() antlr.Parser { return s.parser } func (s *CreateconversionstmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *CreateconversionstmtContext) Opt_default() IOpt_defaultContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_defaultContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_defaultContext) } func (s *CreateconversionstmtContext) CONVERSION_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONVERSION_P, 0) } func (s *CreateconversionstmtContext) AllAny_name() []IAny_nameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAny_nameContext); ok { len++ } } tst := make([]IAny_nameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAny_nameContext); ok { tst[i] = t.(IAny_nameContext) i++ } } return tst } func (s *CreateconversionstmtContext) Any_name(i int) IAny_nameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *CreateconversionstmtContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *CreateconversionstmtContext) AllSconst() []ISconstContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISconstContext); ok { len++ } } tst := make([]ISconstContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISconstContext); ok { tst[i] = t.(ISconstContext) i++ } } return tst } func (s *CreateconversionstmtContext) Sconst(i int) ISconstContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISconstContext) } func (s *CreateconversionstmtContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *CreateconversionstmtContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *CreateconversionstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CreateconversionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CreateconversionstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCreateconversionstmt(s) } } func (s *CreateconversionstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCreateconversionstmt(s) } } func (s *CreateconversionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCreateconversionstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Createconversionstmt() (localctx ICreateconversionstmtContext) { localctx = NewCreateconversionstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 842, PostgreSQLParserRULE_createconversionstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7426) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7427) p.Opt_default() } { p.SetState(7428) p.Match(PostgreSQLParserCONVERSION_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7429) p.Any_name() } { p.SetState(7430) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7431) p.Sconst() } { p.SetState(7432) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7433) p.Sconst() } { p.SetState(7434) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7435) p.Any_name() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IClusterstmtContext is an interface to support dynamic dispatch. type IClusterstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CLUSTER() antlr.TerminalNode Opt_verbose() IOpt_verboseContext Qualified_name() IQualified_nameContext Cluster_index_specification() ICluster_index_specificationContext Name() INameContext ON() antlr.TerminalNode // IsClusterstmtContext differentiates from other interfaces. IsClusterstmtContext() } type ClusterstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyClusterstmtContext() *ClusterstmtContext { var p = new(ClusterstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_clusterstmt return p } func InitEmptyClusterstmtContext(p *ClusterstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_clusterstmt } func (*ClusterstmtContext) IsClusterstmtContext() {} func NewClusterstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClusterstmtContext { var p = new(ClusterstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_clusterstmt return p } func (s *ClusterstmtContext) GetParser() antlr.Parser { return s.parser } func (s *ClusterstmtContext) CLUSTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLUSTER, 0) } func (s *ClusterstmtContext) Opt_verbose() IOpt_verboseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_verboseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_verboseContext) } func (s *ClusterstmtContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *ClusterstmtContext) Cluster_index_specification() ICluster_index_specificationContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICluster_index_specificationContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICluster_index_specificationContext) } func (s *ClusterstmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *ClusterstmtContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *ClusterstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *ClusterstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ClusterstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterClusterstmt(s) } } func (s *ClusterstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitClusterstmt(s) } } func (s *ClusterstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitClusterstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Clusterstmt() (localctx IClusterstmtContext) { localctx = NewClusterstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 844, PostgreSQLParserRULE_clusterstmt) p.SetState(7450) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 358, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7437) p.Match(PostgreSQLParserCLUSTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7438) p.Opt_verbose() } { p.SetState(7439) p.Qualified_name() } { p.SetState(7440) p.Cluster_index_specification() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7442) p.Match(PostgreSQLParserCLUSTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7443) p.Opt_verbose() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(7444) p.Match(PostgreSQLParserCLUSTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7445) p.Opt_verbose() } { p.SetState(7446) p.Name() } { p.SetState(7447) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7448) p.Qualified_name() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICluster_index_specificationContext is an interface to support dynamic dispatch. type ICluster_index_specificationContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USING() antlr.TerminalNode Name() INameContext // IsCluster_index_specificationContext differentiates from other interfaces. IsCluster_index_specificationContext() } type Cluster_index_specificationContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCluster_index_specificationContext() *Cluster_index_specificationContext { var p = new(Cluster_index_specificationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_cluster_index_specification return p } func InitEmptyCluster_index_specificationContext(p *Cluster_index_specificationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_cluster_index_specification } func (*Cluster_index_specificationContext) IsCluster_index_specificationContext() {} func NewCluster_index_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cluster_index_specificationContext { var p = new(Cluster_index_specificationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_cluster_index_specification return p } func (s *Cluster_index_specificationContext) GetParser() antlr.Parser { return s.parser } func (s *Cluster_index_specificationContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *Cluster_index_specificationContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *Cluster_index_specificationContext) GetRuleContext() antlr.RuleContext { return s } func (s *Cluster_index_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Cluster_index_specificationContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCluster_index_specification(s) } } func (s *Cluster_index_specificationContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCluster_index_specification(s) } } func (s *Cluster_index_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCluster_index_specification(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Cluster_index_specification() (localctx ICluster_index_specificationContext) { localctx = NewCluster_index_specificationContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 846, PostgreSQLParserRULE_cluster_index_specification) p.SetState(7455) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 1) { p.SetState(7452) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7453) p.Name() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IVacuumstmtContext is an interface to support dynamic dispatch. type IVacuumstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures VACUUM() antlr.TerminalNode Opt_full() IOpt_fullContext Opt_freeze() IOpt_freezeContext Opt_verbose() IOpt_verboseContext Opt_analyze() IOpt_analyzeContext Opt_vacuum_relation_list() IOpt_vacuum_relation_listContext OPEN_PAREN() antlr.TerminalNode Vac_analyze_option_list() IVac_analyze_option_listContext CLOSE_PAREN() antlr.TerminalNode // IsVacuumstmtContext differentiates from other interfaces. IsVacuumstmtContext() } type VacuumstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyVacuumstmtContext() *VacuumstmtContext { var p = new(VacuumstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_vacuumstmt return p } func InitEmptyVacuumstmtContext(p *VacuumstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_vacuumstmt } func (*VacuumstmtContext) IsVacuumstmtContext() {} func NewVacuumstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VacuumstmtContext { var p = new(VacuumstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_vacuumstmt return p } func (s *VacuumstmtContext) GetParser() antlr.Parser { return s.parser } func (s *VacuumstmtContext) VACUUM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVACUUM, 0) } func (s *VacuumstmtContext) Opt_full() IOpt_fullContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_fullContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_fullContext) } func (s *VacuumstmtContext) Opt_freeze() IOpt_freezeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_freezeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_freezeContext) } func (s *VacuumstmtContext) Opt_verbose() IOpt_verboseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_verboseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_verboseContext) } func (s *VacuumstmtContext) Opt_analyze() IOpt_analyzeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_analyzeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_analyzeContext) } func (s *VacuumstmtContext) Opt_vacuum_relation_list() IOpt_vacuum_relation_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_vacuum_relation_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_vacuum_relation_listContext) } func (s *VacuumstmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *VacuumstmtContext) Vac_analyze_option_list() IVac_analyze_option_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVac_analyze_option_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVac_analyze_option_listContext) } func (s *VacuumstmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *VacuumstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *VacuumstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *VacuumstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterVacuumstmt(s) } } func (s *VacuumstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitVacuumstmt(s) } } func (s *VacuumstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitVacuumstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Vacuumstmt() (localctx IVacuumstmtContext) { localctx = NewVacuumstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 848, PostgreSQLParserRULE_vacuumstmt) p.SetState(7470) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 360, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7457) p.Match(PostgreSQLParserVACUUM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7458) p.Opt_full() } { p.SetState(7459) p.Opt_freeze() } { p.SetState(7460) p.Opt_verbose() } { p.SetState(7461) p.Opt_analyze() } { p.SetState(7462) p.Opt_vacuum_relation_list() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7464) p.Match(PostgreSQLParserVACUUM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7465) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7466) p.Vac_analyze_option_list() } { p.SetState(7467) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7468) p.Opt_vacuum_relation_list() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAnalyzestmtContext is an interface to support dynamic dispatch. type IAnalyzestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Analyze_keyword() IAnalyze_keywordContext Opt_verbose() IOpt_verboseContext Opt_vacuum_relation_list() IOpt_vacuum_relation_listContext OPEN_PAREN() antlr.TerminalNode Vac_analyze_option_list() IVac_analyze_option_listContext CLOSE_PAREN() antlr.TerminalNode // IsAnalyzestmtContext differentiates from other interfaces. IsAnalyzestmtContext() } type AnalyzestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAnalyzestmtContext() *AnalyzestmtContext { var p = new(AnalyzestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_analyzestmt return p } func InitEmptyAnalyzestmtContext(p *AnalyzestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_analyzestmt } func (*AnalyzestmtContext) IsAnalyzestmtContext() {} func NewAnalyzestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnalyzestmtContext { var p = new(AnalyzestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_analyzestmt return p } func (s *AnalyzestmtContext) GetParser() antlr.Parser { return s.parser } func (s *AnalyzestmtContext) Analyze_keyword() IAnalyze_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAnalyze_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAnalyze_keywordContext) } func (s *AnalyzestmtContext) Opt_verbose() IOpt_verboseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_verboseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_verboseContext) } func (s *AnalyzestmtContext) Opt_vacuum_relation_list() IOpt_vacuum_relation_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_vacuum_relation_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_vacuum_relation_listContext) } func (s *AnalyzestmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *AnalyzestmtContext) Vac_analyze_option_list() IVac_analyze_option_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVac_analyze_option_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVac_analyze_option_listContext) } func (s *AnalyzestmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *AnalyzestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *AnalyzestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AnalyzestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAnalyzestmt(s) } } func (s *AnalyzestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAnalyzestmt(s) } } func (s *AnalyzestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAnalyzestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Analyzestmt() (localctx IAnalyzestmtContext) { localctx = NewAnalyzestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 850, PostgreSQLParserRULE_analyzestmt) p.SetState(7482) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 361, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7472) p.Analyze_keyword() } { p.SetState(7473) p.Opt_verbose() } { p.SetState(7474) p.Opt_vacuum_relation_list() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7476) p.Analyze_keyword() } { p.SetState(7477) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7478) p.Vac_analyze_option_list() } { p.SetState(7479) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7480) p.Opt_vacuum_relation_list() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IVac_analyze_option_listContext is an interface to support dynamic dispatch. type IVac_analyze_option_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllVac_analyze_option_elem() []IVac_analyze_option_elemContext Vac_analyze_option_elem(i int) IVac_analyze_option_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsVac_analyze_option_listContext differentiates from other interfaces. IsVac_analyze_option_listContext() } type Vac_analyze_option_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyVac_analyze_option_listContext() *Vac_analyze_option_listContext { var p = new(Vac_analyze_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_list return p } func InitEmptyVac_analyze_option_listContext(p *Vac_analyze_option_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_list } func (*Vac_analyze_option_listContext) IsVac_analyze_option_listContext() {} func NewVac_analyze_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vac_analyze_option_listContext { var p = new(Vac_analyze_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_list return p } func (s *Vac_analyze_option_listContext) GetParser() antlr.Parser { return s.parser } func (s *Vac_analyze_option_listContext) AllVac_analyze_option_elem() []IVac_analyze_option_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IVac_analyze_option_elemContext); ok { len++ } } tst := make([]IVac_analyze_option_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IVac_analyze_option_elemContext); ok { tst[i] = t.(IVac_analyze_option_elemContext) i++ } } return tst } func (s *Vac_analyze_option_listContext) Vac_analyze_option_elem(i int) IVac_analyze_option_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVac_analyze_option_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IVac_analyze_option_elemContext) } func (s *Vac_analyze_option_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Vac_analyze_option_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Vac_analyze_option_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Vac_analyze_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Vac_analyze_option_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterVac_analyze_option_list(s) } } func (s *Vac_analyze_option_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitVac_analyze_option_list(s) } } func (s *Vac_analyze_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitVac_analyze_option_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Vac_analyze_option_list() (localctx IVac_analyze_option_listContext) { localctx = NewVac_analyze_option_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 852, PostgreSQLParserRULE_vac_analyze_option_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7484) p.Vac_analyze_option_elem() } p.SetState(7489) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(7485) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7486) p.Vac_analyze_option_elem() } p.SetState(7491) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAnalyze_keywordContext is an interface to support dynamic dispatch. type IAnalyze_keywordContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ANALYZE() antlr.TerminalNode ANALYSE() antlr.TerminalNode // IsAnalyze_keywordContext differentiates from other interfaces. IsAnalyze_keywordContext() } type Analyze_keywordContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAnalyze_keywordContext() *Analyze_keywordContext { var p = new(Analyze_keywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_analyze_keyword return p } func InitEmptyAnalyze_keywordContext(p *Analyze_keywordContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_analyze_keyword } func (*Analyze_keywordContext) IsAnalyze_keywordContext() {} func NewAnalyze_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Analyze_keywordContext { var p = new(Analyze_keywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_analyze_keyword return p } func (s *Analyze_keywordContext) GetParser() antlr.Parser { return s.parser } func (s *Analyze_keywordContext) ANALYZE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserANALYZE, 0) } func (s *Analyze_keywordContext) ANALYSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserANALYSE, 0) } func (s *Analyze_keywordContext) GetRuleContext() antlr.RuleContext { return s } func (s *Analyze_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Analyze_keywordContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAnalyze_keyword(s) } } func (s *Analyze_keywordContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAnalyze_keyword(s) } } func (s *Analyze_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAnalyze_keyword(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Analyze_keyword() (localctx IAnalyze_keywordContext) { localctx = NewAnalyze_keywordContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 854, PostgreSQLParserRULE_analyze_keyword) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7492) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserANALYSE || _la == PostgreSQLParserANALYZE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IVac_analyze_option_elemContext is an interface to support dynamic dispatch. type IVac_analyze_option_elemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Vac_analyze_option_name() IVac_analyze_option_nameContext Vac_analyze_option_arg() IVac_analyze_option_argContext // IsVac_analyze_option_elemContext differentiates from other interfaces. IsVac_analyze_option_elemContext() } type Vac_analyze_option_elemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyVac_analyze_option_elemContext() *Vac_analyze_option_elemContext { var p = new(Vac_analyze_option_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_elem return p } func InitEmptyVac_analyze_option_elemContext(p *Vac_analyze_option_elemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_elem } func (*Vac_analyze_option_elemContext) IsVac_analyze_option_elemContext() {} func NewVac_analyze_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vac_analyze_option_elemContext { var p = new(Vac_analyze_option_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_elem return p } func (s *Vac_analyze_option_elemContext) GetParser() antlr.Parser { return s.parser } func (s *Vac_analyze_option_elemContext) Vac_analyze_option_name() IVac_analyze_option_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVac_analyze_option_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVac_analyze_option_nameContext) } func (s *Vac_analyze_option_elemContext) Vac_analyze_option_arg() IVac_analyze_option_argContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVac_analyze_option_argContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVac_analyze_option_argContext) } func (s *Vac_analyze_option_elemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Vac_analyze_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Vac_analyze_option_elemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterVac_analyze_option_elem(s) } } func (s *Vac_analyze_option_elemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitVac_analyze_option_elem(s) } } func (s *Vac_analyze_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitVac_analyze_option_elem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Vac_analyze_option_elem() (localctx IVac_analyze_option_elemContext) { localctx = NewVac_analyze_option_elemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 856, PostgreSQLParserRULE_vac_analyze_option_elem) p.EnterOuterAlt(localctx, 1) { p.SetState(7494) p.Vac_analyze_option_name() } { p.SetState(7495) p.Vac_analyze_option_arg() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IVac_analyze_option_nameContext is an interface to support dynamic dispatch. type IVac_analyze_option_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Nonreservedword() INonreservedwordContext Analyze_keyword() IAnalyze_keywordContext // IsVac_analyze_option_nameContext differentiates from other interfaces. IsVac_analyze_option_nameContext() } type Vac_analyze_option_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyVac_analyze_option_nameContext() *Vac_analyze_option_nameContext { var p = new(Vac_analyze_option_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_name return p } func InitEmptyVac_analyze_option_nameContext(p *Vac_analyze_option_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_name } func (*Vac_analyze_option_nameContext) IsVac_analyze_option_nameContext() {} func NewVac_analyze_option_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vac_analyze_option_nameContext { var p = new(Vac_analyze_option_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_name return p } func (s *Vac_analyze_option_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Vac_analyze_option_nameContext) Nonreservedword() INonreservedwordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INonreservedwordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INonreservedwordContext) } func (s *Vac_analyze_option_nameContext) Analyze_keyword() IAnalyze_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAnalyze_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAnalyze_keywordContext) } func (s *Vac_analyze_option_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Vac_analyze_option_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Vac_analyze_option_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterVac_analyze_option_name(s) } } func (s *Vac_analyze_option_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitVac_analyze_option_name(s) } } func (s *Vac_analyze_option_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitVac_analyze_option_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Vac_analyze_option_name() (localctx IVac_analyze_option_nameContext) { localctx = NewVac_analyze_option_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 858, PostgreSQLParserRULE_vac_analyze_option_name) p.SetState(7499) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(7497) p.Nonreservedword() } case PostgreSQLParserANALYSE, PostgreSQLParserANALYZE: p.EnterOuterAlt(localctx, 2) { p.SetState(7498) p.Analyze_keyword() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IVac_analyze_option_argContext is an interface to support dynamic dispatch. type IVac_analyze_option_argContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_boolean_or_string() IOpt_boolean_or_stringContext Numericonly() INumericonlyContext // IsVac_analyze_option_argContext differentiates from other interfaces. IsVac_analyze_option_argContext() } type Vac_analyze_option_argContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyVac_analyze_option_argContext() *Vac_analyze_option_argContext { var p = new(Vac_analyze_option_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_arg return p } func InitEmptyVac_analyze_option_argContext(p *Vac_analyze_option_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_arg } func (*Vac_analyze_option_argContext) IsVac_analyze_option_argContext() {} func NewVac_analyze_option_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vac_analyze_option_argContext { var p = new(Vac_analyze_option_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_vac_analyze_option_arg return p } func (s *Vac_analyze_option_argContext) GetParser() antlr.Parser { return s.parser } func (s *Vac_analyze_option_argContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_boolean_or_stringContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_boolean_or_stringContext) } func (s *Vac_analyze_option_argContext) Numericonly() INumericonlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericonlyContext) } func (s *Vac_analyze_option_argContext) GetRuleContext() antlr.RuleContext { return s } func (s *Vac_analyze_option_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Vac_analyze_option_argContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterVac_analyze_option_arg(s) } } func (s *Vac_analyze_option_argContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitVac_analyze_option_arg(s) } } func (s *Vac_analyze_option_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitVac_analyze_option_arg(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Vac_analyze_option_arg() (localctx IVac_analyze_option_argContext) { localctx = NewVac_analyze_option_argContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 860, PostgreSQLParserRULE_vac_analyze_option_arg) p.SetState(7504) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserON, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(7501) p.Opt_boolean_or_string() } case PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserIntegral, PostgreSQLParserNumeric: p.EnterOuterAlt(localctx, 2) { p.SetState(7502) p.Numericonly() } case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA: p.EnterOuterAlt(localctx, 3) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_analyzeContext is an interface to support dynamic dispatch. type IOpt_analyzeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Analyze_keyword() IAnalyze_keywordContext // IsOpt_analyzeContext differentiates from other interfaces. IsOpt_analyzeContext() } type Opt_analyzeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_analyzeContext() *Opt_analyzeContext { var p = new(Opt_analyzeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_analyze return p } func InitEmptyOpt_analyzeContext(p *Opt_analyzeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_analyze } func (*Opt_analyzeContext) IsOpt_analyzeContext() {} func NewOpt_analyzeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_analyzeContext { var p = new(Opt_analyzeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_analyze return p } func (s *Opt_analyzeContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_analyzeContext) Analyze_keyword() IAnalyze_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAnalyze_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAnalyze_keywordContext) } func (s *Opt_analyzeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_analyzeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_analyzeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_analyze(s) } } func (s *Opt_analyzeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_analyze(s) } } func (s *Opt_analyzeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_analyze(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_analyze() (localctx IOpt_analyzeContext) { localctx = NewOpt_analyzeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 862, PostgreSQLParserRULE_opt_analyze) p.SetState(7508) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 365, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7506) p.Analyze_keyword() } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_verboseContext is an interface to support dynamic dispatch. type IOpt_verboseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures VERBOSE() antlr.TerminalNode // IsOpt_verboseContext differentiates from other interfaces. IsOpt_verboseContext() } type Opt_verboseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_verboseContext() *Opt_verboseContext { var p = new(Opt_verboseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_verbose return p } func InitEmptyOpt_verboseContext(p *Opt_verboseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_verbose } func (*Opt_verboseContext) IsOpt_verboseContext() {} func NewOpt_verboseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_verboseContext { var p = new(Opt_verboseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_verbose return p } func (s *Opt_verboseContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_verboseContext) VERBOSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVERBOSE, 0) } func (s *Opt_verboseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_verboseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_verboseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_verbose(s) } } func (s *Opt_verboseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_verbose(s) } } func (s *Opt_verboseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_verbose(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_verbose() (localctx IOpt_verboseContext) { localctx = NewOpt_verboseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 864, PostgreSQLParserRULE_opt_verbose) p.SetState(7512) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserVERBOSE: p.EnterOuterAlt(localctx, 1) { p.SetState(7510) p.Match(PostgreSQLParserVERBOSE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMERGE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_fullContext is an interface to support dynamic dispatch. type IOpt_fullContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FULL() antlr.TerminalNode // IsOpt_fullContext differentiates from other interfaces. IsOpt_fullContext() } type Opt_fullContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_fullContext() *Opt_fullContext { var p = new(Opt_fullContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_full return p } func InitEmptyOpt_fullContext(p *Opt_fullContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_full } func (*Opt_fullContext) IsOpt_fullContext() {} func NewOpt_fullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_fullContext { var p = new(Opt_fullContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_full return p } func (s *Opt_fullContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_fullContext) FULL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFULL, 0) } func (s *Opt_fullContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_fullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_fullContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_full(s) } } func (s *Opt_fullContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_full(s) } } func (s *Opt_fullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_full(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_full() (localctx IOpt_fullContext) { localctx = NewOpt_fullContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 866, PostgreSQLParserRULE_opt_full) p.SetState(7516) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFULL: p.EnterOuterAlt(localctx, 1) { p.SetState(7514) p.Match(PostgreSQLParserFULL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserFREEZE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMERGE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_freezeContext is an interface to support dynamic dispatch. type IOpt_freezeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FREEZE() antlr.TerminalNode // IsOpt_freezeContext differentiates from other interfaces. IsOpt_freezeContext() } type Opt_freezeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_freezeContext() *Opt_freezeContext { var p = new(Opt_freezeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_freeze return p } func InitEmptyOpt_freezeContext(p *Opt_freezeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_freeze } func (*Opt_freezeContext) IsOpt_freezeContext() {} func NewOpt_freezeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_freezeContext { var p = new(Opt_freezeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_freeze return p } func (s *Opt_freezeContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_freezeContext) FREEZE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFREEZE, 0) } func (s *Opt_freezeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_freezeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_freezeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_freeze(s) } } func (s *Opt_freezeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_freeze(s) } } func (s *Opt_freezeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_freeze(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_freeze() (localctx IOpt_freezeContext) { localctx = NewOpt_freezeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 868, PostgreSQLParserRULE_opt_freeze) p.SetState(7520) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFREEZE: p.EnterOuterAlt(localctx, 1) { p.SetState(7518) p.Match(PostgreSQLParserFREEZE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMERGE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_name_listContext is an interface to support dynamic dispatch. type IOpt_name_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Name_list() IName_listContext CLOSE_PAREN() antlr.TerminalNode // IsOpt_name_listContext differentiates from other interfaces. IsOpt_name_listContext() } type Opt_name_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_name_listContext() *Opt_name_listContext { var p = new(Opt_name_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_name_list return p } func InitEmptyOpt_name_listContext(p *Opt_name_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_name_list } func (*Opt_name_listContext) IsOpt_name_listContext() {} func NewOpt_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_name_listContext { var p = new(Opt_name_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_name_list return p } func (s *Opt_name_listContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_name_listContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Opt_name_listContext) Name_list() IName_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IName_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IName_listContext) } func (s *Opt_name_listContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Opt_name_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_name_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_name_list(s) } } func (s *Opt_name_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_name_list(s) } } func (s *Opt_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_name_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_name_list() (localctx IOpt_name_listContext) { localctx = NewOpt_name_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 870, PostgreSQLParserRULE_opt_name_list) p.SetState(7527) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 369, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7522) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7523) p.Name_list() } { p.SetState(7524) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IVacuum_relationContext is an interface to support dynamic dispatch. type IVacuum_relationContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Qualified_name() IQualified_nameContext Opt_name_list() IOpt_name_listContext // IsVacuum_relationContext differentiates from other interfaces. IsVacuum_relationContext() } type Vacuum_relationContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyVacuum_relationContext() *Vacuum_relationContext { var p = new(Vacuum_relationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_vacuum_relation return p } func InitEmptyVacuum_relationContext(p *Vacuum_relationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_vacuum_relation } func (*Vacuum_relationContext) IsVacuum_relationContext() {} func NewVacuum_relationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vacuum_relationContext { var p = new(Vacuum_relationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_vacuum_relation return p } func (s *Vacuum_relationContext) GetParser() antlr.Parser { return s.parser } func (s *Vacuum_relationContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *Vacuum_relationContext) Opt_name_list() IOpt_name_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_name_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_name_listContext) } func (s *Vacuum_relationContext) GetRuleContext() antlr.RuleContext { return s } func (s *Vacuum_relationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Vacuum_relationContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterVacuum_relation(s) } } func (s *Vacuum_relationContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitVacuum_relation(s) } } func (s *Vacuum_relationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitVacuum_relation(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Vacuum_relation() (localctx IVacuum_relationContext) { localctx = NewVacuum_relationContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 872, PostgreSQLParserRULE_vacuum_relation) p.EnterOuterAlt(localctx, 1) { p.SetState(7529) p.Qualified_name() } { p.SetState(7530) p.Opt_name_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IVacuum_relation_listContext is an interface to support dynamic dispatch. type IVacuum_relation_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllVacuum_relation() []IVacuum_relationContext Vacuum_relation(i int) IVacuum_relationContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsVacuum_relation_listContext differentiates from other interfaces. IsVacuum_relation_listContext() } type Vacuum_relation_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyVacuum_relation_listContext() *Vacuum_relation_listContext { var p = new(Vacuum_relation_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_vacuum_relation_list return p } func InitEmptyVacuum_relation_listContext(p *Vacuum_relation_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_vacuum_relation_list } func (*Vacuum_relation_listContext) IsVacuum_relation_listContext() {} func NewVacuum_relation_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vacuum_relation_listContext { var p = new(Vacuum_relation_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_vacuum_relation_list return p } func (s *Vacuum_relation_listContext) GetParser() antlr.Parser { return s.parser } func (s *Vacuum_relation_listContext) AllVacuum_relation() []IVacuum_relationContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IVacuum_relationContext); ok { len++ } } tst := make([]IVacuum_relationContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IVacuum_relationContext); ok { tst[i] = t.(IVacuum_relationContext) i++ } } return tst } func (s *Vacuum_relation_listContext) Vacuum_relation(i int) IVacuum_relationContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVacuum_relationContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IVacuum_relationContext) } func (s *Vacuum_relation_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Vacuum_relation_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Vacuum_relation_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Vacuum_relation_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Vacuum_relation_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterVacuum_relation_list(s) } } func (s *Vacuum_relation_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitVacuum_relation_list(s) } } func (s *Vacuum_relation_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitVacuum_relation_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Vacuum_relation_list() (localctx IVacuum_relation_listContext) { localctx = NewVacuum_relation_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 874, PostgreSQLParserRULE_vacuum_relation_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7532) p.Vacuum_relation() } p.SetState(7537) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(7533) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7534) p.Vacuum_relation() } p.SetState(7539) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_vacuum_relation_listContext is an interface to support dynamic dispatch. type IOpt_vacuum_relation_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Vacuum_relation_list() IVacuum_relation_listContext // IsOpt_vacuum_relation_listContext differentiates from other interfaces. IsOpt_vacuum_relation_listContext() } type Opt_vacuum_relation_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_vacuum_relation_listContext() *Opt_vacuum_relation_listContext { var p = new(Opt_vacuum_relation_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_vacuum_relation_list return p } func InitEmptyOpt_vacuum_relation_listContext(p *Opt_vacuum_relation_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_vacuum_relation_list } func (*Opt_vacuum_relation_listContext) IsOpt_vacuum_relation_listContext() {} func NewOpt_vacuum_relation_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_vacuum_relation_listContext { var p = new(Opt_vacuum_relation_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_vacuum_relation_list return p } func (s *Opt_vacuum_relation_listContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_vacuum_relation_listContext) Vacuum_relation_list() IVacuum_relation_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IVacuum_relation_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IVacuum_relation_listContext) } func (s *Opt_vacuum_relation_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_vacuum_relation_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_vacuum_relation_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_vacuum_relation_list(s) } } func (s *Opt_vacuum_relation_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_vacuum_relation_list(s) } } func (s *Opt_vacuum_relation_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_vacuum_relation_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_vacuum_relation_list() (localctx IOpt_vacuum_relation_listContext) { localctx = NewOpt_vacuum_relation_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 876, PostgreSQLParserRULE_opt_vacuum_relation_list) p.SetState(7542) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 371, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7540) p.Vacuum_relation_list() } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExplainstmtContext is an interface to support dynamic dispatch. type IExplainstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures EXPLAIN() antlr.TerminalNode Explainablestmt() IExplainablestmtContext Analyze_keyword() IAnalyze_keywordContext Opt_verbose() IOpt_verboseContext VERBOSE() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Explain_option_list() IExplain_option_listContext CLOSE_PAREN() antlr.TerminalNode // IsExplainstmtContext differentiates from other interfaces. IsExplainstmtContext() } type ExplainstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExplainstmtContext() *ExplainstmtContext { var p = new(ExplainstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_explainstmt return p } func InitEmptyExplainstmtContext(p *ExplainstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_explainstmt } func (*ExplainstmtContext) IsExplainstmtContext() {} func NewExplainstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExplainstmtContext { var p = new(ExplainstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_explainstmt return p } func (s *ExplainstmtContext) GetParser() antlr.Parser { return s.parser } func (s *ExplainstmtContext) EXPLAIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXPLAIN, 0) } func (s *ExplainstmtContext) Explainablestmt() IExplainablestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExplainablestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExplainablestmtContext) } func (s *ExplainstmtContext) Analyze_keyword() IAnalyze_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAnalyze_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAnalyze_keywordContext) } func (s *ExplainstmtContext) Opt_verbose() IOpt_verboseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_verboseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_verboseContext) } func (s *ExplainstmtContext) VERBOSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVERBOSE, 0) } func (s *ExplainstmtContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *ExplainstmtContext) Explain_option_list() IExplain_option_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExplain_option_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExplain_option_listContext) } func (s *ExplainstmtContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *ExplainstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *ExplainstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ExplainstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExplainstmt(s) } } func (s *ExplainstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExplainstmt(s) } } func (s *ExplainstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExplainstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Explainstmt() (localctx IExplainstmtContext) { localctx = NewExplainstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 878, PostgreSQLParserRULE_explainstmt) p.SetState(7560) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 372, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7544) p.Match(PostgreSQLParserEXPLAIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7545) p.Explainablestmt() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7546) p.Match(PostgreSQLParserEXPLAIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7547) p.Analyze_keyword() } { p.SetState(7548) p.Opt_verbose() } { p.SetState(7549) p.Explainablestmt() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(7551) p.Match(PostgreSQLParserEXPLAIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7552) p.Match(PostgreSQLParserVERBOSE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7553) p.Explainablestmt() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(7554) p.Match(PostgreSQLParserEXPLAIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7555) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7556) p.Explain_option_list() } { p.SetState(7557) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7558) p.Explainablestmt() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExplainablestmtContext is an interface to support dynamic dispatch. type IExplainablestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Selectstmt() ISelectstmtContext Insertstmt() IInsertstmtContext Updatestmt() IUpdatestmtContext Deletestmt() IDeletestmtContext Declarecursorstmt() IDeclarecursorstmtContext Createasstmt() ICreateasstmtContext Creatematviewstmt() ICreatematviewstmtContext Refreshmatviewstmt() IRefreshmatviewstmtContext Executestmt() IExecutestmtContext // IsExplainablestmtContext differentiates from other interfaces. IsExplainablestmtContext() } type ExplainablestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExplainablestmtContext() *ExplainablestmtContext { var p = new(ExplainablestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_explainablestmt return p } func InitEmptyExplainablestmtContext(p *ExplainablestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_explainablestmt } func (*ExplainablestmtContext) IsExplainablestmtContext() {} func NewExplainablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExplainablestmtContext { var p = new(ExplainablestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_explainablestmt return p } func (s *ExplainablestmtContext) GetParser() antlr.Parser { return s.parser } func (s *ExplainablestmtContext) Selectstmt() ISelectstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectstmtContext) } func (s *ExplainablestmtContext) Insertstmt() IInsertstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInsertstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IInsertstmtContext) } func (s *ExplainablestmtContext) Updatestmt() IUpdatestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUpdatestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUpdatestmtContext) } func (s *ExplainablestmtContext) Deletestmt() IDeletestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDeletestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDeletestmtContext) } func (s *ExplainablestmtContext) Declarecursorstmt() IDeclarecursorstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDeclarecursorstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDeclarecursorstmtContext) } func (s *ExplainablestmtContext) Createasstmt() ICreateasstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreateasstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreateasstmtContext) } func (s *ExplainablestmtContext) Creatematviewstmt() ICreatematviewstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreatematviewstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreatematviewstmtContext) } func (s *ExplainablestmtContext) Refreshmatviewstmt() IRefreshmatviewstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRefreshmatviewstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRefreshmatviewstmtContext) } func (s *ExplainablestmtContext) Executestmt() IExecutestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExecutestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExecutestmtContext) } func (s *ExplainablestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *ExplainablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ExplainablestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExplainablestmt(s) } } func (s *ExplainablestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExplainablestmt(s) } } func (s *ExplainablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExplainablestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Explainablestmt() (localctx IExplainablestmtContext) { localctx = NewExplainablestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 880, PostgreSQLParserRULE_explainablestmt) p.SetState(7571) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 373, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7562) p.Selectstmt() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7563) p.Insertstmt() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(7564) p.Updatestmt() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(7565) p.Deletestmt() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(7566) p.Declarecursorstmt() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(7567) p.Createasstmt() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(7568) p.Creatematviewstmt() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(7569) p.Refreshmatviewstmt() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(7570) p.Executestmt() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExplain_option_listContext is an interface to support dynamic dispatch. type IExplain_option_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllExplain_option_elem() []IExplain_option_elemContext Explain_option_elem(i int) IExplain_option_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsExplain_option_listContext differentiates from other interfaces. IsExplain_option_listContext() } type Explain_option_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExplain_option_listContext() *Explain_option_listContext { var p = new(Explain_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_explain_option_list return p } func InitEmptyExplain_option_listContext(p *Explain_option_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_explain_option_list } func (*Explain_option_listContext) IsExplain_option_listContext() {} func NewExplain_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_option_listContext { var p = new(Explain_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_explain_option_list return p } func (s *Explain_option_listContext) GetParser() antlr.Parser { return s.parser } func (s *Explain_option_listContext) AllExplain_option_elem() []IExplain_option_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IExplain_option_elemContext); ok { len++ } } tst := make([]IExplain_option_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IExplain_option_elemContext); ok { tst[i] = t.(IExplain_option_elemContext) i++ } } return tst } func (s *Explain_option_listContext) Explain_option_elem(i int) IExplain_option_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExplain_option_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IExplain_option_elemContext) } func (s *Explain_option_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Explain_option_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Explain_option_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Explain_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Explain_option_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExplain_option_list(s) } } func (s *Explain_option_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExplain_option_list(s) } } func (s *Explain_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExplain_option_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Explain_option_list() (localctx IExplain_option_listContext) { localctx = NewExplain_option_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 882, PostgreSQLParserRULE_explain_option_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7573) p.Explain_option_elem() } p.SetState(7578) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(7574) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7575) p.Explain_option_elem() } p.SetState(7580) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExplain_option_elemContext is an interface to support dynamic dispatch. type IExplain_option_elemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Explain_option_name() IExplain_option_nameContext Explain_option_arg() IExplain_option_argContext // IsExplain_option_elemContext differentiates from other interfaces. IsExplain_option_elemContext() } type Explain_option_elemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExplain_option_elemContext() *Explain_option_elemContext { var p = new(Explain_option_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_explain_option_elem return p } func InitEmptyExplain_option_elemContext(p *Explain_option_elemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_explain_option_elem } func (*Explain_option_elemContext) IsExplain_option_elemContext() {} func NewExplain_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_option_elemContext { var p = new(Explain_option_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_explain_option_elem return p } func (s *Explain_option_elemContext) GetParser() antlr.Parser { return s.parser } func (s *Explain_option_elemContext) Explain_option_name() IExplain_option_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExplain_option_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExplain_option_nameContext) } func (s *Explain_option_elemContext) Explain_option_arg() IExplain_option_argContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExplain_option_argContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExplain_option_argContext) } func (s *Explain_option_elemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Explain_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Explain_option_elemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExplain_option_elem(s) } } func (s *Explain_option_elemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExplain_option_elem(s) } } func (s *Explain_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExplain_option_elem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Explain_option_elem() (localctx IExplain_option_elemContext) { localctx = NewExplain_option_elemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 884, PostgreSQLParserRULE_explain_option_elem) p.EnterOuterAlt(localctx, 1) { p.SetState(7581) p.Explain_option_name() } { p.SetState(7582) p.Explain_option_arg() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExplain_option_nameContext is an interface to support dynamic dispatch. type IExplain_option_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Nonreservedword() INonreservedwordContext Analyze_keyword() IAnalyze_keywordContext // IsExplain_option_nameContext differentiates from other interfaces. IsExplain_option_nameContext() } type Explain_option_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExplain_option_nameContext() *Explain_option_nameContext { var p = new(Explain_option_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_explain_option_name return p } func InitEmptyExplain_option_nameContext(p *Explain_option_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_explain_option_name } func (*Explain_option_nameContext) IsExplain_option_nameContext() {} func NewExplain_option_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_option_nameContext { var p = new(Explain_option_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_explain_option_name return p } func (s *Explain_option_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Explain_option_nameContext) Nonreservedword() INonreservedwordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INonreservedwordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INonreservedwordContext) } func (s *Explain_option_nameContext) Analyze_keyword() IAnalyze_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAnalyze_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAnalyze_keywordContext) } func (s *Explain_option_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Explain_option_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Explain_option_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExplain_option_name(s) } } func (s *Explain_option_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExplain_option_name(s) } } func (s *Explain_option_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExplain_option_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Explain_option_name() (localctx IExplain_option_nameContext) { localctx = NewExplain_option_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 886, PostgreSQLParserRULE_explain_option_name) p.SetState(7586) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(7584) p.Nonreservedword() } case PostgreSQLParserANALYSE, PostgreSQLParserANALYZE: p.EnterOuterAlt(localctx, 2) { p.SetState(7585) p.Analyze_keyword() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExplain_option_argContext is an interface to support dynamic dispatch. type IExplain_option_argContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_boolean_or_string() IOpt_boolean_or_stringContext Numericonly() INumericonlyContext // IsExplain_option_argContext differentiates from other interfaces. IsExplain_option_argContext() } type Explain_option_argContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExplain_option_argContext() *Explain_option_argContext { var p = new(Explain_option_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_explain_option_arg return p } func InitEmptyExplain_option_argContext(p *Explain_option_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_explain_option_arg } func (*Explain_option_argContext) IsExplain_option_argContext() {} func NewExplain_option_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_option_argContext { var p = new(Explain_option_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_explain_option_arg return p } func (s *Explain_option_argContext) GetParser() antlr.Parser { return s.parser } func (s *Explain_option_argContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_boolean_or_stringContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_boolean_or_stringContext) } func (s *Explain_option_argContext) Numericonly() INumericonlyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericonlyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericonlyContext) } func (s *Explain_option_argContext) GetRuleContext() antlr.RuleContext { return s } func (s *Explain_option_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Explain_option_argContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExplain_option_arg(s) } } func (s *Explain_option_argContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExplain_option_arg(s) } } func (s *Explain_option_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExplain_option_arg(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Explain_option_arg() (localctx IExplain_option_argContext) { localctx = NewExplain_option_argContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 888, PostgreSQLParserRULE_explain_option_arg) p.SetState(7591) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserON, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(7588) p.Opt_boolean_or_string() } case PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserIntegral, PostgreSQLParserNumeric: p.EnterOuterAlt(localctx, 2) { p.SetState(7589) p.Numericonly() } case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA: p.EnterOuterAlt(localctx, 3) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPreparestmtContext is an interface to support dynamic dispatch. type IPreparestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures PREPARE() antlr.TerminalNode Name() INameContext Prep_type_clause() IPrep_type_clauseContext AS() antlr.TerminalNode Preparablestmt() IPreparablestmtContext // IsPreparestmtContext differentiates from other interfaces. IsPreparestmtContext() } type PreparestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPreparestmtContext() *PreparestmtContext { var p = new(PreparestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_preparestmt return p } func InitEmptyPreparestmtContext(p *PreparestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_preparestmt } func (*PreparestmtContext) IsPreparestmtContext() {} func NewPreparestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreparestmtContext { var p = new(PreparestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_preparestmt return p } func (s *PreparestmtContext) GetParser() antlr.Parser { return s.parser } func (s *PreparestmtContext) PREPARE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPREPARE, 0) } func (s *PreparestmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *PreparestmtContext) Prep_type_clause() IPrep_type_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPrep_type_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPrep_type_clauseContext) } func (s *PreparestmtContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *PreparestmtContext) Preparablestmt() IPreparablestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPreparablestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPreparablestmtContext) } func (s *PreparestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *PreparestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *PreparestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPreparestmt(s) } } func (s *PreparestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPreparestmt(s) } } func (s *PreparestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPreparestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Preparestmt() (localctx IPreparestmtContext) { localctx = NewPreparestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 890, PostgreSQLParserRULE_preparestmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7593) p.Match(PostgreSQLParserPREPARE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7594) p.Name() } { p.SetState(7595) p.Prep_type_clause() } { p.SetState(7596) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7597) p.Preparablestmt() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPrep_type_clauseContext is an interface to support dynamic dispatch. type IPrep_type_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Type_list() IType_listContext CLOSE_PAREN() antlr.TerminalNode // IsPrep_type_clauseContext differentiates from other interfaces. IsPrep_type_clauseContext() } type Prep_type_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPrep_type_clauseContext() *Prep_type_clauseContext { var p = new(Prep_type_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_prep_type_clause return p } func InitEmptyPrep_type_clauseContext(p *Prep_type_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_prep_type_clause } func (*Prep_type_clauseContext) IsPrep_type_clauseContext() {} func NewPrep_type_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Prep_type_clauseContext { var p = new(Prep_type_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_prep_type_clause return p } func (s *Prep_type_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Prep_type_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Prep_type_clauseContext) Type_list() IType_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IType_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IType_listContext) } func (s *Prep_type_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Prep_type_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Prep_type_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Prep_type_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPrep_type_clause(s) } } func (s *Prep_type_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPrep_type_clause(s) } } func (s *Prep_type_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPrep_type_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Prep_type_clause() (localctx IPrep_type_clauseContext) { localctx = NewPrep_type_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 892, PostgreSQLParserRULE_prep_type_clause) p.SetState(7604) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN: p.EnterOuterAlt(localctx, 1) { p.SetState(7599) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7600) p.Type_list() } { p.SetState(7601) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserAS: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPreparablestmtContext is an interface to support dynamic dispatch. type IPreparablestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Selectstmt() ISelectstmtContext Insertstmt() IInsertstmtContext Updatestmt() IUpdatestmtContext Deletestmt() IDeletestmtContext // IsPreparablestmtContext differentiates from other interfaces. IsPreparablestmtContext() } type PreparablestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPreparablestmtContext() *PreparablestmtContext { var p = new(PreparablestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_preparablestmt return p } func InitEmptyPreparablestmtContext(p *PreparablestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_preparablestmt } func (*PreparablestmtContext) IsPreparablestmtContext() {} func NewPreparablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreparablestmtContext { var p = new(PreparablestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_preparablestmt return p } func (s *PreparablestmtContext) GetParser() antlr.Parser { return s.parser } func (s *PreparablestmtContext) Selectstmt() ISelectstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectstmtContext) } func (s *PreparablestmtContext) Insertstmt() IInsertstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInsertstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IInsertstmtContext) } func (s *PreparablestmtContext) Updatestmt() IUpdatestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUpdatestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUpdatestmtContext) } func (s *PreparablestmtContext) Deletestmt() IDeletestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDeletestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDeletestmtContext) } func (s *PreparablestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *PreparablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *PreparablestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPreparablestmt(s) } } func (s *PreparablestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPreparablestmt(s) } } func (s *PreparablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPreparablestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Preparablestmt() (localctx IPreparablestmtContext) { localctx = NewPreparablestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 894, PostgreSQLParserRULE_preparablestmt) p.SetState(7610) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 378, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7606) p.Selectstmt() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7607) p.Insertstmt() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(7608) p.Updatestmt() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(7609) p.Deletestmt() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExecutestmtContext is an interface to support dynamic dispatch. type IExecutestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures EXECUTE() antlr.TerminalNode Name() INameContext Execute_param_clause() IExecute_param_clauseContext CREATE() antlr.TerminalNode Opttemp() IOpttempContext TABLE() antlr.TerminalNode Create_as_target() ICreate_as_targetContext AS() antlr.TerminalNode Opt_with_data() IOpt_with_dataContext IF_P() antlr.TerminalNode NOT() antlr.TerminalNode EXISTS() antlr.TerminalNode // IsExecutestmtContext differentiates from other interfaces. IsExecutestmtContext() } type ExecutestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExecutestmtContext() *ExecutestmtContext { var p = new(ExecutestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_executestmt return p } func InitEmptyExecutestmtContext(p *ExecutestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_executestmt } func (*ExecutestmtContext) IsExecutestmtContext() {} func NewExecutestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExecutestmtContext { var p = new(ExecutestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_executestmt return p } func (s *ExecutestmtContext) GetParser() antlr.Parser { return s.parser } func (s *ExecutestmtContext) EXECUTE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXECUTE, 0) } func (s *ExecutestmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *ExecutestmtContext) Execute_param_clause() IExecute_param_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExecute_param_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExecute_param_clauseContext) } func (s *ExecutestmtContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *ExecutestmtContext) Opttemp() IOpttempContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttempContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttempContext) } func (s *ExecutestmtContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *ExecutestmtContext) Create_as_target() ICreate_as_targetContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICreate_as_targetContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICreate_as_targetContext) } func (s *ExecutestmtContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *ExecutestmtContext) Opt_with_data() IOpt_with_dataContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_with_dataContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_with_dataContext) } func (s *ExecutestmtContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *ExecutestmtContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *ExecutestmtContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *ExecutestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *ExecutestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ExecutestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExecutestmt(s) } } func (s *ExecutestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExecutestmt(s) } } func (s *ExecutestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExecutestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Executestmt() (localctx IExecutestmtContext) { localctx = NewExecutestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 896, PostgreSQLParserRULE_executestmt) p.SetState(7639) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 379, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7612) p.Match(PostgreSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7613) p.Name() } { p.SetState(7614) p.Execute_param_clause() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7616) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7617) p.Opttemp() } { p.SetState(7618) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7619) p.Create_as_target() } { p.SetState(7620) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7621) p.Match(PostgreSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7622) p.Name() } { p.SetState(7623) p.Execute_param_clause() } { p.SetState(7624) p.Opt_with_data() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(7626) p.Match(PostgreSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7627) p.Opttemp() } { p.SetState(7628) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7629) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7630) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7631) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7632) p.Create_as_target() } { p.SetState(7633) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7634) p.Match(PostgreSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7635) p.Name() } { p.SetState(7636) p.Execute_param_clause() } { p.SetState(7637) p.Opt_with_data() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExecute_param_clauseContext is an interface to support dynamic dispatch. type IExecute_param_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Expr_list() IExpr_listContext CLOSE_PAREN() antlr.TerminalNode // IsExecute_param_clauseContext differentiates from other interfaces. IsExecute_param_clauseContext() } type Execute_param_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExecute_param_clauseContext() *Execute_param_clauseContext { var p = new(Execute_param_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_execute_param_clause return p } func InitEmptyExecute_param_clauseContext(p *Execute_param_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_execute_param_clause } func (*Execute_param_clauseContext) IsExecute_param_clauseContext() {} func NewExecute_param_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_param_clauseContext { var p = new(Execute_param_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_execute_param_clause return p } func (s *Execute_param_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Execute_param_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Execute_param_clauseContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Execute_param_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Execute_param_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Execute_param_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Execute_param_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExecute_param_clause(s) } } func (s *Execute_param_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExecute_param_clause(s) } } func (s *Execute_param_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExecute_param_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Execute_param_clause() (localctx IExecute_param_clauseContext) { localctx = NewExecute_param_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 898, PostgreSQLParserRULE_execute_param_clause) p.SetState(7646) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 380, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7641) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7642) p.Expr_list() } { p.SetState(7643) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDeallocatestmtContext is an interface to support dynamic dispatch. type IDeallocatestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DEALLOCATE() antlr.TerminalNode Name() INameContext PREPARE() antlr.TerminalNode ALL() antlr.TerminalNode // IsDeallocatestmtContext differentiates from other interfaces. IsDeallocatestmtContext() } type DeallocatestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDeallocatestmtContext() *DeallocatestmtContext { var p = new(DeallocatestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_deallocatestmt return p } func InitEmptyDeallocatestmtContext(p *DeallocatestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_deallocatestmt } func (*DeallocatestmtContext) IsDeallocatestmtContext() {} func NewDeallocatestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeallocatestmtContext { var p = new(DeallocatestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_deallocatestmt return p } func (s *DeallocatestmtContext) GetParser() antlr.Parser { return s.parser } func (s *DeallocatestmtContext) DEALLOCATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEALLOCATE, 0) } func (s *DeallocatestmtContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *DeallocatestmtContext) PREPARE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPREPARE, 0) } func (s *DeallocatestmtContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *DeallocatestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DeallocatestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DeallocatestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDeallocatestmt(s) } } func (s *DeallocatestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDeallocatestmt(s) } } func (s *DeallocatestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDeallocatestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Deallocatestmt() (localctx IDeallocatestmtContext) { localctx = NewDeallocatestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 900, PostgreSQLParserRULE_deallocatestmt) p.SetState(7658) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 381, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7648) p.Match(PostgreSQLParserDEALLOCATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7649) p.Name() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7650) p.Match(PostgreSQLParserDEALLOCATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7651) p.Match(PostgreSQLParserPREPARE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7652) p.Name() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(7653) p.Match(PostgreSQLParserDEALLOCATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7654) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(7655) p.Match(PostgreSQLParserDEALLOCATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7656) p.Match(PostgreSQLParserPREPARE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7657) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IInsertstmtContext is an interface to support dynamic dispatch. type IInsertstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_with_clause() IOpt_with_clauseContext INSERT() antlr.TerminalNode INTO() antlr.TerminalNode Insert_target() IInsert_targetContext Insert_rest() IInsert_restContext Opt_on_conflict() IOpt_on_conflictContext Returning_clause() IReturning_clauseContext // IsInsertstmtContext differentiates from other interfaces. IsInsertstmtContext() } type InsertstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyInsertstmtContext() *InsertstmtContext { var p = new(InsertstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_insertstmt return p } func InitEmptyInsertstmtContext(p *InsertstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_insertstmt } func (*InsertstmtContext) IsInsertstmtContext() {} func NewInsertstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertstmtContext { var p = new(InsertstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_insertstmt return p } func (s *InsertstmtContext) GetParser() antlr.Parser { return s.parser } func (s *InsertstmtContext) Opt_with_clause() IOpt_with_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_with_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_with_clauseContext) } func (s *InsertstmtContext) INSERT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINSERT, 0) } func (s *InsertstmtContext) INTO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINTO, 0) } func (s *InsertstmtContext) Insert_target() IInsert_targetContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInsert_targetContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IInsert_targetContext) } func (s *InsertstmtContext) Insert_rest() IInsert_restContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInsert_restContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IInsert_restContext) } func (s *InsertstmtContext) Opt_on_conflict() IOpt_on_conflictContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_on_conflictContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_on_conflictContext) } func (s *InsertstmtContext) Returning_clause() IReturning_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReturning_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReturning_clauseContext) } func (s *InsertstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *InsertstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *InsertstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterInsertstmt(s) } } func (s *InsertstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitInsertstmt(s) } } func (s *InsertstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitInsertstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Insertstmt() (localctx IInsertstmtContext) { localctx = NewInsertstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 902, PostgreSQLParserRULE_insertstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7660) p.Opt_with_clause() } { p.SetState(7661) p.Match(PostgreSQLParserINSERT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7662) p.Match(PostgreSQLParserINTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7663) p.Insert_target() } { p.SetState(7664) p.Insert_rest() } { p.SetState(7665) p.Opt_on_conflict() } { p.SetState(7666) p.Returning_clause() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IInsert_targetContext is an interface to support dynamic dispatch. type IInsert_targetContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Qualified_name() IQualified_nameContext AS() antlr.TerminalNode Colid() IColidContext // IsInsert_targetContext differentiates from other interfaces. IsInsert_targetContext() } type Insert_targetContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyInsert_targetContext() *Insert_targetContext { var p = new(Insert_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_insert_target return p } func InitEmptyInsert_targetContext(p *Insert_targetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_insert_target } func (*Insert_targetContext) IsInsert_targetContext() {} func NewInsert_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_targetContext { var p = new(Insert_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_insert_target return p } func (s *Insert_targetContext) GetParser() antlr.Parser { return s.parser } func (s *Insert_targetContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *Insert_targetContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Insert_targetContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Insert_targetContext) GetRuleContext() antlr.RuleContext { return s } func (s *Insert_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Insert_targetContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterInsert_target(s) } } func (s *Insert_targetContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitInsert_target(s) } } func (s *Insert_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitInsert_target(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Insert_target() (localctx IInsert_targetContext) { localctx = NewInsert_targetContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 904, PostgreSQLParserRULE_insert_target) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7668) p.Qualified_name() } p.SetState(7671) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserAS { { p.SetState(7669) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7670) p.Colid() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IInsert_restContext is an interface to support dynamic dispatch. type IInsert_restContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Selectstmt() ISelectstmtContext OVERRIDING() antlr.TerminalNode Override_kind() IOverride_kindContext VALUE_P() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Insert_column_list() IInsert_column_listContext CLOSE_PAREN() antlr.TerminalNode DEFAULT() antlr.TerminalNode VALUES() antlr.TerminalNode // IsInsert_restContext differentiates from other interfaces. IsInsert_restContext() } type Insert_restContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyInsert_restContext() *Insert_restContext { var p = new(Insert_restContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_insert_rest return p } func InitEmptyInsert_restContext(p *Insert_restContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_insert_rest } func (*Insert_restContext) IsInsert_restContext() {} func NewInsert_restContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_restContext { var p = new(Insert_restContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_insert_rest return p } func (s *Insert_restContext) GetParser() antlr.Parser { return s.parser } func (s *Insert_restContext) Selectstmt() ISelectstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectstmtContext) } func (s *Insert_restContext) OVERRIDING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOVERRIDING, 0) } func (s *Insert_restContext) Override_kind() IOverride_kindContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOverride_kindContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOverride_kindContext) } func (s *Insert_restContext) VALUE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALUE_P, 0) } func (s *Insert_restContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Insert_restContext) Insert_column_list() IInsert_column_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInsert_column_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IInsert_column_listContext) } func (s *Insert_restContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Insert_restContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Insert_restContext) VALUES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALUES, 0) } func (s *Insert_restContext) GetRuleContext() antlr.RuleContext { return s } func (s *Insert_restContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Insert_restContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterInsert_rest(s) } } func (s *Insert_restContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitInsert_rest(s) } } func (s *Insert_restContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitInsert_rest(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Insert_rest() (localctx IInsert_restContext) { localctx = NewInsert_restContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 906, PostgreSQLParserRULE_insert_rest) var _la int p.SetState(7692) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 384, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7673) p.Selectstmt() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7674) p.Match(PostgreSQLParserOVERRIDING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7675) p.Override_kind() } { p.SetState(7676) p.Match(PostgreSQLParserVALUE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7677) p.Selectstmt() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(7679) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7680) p.Insert_column_list() } { p.SetState(7681) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7686) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserOVERRIDING { { p.SetState(7682) p.Match(PostgreSQLParserOVERRIDING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7683) p.Override_kind() } { p.SetState(7684) p.Match(PostgreSQLParserVALUE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(7688) p.Selectstmt() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(7690) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7691) p.Match(PostgreSQLParserVALUES) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOverride_kindContext is an interface to support dynamic dispatch. type IOverride_kindContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USER() antlr.TerminalNode SYSTEM_P() antlr.TerminalNode // IsOverride_kindContext differentiates from other interfaces. IsOverride_kindContext() } type Override_kindContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOverride_kindContext() *Override_kindContext { var p = new(Override_kindContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_override_kind return p } func InitEmptyOverride_kindContext(p *Override_kindContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_override_kind } func (*Override_kindContext) IsOverride_kindContext() {} func NewOverride_kindContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Override_kindContext { var p = new(Override_kindContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_override_kind return p } func (s *Override_kindContext) GetParser() antlr.Parser { return s.parser } func (s *Override_kindContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *Override_kindContext) SYSTEM_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSYSTEM_P, 0) } func (s *Override_kindContext) GetRuleContext() antlr.RuleContext { return s } func (s *Override_kindContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Override_kindContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOverride_kind(s) } } func (s *Override_kindContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOverride_kind(s) } } func (s *Override_kindContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOverride_kind(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Override_kind() (localctx IOverride_kindContext) { localctx = NewOverride_kindContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 908, PostgreSQLParserRULE_override_kind) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7694) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserUSER || _la == PostgreSQLParserSYSTEM_P) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IInsert_column_listContext is an interface to support dynamic dispatch. type IInsert_column_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllInsert_column_item() []IInsert_column_itemContext Insert_column_item(i int) IInsert_column_itemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsInsert_column_listContext differentiates from other interfaces. IsInsert_column_listContext() } type Insert_column_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyInsert_column_listContext() *Insert_column_listContext { var p = new(Insert_column_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_insert_column_list return p } func InitEmptyInsert_column_listContext(p *Insert_column_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_insert_column_list } func (*Insert_column_listContext) IsInsert_column_listContext() {} func NewInsert_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_column_listContext { var p = new(Insert_column_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_insert_column_list return p } func (s *Insert_column_listContext) GetParser() antlr.Parser { return s.parser } func (s *Insert_column_listContext) AllInsert_column_item() []IInsert_column_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IInsert_column_itemContext); ok { len++ } } tst := make([]IInsert_column_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IInsert_column_itemContext); ok { tst[i] = t.(IInsert_column_itemContext) i++ } } return tst } func (s *Insert_column_listContext) Insert_column_item(i int) IInsert_column_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInsert_column_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IInsert_column_itemContext) } func (s *Insert_column_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Insert_column_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Insert_column_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Insert_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Insert_column_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterInsert_column_list(s) } } func (s *Insert_column_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitInsert_column_list(s) } } func (s *Insert_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitInsert_column_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Insert_column_list() (localctx IInsert_column_listContext) { localctx = NewInsert_column_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 910, PostgreSQLParserRULE_insert_column_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7696) p.Insert_column_item() } p.SetState(7701) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(7697) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7698) p.Insert_column_item() } p.SetState(7703) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IInsert_column_itemContext is an interface to support dynamic dispatch. type IInsert_column_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext Opt_indirection() IOpt_indirectionContext // IsInsert_column_itemContext differentiates from other interfaces. IsInsert_column_itemContext() } type Insert_column_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyInsert_column_itemContext() *Insert_column_itemContext { var p = new(Insert_column_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_insert_column_item return p } func InitEmptyInsert_column_itemContext(p *Insert_column_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_insert_column_item } func (*Insert_column_itemContext) IsInsert_column_itemContext() {} func NewInsert_column_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_column_itemContext { var p = new(Insert_column_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_insert_column_item return p } func (s *Insert_column_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Insert_column_itemContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Insert_column_itemContext) Opt_indirection() IOpt_indirectionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_indirectionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_indirectionContext) } func (s *Insert_column_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Insert_column_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Insert_column_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterInsert_column_item(s) } } func (s *Insert_column_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitInsert_column_item(s) } } func (s *Insert_column_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitInsert_column_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Insert_column_item() (localctx IInsert_column_itemContext) { localctx = NewInsert_column_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 912, PostgreSQLParserRULE_insert_column_item) p.EnterOuterAlt(localctx, 1) { p.SetState(7704) p.Colid() } { p.SetState(7705) p.Opt_indirection() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_on_conflictContext is an interface to support dynamic dispatch. type IOpt_on_conflictContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ON() antlr.TerminalNode CONFLICT() antlr.TerminalNode Opt_conf_expr() IOpt_conf_exprContext DO() antlr.TerminalNode UPDATE() antlr.TerminalNode SET() antlr.TerminalNode Set_clause_list() ISet_clause_listContext Where_clause() IWhere_clauseContext NOTHING() antlr.TerminalNode // IsOpt_on_conflictContext differentiates from other interfaces. IsOpt_on_conflictContext() } type Opt_on_conflictContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_on_conflictContext() *Opt_on_conflictContext { var p = new(Opt_on_conflictContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_on_conflict return p } func InitEmptyOpt_on_conflictContext(p *Opt_on_conflictContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_on_conflict } func (*Opt_on_conflictContext) IsOpt_on_conflictContext() {} func NewOpt_on_conflictContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_on_conflictContext { var p = new(Opt_on_conflictContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_on_conflict return p } func (s *Opt_on_conflictContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_on_conflictContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *Opt_on_conflictContext) CONFLICT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONFLICT, 0) } func (s *Opt_on_conflictContext) Opt_conf_expr() IOpt_conf_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_conf_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_conf_exprContext) } func (s *Opt_on_conflictContext) DO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDO, 0) } func (s *Opt_on_conflictContext) UPDATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUPDATE, 0) } func (s *Opt_on_conflictContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *Opt_on_conflictContext) Set_clause_list() ISet_clause_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISet_clause_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISet_clause_listContext) } func (s *Opt_on_conflictContext) Where_clause() IWhere_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWhere_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWhere_clauseContext) } func (s *Opt_on_conflictContext) NOTHING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOTHING, 0) } func (s *Opt_on_conflictContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_on_conflictContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_on_conflictContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_on_conflict(s) } } func (s *Opt_on_conflictContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_on_conflict(s) } } func (s *Opt_on_conflictContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_on_conflict(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_on_conflict() (localctx IOpt_on_conflictContext) { localctx = NewOpt_on_conflictContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 914, PostgreSQLParserRULE_opt_on_conflict) p.SetState(7720) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserON: p.EnterOuterAlt(localctx, 1) { p.SetState(7707) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7708) p.Match(PostgreSQLParserCONFLICT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7709) p.Opt_conf_expr() } { p.SetState(7710) p.Match(PostgreSQLParserDO) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7717) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUPDATE: { p.SetState(7711) p.Match(PostgreSQLParserUPDATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7712) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7713) p.Set_clause_list() } { p.SetState(7714) p.Where_clause() } case PostgreSQLParserNOTHING: { p.SetState(7716) p.Match(PostgreSQLParserNOTHING) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_conf_exprContext is an interface to support dynamic dispatch. type IOpt_conf_exprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Index_params() IIndex_paramsContext CLOSE_PAREN() antlr.TerminalNode Where_clause() IWhere_clauseContext ON() antlr.TerminalNode CONSTRAINT() antlr.TerminalNode Name() INameContext // IsOpt_conf_exprContext differentiates from other interfaces. IsOpt_conf_exprContext() } type Opt_conf_exprContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_conf_exprContext() *Opt_conf_exprContext { var p = new(Opt_conf_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_conf_expr return p } func InitEmptyOpt_conf_exprContext(p *Opt_conf_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_conf_expr } func (*Opt_conf_exprContext) IsOpt_conf_exprContext() {} func NewOpt_conf_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_conf_exprContext { var p = new(Opt_conf_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_conf_expr return p } func (s *Opt_conf_exprContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_conf_exprContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Opt_conf_exprContext) Index_params() IIndex_paramsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndex_paramsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIndex_paramsContext) } func (s *Opt_conf_exprContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Opt_conf_exprContext) Where_clause() IWhere_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWhere_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWhere_clauseContext) } func (s *Opt_conf_exprContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *Opt_conf_exprContext) CONSTRAINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTRAINT, 0) } func (s *Opt_conf_exprContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *Opt_conf_exprContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_conf_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_conf_exprContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_conf_expr(s) } } func (s *Opt_conf_exprContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_conf_expr(s) } } func (s *Opt_conf_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_conf_expr(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_conf_expr() (localctx IOpt_conf_exprContext) { localctx = NewOpt_conf_exprContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 916, PostgreSQLParserRULE_opt_conf_expr) p.SetState(7731) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN: p.EnterOuterAlt(localctx, 1) { p.SetState(7722) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7723) p.Index_params() } { p.SetState(7724) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7725) p.Where_clause() } case PostgreSQLParserON: p.EnterOuterAlt(localctx, 2) { p.SetState(7727) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7728) p.Match(PostgreSQLParserCONSTRAINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7729) p.Name() } case PostgreSQLParserDO: p.EnterOuterAlt(localctx, 3) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IReturning_clauseContext is an interface to support dynamic dispatch. type IReturning_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures RETURNING() antlr.TerminalNode Target_list() ITarget_listContext // IsReturning_clauseContext differentiates from other interfaces. IsReturning_clauseContext() } type Returning_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyReturning_clauseContext() *Returning_clauseContext { var p = new(Returning_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_returning_clause return p } func InitEmptyReturning_clauseContext(p *Returning_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_returning_clause } func (*Returning_clauseContext) IsReturning_clauseContext() {} func NewReturning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Returning_clauseContext { var p = new(Returning_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_returning_clause return p } func (s *Returning_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Returning_clauseContext) RETURNING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRETURNING, 0) } func (s *Returning_clauseContext) Target_list() ITarget_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITarget_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITarget_listContext) } func (s *Returning_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Returning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Returning_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterReturning_clause(s) } } func (s *Returning_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitReturning_clause(s) } } func (s *Returning_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitReturning_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Returning_clause() (localctx IReturning_clauseContext) { localctx = NewReturning_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 918, PostgreSQLParserRULE_returning_clause) p.SetState(7736) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserRETURNING: p.EnterOuterAlt(localctx, 1) { p.SetState(7733) p.Match(PostgreSQLParserRETURNING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7734) p.Target_list() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IMergestmtContext is an interface to support dynamic dispatch. type IMergestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures MERGE() antlr.TerminalNode AllQualified_name() []IQualified_nameContext Qualified_name(i int) IQualified_nameContext USING() antlr.TerminalNode ON() antlr.TerminalNode A_expr() IA_exprContext Select_with_parens() ISelect_with_parensContext Merge_insert_clause() IMerge_insert_clauseContext Merge_update_clause() IMerge_update_clauseContext INTO() antlr.TerminalNode AllAlias_clause() []IAlias_clauseContext Alias_clause(i int) IAlias_clauseContext Merge_delete_clause() IMerge_delete_clauseContext // IsMergestmtContext differentiates from other interfaces. IsMergestmtContext() } type MergestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyMergestmtContext() *MergestmtContext { var p = new(MergestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_mergestmt return p } func InitEmptyMergestmtContext(p *MergestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_mergestmt } func (*MergestmtContext) IsMergestmtContext() {} func NewMergestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MergestmtContext { var p = new(MergestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_mergestmt return p } func (s *MergestmtContext) GetParser() antlr.Parser { return s.parser } func (s *MergestmtContext) MERGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMERGE, 0) } func (s *MergestmtContext) AllQualified_name() []IQualified_nameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IQualified_nameContext); ok { len++ } } tst := make([]IQualified_nameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IQualified_nameContext); ok { tst[i] = t.(IQualified_nameContext) i++ } } return tst } func (s *MergestmtContext) Qualified_name(i int) IQualified_nameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *MergestmtContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *MergestmtContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *MergestmtContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *MergestmtContext) Select_with_parens() ISelect_with_parensContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_with_parensContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_with_parensContext) } func (s *MergestmtContext) Merge_insert_clause() IMerge_insert_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IMerge_insert_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IMerge_insert_clauseContext) } func (s *MergestmtContext) Merge_update_clause() IMerge_update_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IMerge_update_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IMerge_update_clauseContext) } func (s *MergestmtContext) INTO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINTO, 0) } func (s *MergestmtContext) AllAlias_clause() []IAlias_clauseContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAlias_clauseContext); ok { len++ } } tst := make([]IAlias_clauseContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAlias_clauseContext); ok { tst[i] = t.(IAlias_clauseContext) i++ } } return tst } func (s *MergestmtContext) Alias_clause(i int) IAlias_clauseContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlias_clauseContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAlias_clauseContext) } func (s *MergestmtContext) Merge_delete_clause() IMerge_delete_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IMerge_delete_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IMerge_delete_clauseContext) } func (s *MergestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *MergestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *MergestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterMergestmt(s) } } func (s *MergestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitMergestmt(s) } } func (s *MergestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitMergestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Mergestmt() (localctx IMergestmtContext) { localctx = NewMergestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 920, PostgreSQLParserRULE_mergestmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7738) p.Match(PostgreSQLParserMERGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7740) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserINTO { { p.SetState(7739) p.Match(PostgreSQLParserINTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(7742) p.Qualified_name() } p.SetState(7744) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&2459027080864595968) != 0) || ((int64((_la-92)) & ^0x3f) == 0 && ((int64(1)<<(_la-92))&-113665638399) != 0) || ((int64((_la-156)) & ^0x3f) == 0 && ((int64(1)<<(_la-156))&-1) != 0) || ((int64((_la-220)) & ^0x3f) == 0 && ((int64(1)<<(_la-220))&-9663676417) != 0) || ((int64((_la-284)) & ^0x3f) == 0 && ((int64(1)<<(_la-284))&-1) != 0) || ((int64((_la-348)) & ^0x3f) == 0 && ((int64(1)<<(_la-348))&-1) != 0) || ((int64((_la-412)) & ^0x3f) == 0 && ((int64(1)<<(_la-412))&-1152925902653358081) != 0) || ((int64((_la-476)) & ^0x3f) == 0 && ((int64(1)<<(_la-476))&-8796764110849) != 0) || ((int64((_la-540)) & ^0x3f) == 0 && ((int64(1)<<(_la-540))&-1) != 0) || ((int64((_la-604)) & ^0x3f) == 0 && ((int64(1)<<(_la-604))&432345718846390271) != 0) { { p.SetState(7743) p.Alias_clause() } } { p.SetState(7746) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7749) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN: { p.SetState(7747) p.Select_with_parens() } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: { p.SetState(7748) p.Qualified_name() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.SetState(7752) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&2459027080864595968) != 0) || ((int64((_la-92)) & ^0x3f) == 0 && ((int64(1)<<(_la-92))&-113665638399) != 0) || ((int64((_la-156)) & ^0x3f) == 0 && ((int64(1)<<(_la-156))&-1) != 0) || ((int64((_la-220)) & ^0x3f) == 0 && ((int64(1)<<(_la-220))&-9663676417) != 0) || ((int64((_la-284)) & ^0x3f) == 0 && ((int64(1)<<(_la-284))&-1) != 0) || ((int64((_la-348)) & ^0x3f) == 0 && ((int64(1)<<(_la-348))&-1) != 0) || ((int64((_la-412)) & ^0x3f) == 0 && ((int64(1)<<(_la-412))&-1152925902653358081) != 0) || ((int64((_la-476)) & ^0x3f) == 0 && ((int64(1)<<(_la-476))&-8796764110849) != 0) || ((int64((_la-540)) & ^0x3f) == 0 && ((int64(1)<<(_la-540))&-1) != 0) || ((int64((_la-604)) & ^0x3f) == 0 && ((int64(1)<<(_la-604))&432345718846390271) != 0) { { p.SetState(7751) p.Alias_clause() } } { p.SetState(7754) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7755) p.A_expr() } p.SetState(7764) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 396, p.GetParserRuleContext()) { case 1: { p.SetState(7756) p.Merge_insert_clause() } p.SetState(7758) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 394, p.GetParserRuleContext()) == 1 { { p.SetState(7757) p.Merge_update_clause() } } else if p.HasError() { // JIM goto errorExit } case 2: { p.SetState(7760) p.Merge_update_clause() } p.SetState(7762) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 395, p.GetParserRuleContext()) == 1 { { p.SetState(7761) p.Merge_insert_clause() } } else if p.HasError() { // JIM goto errorExit } case antlr.ATNInvalidAltNumber: goto errorExit } p.SetState(7767) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserWHEN { { p.SetState(7766) p.Merge_delete_clause() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IMerge_insert_clauseContext is an interface to support dynamic dispatch. type IMerge_insert_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WHEN() antlr.TerminalNode NOT() antlr.TerminalNode MATCHED() antlr.TerminalNode INSERT() antlr.TerminalNode Values_clause() IValues_clauseContext AND() antlr.TerminalNode A_expr() IA_exprContext THEN() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Insert_column_list() IInsert_column_listContext CLOSE_PAREN() antlr.TerminalNode // IsMerge_insert_clauseContext differentiates from other interfaces. IsMerge_insert_clauseContext() } type Merge_insert_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyMerge_insert_clauseContext() *Merge_insert_clauseContext { var p = new(Merge_insert_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_merge_insert_clause return p } func InitEmptyMerge_insert_clauseContext(p *Merge_insert_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_merge_insert_clause } func (*Merge_insert_clauseContext) IsMerge_insert_clauseContext() {} func NewMerge_insert_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_insert_clauseContext { var p = new(Merge_insert_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_merge_insert_clause return p } func (s *Merge_insert_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Merge_insert_clauseContext) WHEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHEN, 0) } func (s *Merge_insert_clauseContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *Merge_insert_clauseContext) MATCHED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMATCHED, 0) } func (s *Merge_insert_clauseContext) INSERT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINSERT, 0) } func (s *Merge_insert_clauseContext) Values_clause() IValues_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IValues_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IValues_clauseContext) } func (s *Merge_insert_clauseContext) AND() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAND, 0) } func (s *Merge_insert_clauseContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Merge_insert_clauseContext) THEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTHEN, 0) } func (s *Merge_insert_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Merge_insert_clauseContext) Insert_column_list() IInsert_column_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInsert_column_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IInsert_column_listContext) } func (s *Merge_insert_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Merge_insert_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Merge_insert_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Merge_insert_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterMerge_insert_clause(s) } } func (s *Merge_insert_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitMerge_insert_clause(s) } } func (s *Merge_insert_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitMerge_insert_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Merge_insert_clause() (localctx IMerge_insert_clauseContext) { localctx = NewMerge_insert_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 922, PostgreSQLParserRULE_merge_insert_clause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7769) p.Match(PostgreSQLParserWHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7770) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7771) p.Match(PostgreSQLParserMATCHED) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7774) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserAND { { p.SetState(7772) p.Match(PostgreSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7773) p.A_expr() } } p.SetState(7777) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserTHEN { { p.SetState(7776) p.Match(PostgreSQLParserTHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(7779) p.Match(PostgreSQLParserINSERT) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7784) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserOPEN_PAREN { { p.SetState(7780) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7781) p.Insert_column_list() } { p.SetState(7782) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(7786) p.Values_clause() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IMerge_update_clauseContext is an interface to support dynamic dispatch. type IMerge_update_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WHEN() antlr.TerminalNode MATCHED() antlr.TerminalNode UPDATE() antlr.TerminalNode SET() antlr.TerminalNode Set_clause_list() ISet_clause_listContext AND() antlr.TerminalNode A_expr() IA_exprContext THEN() antlr.TerminalNode // IsMerge_update_clauseContext differentiates from other interfaces. IsMerge_update_clauseContext() } type Merge_update_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyMerge_update_clauseContext() *Merge_update_clauseContext { var p = new(Merge_update_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_merge_update_clause return p } func InitEmptyMerge_update_clauseContext(p *Merge_update_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_merge_update_clause } func (*Merge_update_clauseContext) IsMerge_update_clauseContext() {} func NewMerge_update_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_update_clauseContext { var p = new(Merge_update_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_merge_update_clause return p } func (s *Merge_update_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Merge_update_clauseContext) WHEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHEN, 0) } func (s *Merge_update_clauseContext) MATCHED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMATCHED, 0) } func (s *Merge_update_clauseContext) UPDATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUPDATE, 0) } func (s *Merge_update_clauseContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *Merge_update_clauseContext) Set_clause_list() ISet_clause_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISet_clause_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISet_clause_listContext) } func (s *Merge_update_clauseContext) AND() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAND, 0) } func (s *Merge_update_clauseContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Merge_update_clauseContext) THEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTHEN, 0) } func (s *Merge_update_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Merge_update_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Merge_update_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterMerge_update_clause(s) } } func (s *Merge_update_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitMerge_update_clause(s) } } func (s *Merge_update_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitMerge_update_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Merge_update_clause() (localctx IMerge_update_clauseContext) { localctx = NewMerge_update_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 924, PostgreSQLParserRULE_merge_update_clause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7788) p.Match(PostgreSQLParserWHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7789) p.Match(PostgreSQLParserMATCHED) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7792) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserAND { { p.SetState(7790) p.Match(PostgreSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7791) p.A_expr() } } p.SetState(7795) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserTHEN { { p.SetState(7794) p.Match(PostgreSQLParserTHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(7797) p.Match(PostgreSQLParserUPDATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7798) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7799) p.Set_clause_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IMerge_delete_clauseContext is an interface to support dynamic dispatch. type IMerge_delete_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WHEN() antlr.TerminalNode MATCHED() antlr.TerminalNode DELETE_P() antlr.TerminalNode THEN() antlr.TerminalNode // IsMerge_delete_clauseContext differentiates from other interfaces. IsMerge_delete_clauseContext() } type Merge_delete_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyMerge_delete_clauseContext() *Merge_delete_clauseContext { var p = new(Merge_delete_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_merge_delete_clause return p } func InitEmptyMerge_delete_clauseContext(p *Merge_delete_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_merge_delete_clause } func (*Merge_delete_clauseContext) IsMerge_delete_clauseContext() {} func NewMerge_delete_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_delete_clauseContext { var p = new(Merge_delete_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_merge_delete_clause return p } func (s *Merge_delete_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Merge_delete_clauseContext) WHEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHEN, 0) } func (s *Merge_delete_clauseContext) MATCHED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMATCHED, 0) } func (s *Merge_delete_clauseContext) DELETE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDELETE_P, 0) } func (s *Merge_delete_clauseContext) THEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTHEN, 0) } func (s *Merge_delete_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Merge_delete_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Merge_delete_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterMerge_delete_clause(s) } } func (s *Merge_delete_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitMerge_delete_clause(s) } } func (s *Merge_delete_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitMerge_delete_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Merge_delete_clause() (localctx IMerge_delete_clauseContext) { localctx = NewMerge_delete_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 926, PostgreSQLParserRULE_merge_delete_clause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7801) p.Match(PostgreSQLParserWHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7802) p.Match(PostgreSQLParserMATCHED) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7804) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserTHEN { { p.SetState(7803) p.Match(PostgreSQLParserTHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(7806) p.Match(PostgreSQLParserDELETE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDeletestmtContext is an interface to support dynamic dispatch. type IDeletestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_with_clause() IOpt_with_clauseContext DELETE_P() antlr.TerminalNode FROM() antlr.TerminalNode Relation_expr_opt_alias() IRelation_expr_opt_aliasContext Using_clause() IUsing_clauseContext Where_or_current_clause() IWhere_or_current_clauseContext Returning_clause() IReturning_clauseContext // IsDeletestmtContext differentiates from other interfaces. IsDeletestmtContext() } type DeletestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDeletestmtContext() *DeletestmtContext { var p = new(DeletestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_deletestmt return p } func InitEmptyDeletestmtContext(p *DeletestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_deletestmt } func (*DeletestmtContext) IsDeletestmtContext() {} func NewDeletestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeletestmtContext { var p = new(DeletestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_deletestmt return p } func (s *DeletestmtContext) GetParser() antlr.Parser { return s.parser } func (s *DeletestmtContext) Opt_with_clause() IOpt_with_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_with_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_with_clauseContext) } func (s *DeletestmtContext) DELETE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDELETE_P, 0) } func (s *DeletestmtContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *DeletestmtContext) Relation_expr_opt_alias() IRelation_expr_opt_aliasContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_expr_opt_aliasContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRelation_expr_opt_aliasContext) } func (s *DeletestmtContext) Using_clause() IUsing_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUsing_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUsing_clauseContext) } func (s *DeletestmtContext) Where_or_current_clause() IWhere_or_current_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWhere_or_current_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWhere_or_current_clauseContext) } func (s *DeletestmtContext) Returning_clause() IReturning_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReturning_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReturning_clauseContext) } func (s *DeletestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DeletestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DeletestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDeletestmt(s) } } func (s *DeletestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDeletestmt(s) } } func (s *DeletestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDeletestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Deletestmt() (localctx IDeletestmtContext) { localctx = NewDeletestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 928, PostgreSQLParserRULE_deletestmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7808) p.Opt_with_clause() } { p.SetState(7809) p.Match(PostgreSQLParserDELETE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7810) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7811) p.Relation_expr_opt_alias() } { p.SetState(7812) p.Using_clause() } { p.SetState(7813) p.Where_or_current_clause() } { p.SetState(7814) p.Returning_clause() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IUsing_clauseContext is an interface to support dynamic dispatch. type IUsing_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USING() antlr.TerminalNode From_list() IFrom_listContext // IsUsing_clauseContext differentiates from other interfaces. IsUsing_clauseContext() } type Using_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyUsing_clauseContext() *Using_clauseContext { var p = new(Using_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_using_clause return p } func InitEmptyUsing_clauseContext(p *Using_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_using_clause } func (*Using_clauseContext) IsUsing_clauseContext() {} func NewUsing_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_clauseContext { var p = new(Using_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_using_clause return p } func (s *Using_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Using_clauseContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *Using_clauseContext) From_list() IFrom_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFrom_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFrom_listContext) } func (s *Using_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterUsing_clause(s) } } func (s *Using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitUsing_clause(s) } } func (s *Using_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitUsing_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Using_clause() (localctx IUsing_clauseContext) { localctx = NewUsing_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 930, PostgreSQLParserRULE_using_clause) p.SetState(7819) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 1) { p.SetState(7816) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7817) p.From_list() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWHERE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ILockstmtContext is an interface to support dynamic dispatch. type ILockstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures LOCK_P() antlr.TerminalNode Opt_table() IOpt_tableContext Relation_expr_list() IRelation_expr_listContext Opt_lock() IOpt_lockContext Opt_nowait() IOpt_nowaitContext // IsLockstmtContext differentiates from other interfaces. IsLockstmtContext() } type LockstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyLockstmtContext() *LockstmtContext { var p = new(LockstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_lockstmt return p } func InitEmptyLockstmtContext(p *LockstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_lockstmt } func (*LockstmtContext) IsLockstmtContext() {} func NewLockstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LockstmtContext { var p = new(LockstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_lockstmt return p } func (s *LockstmtContext) GetParser() antlr.Parser { return s.parser } func (s *LockstmtContext) LOCK_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCK_P, 0) } func (s *LockstmtContext) Opt_table() IOpt_tableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_tableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_tableContext) } func (s *LockstmtContext) Relation_expr_list() IRelation_expr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_expr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRelation_expr_listContext) } func (s *LockstmtContext) Opt_lock() IOpt_lockContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_lockContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_lockContext) } func (s *LockstmtContext) Opt_nowait() IOpt_nowaitContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_nowaitContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_nowaitContext) } func (s *LockstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *LockstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *LockstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterLockstmt(s) } } func (s *LockstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitLockstmt(s) } } func (s *LockstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitLockstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Lockstmt() (localctx ILockstmtContext) { localctx = NewLockstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 932, PostgreSQLParserRULE_lockstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7821) p.Match(PostgreSQLParserLOCK_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7822) p.Opt_table() } { p.SetState(7823) p.Relation_expr_list() } { p.SetState(7824) p.Opt_lock() } { p.SetState(7825) p.Opt_nowait() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_lockContext is an interface to support dynamic dispatch. type IOpt_lockContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures IN_P() antlr.TerminalNode Lock_type() ILock_typeContext MODE() antlr.TerminalNode // IsOpt_lockContext differentiates from other interfaces. IsOpt_lockContext() } type Opt_lockContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_lockContext() *Opt_lockContext { var p = new(Opt_lockContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_lock return p } func InitEmptyOpt_lockContext(p *Opt_lockContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_lock } func (*Opt_lockContext) IsOpt_lockContext() {} func NewOpt_lockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_lockContext { var p = new(Opt_lockContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_lock return p } func (s *Opt_lockContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_lockContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *Opt_lockContext) Lock_type() ILock_typeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ILock_typeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ILock_typeContext) } func (s *Opt_lockContext) MODE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMODE, 0) } func (s *Opt_lockContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_lockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_lockContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_lock(s) } } func (s *Opt_lockContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_lock(s) } } func (s *Opt_lockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_lock(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_lock() (localctx IOpt_lockContext) { localctx = NewOpt_lockContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 934, PostgreSQLParserRULE_opt_lock) p.SetState(7832) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserIN_P: p.EnterOuterAlt(localctx, 1) { p.SetState(7827) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7828) p.Lock_type() } { p.SetState(7829) p.Match(PostgreSQLParserMODE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ILock_typeContext is an interface to support dynamic dispatch. type ILock_typeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ACCESS() antlr.TerminalNode SHARE() antlr.TerminalNode EXCLUSIVE() antlr.TerminalNode ROW() antlr.TerminalNode UPDATE() antlr.TerminalNode // IsLock_typeContext differentiates from other interfaces. IsLock_typeContext() } type Lock_typeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyLock_typeContext() *Lock_typeContext { var p = new(Lock_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_lock_type return p } func InitEmptyLock_typeContext(p *Lock_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_lock_type } func (*Lock_typeContext) IsLock_typeContext() {} func NewLock_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lock_typeContext { var p = new(Lock_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_lock_type return p } func (s *Lock_typeContext) GetParser() antlr.Parser { return s.parser } func (s *Lock_typeContext) ACCESS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserACCESS, 0) } func (s *Lock_typeContext) SHARE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSHARE, 0) } func (s *Lock_typeContext) EXCLUSIVE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXCLUSIVE, 0) } func (s *Lock_typeContext) ROW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROW, 0) } func (s *Lock_typeContext) UPDATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUPDATE, 0) } func (s *Lock_typeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Lock_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Lock_typeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterLock_type(s) } } func (s *Lock_typeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitLock_type(s) } } func (s *Lock_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitLock_type(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Lock_type() (localctx ILock_typeContext) { localctx = NewLock_typeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 936, PostgreSQLParserRULE_lock_type) var _la int p.SetState(7846) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserACCESS: p.EnterOuterAlt(localctx, 1) { p.SetState(7834) p.Match(PostgreSQLParserACCESS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7835) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserEXCLUSIVE || _la == PostgreSQLParserSHARE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } case PostgreSQLParserROW: p.EnterOuterAlt(localctx, 2) { p.SetState(7836) p.Match(PostgreSQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7837) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserEXCLUSIVE || _la == PostgreSQLParserSHARE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } case PostgreSQLParserSHARE: p.EnterOuterAlt(localctx, 3) { p.SetState(7838) p.Match(PostgreSQLParserSHARE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7843) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUPDATE: { p.SetState(7839) p.Match(PostgreSQLParserUPDATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7840) p.Match(PostgreSQLParserEXCLUSIVE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserROW: { p.SetState(7841) p.Match(PostgreSQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7842) p.Match(PostgreSQLParserEXCLUSIVE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserMODE: default: } case PostgreSQLParserEXCLUSIVE: p.EnterOuterAlt(localctx, 4) { p.SetState(7845) p.Match(PostgreSQLParserEXCLUSIVE) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_nowaitContext is an interface to support dynamic dispatch. type IOpt_nowaitContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NOWAIT() antlr.TerminalNode // IsOpt_nowaitContext differentiates from other interfaces. IsOpt_nowaitContext() } type Opt_nowaitContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_nowaitContext() *Opt_nowaitContext { var p = new(Opt_nowaitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_nowait return p } func InitEmptyOpt_nowaitContext(p *Opt_nowaitContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_nowait } func (*Opt_nowaitContext) IsOpt_nowaitContext() {} func NewOpt_nowaitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_nowaitContext { var p = new(Opt_nowaitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_nowait return p } func (s *Opt_nowaitContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_nowaitContext) NOWAIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOWAIT, 0) } func (s *Opt_nowaitContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_nowaitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_nowaitContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_nowait(s) } } func (s *Opt_nowaitContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_nowait(s) } } func (s *Opt_nowaitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_nowait(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_nowait() (localctx IOpt_nowaitContext) { localctx = NewOpt_nowaitContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 938, PostgreSQLParserRULE_opt_nowait) p.SetState(7850) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserNOWAIT: p.EnterOuterAlt(localctx, 1) { p.SetState(7848) p.Match(PostgreSQLParserNOWAIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_nowait_or_skipContext is an interface to support dynamic dispatch. type IOpt_nowait_or_skipContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NOWAIT() antlr.TerminalNode SKIP_P() antlr.TerminalNode LOCKED() antlr.TerminalNode // IsOpt_nowait_or_skipContext differentiates from other interfaces. IsOpt_nowait_or_skipContext() } type Opt_nowait_or_skipContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_nowait_or_skipContext() *Opt_nowait_or_skipContext { var p = new(Opt_nowait_or_skipContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_nowait_or_skip return p } func InitEmptyOpt_nowait_or_skipContext(p *Opt_nowait_or_skipContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_nowait_or_skip } func (*Opt_nowait_or_skipContext) IsOpt_nowait_or_skipContext() {} func NewOpt_nowait_or_skipContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_nowait_or_skipContext { var p = new(Opt_nowait_or_skipContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_nowait_or_skip return p } func (s *Opt_nowait_or_skipContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_nowait_or_skipContext) NOWAIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOWAIT, 0) } func (s *Opt_nowait_or_skipContext) SKIP_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSKIP_P, 0) } func (s *Opt_nowait_or_skipContext) LOCKED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCKED, 0) } func (s *Opt_nowait_or_skipContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_nowait_or_skipContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_nowait_or_skipContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_nowait_or_skip(s) } } func (s *Opt_nowait_or_skipContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_nowait_or_skip(s) } } func (s *Opt_nowait_or_skipContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_nowait_or_skip(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_nowait_or_skip() (localctx IOpt_nowait_or_skipContext) { localctx = NewOpt_nowait_or_skipContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 940, PostgreSQLParserRULE_opt_nowait_or_skip) p.SetState(7856) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserNOWAIT: p.EnterOuterAlt(localctx, 1) { p.SetState(7852) p.Match(PostgreSQLParserNOWAIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSKIP_P: p.EnterOuterAlt(localctx, 2) { p.SetState(7853) p.Match(PostgreSQLParserSKIP_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7854) p.Match(PostgreSQLParserLOCKED) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 3) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IUpdatestmtContext is an interface to support dynamic dispatch. type IUpdatestmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_with_clause() IOpt_with_clauseContext UPDATE() antlr.TerminalNode Relation_expr_opt_alias() IRelation_expr_opt_aliasContext SET() antlr.TerminalNode Set_clause_list() ISet_clause_listContext From_clause() IFrom_clauseContext Where_or_current_clause() IWhere_or_current_clauseContext Returning_clause() IReturning_clauseContext // IsUpdatestmtContext differentiates from other interfaces. IsUpdatestmtContext() } type UpdatestmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyUpdatestmtContext() *UpdatestmtContext { var p = new(UpdatestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_updatestmt return p } func InitEmptyUpdatestmtContext(p *UpdatestmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_updatestmt } func (*UpdatestmtContext) IsUpdatestmtContext() {} func NewUpdatestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdatestmtContext { var p = new(UpdatestmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_updatestmt return p } func (s *UpdatestmtContext) GetParser() antlr.Parser { return s.parser } func (s *UpdatestmtContext) Opt_with_clause() IOpt_with_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_with_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_with_clauseContext) } func (s *UpdatestmtContext) UPDATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUPDATE, 0) } func (s *UpdatestmtContext) Relation_expr_opt_alias() IRelation_expr_opt_aliasContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_expr_opt_aliasContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRelation_expr_opt_aliasContext) } func (s *UpdatestmtContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *UpdatestmtContext) Set_clause_list() ISet_clause_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISet_clause_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISet_clause_listContext) } func (s *UpdatestmtContext) From_clause() IFrom_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFrom_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFrom_clauseContext) } func (s *UpdatestmtContext) Where_or_current_clause() IWhere_or_current_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWhere_or_current_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWhere_or_current_clauseContext) } func (s *UpdatestmtContext) Returning_clause() IReturning_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReturning_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReturning_clauseContext) } func (s *UpdatestmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *UpdatestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *UpdatestmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterUpdatestmt(s) } } func (s *UpdatestmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitUpdatestmt(s) } } func (s *UpdatestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitUpdatestmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Updatestmt() (localctx IUpdatestmtContext) { localctx = NewUpdatestmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 942, PostgreSQLParserRULE_updatestmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7858) p.Opt_with_clause() } { p.SetState(7859) p.Match(PostgreSQLParserUPDATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7860) p.Relation_expr_opt_alias() } { p.SetState(7861) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7862) p.Set_clause_list() } { p.SetState(7863) p.From_clause() } { p.SetState(7864) p.Where_or_current_clause() } { p.SetState(7865) p.Returning_clause() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISet_clause_listContext is an interface to support dynamic dispatch. type ISet_clause_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllSet_clause() []ISet_clauseContext Set_clause(i int) ISet_clauseContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsSet_clause_listContext differentiates from other interfaces. IsSet_clause_listContext() } type Set_clause_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySet_clause_listContext() *Set_clause_listContext { var p = new(Set_clause_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_set_clause_list return p } func InitEmptySet_clause_listContext(p *Set_clause_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_set_clause_list } func (*Set_clause_listContext) IsSet_clause_listContext() {} func NewSet_clause_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_clause_listContext { var p = new(Set_clause_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_set_clause_list return p } func (s *Set_clause_listContext) GetParser() antlr.Parser { return s.parser } func (s *Set_clause_listContext) AllSet_clause() []ISet_clauseContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISet_clauseContext); ok { len++ } } tst := make([]ISet_clauseContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISet_clauseContext); ok { tst[i] = t.(ISet_clauseContext) i++ } } return tst } func (s *Set_clause_listContext) Set_clause(i int) ISet_clauseContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISet_clauseContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISet_clauseContext) } func (s *Set_clause_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Set_clause_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Set_clause_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Set_clause_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Set_clause_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSet_clause_list(s) } } func (s *Set_clause_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSet_clause_list(s) } } func (s *Set_clause_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSet_clause_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Set_clause_list() (localctx ISet_clause_listContext) { localctx = NewSet_clause_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 944, PostgreSQLParserRULE_set_clause_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7867) p.Set_clause() } p.SetState(7872) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(7868) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7869) p.Set_clause() } p.SetState(7874) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISet_clauseContext is an interface to support dynamic dispatch. type ISet_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Set_target() ISet_targetContext EQUAL() antlr.TerminalNode A_expr() IA_exprContext OPEN_PAREN() antlr.TerminalNode Set_target_list() ISet_target_listContext CLOSE_PAREN() antlr.TerminalNode // IsSet_clauseContext differentiates from other interfaces. IsSet_clauseContext() } type Set_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySet_clauseContext() *Set_clauseContext { var p = new(Set_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_set_clause return p } func InitEmptySet_clauseContext(p *Set_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_set_clause } func (*Set_clauseContext) IsSet_clauseContext() {} func NewSet_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_clauseContext { var p = new(Set_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_set_clause return p } func (s *Set_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Set_clauseContext) Set_target() ISet_targetContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISet_targetContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISet_targetContext) } func (s *Set_clauseContext) EQUAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEQUAL, 0) } func (s *Set_clauseContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Set_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Set_clauseContext) Set_target_list() ISet_target_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISet_target_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISet_target_listContext) } func (s *Set_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Set_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Set_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Set_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSet_clause(s) } } func (s *Set_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSet_clause(s) } } func (s *Set_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSet_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Set_clause() (localctx ISet_clauseContext) { localctx = NewSet_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 946, PostgreSQLParserRULE_set_clause) p.SetState(7885) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(7875) p.Set_target() } { p.SetState(7876) p.Match(PostgreSQLParserEQUAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7877) p.A_expr() } case PostgreSQLParserOPEN_PAREN: p.EnterOuterAlt(localctx, 2) { p.SetState(7879) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7880) p.Set_target_list() } { p.SetState(7881) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7882) p.Match(PostgreSQLParserEQUAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7883) p.A_expr() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISet_targetContext is an interface to support dynamic dispatch. type ISet_targetContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext Opt_indirection() IOpt_indirectionContext // IsSet_targetContext differentiates from other interfaces. IsSet_targetContext() } type Set_targetContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySet_targetContext() *Set_targetContext { var p = new(Set_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_set_target return p } func InitEmptySet_targetContext(p *Set_targetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_set_target } func (*Set_targetContext) IsSet_targetContext() {} func NewSet_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_targetContext { var p = new(Set_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_set_target return p } func (s *Set_targetContext) GetParser() antlr.Parser { return s.parser } func (s *Set_targetContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Set_targetContext) Opt_indirection() IOpt_indirectionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_indirectionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_indirectionContext) } func (s *Set_targetContext) GetRuleContext() antlr.RuleContext { return s } func (s *Set_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Set_targetContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSet_target(s) } } func (s *Set_targetContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSet_target(s) } } func (s *Set_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSet_target(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Set_target() (localctx ISet_targetContext) { localctx = NewSet_targetContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 948, PostgreSQLParserRULE_set_target) p.EnterOuterAlt(localctx, 1) { p.SetState(7887) p.Colid() } { p.SetState(7888) p.Opt_indirection() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISet_target_listContext is an interface to support dynamic dispatch. type ISet_target_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllSet_target() []ISet_targetContext Set_target(i int) ISet_targetContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsSet_target_listContext differentiates from other interfaces. IsSet_target_listContext() } type Set_target_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySet_target_listContext() *Set_target_listContext { var p = new(Set_target_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_set_target_list return p } func InitEmptySet_target_listContext(p *Set_target_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_set_target_list } func (*Set_target_listContext) IsSet_target_listContext() {} func NewSet_target_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_target_listContext { var p = new(Set_target_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_set_target_list return p } func (s *Set_target_listContext) GetParser() antlr.Parser { return s.parser } func (s *Set_target_listContext) AllSet_target() []ISet_targetContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISet_targetContext); ok { len++ } } tst := make([]ISet_targetContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISet_targetContext); ok { tst[i] = t.(ISet_targetContext) i++ } } return tst } func (s *Set_target_listContext) Set_target(i int) ISet_targetContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISet_targetContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISet_targetContext) } func (s *Set_target_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Set_target_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Set_target_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Set_target_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Set_target_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSet_target_list(s) } } func (s *Set_target_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSet_target_list(s) } } func (s *Set_target_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSet_target_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Set_target_list() (localctx ISet_target_listContext) { localctx = NewSet_target_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 950, PostgreSQLParserRULE_set_target_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7890) p.Set_target() } p.SetState(7895) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(7891) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7892) p.Set_target() } p.SetState(7897) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDeclarecursorstmtContext is an interface to support dynamic dispatch. type IDeclarecursorstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DECLARE() antlr.TerminalNode Cursor_name() ICursor_nameContext Cursor_options() ICursor_optionsContext CURSOR() antlr.TerminalNode Opt_hold() IOpt_holdContext FOR() antlr.TerminalNode Selectstmt() ISelectstmtContext // IsDeclarecursorstmtContext differentiates from other interfaces. IsDeclarecursorstmtContext() } type DeclarecursorstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDeclarecursorstmtContext() *DeclarecursorstmtContext { var p = new(DeclarecursorstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_declarecursorstmt return p } func InitEmptyDeclarecursorstmtContext(p *DeclarecursorstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_declarecursorstmt } func (*DeclarecursorstmtContext) IsDeclarecursorstmtContext() {} func NewDeclarecursorstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclarecursorstmtContext { var p = new(DeclarecursorstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_declarecursorstmt return p } func (s *DeclarecursorstmtContext) GetParser() antlr.Parser { return s.parser } func (s *DeclarecursorstmtContext) DECLARE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDECLARE, 0) } func (s *DeclarecursorstmtContext) Cursor_name() ICursor_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICursor_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICursor_nameContext) } func (s *DeclarecursorstmtContext) Cursor_options() ICursor_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICursor_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICursor_optionsContext) } func (s *DeclarecursorstmtContext) CURSOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURSOR, 0) } func (s *DeclarecursorstmtContext) Opt_hold() IOpt_holdContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_holdContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_holdContext) } func (s *DeclarecursorstmtContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *DeclarecursorstmtContext) Selectstmt() ISelectstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectstmtContext) } func (s *DeclarecursorstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *DeclarecursorstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *DeclarecursorstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDeclarecursorstmt(s) } } func (s *DeclarecursorstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDeclarecursorstmt(s) } } func (s *DeclarecursorstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDeclarecursorstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Declarecursorstmt() (localctx IDeclarecursorstmtContext) { localctx = NewDeclarecursorstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 952, PostgreSQLParserRULE_declarecursorstmt) p.EnterOuterAlt(localctx, 1) { p.SetState(7898) p.Match(PostgreSQLParserDECLARE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7899) p.Cursor_name() } { p.SetState(7900) p.Cursor_options() } { p.SetState(7901) p.Match(PostgreSQLParserCURSOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7902) p.Opt_hold() } { p.SetState(7903) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7904) p.Selectstmt() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICursor_nameContext is an interface to support dynamic dispatch. type ICursor_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Name() INameContext // IsCursor_nameContext differentiates from other interfaces. IsCursor_nameContext() } type Cursor_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCursor_nameContext() *Cursor_nameContext { var p = new(Cursor_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_cursor_name return p } func InitEmptyCursor_nameContext(p *Cursor_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_cursor_name } func (*Cursor_nameContext) IsCursor_nameContext() {} func NewCursor_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_nameContext { var p = new(Cursor_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_cursor_name return p } func (s *Cursor_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Cursor_nameContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *Cursor_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Cursor_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Cursor_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCursor_name(s) } } func (s *Cursor_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCursor_name(s) } } func (s *Cursor_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCursor_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Cursor_name() (localctx ICursor_nameContext) { localctx = NewCursor_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 954, PostgreSQLParserRULE_cursor_name) p.EnterOuterAlt(localctx, 1) { p.SetState(7906) p.Name() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICursor_optionsContext is an interface to support dynamic dispatch. type ICursor_optionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllNO() []antlr.TerminalNode NO(i int) antlr.TerminalNode AllSCROLL() []antlr.TerminalNode SCROLL(i int) antlr.TerminalNode AllBINARY() []antlr.TerminalNode BINARY(i int) antlr.TerminalNode AllINSENSITIVE() []antlr.TerminalNode INSENSITIVE(i int) antlr.TerminalNode // IsCursor_optionsContext differentiates from other interfaces. IsCursor_optionsContext() } type Cursor_optionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCursor_optionsContext() *Cursor_optionsContext { var p = new(Cursor_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_cursor_options return p } func InitEmptyCursor_optionsContext(p *Cursor_optionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_cursor_options } func (*Cursor_optionsContext) IsCursor_optionsContext() {} func NewCursor_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_optionsContext { var p = new(Cursor_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_cursor_options return p } func (s *Cursor_optionsContext) GetParser() antlr.Parser { return s.parser } func (s *Cursor_optionsContext) AllNO() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserNO) } func (s *Cursor_optionsContext) NO(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, i) } func (s *Cursor_optionsContext) AllSCROLL() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserSCROLL) } func (s *Cursor_optionsContext) SCROLL(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCROLL, i) } func (s *Cursor_optionsContext) AllBINARY() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserBINARY) } func (s *Cursor_optionsContext) BINARY(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserBINARY, i) } func (s *Cursor_optionsContext) AllINSENSITIVE() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserINSENSITIVE) } func (s *Cursor_optionsContext) INSENSITIVE(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserINSENSITIVE, i) } func (s *Cursor_optionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Cursor_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Cursor_optionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCursor_options(s) } } func (s *Cursor_optionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCursor_options(s) } } func (s *Cursor_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCursor_options(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Cursor_options() (localctx ICursor_optionsContext) { localctx = NewCursor_optionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 956, PostgreSQLParserRULE_cursor_options) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(7915) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserBINARY || _la == PostgreSQLParserINSENSITIVE || _la == PostgreSQLParserNO || _la == PostgreSQLParserSCROLL { p.SetState(7913) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserNO: { p.SetState(7908) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7909) p.Match(PostgreSQLParserSCROLL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSCROLL: { p.SetState(7910) p.Match(PostgreSQLParserSCROLL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserBINARY: { p.SetState(7911) p.Match(PostgreSQLParserBINARY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserINSENSITIVE: { p.SetState(7912) p.Match(PostgreSQLParserINSENSITIVE) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.SetState(7917) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_holdContext is an interface to support dynamic dispatch. type IOpt_holdContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITH() antlr.TerminalNode HOLD() antlr.TerminalNode WITHOUT() antlr.TerminalNode // IsOpt_holdContext differentiates from other interfaces. IsOpt_holdContext() } type Opt_holdContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_holdContext() *Opt_holdContext { var p = new(Opt_holdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_hold return p } func InitEmptyOpt_holdContext(p *Opt_holdContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_hold } func (*Opt_holdContext) IsOpt_holdContext() {} func NewOpt_holdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_holdContext { var p = new(Opt_holdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_hold return p } func (s *Opt_holdContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_holdContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *Opt_holdContext) HOLD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserHOLD, 0) } func (s *Opt_holdContext) WITHOUT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITHOUT, 0) } func (s *Opt_holdContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_holdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_holdContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_hold(s) } } func (s *Opt_holdContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_hold(s) } } func (s *Opt_holdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_hold(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_hold() (localctx IOpt_holdContext) { localctx = NewOpt_holdContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 958, PostgreSQLParserRULE_opt_hold) p.SetState(7923) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFOR: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserWITH: p.EnterOuterAlt(localctx, 2) { p.SetState(7919) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7920) p.Match(PostgreSQLParserHOLD) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserWITHOUT: p.EnterOuterAlt(localctx, 3) { p.SetState(7921) p.Match(PostgreSQLParserWITHOUT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7922) p.Match(PostgreSQLParserHOLD) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISelectstmtContext is an interface to support dynamic dispatch. type ISelectstmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Select_no_parens() ISelect_no_parensContext Select_with_parens() ISelect_with_parensContext // IsSelectstmtContext differentiates from other interfaces. IsSelectstmtContext() } type SelectstmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySelectstmtContext() *SelectstmtContext { var p = new(SelectstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_selectstmt return p } func InitEmptySelectstmtContext(p *SelectstmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_selectstmt } func (*SelectstmtContext) IsSelectstmtContext() {} func NewSelectstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectstmtContext { var p = new(SelectstmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_selectstmt return p } func (s *SelectstmtContext) GetParser() antlr.Parser { return s.parser } func (s *SelectstmtContext) Select_no_parens() ISelect_no_parensContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_no_parensContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_no_parensContext) } func (s *SelectstmtContext) Select_with_parens() ISelect_with_parensContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_with_parensContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_with_parensContext) } func (s *SelectstmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *SelectstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SelectstmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSelectstmt(s) } } func (s *SelectstmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSelectstmt(s) } } func (s *SelectstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSelectstmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Selectstmt() (localctx ISelectstmtContext) { localctx = NewSelectstmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 960, PostgreSQLParserRULE_selectstmt) p.SetState(7927) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 416, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7925) p.Select_no_parens() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7926) p.Select_with_parens() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISelect_with_parensContext is an interface to support dynamic dispatch. type ISelect_with_parensContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Select_no_parens() ISelect_no_parensContext CLOSE_PAREN() antlr.TerminalNode Select_with_parens() ISelect_with_parensContext // IsSelect_with_parensContext differentiates from other interfaces. IsSelect_with_parensContext() } type Select_with_parensContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySelect_with_parensContext() *Select_with_parensContext { var p = new(Select_with_parensContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_select_with_parens return p } func InitEmptySelect_with_parensContext(p *Select_with_parensContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_select_with_parens } func (*Select_with_parensContext) IsSelect_with_parensContext() {} func NewSelect_with_parensContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_with_parensContext { var p = new(Select_with_parensContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_select_with_parens return p } func (s *Select_with_parensContext) GetParser() antlr.Parser { return s.parser } func (s *Select_with_parensContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Select_with_parensContext) Select_no_parens() ISelect_no_parensContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_no_parensContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_no_parensContext) } func (s *Select_with_parensContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Select_with_parensContext) Select_with_parens() ISelect_with_parensContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_with_parensContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_with_parensContext) } func (s *Select_with_parensContext) GetRuleContext() antlr.RuleContext { return s } func (s *Select_with_parensContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Select_with_parensContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSelect_with_parens(s) } } func (s *Select_with_parensContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSelect_with_parens(s) } } func (s *Select_with_parensContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSelect_with_parens(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Select_with_parens() (localctx ISelect_with_parensContext) { localctx = NewSelect_with_parensContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 962, PostgreSQLParserRULE_select_with_parens) p.SetState(7937) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 417, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(7929) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7930) p.Select_no_parens() } { p.SetState(7931) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(7933) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7934) p.Select_with_parens() } { p.SetState(7935) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISelect_no_parensContext is an interface to support dynamic dispatch. type ISelect_no_parensContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Select_clause() ISelect_clauseContext Opt_sort_clause() IOpt_sort_clauseContext For_locking_clause() IFor_locking_clauseContext Opt_select_limit() IOpt_select_limitContext Select_limit() ISelect_limitContext Opt_for_locking_clause() IOpt_for_locking_clauseContext With_clause() IWith_clauseContext // IsSelect_no_parensContext differentiates from other interfaces. IsSelect_no_parensContext() } type Select_no_parensContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySelect_no_parensContext() *Select_no_parensContext { var p = new(Select_no_parensContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_select_no_parens return p } func InitEmptySelect_no_parensContext(p *Select_no_parensContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_select_no_parens } func (*Select_no_parensContext) IsSelect_no_parensContext() {} func NewSelect_no_parensContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_no_parensContext { var p = new(Select_no_parensContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_select_no_parens return p } func (s *Select_no_parensContext) GetParser() antlr.Parser { return s.parser } func (s *Select_no_parensContext) Select_clause() ISelect_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_clauseContext) } func (s *Select_no_parensContext) Opt_sort_clause() IOpt_sort_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_sort_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_sort_clauseContext) } func (s *Select_no_parensContext) For_locking_clause() IFor_locking_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFor_locking_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFor_locking_clauseContext) } func (s *Select_no_parensContext) Opt_select_limit() IOpt_select_limitContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_select_limitContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_select_limitContext) } func (s *Select_no_parensContext) Select_limit() ISelect_limitContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_limitContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_limitContext) } func (s *Select_no_parensContext) Opt_for_locking_clause() IOpt_for_locking_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_for_locking_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_for_locking_clauseContext) } func (s *Select_no_parensContext) With_clause() IWith_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWith_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWith_clauseContext) } func (s *Select_no_parensContext) GetRuleContext() antlr.RuleContext { return s } func (s *Select_no_parensContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Select_no_parensContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSelect_no_parens(s) } } func (s *Select_no_parensContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSelect_no_parens(s) } } func (s *Select_no_parensContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSelect_no_parens(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Select_no_parens() (localctx ISelect_no_parensContext) { localctx = NewSelect_no_parensContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 964, PostgreSQLParserRULE_select_no_parens) p.SetState(7960) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserVALUES: p.EnterOuterAlt(localctx, 1) { p.SetState(7939) p.Select_clause() } { p.SetState(7940) p.Opt_sort_clause() } p.SetState(7947) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 418, p.GetParserRuleContext()) == 1 { { p.SetState(7941) p.For_locking_clause() } { p.SetState(7942) p.Opt_select_limit() } } else if p.HasError() { // JIM goto errorExit } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 418, p.GetParserRuleContext()) == 2 { { p.SetState(7944) p.Select_limit() } { p.SetState(7945) p.Opt_for_locking_clause() } } else if p.HasError() { // JIM goto errorExit } case PostgreSQLParserWITH: p.EnterOuterAlt(localctx, 2) { p.SetState(7949) p.With_clause() } { p.SetState(7950) p.Select_clause() } { p.SetState(7951) p.Opt_sort_clause() } p.SetState(7958) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 419, p.GetParserRuleContext()) == 1 { { p.SetState(7952) p.For_locking_clause() } { p.SetState(7953) p.Opt_select_limit() } } else if p.HasError() { // JIM goto errorExit } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 419, p.GetParserRuleContext()) == 2 { { p.SetState(7955) p.Select_limit() } { p.SetState(7956) p.Opt_for_locking_clause() } } else if p.HasError() { // JIM goto errorExit } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISelect_clauseContext is an interface to support dynamic dispatch. type ISelect_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllSimple_select_intersect() []ISimple_select_intersectContext Simple_select_intersect(i int) ISimple_select_intersectContext AllAll_or_distinct() []IAll_or_distinctContext All_or_distinct(i int) IAll_or_distinctContext AllUNION() []antlr.TerminalNode UNION(i int) antlr.TerminalNode AllEXCEPT() []antlr.TerminalNode EXCEPT(i int) antlr.TerminalNode // IsSelect_clauseContext differentiates from other interfaces. IsSelect_clauseContext() } type Select_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySelect_clauseContext() *Select_clauseContext { var p = new(Select_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_select_clause return p } func InitEmptySelect_clauseContext(p *Select_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_select_clause } func (*Select_clauseContext) IsSelect_clauseContext() {} func NewSelect_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_clauseContext { var p = new(Select_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_select_clause return p } func (s *Select_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Select_clauseContext) AllSimple_select_intersect() []ISimple_select_intersectContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISimple_select_intersectContext); ok { len++ } } tst := make([]ISimple_select_intersectContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISimple_select_intersectContext); ok { tst[i] = t.(ISimple_select_intersectContext) i++ } } return tst } func (s *Select_clauseContext) Simple_select_intersect(i int) ISimple_select_intersectContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISimple_select_intersectContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISimple_select_intersectContext) } func (s *Select_clauseContext) AllAll_or_distinct() []IAll_or_distinctContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAll_or_distinctContext); ok { len++ } } tst := make([]IAll_or_distinctContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAll_or_distinctContext); ok { tst[i] = t.(IAll_or_distinctContext) i++ } } return tst } func (s *Select_clauseContext) All_or_distinct(i int) IAll_or_distinctContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAll_or_distinctContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAll_or_distinctContext) } func (s *Select_clauseContext) AllUNION() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserUNION) } func (s *Select_clauseContext) UNION(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNION, i) } func (s *Select_clauseContext) AllEXCEPT() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserEXCEPT) } func (s *Select_clauseContext) EXCEPT(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXCEPT, i) } func (s *Select_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Select_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Select_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSelect_clause(s) } } func (s *Select_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSelect_clause(s) } } func (s *Select_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSelect_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Select_clause() (localctx ISelect_clauseContext) { localctx = NewSelect_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 966, PostgreSQLParserRULE_select_clause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7962) p.Simple_select_intersect() } p.SetState(7969) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserEXCEPT || _la == PostgreSQLParserUNION { { p.SetState(7963) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserEXCEPT || _la == PostgreSQLParserUNION) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(7964) p.All_or_distinct() } { p.SetState(7965) p.Simple_select_intersect() } p.SetState(7971) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISimple_select_intersectContext is an interface to support dynamic dispatch. type ISimple_select_intersectContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllSimple_select_pramary() []ISimple_select_pramaryContext Simple_select_pramary(i int) ISimple_select_pramaryContext AllINTERSECT() []antlr.TerminalNode INTERSECT(i int) antlr.TerminalNode AllAll_or_distinct() []IAll_or_distinctContext All_or_distinct(i int) IAll_or_distinctContext // IsSimple_select_intersectContext differentiates from other interfaces. IsSimple_select_intersectContext() } type Simple_select_intersectContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySimple_select_intersectContext() *Simple_select_intersectContext { var p = new(Simple_select_intersectContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_simple_select_intersect return p } func InitEmptySimple_select_intersectContext(p *Simple_select_intersectContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_simple_select_intersect } func (*Simple_select_intersectContext) IsSimple_select_intersectContext() {} func NewSimple_select_intersectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_select_intersectContext { var p = new(Simple_select_intersectContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_simple_select_intersect return p } func (s *Simple_select_intersectContext) GetParser() antlr.Parser { return s.parser } func (s *Simple_select_intersectContext) AllSimple_select_pramary() []ISimple_select_pramaryContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISimple_select_pramaryContext); ok { len++ } } tst := make([]ISimple_select_pramaryContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISimple_select_pramaryContext); ok { tst[i] = t.(ISimple_select_pramaryContext) i++ } } return tst } func (s *Simple_select_intersectContext) Simple_select_pramary(i int) ISimple_select_pramaryContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISimple_select_pramaryContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISimple_select_pramaryContext) } func (s *Simple_select_intersectContext) AllINTERSECT() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserINTERSECT) } func (s *Simple_select_intersectContext) INTERSECT(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserINTERSECT, i) } func (s *Simple_select_intersectContext) AllAll_or_distinct() []IAll_or_distinctContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IAll_or_distinctContext); ok { len++ } } tst := make([]IAll_or_distinctContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IAll_or_distinctContext); ok { tst[i] = t.(IAll_or_distinctContext) i++ } } return tst } func (s *Simple_select_intersectContext) All_or_distinct(i int) IAll_or_distinctContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAll_or_distinctContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IAll_or_distinctContext) } func (s *Simple_select_intersectContext) GetRuleContext() antlr.RuleContext { return s } func (s *Simple_select_intersectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Simple_select_intersectContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSimple_select_intersect(s) } } func (s *Simple_select_intersectContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSimple_select_intersect(s) } } func (s *Simple_select_intersectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSimple_select_intersect(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Simple_select_intersect() (localctx ISimple_select_intersectContext) { localctx = NewSimple_select_intersectContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 968, PostgreSQLParserRULE_simple_select_intersect) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7972) p.Simple_select_pramary() } p.SetState(7979) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserINTERSECT { { p.SetState(7973) p.Match(PostgreSQLParserINTERSECT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(7974) p.All_or_distinct() } { p.SetState(7975) p.Simple_select_pramary() } p.SetState(7981) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISimple_select_pramaryContext is an interface to support dynamic dispatch. type ISimple_select_pramaryContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SELECT() antlr.TerminalNode AllInto_clause() []IInto_clauseContext Into_clause(i int) IInto_clauseContext From_clause() IFrom_clauseContext Where_clause() IWhere_clauseContext Group_clause() IGroup_clauseContext Having_clause() IHaving_clauseContext Window_clause() IWindow_clauseContext Opt_all_clause() IOpt_all_clauseContext Opt_target_list() IOpt_target_listContext Distinct_clause() IDistinct_clauseContext Target_list() ITarget_listContext Values_clause() IValues_clauseContext TABLE() antlr.TerminalNode Relation_expr() IRelation_exprContext Select_with_parens() ISelect_with_parensContext // IsSimple_select_pramaryContext differentiates from other interfaces. IsSimple_select_pramaryContext() } type Simple_select_pramaryContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySimple_select_pramaryContext() *Simple_select_pramaryContext { var p = new(Simple_select_pramaryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_simple_select_pramary return p } func InitEmptySimple_select_pramaryContext(p *Simple_select_pramaryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_simple_select_pramary } func (*Simple_select_pramaryContext) IsSimple_select_pramaryContext() {} func NewSimple_select_pramaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_select_pramaryContext { var p = new(Simple_select_pramaryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_simple_select_pramary return p } func (s *Simple_select_pramaryContext) GetParser() antlr.Parser { return s.parser } func (s *Simple_select_pramaryContext) SELECT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSELECT, 0) } func (s *Simple_select_pramaryContext) AllInto_clause() []IInto_clauseContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IInto_clauseContext); ok { len++ } } tst := make([]IInto_clauseContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IInto_clauseContext); ok { tst[i] = t.(IInto_clauseContext) i++ } } return tst } func (s *Simple_select_pramaryContext) Into_clause(i int) IInto_clauseContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInto_clauseContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IInto_clauseContext) } func (s *Simple_select_pramaryContext) From_clause() IFrom_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFrom_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFrom_clauseContext) } func (s *Simple_select_pramaryContext) Where_clause() IWhere_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWhere_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWhere_clauseContext) } func (s *Simple_select_pramaryContext) Group_clause() IGroup_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGroup_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGroup_clauseContext) } func (s *Simple_select_pramaryContext) Having_clause() IHaving_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IHaving_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IHaving_clauseContext) } func (s *Simple_select_pramaryContext) Window_clause() IWindow_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWindow_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWindow_clauseContext) } func (s *Simple_select_pramaryContext) Opt_all_clause() IOpt_all_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_all_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_all_clauseContext) } func (s *Simple_select_pramaryContext) Opt_target_list() IOpt_target_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_target_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_target_listContext) } func (s *Simple_select_pramaryContext) Distinct_clause() IDistinct_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDistinct_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDistinct_clauseContext) } func (s *Simple_select_pramaryContext) Target_list() ITarget_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITarget_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITarget_listContext) } func (s *Simple_select_pramaryContext) Values_clause() IValues_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IValues_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IValues_clauseContext) } func (s *Simple_select_pramaryContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *Simple_select_pramaryContext) Relation_expr() IRelation_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRelation_exprContext) } func (s *Simple_select_pramaryContext) Select_with_parens() ISelect_with_parensContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_with_parensContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_with_parensContext) } func (s *Simple_select_pramaryContext) GetRuleContext() antlr.RuleContext { return s } func (s *Simple_select_pramaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Simple_select_pramaryContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSimple_select_pramary(s) } } func (s *Simple_select_pramaryContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSimple_select_pramary(s) } } func (s *Simple_select_pramaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSimple_select_pramary(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Simple_select_pramary() (localctx ISimple_select_pramaryContext) { localctx = NewSimple_select_pramaryContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 970, PostgreSQLParserRULE_simple_select_pramary) p.SetState(8003) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSELECT: p.EnterOuterAlt(localctx, 1) { p.SetState(7982) p.Match(PostgreSQLParserSELECT) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(7990) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserSTAR, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserALL, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserFROM, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNION, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserWHERE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMERGE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserLOOP, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserMetaCommand, PostgreSQLParserEscapeStringConstant: { p.SetState(7983) p.Opt_all_clause() } { p.SetState(7984) p.Into_clause() } { p.SetState(7985) p.Opt_target_list() } case PostgreSQLParserDISTINCT: { p.SetState(7987) p.Distinct_clause() } { p.SetState(7988) p.Target_list() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } { p.SetState(7992) p.Into_clause() } { p.SetState(7993) p.From_clause() } { p.SetState(7994) p.Where_clause() } { p.SetState(7995) p.Group_clause() } { p.SetState(7996) p.Having_clause() } { p.SetState(7997) p.Window_clause() } case PostgreSQLParserVALUES: p.EnterOuterAlt(localctx, 2) { p.SetState(7999) p.Values_clause() } case PostgreSQLParserTABLE: p.EnterOuterAlt(localctx, 3) { p.SetState(8000) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8001) p.Relation_expr() } case PostgreSQLParserOPEN_PAREN: p.EnterOuterAlt(localctx, 4) { p.SetState(8002) p.Select_with_parens() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IWith_clauseContext is an interface to support dynamic dispatch. type IWith_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITH() antlr.TerminalNode Cte_list() ICte_listContext RECURSIVE() antlr.TerminalNode // IsWith_clauseContext differentiates from other interfaces. IsWith_clauseContext() } type With_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyWith_clauseContext() *With_clauseContext { var p = new(With_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_with_clause return p } func InitEmptyWith_clauseContext(p *With_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_with_clause } func (*With_clauseContext) IsWith_clauseContext() {} func NewWith_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_clauseContext { var p = new(With_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_with_clause return p } func (s *With_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *With_clauseContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *With_clauseContext) Cte_list() ICte_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICte_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICte_listContext) } func (s *With_clauseContext) RECURSIVE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRECURSIVE, 0) } func (s *With_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *With_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *With_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterWith_clause(s) } } func (s *With_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitWith_clause(s) } } func (s *With_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitWith_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) With_clause() (localctx IWith_clauseContext) { localctx = NewWith_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 972, PostgreSQLParserRULE_with_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(8005) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8007) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 425, p.GetParserRuleContext()) == 1 { { p.SetState(8006) p.Match(PostgreSQLParserRECURSIVE) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(8009) p.Cte_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICte_listContext is an interface to support dynamic dispatch. type ICte_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllCommon_table_expr() []ICommon_table_exprContext Common_table_expr(i int) ICommon_table_exprContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsCte_listContext differentiates from other interfaces. IsCte_listContext() } type Cte_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCte_listContext() *Cte_listContext { var p = new(Cte_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_cte_list return p } func InitEmptyCte_listContext(p *Cte_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_cte_list } func (*Cte_listContext) IsCte_listContext() {} func NewCte_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cte_listContext { var p = new(Cte_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_cte_list return p } func (s *Cte_listContext) GetParser() antlr.Parser { return s.parser } func (s *Cte_listContext) AllCommon_table_expr() []ICommon_table_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ICommon_table_exprContext); ok { len++ } } tst := make([]ICommon_table_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ICommon_table_exprContext); ok { tst[i] = t.(ICommon_table_exprContext) i++ } } return tst } func (s *Cte_listContext) Common_table_expr(i int) ICommon_table_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICommon_table_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ICommon_table_exprContext) } func (s *Cte_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Cte_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Cte_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Cte_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Cte_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCte_list(s) } } func (s *Cte_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCte_list(s) } } func (s *Cte_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCte_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Cte_list() (localctx ICte_listContext) { localctx = NewCte_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 974, PostgreSQLParserRULE_cte_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8011) p.Common_table_expr() } p.SetState(8016) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(8012) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8013) p.Common_table_expr() } p.SetState(8018) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICommon_table_exprContext is an interface to support dynamic dispatch. type ICommon_table_exprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Name() INameContext Opt_name_list() IOpt_name_listContext AS() antlr.TerminalNode Opt_materialized() IOpt_materializedContext OPEN_PAREN() antlr.TerminalNode Preparablestmt() IPreparablestmtContext CLOSE_PAREN() antlr.TerminalNode // IsCommon_table_exprContext differentiates from other interfaces. IsCommon_table_exprContext() } type Common_table_exprContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCommon_table_exprContext() *Common_table_exprContext { var p = new(Common_table_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_common_table_expr return p } func InitEmptyCommon_table_exprContext(p *Common_table_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_common_table_expr } func (*Common_table_exprContext) IsCommon_table_exprContext() {} func NewCommon_table_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_table_exprContext { var p = new(Common_table_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_common_table_expr return p } func (s *Common_table_exprContext) GetParser() antlr.Parser { return s.parser } func (s *Common_table_exprContext) Name() INameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INameContext) } func (s *Common_table_exprContext) Opt_name_list() IOpt_name_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_name_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_name_listContext) } func (s *Common_table_exprContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Common_table_exprContext) Opt_materialized() IOpt_materializedContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_materializedContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_materializedContext) } func (s *Common_table_exprContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Common_table_exprContext) Preparablestmt() IPreparablestmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPreparablestmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPreparablestmtContext) } func (s *Common_table_exprContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Common_table_exprContext) GetRuleContext() antlr.RuleContext { return s } func (s *Common_table_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Common_table_exprContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCommon_table_expr(s) } } func (s *Common_table_exprContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCommon_table_expr(s) } } func (s *Common_table_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCommon_table_expr(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Common_table_expr() (localctx ICommon_table_exprContext) { localctx = NewCommon_table_exprContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 976, PostgreSQLParserRULE_common_table_expr) p.EnterOuterAlt(localctx, 1) { p.SetState(8019) p.Name() } { p.SetState(8020) p.Opt_name_list() } { p.SetState(8021) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8022) p.Opt_materialized() } { p.SetState(8023) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8024) p.Preparablestmt() } { p.SetState(8025) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_materializedContext is an interface to support dynamic dispatch. type IOpt_materializedContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures MATERIALIZED() antlr.TerminalNode NOT() antlr.TerminalNode // IsOpt_materializedContext differentiates from other interfaces. IsOpt_materializedContext() } type Opt_materializedContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_materializedContext() *Opt_materializedContext { var p = new(Opt_materializedContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_materialized return p } func InitEmptyOpt_materializedContext(p *Opt_materializedContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_materialized } func (*Opt_materializedContext) IsOpt_materializedContext() {} func NewOpt_materializedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_materializedContext { var p = new(Opt_materializedContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_materialized return p } func (s *Opt_materializedContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_materializedContext) MATERIALIZED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMATERIALIZED, 0) } func (s *Opt_materializedContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *Opt_materializedContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_materializedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_materializedContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_materialized(s) } } func (s *Opt_materializedContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_materialized(s) } } func (s *Opt_materializedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_materialized(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_materialized() (localctx IOpt_materializedContext) { localctx = NewOpt_materializedContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 978, PostgreSQLParserRULE_opt_materialized) p.SetState(8031) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserMATERIALIZED: p.EnterOuterAlt(localctx, 1) { p.SetState(8027) p.Match(PostgreSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserNOT: p.EnterOuterAlt(localctx, 2) { p.SetState(8028) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8029) p.Match(PostgreSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserOPEN_PAREN: p.EnterOuterAlt(localctx, 3) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_with_clauseContext is an interface to support dynamic dispatch. type IOpt_with_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures With_clause() IWith_clauseContext // IsOpt_with_clauseContext differentiates from other interfaces. IsOpt_with_clauseContext() } type Opt_with_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_with_clauseContext() *Opt_with_clauseContext { var p = new(Opt_with_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_with_clause return p } func InitEmptyOpt_with_clauseContext(p *Opt_with_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_with_clause } func (*Opt_with_clauseContext) IsOpt_with_clauseContext() {} func NewOpt_with_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_with_clauseContext { var p = new(Opt_with_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_with_clause return p } func (s *Opt_with_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_with_clauseContext) With_clause() IWith_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWith_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWith_clauseContext) } func (s *Opt_with_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_with_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_with_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_with_clause(s) } } func (s *Opt_with_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_with_clause(s) } } func (s *Opt_with_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_with_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_with_clause() (localctx IOpt_with_clauseContext) { localctx = NewOpt_with_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 980, PostgreSQLParserRULE_opt_with_clause) p.SetState(8035) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserWITH: p.EnterOuterAlt(localctx, 1) { p.SetState(8033) p.With_clause() } case PostgreSQLParserDELETE_P, PostgreSQLParserINSERT, PostgreSQLParserUPDATE: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IInto_clauseContext is an interface to support dynamic dispatch. type IInto_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures INTO() antlr.TerminalNode Opt_strict() IOpt_strictContext OpttempTableName() IOpttempTableNameContext Into_target() IInto_targetContext // IsInto_clauseContext differentiates from other interfaces. IsInto_clauseContext() } type Into_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyInto_clauseContext() *Into_clauseContext { var p = new(Into_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_into_clause return p } func InitEmptyInto_clauseContext(p *Into_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_into_clause } func (*Into_clauseContext) IsInto_clauseContext() {} func NewInto_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Into_clauseContext { var p = new(Into_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_into_clause return p } func (s *Into_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Into_clauseContext) INTO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINTO, 0) } func (s *Into_clauseContext) Opt_strict() IOpt_strictContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_strictContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_strictContext) } func (s *Into_clauseContext) OpttempTableName() IOpttempTableNameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpttempTableNameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpttempTableNameContext) } func (s *Into_clauseContext) Into_target() IInto_targetContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInto_targetContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IInto_targetContext) } func (s *Into_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Into_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Into_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterInto_clause(s) } } func (s *Into_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitInto_clause(s) } } func (s *Into_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitInto_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Into_clause() (localctx IInto_clauseContext) { localctx = NewInto_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 982, PostgreSQLParserRULE_into_clause) p.SetState(8045) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 430, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8037) p.Match(PostgreSQLParserINTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8042) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 429, p.GetParserRuleContext()) { case 1: { p.SetState(8038) p.Opt_strict() } { p.SetState(8039) p.OpttempTableName() } case 2: { p.SetState(8041) p.Into_target() } case antlr.ATNInvalidAltNumber: goto errorExit } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_strictContext is an interface to support dynamic dispatch. type IOpt_strictContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures STRICT_P() antlr.TerminalNode // IsOpt_strictContext differentiates from other interfaces. IsOpt_strictContext() } type Opt_strictContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_strictContext() *Opt_strictContext { var p = new(Opt_strictContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_strict return p } func InitEmptyOpt_strictContext(p *Opt_strictContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_strict } func (*Opt_strictContext) IsOpt_strictContext() {} func NewOpt_strictContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_strictContext { var p = new(Opt_strictContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_strict return p } func (s *Opt_strictContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_strictContext) STRICT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTRICT_P, 0) } func (s *Opt_strictContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_strictContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_strictContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_strict(s) } } func (s *Opt_strictContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_strict(s) } } func (s *Opt_strictContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_strict(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_strict() (localctx IOpt_strictContext) { localctx = NewOpt_strictContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 984, PostgreSQLParserRULE_opt_strict) p.SetState(8049) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 431, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(8048) p.Match(PostgreSQLParserSTRICT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpttempTableNameContext is an interface to support dynamic dispatch. type IOpttempTableNameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_table() IOpt_tableContext Qualified_name() IQualified_nameContext TEMPORARY() antlr.TerminalNode TEMP() antlr.TerminalNode LOCAL() antlr.TerminalNode GLOBAL() antlr.TerminalNode UNLOGGED() antlr.TerminalNode TABLE() antlr.TerminalNode // IsOpttempTableNameContext differentiates from other interfaces. IsOpttempTableNameContext() } type OpttempTableNameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpttempTableNameContext() *OpttempTableNameContext { var p = new(OpttempTableNameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opttempTableName return p } func InitEmptyOpttempTableNameContext(p *OpttempTableNameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opttempTableName } func (*OpttempTableNameContext) IsOpttempTableNameContext() {} func NewOpttempTableNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttempTableNameContext { var p = new(OpttempTableNameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opttempTableName return p } func (s *OpttempTableNameContext) GetParser() antlr.Parser { return s.parser } func (s *OpttempTableNameContext) Opt_table() IOpt_tableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_tableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_tableContext) } func (s *OpttempTableNameContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *OpttempTableNameContext) TEMPORARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEMPORARY, 0) } func (s *OpttempTableNameContext) TEMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEMP, 0) } func (s *OpttempTableNameContext) LOCAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCAL, 0) } func (s *OpttempTableNameContext) GLOBAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGLOBAL, 0) } func (s *OpttempTableNameContext) UNLOGGED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNLOGGED, 0) } func (s *OpttempTableNameContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *OpttempTableNameContext) GetRuleContext() antlr.RuleContext { return s } func (s *OpttempTableNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OpttempTableNameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpttempTableName(s) } } func (s *OpttempTableNameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpttempTableName(s) } } func (s *OpttempTableNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpttempTableName(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) OpttempTableName() (localctx IOpttempTableNameContext) { localctx = NewOpttempTableNameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 986, PostgreSQLParserRULE_opttempTableName) var _la int p.SetState(8065) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 433, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) p.SetState(8052) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserGLOBAL || _la == PostgreSQLParserLOCAL { { p.SetState(8051) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserGLOBAL || _la == PostgreSQLParserLOCAL) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } } { p.SetState(8054) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserTEMP || _la == PostgreSQLParserTEMPORARY) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(8055) p.Opt_table() } { p.SetState(8056) p.Qualified_name() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(8058) p.Match(PostgreSQLParserUNLOGGED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8059) p.Opt_table() } { p.SetState(8060) p.Qualified_name() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(8062) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8063) p.Qualified_name() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(8064) p.Qualified_name() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_tableContext is an interface to support dynamic dispatch. type IOpt_tableContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TABLE() antlr.TerminalNode // IsOpt_tableContext differentiates from other interfaces. IsOpt_tableContext() } type Opt_tableContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_tableContext() *Opt_tableContext { var p = new(Opt_tableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_table return p } func InitEmptyOpt_tableContext(p *Opt_tableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_table } func (*Opt_tableContext) IsOpt_tableContext() {} func NewOpt_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_tableContext { var p = new(Opt_tableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_table return p } func (s *Opt_tableContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_tableContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *Opt_tableContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_tableContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_table(s) } } func (s *Opt_tableContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_table(s) } } func (s *Opt_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_table(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_table() (localctx IOpt_tableContext) { localctx = NewOpt_tableContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 988, PostgreSQLParserRULE_opt_table) p.SetState(8069) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 434, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8067) p.Match(PostgreSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAll_or_distinctContext is an interface to support dynamic dispatch. type IAll_or_distinctContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALL() antlr.TerminalNode DISTINCT() antlr.TerminalNode // IsAll_or_distinctContext differentiates from other interfaces. IsAll_or_distinctContext() } type All_or_distinctContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAll_or_distinctContext() *All_or_distinctContext { var p = new(All_or_distinctContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_all_or_distinct return p } func InitEmptyAll_or_distinctContext(p *All_or_distinctContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_all_or_distinct } func (*All_or_distinctContext) IsAll_or_distinctContext() {} func NewAll_or_distinctContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_or_distinctContext { var p = new(All_or_distinctContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_all_or_distinct return p } func (s *All_or_distinctContext) GetParser() antlr.Parser { return s.parser } func (s *All_or_distinctContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *All_or_distinctContext) DISTINCT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDISTINCT, 0) } func (s *All_or_distinctContext) GetRuleContext() antlr.RuleContext { return s } func (s *All_or_distinctContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *All_or_distinctContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAll_or_distinct(s) } } func (s *All_or_distinctContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAll_or_distinct(s) } } func (s *All_or_distinctContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAll_or_distinct(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) All_or_distinct() (localctx IAll_or_distinctContext) { localctx = NewAll_or_distinctContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 990, PostgreSQLParserRULE_all_or_distinct) p.SetState(8074) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserALL: p.EnterOuterAlt(localctx, 1) { p.SetState(8071) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserDISTINCT: p.EnterOuterAlt(localctx, 2) { p.SetState(8072) p.Match(PostgreSQLParserDISTINCT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserOPEN_PAREN, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserVALUES: p.EnterOuterAlt(localctx, 3) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDistinct_clauseContext is an interface to support dynamic dispatch. type IDistinct_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DISTINCT() antlr.TerminalNode ON() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Expr_list() IExpr_listContext CLOSE_PAREN() antlr.TerminalNode // IsDistinct_clauseContext differentiates from other interfaces. IsDistinct_clauseContext() } type Distinct_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDistinct_clauseContext() *Distinct_clauseContext { var p = new(Distinct_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_distinct_clause return p } func InitEmptyDistinct_clauseContext(p *Distinct_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_distinct_clause } func (*Distinct_clauseContext) IsDistinct_clauseContext() {} func NewDistinct_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Distinct_clauseContext { var p = new(Distinct_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_distinct_clause return p } func (s *Distinct_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Distinct_clauseContext) DISTINCT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDISTINCT, 0) } func (s *Distinct_clauseContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *Distinct_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Distinct_clauseContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Distinct_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Distinct_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Distinct_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Distinct_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDistinct_clause(s) } } func (s *Distinct_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDistinct_clause(s) } } func (s *Distinct_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDistinct_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Distinct_clause() (localctx IDistinct_clauseContext) { localctx = NewDistinct_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 992, PostgreSQLParserRULE_distinct_clause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8076) p.Match(PostgreSQLParserDISTINCT) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8082) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserON { { p.SetState(8077) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8078) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8079) p.Expr_list() } { p.SetState(8080) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_all_clauseContext is an interface to support dynamic dispatch. type IOpt_all_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALL() antlr.TerminalNode // IsOpt_all_clauseContext differentiates from other interfaces. IsOpt_all_clauseContext() } type Opt_all_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_all_clauseContext() *Opt_all_clauseContext { var p = new(Opt_all_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_all_clause return p } func InitEmptyOpt_all_clauseContext(p *Opt_all_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_all_clause } func (*Opt_all_clauseContext) IsOpt_all_clauseContext() {} func NewOpt_all_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_all_clauseContext { var p = new(Opt_all_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_all_clause return p } func (s *Opt_all_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_all_clauseContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *Opt_all_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_all_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_all_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_all_clause(s) } } func (s *Opt_all_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_all_clause(s) } } func (s *Opt_all_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_all_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_all_clause() (localctx IOpt_all_clauseContext) { localctx = NewOpt_all_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 994, PostgreSQLParserRULE_opt_all_clause) p.SetState(8086) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserALL: p.EnterOuterAlt(localctx, 1) { p.SetState(8084) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserSTAR, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserFROM, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNION, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserWHERE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMERGE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserLOOP, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserMetaCommand, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_sort_clauseContext is an interface to support dynamic dispatch. type IOpt_sort_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sort_clause() ISort_clauseContext // IsOpt_sort_clauseContext differentiates from other interfaces. IsOpt_sort_clauseContext() } type Opt_sort_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_sort_clauseContext() *Opt_sort_clauseContext { var p = new(Opt_sort_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_sort_clause return p } func InitEmptyOpt_sort_clauseContext(p *Opt_sort_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_sort_clause } func (*Opt_sort_clauseContext) IsOpt_sort_clauseContext() {} func NewOpt_sort_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_sort_clauseContext { var p = new(Opt_sort_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_sort_clause return p } func (s *Opt_sort_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_sort_clauseContext) Sort_clause() ISort_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISort_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISort_clauseContext) } func (s *Opt_sort_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_sort_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_sort_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_sort_clause(s) } } func (s *Opt_sort_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_sort_clause(s) } } func (s *Opt_sort_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_sort_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_sort_clause() (localctx IOpt_sort_clauseContext) { localctx = NewOpt_sort_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 996, PostgreSQLParserRULE_opt_sort_clause) p.SetState(8090) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserORDER: p.EnterOuterAlt(localctx, 1) { p.SetState(8088) p.Sort_clause() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserRANGE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserGROUPS, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISort_clauseContext is an interface to support dynamic dispatch. type ISort_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ORDER() antlr.TerminalNode BY() antlr.TerminalNode Sortby_list() ISortby_listContext // IsSort_clauseContext differentiates from other interfaces. IsSort_clauseContext() } type Sort_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySort_clauseContext() *Sort_clauseContext { var p = new(Sort_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_sort_clause return p } func InitEmptySort_clauseContext(p *Sort_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_sort_clause } func (*Sort_clauseContext) IsSort_clauseContext() {} func NewSort_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sort_clauseContext { var p = new(Sort_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_sort_clause return p } func (s *Sort_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Sort_clauseContext) ORDER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserORDER, 0) } func (s *Sort_clauseContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *Sort_clauseContext) Sortby_list() ISortby_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISortby_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISortby_listContext) } func (s *Sort_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Sort_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Sort_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSort_clause(s) } } func (s *Sort_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSort_clause(s) } } func (s *Sort_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSort_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Sort_clause() (localctx ISort_clauseContext) { localctx = NewSort_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 998, PostgreSQLParserRULE_sort_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(8092) p.Match(PostgreSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8093) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8094) p.Sortby_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISortby_listContext is an interface to support dynamic dispatch. type ISortby_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllSortby() []ISortbyContext Sortby(i int) ISortbyContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsSortby_listContext differentiates from other interfaces. IsSortby_listContext() } type Sortby_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySortby_listContext() *Sortby_listContext { var p = new(Sortby_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_sortby_list return p } func InitEmptySortby_listContext(p *Sortby_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_sortby_list } func (*Sortby_listContext) IsSortby_listContext() {} func NewSortby_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sortby_listContext { var p = new(Sortby_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_sortby_list return p } func (s *Sortby_listContext) GetParser() antlr.Parser { return s.parser } func (s *Sortby_listContext) AllSortby() []ISortbyContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISortbyContext); ok { len++ } } tst := make([]ISortbyContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISortbyContext); ok { tst[i] = t.(ISortbyContext) i++ } } return tst } func (s *Sortby_listContext) Sortby(i int) ISortbyContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISortbyContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISortbyContext) } func (s *Sortby_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Sortby_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Sortby_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Sortby_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Sortby_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSortby_list(s) } } func (s *Sortby_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSortby_list(s) } } func (s *Sortby_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSortby_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Sortby_list() (localctx ISortby_listContext) { localctx = NewSortby_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1000, PostgreSQLParserRULE_sortby_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8096) p.Sortby() } p.SetState(8101) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(8097) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8098) p.Sortby() } p.SetState(8103) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISortbyContext is an interface to support dynamic dispatch. type ISortbyContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr() IA_exprContext Opt_nulls_order() IOpt_nulls_orderContext USING() antlr.TerminalNode Qual_all_op() IQual_all_opContext Opt_asc_desc() IOpt_asc_descContext // IsSortbyContext differentiates from other interfaces. IsSortbyContext() } type SortbyContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySortbyContext() *SortbyContext { var p = new(SortbyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_sortby return p } func InitEmptySortbyContext(p *SortbyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_sortby } func (*SortbyContext) IsSortbyContext() {} func NewSortbyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortbyContext { var p = new(SortbyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_sortby return p } func (s *SortbyContext) GetParser() antlr.Parser { return s.parser } func (s *SortbyContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *SortbyContext) Opt_nulls_order() IOpt_nulls_orderContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_nulls_orderContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_nulls_orderContext) } func (s *SortbyContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *SortbyContext) Qual_all_op() IQual_all_opContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQual_all_opContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQual_all_opContext) } func (s *SortbyContext) Opt_asc_desc() IOpt_asc_descContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_asc_descContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_asc_descContext) } func (s *SortbyContext) GetRuleContext() antlr.RuleContext { return s } func (s *SortbyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SortbyContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSortby(s) } } func (s *SortbyContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSortby(s) } } func (s *SortbyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSortby(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Sortby() (localctx ISortbyContext) { localctx = NewSortbyContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1002, PostgreSQLParserRULE_sortby) p.EnterOuterAlt(localctx, 1) { p.SetState(8104) p.A_expr() } p.SetState(8108) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUSING: { p.SetState(8105) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8106) p.Qual_all_op() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserASC, PostgreSQLParserCREATE, PostgreSQLParserDESC, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserNULLS_P, PostgreSQLParserPREPARE, PostgreSQLParserRANGE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserGROUPS, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: { p.SetState(8107) p.Opt_asc_desc() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } { p.SetState(8110) p.Opt_nulls_order() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISelect_limitContext is an interface to support dynamic dispatch. type ISelect_limitContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Limit_clause() ILimit_clauseContext Offset_clause() IOffset_clauseContext // IsSelect_limitContext differentiates from other interfaces. IsSelect_limitContext() } type Select_limitContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySelect_limitContext() *Select_limitContext { var p = new(Select_limitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_select_limit return p } func InitEmptySelect_limitContext(p *Select_limitContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_select_limit } func (*Select_limitContext) IsSelect_limitContext() {} func NewSelect_limitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_limitContext { var p = new(Select_limitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_select_limit return p } func (s *Select_limitContext) GetParser() antlr.Parser { return s.parser } func (s *Select_limitContext) Limit_clause() ILimit_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ILimit_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ILimit_clauseContext) } func (s *Select_limitContext) Offset_clause() IOffset_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOffset_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOffset_clauseContext) } func (s *Select_limitContext) GetRuleContext() antlr.RuleContext { return s } func (s *Select_limitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Select_limitContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSelect_limit(s) } } func (s *Select_limitContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSelect_limit(s) } } func (s *Select_limitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSelect_limit(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Select_limit() (localctx ISelect_limitContext) { localctx = NewSelect_limitContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1004, PostgreSQLParserRULE_select_limit) var _la int p.SetState(8120) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFETCH, PostgreSQLParserLIMIT: p.EnterOuterAlt(localctx, 1) { p.SetState(8112) p.Limit_clause() } p.SetState(8114) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserOFFSET { { p.SetState(8113) p.Offset_clause() } } case PostgreSQLParserOFFSET: p.EnterOuterAlt(localctx, 2) { p.SetState(8116) p.Offset_clause() } p.SetState(8118) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 442, p.GetParserRuleContext()) == 1 { { p.SetState(8117) p.Limit_clause() } } else if p.HasError() { // JIM goto errorExit } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_select_limitContext is an interface to support dynamic dispatch. type IOpt_select_limitContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Select_limit() ISelect_limitContext // IsOpt_select_limitContext differentiates from other interfaces. IsOpt_select_limitContext() } type Opt_select_limitContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_select_limitContext() *Opt_select_limitContext { var p = new(Opt_select_limitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_select_limit return p } func InitEmptyOpt_select_limitContext(p *Opt_select_limitContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_select_limit } func (*Opt_select_limitContext) IsOpt_select_limitContext() {} func NewOpt_select_limitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_select_limitContext { var p = new(Opt_select_limitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_select_limit return p } func (s *Opt_select_limitContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_select_limitContext) Select_limit() ISelect_limitContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_limitContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_limitContext) } func (s *Opt_select_limitContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_select_limitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_select_limitContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_select_limit(s) } } func (s *Opt_select_limitContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_select_limit(s) } } func (s *Opt_select_limitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_select_limit(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_select_limit() (localctx IOpt_select_limitContext) { localctx = NewOpt_select_limitContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1006, PostgreSQLParserRULE_opt_select_limit) p.SetState(8124) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 444, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8122) p.Select_limit() } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ILimit_clauseContext is an interface to support dynamic dispatch. type ILimit_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures LIMIT() antlr.TerminalNode Select_limit_value() ISelect_limit_valueContext COMMA() antlr.TerminalNode Select_offset_value() ISelect_offset_valueContext FETCH() antlr.TerminalNode First_or_next() IFirst_or_nextContext Select_fetch_first_value() ISelect_fetch_first_valueContext Row_or_rows() IRow_or_rowsContext ONLY() antlr.TerminalNode WITH() antlr.TerminalNode TIES() antlr.TerminalNode // IsLimit_clauseContext differentiates from other interfaces. IsLimit_clauseContext() } type Limit_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyLimit_clauseContext() *Limit_clauseContext { var p = new(Limit_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_limit_clause return p } func InitEmptyLimit_clauseContext(p *Limit_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_limit_clause } func (*Limit_clauseContext) IsLimit_clauseContext() {} func NewLimit_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Limit_clauseContext { var p = new(Limit_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_limit_clause return p } func (s *Limit_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Limit_clauseContext) LIMIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLIMIT, 0) } func (s *Limit_clauseContext) Select_limit_value() ISelect_limit_valueContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_limit_valueContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_limit_valueContext) } func (s *Limit_clauseContext) COMMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, 0) } func (s *Limit_clauseContext) Select_offset_value() ISelect_offset_valueContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_offset_valueContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_offset_valueContext) } func (s *Limit_clauseContext) FETCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFETCH, 0) } func (s *Limit_clauseContext) First_or_next() IFirst_or_nextContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFirst_or_nextContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFirst_or_nextContext) } func (s *Limit_clauseContext) Select_fetch_first_value() ISelect_fetch_first_valueContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_fetch_first_valueContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_fetch_first_valueContext) } func (s *Limit_clauseContext) Row_or_rows() IRow_or_rowsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRow_or_rowsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRow_or_rowsContext) } func (s *Limit_clauseContext) ONLY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserONLY, 0) } func (s *Limit_clauseContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *Limit_clauseContext) TIES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTIES, 0) } func (s *Limit_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Limit_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Limit_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterLimit_clause(s) } } func (s *Limit_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitLimit_clause(s) } } func (s *Limit_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitLimit_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Limit_clause() (localctx ILimit_clauseContext) { localctx = NewLimit_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1008, PostgreSQLParserRULE_limit_clause) var _la int p.SetState(8149) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserLIMIT: p.EnterOuterAlt(localctx, 1) { p.SetState(8126) p.Match(PostgreSQLParserLIMIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8127) p.Select_limit_value() } p.SetState(8130) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserCOMMA { { p.SetState(8128) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8129) p.Select_offset_value() } } case PostgreSQLParserFETCH: p.EnterOuterAlt(localctx, 2) { p.SetState(8132) p.Match(PostgreSQLParserFETCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8133) p.First_or_next() } p.SetState(8147) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 448, p.GetParserRuleContext()) { case 1: { p.SetState(8134) p.Select_fetch_first_value() } { p.SetState(8135) p.Row_or_rows() } p.SetState(8139) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserONLY: { p.SetState(8136) p.Match(PostgreSQLParserONLY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserWITH: { p.SetState(8137) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8138) p.Match(PostgreSQLParserTIES) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case 2: { p.SetState(8141) p.Row_or_rows() } p.SetState(8145) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserONLY: { p.SetState(8142) p.Match(PostgreSQLParserONLY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserWITH: { p.SetState(8143) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8144) p.Match(PostgreSQLParserTIES) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case antlr.ATNInvalidAltNumber: goto errorExit } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOffset_clauseContext is an interface to support dynamic dispatch. type IOffset_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OFFSET() antlr.TerminalNode Select_offset_value() ISelect_offset_valueContext Select_fetch_first_value() ISelect_fetch_first_valueContext Row_or_rows() IRow_or_rowsContext // IsOffset_clauseContext differentiates from other interfaces. IsOffset_clauseContext() } type Offset_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOffset_clauseContext() *Offset_clauseContext { var p = new(Offset_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_offset_clause return p } func InitEmptyOffset_clauseContext(p *Offset_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_offset_clause } func (*Offset_clauseContext) IsOffset_clauseContext() {} func NewOffset_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Offset_clauseContext { var p = new(Offset_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_offset_clause return p } func (s *Offset_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Offset_clauseContext) OFFSET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOFFSET, 0) } func (s *Offset_clauseContext) Select_offset_value() ISelect_offset_valueContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_offset_valueContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_offset_valueContext) } func (s *Offset_clauseContext) Select_fetch_first_value() ISelect_fetch_first_valueContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_fetch_first_valueContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_fetch_first_valueContext) } func (s *Offset_clauseContext) Row_or_rows() IRow_or_rowsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRow_or_rowsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRow_or_rowsContext) } func (s *Offset_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Offset_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Offset_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOffset_clause(s) } } func (s *Offset_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOffset_clause(s) } } func (s *Offset_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOffset_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Offset_clause() (localctx IOffset_clauseContext) { localctx = NewOffset_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1010, PostgreSQLParserRULE_offset_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(8151) p.Match(PostgreSQLParserOFFSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8156) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 450, p.GetParserRuleContext()) { case 1: { p.SetState(8152) p.Select_offset_value() } case 2: { p.SetState(8153) p.Select_fetch_first_value() } { p.SetState(8154) p.Row_or_rows() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISelect_limit_valueContext is an interface to support dynamic dispatch. type ISelect_limit_valueContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr() IA_exprContext ALL() antlr.TerminalNode // IsSelect_limit_valueContext differentiates from other interfaces. IsSelect_limit_valueContext() } type Select_limit_valueContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySelect_limit_valueContext() *Select_limit_valueContext { var p = new(Select_limit_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_select_limit_value return p } func InitEmptySelect_limit_valueContext(p *Select_limit_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_select_limit_value } func (*Select_limit_valueContext) IsSelect_limit_valueContext() {} func NewSelect_limit_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_limit_valueContext { var p = new(Select_limit_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_select_limit_value return p } func (s *Select_limit_valueContext) GetParser() antlr.Parser { return s.parser } func (s *Select_limit_valueContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Select_limit_valueContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *Select_limit_valueContext) GetRuleContext() antlr.RuleContext { return s } func (s *Select_limit_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Select_limit_valueContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSelect_limit_value(s) } } func (s *Select_limit_valueContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSelect_limit_value(s) } } func (s *Select_limit_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSelect_limit_value(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Select_limit_value() (localctx ISelect_limit_valueContext) { localctx = NewSelect_limit_valueContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1012, PostgreSQLParserRULE_select_limit_value) p.SetState(8160) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(8158) p.A_expr() } case PostgreSQLParserALL: p.EnterOuterAlt(localctx, 2) { p.SetState(8159) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISelect_offset_valueContext is an interface to support dynamic dispatch. type ISelect_offset_valueContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr() IA_exprContext // IsSelect_offset_valueContext differentiates from other interfaces. IsSelect_offset_valueContext() } type Select_offset_valueContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySelect_offset_valueContext() *Select_offset_valueContext { var p = new(Select_offset_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_select_offset_value return p } func InitEmptySelect_offset_valueContext(p *Select_offset_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_select_offset_value } func (*Select_offset_valueContext) IsSelect_offset_valueContext() {} func NewSelect_offset_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_offset_valueContext { var p = new(Select_offset_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_select_offset_value return p } func (s *Select_offset_valueContext) GetParser() antlr.Parser { return s.parser } func (s *Select_offset_valueContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Select_offset_valueContext) GetRuleContext() antlr.RuleContext { return s } func (s *Select_offset_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Select_offset_valueContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSelect_offset_value(s) } } func (s *Select_offset_valueContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSelect_offset_value(s) } } func (s *Select_offset_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSelect_offset_value(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Select_offset_value() (localctx ISelect_offset_valueContext) { localctx = NewSelect_offset_valueContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1014, PostgreSQLParserRULE_select_offset_value) p.EnterOuterAlt(localctx, 1) { p.SetState(8162) p.A_expr() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISelect_fetch_first_valueContext is an interface to support dynamic dispatch. type ISelect_fetch_first_valueContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures C_expr() IC_exprContext PLUS() antlr.TerminalNode I_or_f_const() II_or_f_constContext MINUS() antlr.TerminalNode // IsSelect_fetch_first_valueContext differentiates from other interfaces. IsSelect_fetch_first_valueContext() } type Select_fetch_first_valueContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySelect_fetch_first_valueContext() *Select_fetch_first_valueContext { var p = new(Select_fetch_first_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_select_fetch_first_value return p } func InitEmptySelect_fetch_first_valueContext(p *Select_fetch_first_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_select_fetch_first_value } func (*Select_fetch_first_valueContext) IsSelect_fetch_first_valueContext() {} func NewSelect_fetch_first_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_fetch_first_valueContext { var p = new(Select_fetch_first_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_select_fetch_first_value return p } func (s *Select_fetch_first_valueContext) GetParser() antlr.Parser { return s.parser } func (s *Select_fetch_first_valueContext) C_expr() IC_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IC_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IC_exprContext) } func (s *Select_fetch_first_valueContext) PLUS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPLUS, 0) } func (s *Select_fetch_first_valueContext) I_or_f_const() II_or_f_constContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(II_or_f_constContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(II_or_f_constContext) } func (s *Select_fetch_first_valueContext) MINUS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMINUS, 0) } func (s *Select_fetch_first_valueContext) GetRuleContext() antlr.RuleContext { return s } func (s *Select_fetch_first_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Select_fetch_first_valueContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSelect_fetch_first_value(s) } } func (s *Select_fetch_first_valueContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSelect_fetch_first_value(s) } } func (s *Select_fetch_first_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSelect_fetch_first_value(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Select_fetch_first_value() (localctx ISelect_fetch_first_valueContext) { localctx = NewSelect_fetch_first_valueContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1016, PostgreSQLParserRULE_select_fetch_first_value) p.SetState(8169) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPARAM, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(8164) p.C_expr() } case PostgreSQLParserPLUS: p.EnterOuterAlt(localctx, 2) { p.SetState(8165) p.Match(PostgreSQLParserPLUS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8166) p.I_or_f_const() } case PostgreSQLParserMINUS: p.EnterOuterAlt(localctx, 3) { p.SetState(8167) p.Match(PostgreSQLParserMINUS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8168) p.I_or_f_const() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // II_or_f_constContext is an interface to support dynamic dispatch. type II_or_f_constContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Iconst() IIconstContext Fconst() IFconstContext // IsI_or_f_constContext differentiates from other interfaces. IsI_or_f_constContext() } type I_or_f_constContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyI_or_f_constContext() *I_or_f_constContext { var p = new(I_or_f_constContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_i_or_f_const return p } func InitEmptyI_or_f_constContext(p *I_or_f_constContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_i_or_f_const } func (*I_or_f_constContext) IsI_or_f_constContext() {} func NewI_or_f_constContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *I_or_f_constContext { var p = new(I_or_f_constContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_i_or_f_const return p } func (s *I_or_f_constContext) GetParser() antlr.Parser { return s.parser } func (s *I_or_f_constContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *I_or_f_constContext) Fconst() IFconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFconstContext) } func (s *I_or_f_constContext) GetRuleContext() antlr.RuleContext { return s } func (s *I_or_f_constContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *I_or_f_constContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterI_or_f_const(s) } } func (s *I_or_f_constContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitI_or_f_const(s) } } func (s *I_or_f_constContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitI_or_f_const(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) I_or_f_const() (localctx II_or_f_constContext) { localctx = NewI_or_f_constContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1018, PostgreSQLParserRULE_i_or_f_const) p.SetState(8173) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserIntegral: p.EnterOuterAlt(localctx, 1) { p.SetState(8171) p.Iconst() } case PostgreSQLParserNumeric: p.EnterOuterAlt(localctx, 2) { p.SetState(8172) p.Fconst() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRow_or_rowsContext is an interface to support dynamic dispatch. type IRow_or_rowsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ROW() antlr.TerminalNode ROWS() antlr.TerminalNode // IsRow_or_rowsContext differentiates from other interfaces. IsRow_or_rowsContext() } type Row_or_rowsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRow_or_rowsContext() *Row_or_rowsContext { var p = new(Row_or_rowsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_row_or_rows return p } func InitEmptyRow_or_rowsContext(p *Row_or_rowsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_row_or_rows } func (*Row_or_rowsContext) IsRow_or_rowsContext() {} func NewRow_or_rowsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_or_rowsContext { var p = new(Row_or_rowsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_row_or_rows return p } func (s *Row_or_rowsContext) GetParser() antlr.Parser { return s.parser } func (s *Row_or_rowsContext) ROW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROW, 0) } func (s *Row_or_rowsContext) ROWS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROWS, 0) } func (s *Row_or_rowsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Row_or_rowsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Row_or_rowsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRow_or_rows(s) } } func (s *Row_or_rowsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRow_or_rows(s) } } func (s *Row_or_rowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRow_or_rows(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Row_or_rows() (localctx IRow_or_rowsContext) { localctx = NewRow_or_rowsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1020, PostgreSQLParserRULE_row_or_rows) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8175) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserROWS || _la == PostgreSQLParserROW) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFirst_or_nextContext is an interface to support dynamic dispatch. type IFirst_or_nextContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FIRST_P() antlr.TerminalNode NEXT() antlr.TerminalNode // IsFirst_or_nextContext differentiates from other interfaces. IsFirst_or_nextContext() } type First_or_nextContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFirst_or_nextContext() *First_or_nextContext { var p = new(First_or_nextContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_first_or_next return p } func InitEmptyFirst_or_nextContext(p *First_or_nextContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_first_or_next } func (*First_or_nextContext) IsFirst_or_nextContext() {} func NewFirst_or_nextContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *First_or_nextContext { var p = new(First_or_nextContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_first_or_next return p } func (s *First_or_nextContext) GetParser() antlr.Parser { return s.parser } func (s *First_or_nextContext) FIRST_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFIRST_P, 0) } func (s *First_or_nextContext) NEXT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNEXT, 0) } func (s *First_or_nextContext) GetRuleContext() antlr.RuleContext { return s } func (s *First_or_nextContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *First_or_nextContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFirst_or_next(s) } } func (s *First_or_nextContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFirst_or_next(s) } } func (s *First_or_nextContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFirst_or_next(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) First_or_next() (localctx IFirst_or_nextContext) { localctx = NewFirst_or_nextContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1022, PostgreSQLParserRULE_first_or_next) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8177) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserFIRST_P || _la == PostgreSQLParserNEXT) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGroup_clauseContext is an interface to support dynamic dispatch. type IGroup_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures GROUP_P() antlr.TerminalNode BY() antlr.TerminalNode Group_by_list() IGroup_by_listContext // IsGroup_clauseContext differentiates from other interfaces. IsGroup_clauseContext() } type Group_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGroup_clauseContext() *Group_clauseContext { var p = new(Group_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_group_clause return p } func InitEmptyGroup_clauseContext(p *Group_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_group_clause } func (*Group_clauseContext) IsGroup_clauseContext() {} func NewGroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_clauseContext { var p = new(Group_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_group_clause return p } func (s *Group_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Group_clauseContext) GROUP_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUP_P, 0) } func (s *Group_clauseContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *Group_clauseContext) Group_by_list() IGroup_by_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGroup_by_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGroup_by_listContext) } func (s *Group_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Group_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Group_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGroup_clause(s) } } func (s *Group_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGroup_clause(s) } } func (s *Group_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGroup_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Group_clause() (localctx IGroup_clauseContext) { localctx = NewGroup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1024, PostgreSQLParserRULE_group_clause) p.SetState(8183) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserGROUP_P: p.EnterOuterAlt(localctx, 1) { p.SetState(8179) p.Match(PostgreSQLParserGROUP_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8180) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8181) p.Group_by_list() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserHAVING, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserUNION, PostgreSQLParserUSING, PostgreSQLParserWHEN, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGroup_by_listContext is an interface to support dynamic dispatch. type IGroup_by_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllGroup_by_item() []IGroup_by_itemContext Group_by_item(i int) IGroup_by_itemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsGroup_by_listContext differentiates from other interfaces. IsGroup_by_listContext() } type Group_by_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGroup_by_listContext() *Group_by_listContext { var p = new(Group_by_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_group_by_list return p } func InitEmptyGroup_by_listContext(p *Group_by_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_group_by_list } func (*Group_by_listContext) IsGroup_by_listContext() {} func NewGroup_by_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_listContext { var p = new(Group_by_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_group_by_list return p } func (s *Group_by_listContext) GetParser() antlr.Parser { return s.parser } func (s *Group_by_listContext) AllGroup_by_item() []IGroup_by_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IGroup_by_itemContext); ok { len++ } } tst := make([]IGroup_by_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IGroup_by_itemContext); ok { tst[i] = t.(IGroup_by_itemContext) i++ } } return tst } func (s *Group_by_listContext) Group_by_item(i int) IGroup_by_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGroup_by_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IGroup_by_itemContext) } func (s *Group_by_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Group_by_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Group_by_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Group_by_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Group_by_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGroup_by_list(s) } } func (s *Group_by_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGroup_by_list(s) } } func (s *Group_by_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGroup_by_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Group_by_list() (localctx IGroup_by_listContext) { localctx = NewGroup_by_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1026, PostgreSQLParserRULE_group_by_list) var _alt int p.EnterOuterAlt(localctx, 1) { p.SetState(8185) p.Group_by_item() } p.SetState(8190) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 455, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(8186) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8187) p.Group_by_item() } } p.SetState(8192) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 455, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGroup_by_itemContext is an interface to support dynamic dispatch. type IGroup_by_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Empty_grouping_set() IEmpty_grouping_setContext Cube_clause() ICube_clauseContext Rollup_clause() IRollup_clauseContext Grouping_sets_clause() IGrouping_sets_clauseContext A_expr() IA_exprContext // IsGroup_by_itemContext differentiates from other interfaces. IsGroup_by_itemContext() } type Group_by_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGroup_by_itemContext() *Group_by_itemContext { var p = new(Group_by_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_group_by_item return p } func InitEmptyGroup_by_itemContext(p *Group_by_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_group_by_item } func (*Group_by_itemContext) IsGroup_by_itemContext() {} func NewGroup_by_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_itemContext { var p = new(Group_by_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_group_by_item return p } func (s *Group_by_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Group_by_itemContext) Empty_grouping_set() IEmpty_grouping_setContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IEmpty_grouping_setContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IEmpty_grouping_setContext) } func (s *Group_by_itemContext) Cube_clause() ICube_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICube_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICube_clauseContext) } func (s *Group_by_itemContext) Rollup_clause() IRollup_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRollup_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRollup_clauseContext) } func (s *Group_by_itemContext) Grouping_sets_clause() IGrouping_sets_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGrouping_sets_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGrouping_sets_clauseContext) } func (s *Group_by_itemContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Group_by_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Group_by_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Group_by_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGroup_by_item(s) } } func (s *Group_by_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGroup_by_item(s) } } func (s *Group_by_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGroup_by_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Group_by_item() (localctx IGroup_by_itemContext) { localctx = NewGroup_by_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1028, PostgreSQLParserRULE_group_by_item) p.SetState(8198) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 456, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8193) p.Empty_grouping_set() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(8194) p.Cube_clause() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(8195) p.Rollup_clause() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(8196) p.Grouping_sets_clause() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(8197) p.A_expr() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IEmpty_grouping_setContext is an interface to support dynamic dispatch. type IEmpty_grouping_setContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode CLOSE_PAREN() antlr.TerminalNode // IsEmpty_grouping_setContext differentiates from other interfaces. IsEmpty_grouping_setContext() } type Empty_grouping_setContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyEmpty_grouping_setContext() *Empty_grouping_setContext { var p = new(Empty_grouping_setContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_empty_grouping_set return p } func InitEmptyEmpty_grouping_setContext(p *Empty_grouping_setContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_empty_grouping_set } func (*Empty_grouping_setContext) IsEmpty_grouping_setContext() {} func NewEmpty_grouping_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Empty_grouping_setContext { var p = new(Empty_grouping_setContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_empty_grouping_set return p } func (s *Empty_grouping_setContext) GetParser() antlr.Parser { return s.parser } func (s *Empty_grouping_setContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Empty_grouping_setContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Empty_grouping_setContext) GetRuleContext() antlr.RuleContext { return s } func (s *Empty_grouping_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Empty_grouping_setContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterEmpty_grouping_set(s) } } func (s *Empty_grouping_setContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitEmpty_grouping_set(s) } } func (s *Empty_grouping_setContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitEmpty_grouping_set(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Empty_grouping_set() (localctx IEmpty_grouping_setContext) { localctx = NewEmpty_grouping_setContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1030, PostgreSQLParserRULE_empty_grouping_set) p.EnterOuterAlt(localctx, 1) { p.SetState(8200) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8201) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRollup_clauseContext is an interface to support dynamic dispatch. type IRollup_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ROLLUP() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Expr_list() IExpr_listContext CLOSE_PAREN() antlr.TerminalNode // IsRollup_clauseContext differentiates from other interfaces. IsRollup_clauseContext() } type Rollup_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRollup_clauseContext() *Rollup_clauseContext { var p = new(Rollup_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rollup_clause return p } func InitEmptyRollup_clauseContext(p *Rollup_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rollup_clause } func (*Rollup_clauseContext) IsRollup_clauseContext() {} func NewRollup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollup_clauseContext { var p = new(Rollup_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_rollup_clause return p } func (s *Rollup_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Rollup_clauseContext) ROLLUP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLLUP, 0) } func (s *Rollup_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Rollup_clauseContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Rollup_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Rollup_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Rollup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Rollup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRollup_clause(s) } } func (s *Rollup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRollup_clause(s) } } func (s *Rollup_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRollup_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Rollup_clause() (localctx IRollup_clauseContext) { localctx = NewRollup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1032, PostgreSQLParserRULE_rollup_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(8203) p.Match(PostgreSQLParserROLLUP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8204) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8205) p.Expr_list() } { p.SetState(8206) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICube_clauseContext is an interface to support dynamic dispatch. type ICube_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CUBE() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Expr_list() IExpr_listContext CLOSE_PAREN() antlr.TerminalNode // IsCube_clauseContext differentiates from other interfaces. IsCube_clauseContext() } type Cube_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCube_clauseContext() *Cube_clauseContext { var p = new(Cube_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_cube_clause return p } func InitEmptyCube_clauseContext(p *Cube_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_cube_clause } func (*Cube_clauseContext) IsCube_clauseContext() {} func NewCube_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cube_clauseContext { var p = new(Cube_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_cube_clause return p } func (s *Cube_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Cube_clauseContext) CUBE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCUBE, 0) } func (s *Cube_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Cube_clauseContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Cube_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Cube_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Cube_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Cube_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCube_clause(s) } } func (s *Cube_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCube_clause(s) } } func (s *Cube_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCube_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Cube_clause() (localctx ICube_clauseContext) { localctx = NewCube_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1034, PostgreSQLParserRULE_cube_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(8208) p.Match(PostgreSQLParserCUBE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8209) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8210) p.Expr_list() } { p.SetState(8211) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGrouping_sets_clauseContext is an interface to support dynamic dispatch. type IGrouping_sets_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures GROUPING() antlr.TerminalNode SETS() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Group_by_list() IGroup_by_listContext CLOSE_PAREN() antlr.TerminalNode // IsGrouping_sets_clauseContext differentiates from other interfaces. IsGrouping_sets_clauseContext() } type Grouping_sets_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGrouping_sets_clauseContext() *Grouping_sets_clauseContext { var p = new(Grouping_sets_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_grouping_sets_clause return p } func InitEmptyGrouping_sets_clauseContext(p *Grouping_sets_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_grouping_sets_clause } func (*Grouping_sets_clauseContext) IsGrouping_sets_clauseContext() {} func NewGrouping_sets_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grouping_sets_clauseContext { var p = new(Grouping_sets_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_grouping_sets_clause return p } func (s *Grouping_sets_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Grouping_sets_clauseContext) GROUPING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUPING, 0) } func (s *Grouping_sets_clauseContext) SETS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSETS, 0) } func (s *Grouping_sets_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Grouping_sets_clauseContext) Group_by_list() IGroup_by_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGroup_by_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGroup_by_listContext) } func (s *Grouping_sets_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Grouping_sets_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Grouping_sets_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Grouping_sets_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGrouping_sets_clause(s) } } func (s *Grouping_sets_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGrouping_sets_clause(s) } } func (s *Grouping_sets_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGrouping_sets_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Grouping_sets_clause() (localctx IGrouping_sets_clauseContext) { localctx = NewGrouping_sets_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1036, PostgreSQLParserRULE_grouping_sets_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(8213) p.Match(PostgreSQLParserGROUPING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8214) p.Match(PostgreSQLParserSETS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8215) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8216) p.Group_by_list() } { p.SetState(8217) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IHaving_clauseContext is an interface to support dynamic dispatch. type IHaving_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures HAVING() antlr.TerminalNode A_expr() IA_exprContext // IsHaving_clauseContext differentiates from other interfaces. IsHaving_clauseContext() } type Having_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyHaving_clauseContext() *Having_clauseContext { var p = new(Having_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_having_clause return p } func InitEmptyHaving_clauseContext(p *Having_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_having_clause } func (*Having_clauseContext) IsHaving_clauseContext() {} func NewHaving_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Having_clauseContext { var p = new(Having_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_having_clause return p } func (s *Having_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Having_clauseContext) HAVING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserHAVING, 0) } func (s *Having_clauseContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Having_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Having_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Having_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterHaving_clause(s) } } func (s *Having_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitHaving_clause(s) } } func (s *Having_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitHaving_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Having_clause() (localctx IHaving_clauseContext) { localctx = NewHaving_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1038, PostgreSQLParserRULE_having_clause) p.SetState(8222) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserHAVING: p.EnterOuterAlt(localctx, 1) { p.SetState(8219) p.Match(PostgreSQLParserHAVING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8220) p.A_expr() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserUNION, PostgreSQLParserUSING, PostgreSQLParserWHEN, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFor_locking_clauseContext is an interface to support dynamic dispatch. type IFor_locking_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures For_locking_items() IFor_locking_itemsContext FOR() antlr.TerminalNode READ() antlr.TerminalNode ONLY() antlr.TerminalNode // IsFor_locking_clauseContext differentiates from other interfaces. IsFor_locking_clauseContext() } type For_locking_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFor_locking_clauseContext() *For_locking_clauseContext { var p = new(For_locking_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_for_locking_clause return p } func InitEmptyFor_locking_clauseContext(p *For_locking_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_for_locking_clause } func (*For_locking_clauseContext) IsFor_locking_clauseContext() {} func NewFor_locking_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_locking_clauseContext { var p = new(For_locking_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_for_locking_clause return p } func (s *For_locking_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *For_locking_clauseContext) For_locking_items() IFor_locking_itemsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFor_locking_itemsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFor_locking_itemsContext) } func (s *For_locking_clauseContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *For_locking_clauseContext) READ() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREAD, 0) } func (s *For_locking_clauseContext) ONLY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserONLY, 0) } func (s *For_locking_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *For_locking_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *For_locking_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFor_locking_clause(s) } } func (s *For_locking_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFor_locking_clause(s) } } func (s *For_locking_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFor_locking_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) For_locking_clause() (localctx IFor_locking_clauseContext) { localctx = NewFor_locking_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1040, PostgreSQLParserRULE_for_locking_clause) p.SetState(8228) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 458, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8224) p.For_locking_items() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(8225) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8226) p.Match(PostgreSQLParserREAD) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8227) p.Match(PostgreSQLParserONLY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_for_locking_clauseContext is an interface to support dynamic dispatch. type IOpt_for_locking_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures For_locking_clause() IFor_locking_clauseContext // IsOpt_for_locking_clauseContext differentiates from other interfaces. IsOpt_for_locking_clauseContext() } type Opt_for_locking_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_for_locking_clauseContext() *Opt_for_locking_clauseContext { var p = new(Opt_for_locking_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_for_locking_clause return p } func InitEmptyOpt_for_locking_clauseContext(p *Opt_for_locking_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_for_locking_clause } func (*Opt_for_locking_clauseContext) IsOpt_for_locking_clauseContext() {} func NewOpt_for_locking_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_for_locking_clauseContext { var p = new(Opt_for_locking_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_for_locking_clause return p } func (s *Opt_for_locking_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_for_locking_clauseContext) For_locking_clause() IFor_locking_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFor_locking_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFor_locking_clauseContext) } func (s *Opt_for_locking_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_for_locking_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_for_locking_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_for_locking_clause(s) } } func (s *Opt_for_locking_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_for_locking_clause(s) } } func (s *Opt_for_locking_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_for_locking_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_for_locking_clause() (localctx IOpt_for_locking_clauseContext) { localctx = NewOpt_for_locking_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1042, PostgreSQLParserRULE_opt_for_locking_clause) p.SetState(8232) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFOR: p.EnterOuterAlt(localctx, 1) { p.SetState(8230) p.For_locking_clause() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserON, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFor_locking_itemsContext is an interface to support dynamic dispatch. type IFor_locking_itemsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllFor_locking_item() []IFor_locking_itemContext For_locking_item(i int) IFor_locking_itemContext // IsFor_locking_itemsContext differentiates from other interfaces. IsFor_locking_itemsContext() } type For_locking_itemsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFor_locking_itemsContext() *For_locking_itemsContext { var p = new(For_locking_itemsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_for_locking_items return p } func InitEmptyFor_locking_itemsContext(p *For_locking_itemsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_for_locking_items } func (*For_locking_itemsContext) IsFor_locking_itemsContext() {} func NewFor_locking_itemsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_locking_itemsContext { var p = new(For_locking_itemsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_for_locking_items return p } func (s *For_locking_itemsContext) GetParser() antlr.Parser { return s.parser } func (s *For_locking_itemsContext) AllFor_locking_item() []IFor_locking_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IFor_locking_itemContext); ok { len++ } } tst := make([]IFor_locking_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IFor_locking_itemContext); ok { tst[i] = t.(IFor_locking_itemContext) i++ } } return tst } func (s *For_locking_itemsContext) For_locking_item(i int) IFor_locking_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFor_locking_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IFor_locking_itemContext) } func (s *For_locking_itemsContext) GetRuleContext() antlr.RuleContext { return s } func (s *For_locking_itemsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *For_locking_itemsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFor_locking_items(s) } } func (s *For_locking_itemsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFor_locking_items(s) } } func (s *For_locking_itemsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFor_locking_items(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) For_locking_items() (localctx IFor_locking_itemsContext) { localctx = NewFor_locking_itemsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1044, PostgreSQLParserRULE_for_locking_items) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(8235) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ok := true; ok; ok = _la == PostgreSQLParserFOR { { p.SetState(8234) p.For_locking_item() } p.SetState(8237) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFor_locking_itemContext is an interface to support dynamic dispatch. type IFor_locking_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures For_locking_strength() IFor_locking_strengthContext Locked_rels_list() ILocked_rels_listContext Opt_nowait_or_skip() IOpt_nowait_or_skipContext // IsFor_locking_itemContext differentiates from other interfaces. IsFor_locking_itemContext() } type For_locking_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFor_locking_itemContext() *For_locking_itemContext { var p = new(For_locking_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_for_locking_item return p } func InitEmptyFor_locking_itemContext(p *For_locking_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_for_locking_item } func (*For_locking_itemContext) IsFor_locking_itemContext() {} func NewFor_locking_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_locking_itemContext { var p = new(For_locking_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_for_locking_item return p } func (s *For_locking_itemContext) GetParser() antlr.Parser { return s.parser } func (s *For_locking_itemContext) For_locking_strength() IFor_locking_strengthContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFor_locking_strengthContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFor_locking_strengthContext) } func (s *For_locking_itemContext) Locked_rels_list() ILocked_rels_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ILocked_rels_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ILocked_rels_listContext) } func (s *For_locking_itemContext) Opt_nowait_or_skip() IOpt_nowait_or_skipContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_nowait_or_skipContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_nowait_or_skipContext) } func (s *For_locking_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *For_locking_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *For_locking_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFor_locking_item(s) } } func (s *For_locking_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFor_locking_item(s) } } func (s *For_locking_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFor_locking_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) For_locking_item() (localctx IFor_locking_itemContext) { localctx = NewFor_locking_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1046, PostgreSQLParserRULE_for_locking_item) p.EnterOuterAlt(localctx, 1) { p.SetState(8239) p.For_locking_strength() } { p.SetState(8240) p.Locked_rels_list() } { p.SetState(8241) p.Opt_nowait_or_skip() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFor_locking_strengthContext is an interface to support dynamic dispatch. type IFor_locking_strengthContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FOR() antlr.TerminalNode UPDATE() antlr.TerminalNode SHARE() antlr.TerminalNode NO() antlr.TerminalNode KEY() antlr.TerminalNode // IsFor_locking_strengthContext differentiates from other interfaces. IsFor_locking_strengthContext() } type For_locking_strengthContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFor_locking_strengthContext() *For_locking_strengthContext { var p = new(For_locking_strengthContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_for_locking_strength return p } func InitEmptyFor_locking_strengthContext(p *For_locking_strengthContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_for_locking_strength } func (*For_locking_strengthContext) IsFor_locking_strengthContext() {} func NewFor_locking_strengthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_locking_strengthContext { var p = new(For_locking_strengthContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_for_locking_strength return p } func (s *For_locking_strengthContext) GetParser() antlr.Parser { return s.parser } func (s *For_locking_strengthContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *For_locking_strengthContext) UPDATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUPDATE, 0) } func (s *For_locking_strengthContext) SHARE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSHARE, 0) } func (s *For_locking_strengthContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *For_locking_strengthContext) KEY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserKEY, 0) } func (s *For_locking_strengthContext) GetRuleContext() antlr.RuleContext { return s } func (s *For_locking_strengthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *For_locking_strengthContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFor_locking_strength(s) } } func (s *For_locking_strengthContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFor_locking_strength(s) } } func (s *For_locking_strengthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFor_locking_strength(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) For_locking_strength() (localctx IFor_locking_strengthContext) { localctx = NewFor_locking_strengthContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1048, PostgreSQLParserRULE_for_locking_strength) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8243) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8253) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserNO, PostgreSQLParserUPDATE: p.SetState(8246) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserNO { { p.SetState(8244) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8245) p.Match(PostgreSQLParserKEY) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(8248) p.Match(PostgreSQLParserUPDATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserKEY, PostgreSQLParserSHARE: p.SetState(8250) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserKEY { { p.SetState(8249) p.Match(PostgreSQLParserKEY) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(8252) p.Match(PostgreSQLParserSHARE) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ILocked_rels_listContext is an interface to support dynamic dispatch. type ILocked_rels_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OF() antlr.TerminalNode Qualified_name_list() IQualified_name_listContext // IsLocked_rels_listContext differentiates from other interfaces. IsLocked_rels_listContext() } type Locked_rels_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyLocked_rels_listContext() *Locked_rels_listContext { var p = new(Locked_rels_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_locked_rels_list return p } func InitEmptyLocked_rels_listContext(p *Locked_rels_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_locked_rels_list } func (*Locked_rels_listContext) IsLocked_rels_listContext() {} func NewLocked_rels_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Locked_rels_listContext { var p = new(Locked_rels_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_locked_rels_list return p } func (s *Locked_rels_listContext) GetParser() antlr.Parser { return s.parser } func (s *Locked_rels_listContext) OF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOF, 0) } func (s *Locked_rels_listContext) Qualified_name_list() IQualified_name_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_name_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_name_listContext) } func (s *Locked_rels_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Locked_rels_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Locked_rels_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterLocked_rels_list(s) } } func (s *Locked_rels_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitLocked_rels_list(s) } } func (s *Locked_rels_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitLocked_rels_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Locked_rels_list() (localctx ILocked_rels_listContext) { localctx = NewLocked_rels_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1050, PostgreSQLParserRULE_locked_rels_list) p.SetState(8258) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOF: p.EnterOuterAlt(localctx, 1) { p.SetState(8255) p.Match(PostgreSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8256) p.Qualified_name_list() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserSKIP_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IValues_clauseContext is an interface to support dynamic dispatch. type IValues_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures VALUES() antlr.TerminalNode AllOPEN_PAREN() []antlr.TerminalNode OPEN_PAREN(i int) antlr.TerminalNode AllExpr_list() []IExpr_listContext Expr_list(i int) IExpr_listContext AllCLOSE_PAREN() []antlr.TerminalNode CLOSE_PAREN(i int) antlr.TerminalNode AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsValues_clauseContext differentiates from other interfaces. IsValues_clauseContext() } type Values_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyValues_clauseContext() *Values_clauseContext { var p = new(Values_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_values_clause return p } func InitEmptyValues_clauseContext(p *Values_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_values_clause } func (*Values_clauseContext) IsValues_clauseContext() {} func NewValues_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Values_clauseContext { var p = new(Values_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_values_clause return p } func (s *Values_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Values_clauseContext) VALUES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALUES, 0) } func (s *Values_clauseContext) AllOPEN_PAREN() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserOPEN_PAREN) } func (s *Values_clauseContext) OPEN_PAREN(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, i) } func (s *Values_clauseContext) AllExpr_list() []IExpr_listContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IExpr_listContext); ok { len++ } } tst := make([]IExpr_listContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IExpr_listContext); ok { tst[i] = t.(IExpr_listContext) i++ } } return tst } func (s *Values_clauseContext) Expr_list(i int) IExpr_listContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Values_clauseContext) AllCLOSE_PAREN() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCLOSE_PAREN) } func (s *Values_clauseContext) CLOSE_PAREN(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, i) } func (s *Values_clauseContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Values_clauseContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Values_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Values_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Values_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterValues_clause(s) } } func (s *Values_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitValues_clause(s) } } func (s *Values_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitValues_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Values_clause() (localctx IValues_clauseContext) { localctx = NewValues_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1052, PostgreSQLParserRULE_values_clause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8260) p.Match(PostgreSQLParserVALUES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8261) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8262) p.Expr_list() } { p.SetState(8263) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8271) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(8264) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8265) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8266) p.Expr_list() } { p.SetState(8267) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8273) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFrom_clauseContext is an interface to support dynamic dispatch. type IFrom_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FROM() antlr.TerminalNode From_list() IFrom_listContext // IsFrom_clauseContext differentiates from other interfaces. IsFrom_clauseContext() } type From_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFrom_clauseContext() *From_clauseContext { var p = new(From_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_from_clause return p } func InitEmptyFrom_clauseContext(p *From_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_from_clause } func (*From_clauseContext) IsFrom_clauseContext() {} func NewFrom_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *From_clauseContext { var p = new(From_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_from_clause return p } func (s *From_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *From_clauseContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *From_clauseContext) From_list() IFrom_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFrom_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFrom_listContext) } func (s *From_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *From_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *From_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFrom_clause(s) } } func (s *From_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFrom_clause(s) } } func (s *From_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFrom_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) From_clause() (localctx IFrom_clauseContext) { localctx = NewFrom_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1054, PostgreSQLParserRULE_from_clause) p.SetState(8277) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFROM: p.EnterOuterAlt(localctx, 1) { p.SetState(8274) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8275) p.From_list() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserUNION, PostgreSQLParserUSING, PostgreSQLParserWHEN, PostgreSQLParserWHERE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFrom_listContext is an interface to support dynamic dispatch. type IFrom_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Non_ansi_join() INon_ansi_joinContext AllTable_ref() []ITable_refContext Table_ref(i int) ITable_refContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsFrom_listContext differentiates from other interfaces. IsFrom_listContext() } type From_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFrom_listContext() *From_listContext { var p = new(From_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_from_list return p } func InitEmptyFrom_listContext(p *From_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_from_list } func (*From_listContext) IsFrom_listContext() {} func NewFrom_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *From_listContext { var p = new(From_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_from_list return p } func (s *From_listContext) GetParser() antlr.Parser { return s.parser } func (s *From_listContext) Non_ansi_join() INon_ansi_joinContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INon_ansi_joinContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INon_ansi_joinContext) } func (s *From_listContext) AllTable_ref() []ITable_refContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITable_refContext); ok { len++ } } tst := make([]ITable_refContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITable_refContext); ok { tst[i] = t.(ITable_refContext) i++ } } return tst } func (s *From_listContext) Table_ref(i int) ITable_refContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITable_refContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITable_refContext) } func (s *From_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *From_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *From_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *From_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *From_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFrom_list(s) } } func (s *From_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFrom_list(s) } } func (s *From_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFrom_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) From_list() (localctx IFrom_listContext) { localctx = NewFrom_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1056, PostgreSQLParserRULE_from_list) var _alt int p.SetState(8288) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 468, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8279) p.Non_ansi_join() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(8280) p.Table_ref() } p.SetState(8285) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 467, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(8281) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8282) p.Table_ref() } } p.SetState(8287) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 467, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // INon_ansi_joinContext is an interface to support dynamic dispatch. type INon_ansi_joinContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllTable_ref() []ITable_refContext Table_ref(i int) ITable_refContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsNon_ansi_joinContext differentiates from other interfaces. IsNon_ansi_joinContext() } type Non_ansi_joinContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyNon_ansi_joinContext() *Non_ansi_joinContext { var p = new(Non_ansi_joinContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_non_ansi_join return p } func InitEmptyNon_ansi_joinContext(p *Non_ansi_joinContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_non_ansi_join } func (*Non_ansi_joinContext) IsNon_ansi_joinContext() {} func NewNon_ansi_joinContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Non_ansi_joinContext { var p = new(Non_ansi_joinContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_non_ansi_join return p } func (s *Non_ansi_joinContext) GetParser() antlr.Parser { return s.parser } func (s *Non_ansi_joinContext) AllTable_ref() []ITable_refContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITable_refContext); ok { len++ } } tst := make([]ITable_refContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITable_refContext); ok { tst[i] = t.(ITable_refContext) i++ } } return tst } func (s *Non_ansi_joinContext) Table_ref(i int) ITable_refContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITable_refContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITable_refContext) } func (s *Non_ansi_joinContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Non_ansi_joinContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Non_ansi_joinContext) GetRuleContext() antlr.RuleContext { return s } func (s *Non_ansi_joinContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Non_ansi_joinContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterNon_ansi_join(s) } } func (s *Non_ansi_joinContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitNon_ansi_join(s) } } func (s *Non_ansi_joinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitNon_ansi_join(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Non_ansi_join() (localctx INon_ansi_joinContext) { localctx = NewNon_ansi_joinContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1058, PostgreSQLParserRULE_non_ansi_join) var _alt int p.EnterOuterAlt(localctx, 1) { p.SetState(8290) p.Table_ref() } p.SetState(8293) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = 1 for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { switch _alt { case 1: { p.SetState(8291) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8292) p.Table_ref() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.SetState(8295) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 469, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITable_refContext is an interface to support dynamic dispatch. type ITable_refContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Relation_expr() IRelation_exprContext Opt_alias_clause() IOpt_alias_clauseContext Func_table() IFunc_tableContext Func_alias_clause() IFunc_alias_clauseContext Xmltable() IXmltableContext Select_with_parens() ISelect_with_parensContext LATERAL_P() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode AllTable_ref() []ITable_refContext Table_ref(i int) ITable_refContext CLOSE_PAREN() antlr.TerminalNode AllCROSS() []antlr.TerminalNode CROSS(i int) antlr.TerminalNode AllJOIN() []antlr.TerminalNode JOIN(i int) antlr.TerminalNode AllNATURAL() []antlr.TerminalNode NATURAL(i int) antlr.TerminalNode AllJoin_qual() []IJoin_qualContext Join_qual(i int) IJoin_qualContext Tablesample_clause() ITablesample_clauseContext AllJoin_type() []IJoin_typeContext Join_type(i int) IJoin_typeContext // IsTable_refContext differentiates from other interfaces. IsTable_refContext() } type Table_refContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTable_refContext() *Table_refContext { var p = new(Table_refContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_table_ref return p } func InitEmptyTable_refContext(p *Table_refContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_table_ref } func (*Table_refContext) IsTable_refContext() {} func NewTable_refContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_refContext { var p = new(Table_refContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_table_ref return p } func (s *Table_refContext) GetParser() antlr.Parser { return s.parser } func (s *Table_refContext) Relation_expr() IRelation_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRelation_exprContext) } func (s *Table_refContext) Opt_alias_clause() IOpt_alias_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_alias_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_alias_clauseContext) } func (s *Table_refContext) Func_table() IFunc_tableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_tableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_tableContext) } func (s *Table_refContext) Func_alias_clause() IFunc_alias_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_alias_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_alias_clauseContext) } func (s *Table_refContext) Xmltable() IXmltableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXmltableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IXmltableContext) } func (s *Table_refContext) Select_with_parens() ISelect_with_parensContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_with_parensContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_with_parensContext) } func (s *Table_refContext) LATERAL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLATERAL_P, 0) } func (s *Table_refContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Table_refContext) AllTable_ref() []ITable_refContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITable_refContext); ok { len++ } } tst := make([]ITable_refContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITable_refContext); ok { tst[i] = t.(ITable_refContext) i++ } } return tst } func (s *Table_refContext) Table_ref(i int) ITable_refContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITable_refContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITable_refContext) } func (s *Table_refContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Table_refContext) AllCROSS() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCROSS) } func (s *Table_refContext) CROSS(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCROSS, i) } func (s *Table_refContext) AllJOIN() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserJOIN) } func (s *Table_refContext) JOIN(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserJOIN, i) } func (s *Table_refContext) AllNATURAL() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserNATURAL) } func (s *Table_refContext) NATURAL(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserNATURAL, i) } func (s *Table_refContext) AllJoin_qual() []IJoin_qualContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IJoin_qualContext); ok { len++ } } tst := make([]IJoin_qualContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IJoin_qualContext); ok { tst[i] = t.(IJoin_qualContext) i++ } } return tst } func (s *Table_refContext) Join_qual(i int) IJoin_qualContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IJoin_qualContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IJoin_qualContext) } func (s *Table_refContext) Tablesample_clause() ITablesample_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITablesample_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITablesample_clauseContext) } func (s *Table_refContext) AllJoin_type() []IJoin_typeContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IJoin_typeContext); ok { len++ } } tst := make([]IJoin_typeContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IJoin_typeContext); ok { tst[i] = t.(IJoin_typeContext) i++ } } return tst } func (s *Table_refContext) Join_type(i int) IJoin_typeContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IJoin_typeContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IJoin_typeContext) } func (s *Table_refContext) GetRuleContext() antlr.RuleContext { return s } func (s *Table_refContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Table_refContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTable_ref(s) } } func (s *Table_refContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTable_ref(s) } } func (s *Table_refContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTable_ref(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Table_ref() (localctx ITable_refContext) { localctx = NewTable_refContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1060, PostgreSQLParserRULE_table_ref) var _la int var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(8346) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 475, p.GetParserRuleContext()) { case 1: { p.SetState(8297) p.Relation_expr() } { p.SetState(8298) p.Opt_alias_clause() } p.SetState(8300) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserTABLESAMPLE { { p.SetState(8299) p.Tablesample_clause() } } case 2: { p.SetState(8302) p.Func_table() } { p.SetState(8303) p.Func_alias_clause() } case 3: { p.SetState(8305) p.Xmltable() } { p.SetState(8306) p.Opt_alias_clause() } case 4: { p.SetState(8308) p.Select_with_parens() } { p.SetState(8309) p.Opt_alias_clause() } case 5: { p.SetState(8311) p.Match(PostgreSQLParserLATERAL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8321) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 471, p.GetParserRuleContext()) { case 1: { p.SetState(8312) p.Xmltable() } { p.SetState(8313) p.Opt_alias_clause() } case 2: { p.SetState(8315) p.Func_table() } { p.SetState(8316) p.Func_alias_clause() } case 3: { p.SetState(8318) p.Select_with_parens() } { p.SetState(8319) p.Opt_alias_clause() } case antlr.ATNInvalidAltNumber: goto errorExit } case 6: { p.SetState(8323) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8324) p.Table_ref() } p.SetState(8341) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCROSS: { p.SetState(8325) p.Match(PostgreSQLParserCROSS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8326) p.Match(PostgreSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8327) p.Table_ref() } case PostgreSQLParserNATURAL: { p.SetState(8328) p.Match(PostgreSQLParserNATURAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8330) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if (int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&8261) != 0 { { p.SetState(8329) p.Join_type() } } { p.SetState(8332) p.Match(PostgreSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8333) p.Table_ref() } case PostgreSQLParserFULL, PostgreSQLParserINNER_P, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserRIGHT: p.SetState(8335) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if (int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&8261) != 0 { { p.SetState(8334) p.Join_type() } } { p.SetState(8337) p.Match(PostgreSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8338) p.Table_ref() } { p.SetState(8339) p.Join_qual() } case PostgreSQLParserCLOSE_PAREN: default: } { p.SetState(8343) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8344) p.Opt_alias_clause() } case antlr.ATNInvalidAltNumber: goto errorExit } p.SetState(8366) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 479, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { p.SetState(8364) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCROSS: { p.SetState(8348) p.Match(PostgreSQLParserCROSS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8349) p.Match(PostgreSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8350) p.Table_ref() } case PostgreSQLParserNATURAL: { p.SetState(8351) p.Match(PostgreSQLParserNATURAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8353) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if (int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&8261) != 0 { { p.SetState(8352) p.Join_type() } } { p.SetState(8355) p.Match(PostgreSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8356) p.Table_ref() } case PostgreSQLParserFULL, PostgreSQLParserINNER_P, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserRIGHT: p.SetState(8358) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if (int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&8261) != 0 { { p.SetState(8357) p.Join_type() } } { p.SetState(8360) p.Match(PostgreSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8361) p.Table_ref() } { p.SetState(8362) p.Join_qual() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } } p.SetState(8368) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 479, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAlias_clauseContext is an interface to support dynamic dispatch. type IAlias_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext AS() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Name_list() IName_listContext CLOSE_PAREN() antlr.TerminalNode // IsAlias_clauseContext differentiates from other interfaces. IsAlias_clauseContext() } type Alias_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAlias_clauseContext() *Alias_clauseContext { var p = new(Alias_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alias_clause return p } func InitEmptyAlias_clauseContext(p *Alias_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_alias_clause } func (*Alias_clauseContext) IsAlias_clauseContext() {} func NewAlias_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alias_clauseContext { var p = new(Alias_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_alias_clause return p } func (s *Alias_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Alias_clauseContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Alias_clauseContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Alias_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Alias_clauseContext) Name_list() IName_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IName_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IName_listContext) } func (s *Alias_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Alias_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Alias_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Alias_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAlias_clause(s) } } func (s *Alias_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAlias_clause(s) } } func (s *Alias_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAlias_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Alias_clause() (localctx IAlias_clauseContext) { localctx = NewAlias_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1062, PostgreSQLParserRULE_alias_clause) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(8370) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserAS { { p.SetState(8369) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(8372) p.Colid() } p.SetState(8377) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 481, p.GetParserRuleContext()) == 1 { { p.SetState(8373) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8374) p.Name_list() } { p.SetState(8375) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_alias_clauseContext is an interface to support dynamic dispatch. type IOpt_alias_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Table_alias_clause() ITable_alias_clauseContext // IsOpt_alias_clauseContext differentiates from other interfaces. IsOpt_alias_clauseContext() } type Opt_alias_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_alias_clauseContext() *Opt_alias_clauseContext { var p = new(Opt_alias_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_alias_clause return p } func InitEmptyOpt_alias_clauseContext(p *Opt_alias_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_alias_clause } func (*Opt_alias_clauseContext) IsOpt_alias_clauseContext() {} func NewOpt_alias_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_alias_clauseContext { var p = new(Opt_alias_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_alias_clause return p } func (s *Opt_alias_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_alias_clauseContext) Table_alias_clause() ITable_alias_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITable_alias_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITable_alias_clauseContext) } func (s *Opt_alias_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_alias_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_alias_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_alias_clause(s) } } func (s *Opt_alias_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_alias_clause(s) } } func (s *Opt_alias_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_alias_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_alias_clause() (localctx IOpt_alias_clauseContext) { localctx = NewOpt_alias_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1064, PostgreSQLParserRULE_opt_alias_clause) p.SetState(8381) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 482, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8379) p.Table_alias_clause() } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITable_alias_clauseContext is an interface to support dynamic dispatch. type ITable_alias_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Table_alias() ITable_aliasContext AS() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Name_list() IName_listContext CLOSE_PAREN() antlr.TerminalNode // IsTable_alias_clauseContext differentiates from other interfaces. IsTable_alias_clauseContext() } type Table_alias_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTable_alias_clauseContext() *Table_alias_clauseContext { var p = new(Table_alias_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_table_alias_clause return p } func InitEmptyTable_alias_clauseContext(p *Table_alias_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_table_alias_clause } func (*Table_alias_clauseContext) IsTable_alias_clauseContext() {} func NewTable_alias_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_alias_clauseContext { var p = new(Table_alias_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_table_alias_clause return p } func (s *Table_alias_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Table_alias_clauseContext) Table_alias() ITable_aliasContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITable_aliasContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITable_aliasContext) } func (s *Table_alias_clauseContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Table_alias_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Table_alias_clauseContext) Name_list() IName_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IName_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IName_listContext) } func (s *Table_alias_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Table_alias_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Table_alias_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Table_alias_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTable_alias_clause(s) } } func (s *Table_alias_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTable_alias_clause(s) } } func (s *Table_alias_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTable_alias_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Table_alias_clause() (localctx ITable_alias_clauseContext) { localctx = NewTable_alias_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1066, PostgreSQLParserRULE_table_alias_clause) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(8384) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserAS { { p.SetState(8383) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(8386) p.Table_alias() } p.SetState(8391) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 484, p.GetParserRuleContext()) == 1 { { p.SetState(8387) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8388) p.Name_list() } { p.SetState(8389) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_alias_clauseContext is an interface to support dynamic dispatch. type IFunc_alias_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Alias_clause() IAlias_clauseContext OPEN_PAREN() antlr.TerminalNode Tablefuncelementlist() ITablefuncelementlistContext CLOSE_PAREN() antlr.TerminalNode AS() antlr.TerminalNode Colid() IColidContext // IsFunc_alias_clauseContext differentiates from other interfaces. IsFunc_alias_clauseContext() } type Func_alias_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_alias_clauseContext() *Func_alias_clauseContext { var p = new(Func_alias_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_alias_clause return p } func InitEmptyFunc_alias_clauseContext(p *Func_alias_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_alias_clause } func (*Func_alias_clauseContext) IsFunc_alias_clauseContext() {} func NewFunc_alias_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_alias_clauseContext { var p = new(Func_alias_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_alias_clause return p } func (s *Func_alias_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Func_alias_clauseContext) Alias_clause() IAlias_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAlias_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAlias_clauseContext) } func (s *Func_alias_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Func_alias_clauseContext) Tablefuncelementlist() ITablefuncelementlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITablefuncelementlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITablefuncelementlistContext) } func (s *Func_alias_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Func_alias_clauseContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Func_alias_clauseContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Func_alias_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_alias_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_alias_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_alias_clause(s) } } func (s *Func_alias_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_alias_clause(s) } } func (s *Func_alias_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_alias_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_alias_clause() (localctx IFunc_alias_clauseContext) { localctx = NewFunc_alias_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1068, PostgreSQLParserRULE_func_alias_clause) var _la int p.SetState(8406) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 487, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8393) p.Alias_clause() } case 2: p.EnterOuterAlt(localctx, 2) p.SetState(8399) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAS: { p.SetState(8394) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8396) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&2459027012145119232) != 0) || ((int64((_la-92)) & ^0x3f) == 0 && ((int64(1)<<(_la-92))&-113665638399) != 0) || ((int64((_la-156)) & ^0x3f) == 0 && ((int64(1)<<(_la-156))&-1) != 0) || ((int64((_la-220)) & ^0x3f) == 0 && ((int64(1)<<(_la-220))&-9663676417) != 0) || ((int64((_la-284)) & ^0x3f) == 0 && ((int64(1)<<(_la-284))&-1) != 0) || ((int64((_la-348)) & ^0x3f) == 0 && ((int64(1)<<(_la-348))&-1) != 0) || ((int64((_la-412)) & ^0x3f) == 0 && ((int64(1)<<(_la-412))&-1152925902653358081) != 0) || ((int64((_la-476)) & ^0x3f) == 0 && ((int64(1)<<(_la-476))&-8796764110849) != 0) || ((int64((_la-540)) & ^0x3f) == 0 && ((int64(1)<<(_la-540))&-1) != 0) || ((int64((_la-604)) & ^0x3f) == 0 && ((int64(1)<<(_la-604))&432345718846390271) != 0) { { p.SetState(8395) p.Colid() } } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: { p.SetState(8398) p.Colid() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } { p.SetState(8401) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8402) p.Tablefuncelementlist() } { p.SetState(8403) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IJoin_typeContext is an interface to support dynamic dispatch. type IJoin_typeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FULL() antlr.TerminalNode LEFT() antlr.TerminalNode RIGHT() antlr.TerminalNode INNER_P() antlr.TerminalNode OUTER_P() antlr.TerminalNode // IsJoin_typeContext differentiates from other interfaces. IsJoin_typeContext() } type Join_typeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyJoin_typeContext() *Join_typeContext { var p = new(Join_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_join_type return p } func InitEmptyJoin_typeContext(p *Join_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_join_type } func (*Join_typeContext) IsJoin_typeContext() {} func NewJoin_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_typeContext { var p = new(Join_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_join_type return p } func (s *Join_typeContext) GetParser() antlr.Parser { return s.parser } func (s *Join_typeContext) FULL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFULL, 0) } func (s *Join_typeContext) LEFT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEFT, 0) } func (s *Join_typeContext) RIGHT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRIGHT, 0) } func (s *Join_typeContext) INNER_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINNER_P, 0) } func (s *Join_typeContext) OUTER_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOUTER_P, 0) } func (s *Join_typeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Join_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Join_typeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterJoin_type(s) } } func (s *Join_typeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitJoin_type(s) } } func (s *Join_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitJoin_type(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Join_type() (localctx IJoin_typeContext) { localctx = NewJoin_typeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1070, PostgreSQLParserRULE_join_type) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8408) _la = p.GetTokenStream().LA(1) if !((int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&8261) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } p.SetState(8410) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserOUTER_P { { p.SetState(8409) p.Match(PostgreSQLParserOUTER_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IJoin_qualContext is an interface to support dynamic dispatch. type IJoin_qualContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USING() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Name_list() IName_listContext CLOSE_PAREN() antlr.TerminalNode ON() antlr.TerminalNode A_expr() IA_exprContext // IsJoin_qualContext differentiates from other interfaces. IsJoin_qualContext() } type Join_qualContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyJoin_qualContext() *Join_qualContext { var p = new(Join_qualContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_join_qual return p } func InitEmptyJoin_qualContext(p *Join_qualContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_join_qual } func (*Join_qualContext) IsJoin_qualContext() {} func NewJoin_qualContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_qualContext { var p = new(Join_qualContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_join_qual return p } func (s *Join_qualContext) GetParser() antlr.Parser { return s.parser } func (s *Join_qualContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *Join_qualContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Join_qualContext) Name_list() IName_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IName_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IName_listContext) } func (s *Join_qualContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Join_qualContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *Join_qualContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Join_qualContext) GetRuleContext() antlr.RuleContext { return s } func (s *Join_qualContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Join_qualContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterJoin_qual(s) } } func (s *Join_qualContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitJoin_qual(s) } } func (s *Join_qualContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitJoin_qual(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Join_qual() (localctx IJoin_qualContext) { localctx = NewJoin_qualContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1072, PostgreSQLParserRULE_join_qual) p.SetState(8419) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 1) { p.SetState(8412) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8413) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8414) p.Name_list() } { p.SetState(8415) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserON: p.EnterOuterAlt(localctx, 2) { p.SetState(8417) p.Match(PostgreSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8418) p.A_expr() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRelation_exprContext is an interface to support dynamic dispatch. type IRelation_exprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Qualified_name() IQualified_nameContext STAR() antlr.TerminalNode ONLY() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode CLOSE_PAREN() antlr.TerminalNode // IsRelation_exprContext differentiates from other interfaces. IsRelation_exprContext() } type Relation_exprContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRelation_exprContext() *Relation_exprContext { var p = new(Relation_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_relation_expr return p } func InitEmptyRelation_exprContext(p *Relation_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_relation_expr } func (*Relation_exprContext) IsRelation_exprContext() {} func NewRelation_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relation_exprContext { var p = new(Relation_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_relation_expr return p } func (s *Relation_exprContext) GetParser() antlr.Parser { return s.parser } func (s *Relation_exprContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *Relation_exprContext) STAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTAR, 0) } func (s *Relation_exprContext) ONLY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserONLY, 0) } func (s *Relation_exprContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Relation_exprContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Relation_exprContext) GetRuleContext() antlr.RuleContext { return s } func (s *Relation_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Relation_exprContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRelation_expr(s) } } func (s *Relation_exprContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRelation_expr(s) } } func (s *Relation_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRelation_expr(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Relation_expr() (localctx IRelation_exprContext) { localctx = NewRelation_exprContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1074, PostgreSQLParserRULE_relation_expr) var _la int p.SetState(8433) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(8421) p.Qualified_name() } p.SetState(8423) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserSTAR { { p.SetState(8422) p.Match(PostgreSQLParserSTAR) if p.HasError() { // Recognition error - abort rule goto errorExit } } } case PostgreSQLParserONLY: p.EnterOuterAlt(localctx, 2) { p.SetState(8425) p.Match(PostgreSQLParserONLY) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8431) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: { p.SetState(8426) p.Qualified_name() } case PostgreSQLParserOPEN_PAREN: { p.SetState(8427) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8428) p.Qualified_name() } { p.SetState(8429) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRelation_expr_listContext is an interface to support dynamic dispatch. type IRelation_expr_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllRelation_expr() []IRelation_exprContext Relation_expr(i int) IRelation_exprContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsRelation_expr_listContext differentiates from other interfaces. IsRelation_expr_listContext() } type Relation_expr_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRelation_expr_listContext() *Relation_expr_listContext { var p = new(Relation_expr_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_relation_expr_list return p } func InitEmptyRelation_expr_listContext(p *Relation_expr_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_relation_expr_list } func (*Relation_expr_listContext) IsRelation_expr_listContext() {} func NewRelation_expr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relation_expr_listContext { var p = new(Relation_expr_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_relation_expr_list return p } func (s *Relation_expr_listContext) GetParser() antlr.Parser { return s.parser } func (s *Relation_expr_listContext) AllRelation_expr() []IRelation_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IRelation_exprContext); ok { len++ } } tst := make([]IRelation_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IRelation_exprContext); ok { tst[i] = t.(IRelation_exprContext) i++ } } return tst } func (s *Relation_expr_listContext) Relation_expr(i int) IRelation_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IRelation_exprContext) } func (s *Relation_expr_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Relation_expr_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Relation_expr_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Relation_expr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Relation_expr_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRelation_expr_list(s) } } func (s *Relation_expr_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRelation_expr_list(s) } } func (s *Relation_expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRelation_expr_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Relation_expr_list() (localctx IRelation_expr_listContext) { localctx = NewRelation_expr_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1076, PostgreSQLParserRULE_relation_expr_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8435) p.Relation_expr() } p.SetState(8440) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(8436) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8437) p.Relation_expr() } p.SetState(8442) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRelation_expr_opt_aliasContext is an interface to support dynamic dispatch. type IRelation_expr_opt_aliasContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Relation_expr() IRelation_exprContext Colid() IColidContext AS() antlr.TerminalNode // IsRelation_expr_opt_aliasContext differentiates from other interfaces. IsRelation_expr_opt_aliasContext() } type Relation_expr_opt_aliasContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRelation_expr_opt_aliasContext() *Relation_expr_opt_aliasContext { var p = new(Relation_expr_opt_aliasContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_relation_expr_opt_alias return p } func InitEmptyRelation_expr_opt_aliasContext(p *Relation_expr_opt_aliasContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_relation_expr_opt_alias } func (*Relation_expr_opt_aliasContext) IsRelation_expr_opt_aliasContext() {} func NewRelation_expr_opt_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relation_expr_opt_aliasContext { var p = new(Relation_expr_opt_aliasContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_relation_expr_opt_alias return p } func (s *Relation_expr_opt_aliasContext) GetParser() antlr.Parser { return s.parser } func (s *Relation_expr_opt_aliasContext) Relation_expr() IRelation_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRelation_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRelation_exprContext) } func (s *Relation_expr_opt_aliasContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Relation_expr_opt_aliasContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Relation_expr_opt_aliasContext) GetRuleContext() antlr.RuleContext { return s } func (s *Relation_expr_opt_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Relation_expr_opt_aliasContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRelation_expr_opt_alias(s) } } func (s *Relation_expr_opt_aliasContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRelation_expr_opt_alias(s) } } func (s *Relation_expr_opt_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRelation_expr_opt_alias(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Relation_expr_opt_alias() (localctx IRelation_expr_opt_aliasContext) { localctx = NewRelation_expr_opt_aliasContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1078, PostgreSQLParserRULE_relation_expr_opt_alias) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8443) p.Relation_expr() } p.SetState(8448) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 495, p.GetParserRuleContext()) == 1 { p.SetState(8445) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserAS { { p.SetState(8444) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(8447) p.Colid() } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITablesample_clauseContext is an interface to support dynamic dispatch. type ITablesample_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures TABLESAMPLE() antlr.TerminalNode Func_name() IFunc_nameContext OPEN_PAREN() antlr.TerminalNode Expr_list() IExpr_listContext CLOSE_PAREN() antlr.TerminalNode Opt_repeatable_clause() IOpt_repeatable_clauseContext // IsTablesample_clauseContext differentiates from other interfaces. IsTablesample_clauseContext() } type Tablesample_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTablesample_clauseContext() *Tablesample_clauseContext { var p = new(Tablesample_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tablesample_clause return p } func InitEmptyTablesample_clauseContext(p *Tablesample_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tablesample_clause } func (*Tablesample_clauseContext) IsTablesample_clauseContext() {} func NewTablesample_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablesample_clauseContext { var p = new(Tablesample_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_tablesample_clause return p } func (s *Tablesample_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Tablesample_clauseContext) TABLESAMPLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESAMPLE, 0) } func (s *Tablesample_clauseContext) Func_name() IFunc_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_nameContext) } func (s *Tablesample_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Tablesample_clauseContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Tablesample_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Tablesample_clauseContext) Opt_repeatable_clause() IOpt_repeatable_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_repeatable_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_repeatable_clauseContext) } func (s *Tablesample_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Tablesample_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Tablesample_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTablesample_clause(s) } } func (s *Tablesample_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTablesample_clause(s) } } func (s *Tablesample_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTablesample_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Tablesample_clause() (localctx ITablesample_clauseContext) { localctx = NewTablesample_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1080, PostgreSQLParserRULE_tablesample_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(8450) p.Match(PostgreSQLParserTABLESAMPLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8451) p.Func_name() } { p.SetState(8452) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8453) p.Expr_list() } { p.SetState(8454) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8455) p.Opt_repeatable_clause() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_repeatable_clauseContext is an interface to support dynamic dispatch. type IOpt_repeatable_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures REPEATABLE() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode A_expr() IA_exprContext CLOSE_PAREN() antlr.TerminalNode // IsOpt_repeatable_clauseContext differentiates from other interfaces. IsOpt_repeatable_clauseContext() } type Opt_repeatable_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_repeatable_clauseContext() *Opt_repeatable_clauseContext { var p = new(Opt_repeatable_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_repeatable_clause return p } func InitEmptyOpt_repeatable_clauseContext(p *Opt_repeatable_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_repeatable_clause } func (*Opt_repeatable_clauseContext) IsOpt_repeatable_clauseContext() {} func NewOpt_repeatable_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_repeatable_clauseContext { var p = new(Opt_repeatable_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_repeatable_clause return p } func (s *Opt_repeatable_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_repeatable_clauseContext) REPEATABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREPEATABLE, 0) } func (s *Opt_repeatable_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Opt_repeatable_clauseContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Opt_repeatable_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Opt_repeatable_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_repeatable_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_repeatable_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_repeatable_clause(s) } } func (s *Opt_repeatable_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_repeatable_clause(s) } } func (s *Opt_repeatable_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_repeatable_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_repeatable_clause() (localctx IOpt_repeatable_clauseContext) { localctx = NewOpt_repeatable_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1082, PostgreSQLParserRULE_opt_repeatable_clause) p.SetState(8463) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserREPEATABLE: p.EnterOuterAlt(localctx, 1) { p.SetState(8457) p.Match(PostgreSQLParserREPEATABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8458) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8459) p.A_expr() } { p.SetState(8460) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserUNION, PostgreSQLParserUSING, PostgreSQLParserWHEN, PostgreSQLParserWHERE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserCROSS, PostgreSQLParserFULL, PostgreSQLParserINNER_P, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserNATURAL, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_tableContext is an interface to support dynamic dispatch. type IFunc_tableContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Func_expr_windowless() IFunc_expr_windowlessContext Opt_ordinality() IOpt_ordinalityContext ROWS() antlr.TerminalNode FROM() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Rowsfrom_list() IRowsfrom_listContext CLOSE_PAREN() antlr.TerminalNode // IsFunc_tableContext differentiates from other interfaces. IsFunc_tableContext() } type Func_tableContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_tableContext() *Func_tableContext { var p = new(Func_tableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_table return p } func InitEmptyFunc_tableContext(p *Func_tableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_table } func (*Func_tableContext) IsFunc_tableContext() {} func NewFunc_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_tableContext { var p = new(Func_tableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_table return p } func (s *Func_tableContext) GetParser() antlr.Parser { return s.parser } func (s *Func_tableContext) Func_expr_windowless() IFunc_expr_windowlessContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_expr_windowlessContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_expr_windowlessContext) } func (s *Func_tableContext) Opt_ordinality() IOpt_ordinalityContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_ordinalityContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_ordinalityContext) } func (s *Func_tableContext) ROWS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROWS, 0) } func (s *Func_tableContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *Func_tableContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Func_tableContext) Rowsfrom_list() IRowsfrom_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRowsfrom_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRowsfrom_listContext) } func (s *Func_tableContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Func_tableContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_tableContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_table(s) } } func (s *Func_tableContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_table(s) } } func (s *Func_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_table(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_table() (localctx IFunc_tableContext) { localctx = NewFunc_tableContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1084, PostgreSQLParserRULE_func_table) p.SetState(8475) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 497, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8465) p.Func_expr_windowless() } { p.SetState(8466) p.Opt_ordinality() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(8468) p.Match(PostgreSQLParserROWS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8469) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8470) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8471) p.Rowsfrom_list() } { p.SetState(8472) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8473) p.Opt_ordinality() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRowsfrom_itemContext is an interface to support dynamic dispatch. type IRowsfrom_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Func_expr_windowless() IFunc_expr_windowlessContext Opt_col_def_list() IOpt_col_def_listContext // IsRowsfrom_itemContext differentiates from other interfaces. IsRowsfrom_itemContext() } type Rowsfrom_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRowsfrom_itemContext() *Rowsfrom_itemContext { var p = new(Rowsfrom_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsfrom_item return p } func InitEmptyRowsfrom_itemContext(p *Rowsfrom_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsfrom_item } func (*Rowsfrom_itemContext) IsRowsfrom_itemContext() {} func NewRowsfrom_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rowsfrom_itemContext { var p = new(Rowsfrom_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_rowsfrom_item return p } func (s *Rowsfrom_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Rowsfrom_itemContext) Func_expr_windowless() IFunc_expr_windowlessContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_expr_windowlessContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_expr_windowlessContext) } func (s *Rowsfrom_itemContext) Opt_col_def_list() IOpt_col_def_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_col_def_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_col_def_listContext) } func (s *Rowsfrom_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Rowsfrom_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Rowsfrom_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRowsfrom_item(s) } } func (s *Rowsfrom_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRowsfrom_item(s) } } func (s *Rowsfrom_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRowsfrom_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Rowsfrom_item() (localctx IRowsfrom_itemContext) { localctx = NewRowsfrom_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1086, PostgreSQLParserRULE_rowsfrom_item) p.EnterOuterAlt(localctx, 1) { p.SetState(8477) p.Func_expr_windowless() } { p.SetState(8478) p.Opt_col_def_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRowsfrom_listContext is an interface to support dynamic dispatch. type IRowsfrom_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllRowsfrom_item() []IRowsfrom_itemContext Rowsfrom_item(i int) IRowsfrom_itemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsRowsfrom_listContext differentiates from other interfaces. IsRowsfrom_listContext() } type Rowsfrom_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRowsfrom_listContext() *Rowsfrom_listContext { var p = new(Rowsfrom_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsfrom_list return p } func InitEmptyRowsfrom_listContext(p *Rowsfrom_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rowsfrom_list } func (*Rowsfrom_listContext) IsRowsfrom_listContext() {} func NewRowsfrom_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rowsfrom_listContext { var p = new(Rowsfrom_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_rowsfrom_list return p } func (s *Rowsfrom_listContext) GetParser() antlr.Parser { return s.parser } func (s *Rowsfrom_listContext) AllRowsfrom_item() []IRowsfrom_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IRowsfrom_itemContext); ok { len++ } } tst := make([]IRowsfrom_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IRowsfrom_itemContext); ok { tst[i] = t.(IRowsfrom_itemContext) i++ } } return tst } func (s *Rowsfrom_listContext) Rowsfrom_item(i int) IRowsfrom_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRowsfrom_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IRowsfrom_itemContext) } func (s *Rowsfrom_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Rowsfrom_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Rowsfrom_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Rowsfrom_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Rowsfrom_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRowsfrom_list(s) } } func (s *Rowsfrom_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRowsfrom_list(s) } } func (s *Rowsfrom_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRowsfrom_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Rowsfrom_list() (localctx IRowsfrom_listContext) { localctx = NewRowsfrom_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1088, PostgreSQLParserRULE_rowsfrom_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8480) p.Rowsfrom_item() } p.SetState(8485) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(8481) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8482) p.Rowsfrom_item() } p.SetState(8487) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_col_def_listContext is an interface to support dynamic dispatch. type IOpt_col_def_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AS() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Tablefuncelementlist() ITablefuncelementlistContext CLOSE_PAREN() antlr.TerminalNode // IsOpt_col_def_listContext differentiates from other interfaces. IsOpt_col_def_listContext() } type Opt_col_def_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_col_def_listContext() *Opt_col_def_listContext { var p = new(Opt_col_def_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_col_def_list return p } func InitEmptyOpt_col_def_listContext(p *Opt_col_def_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_col_def_list } func (*Opt_col_def_listContext) IsOpt_col_def_listContext() {} func NewOpt_col_def_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_col_def_listContext { var p = new(Opt_col_def_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_col_def_list return p } func (s *Opt_col_def_listContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_col_def_listContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Opt_col_def_listContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Opt_col_def_listContext) Tablefuncelementlist() ITablefuncelementlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITablefuncelementlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITablefuncelementlistContext) } func (s *Opt_col_def_listContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Opt_col_def_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_col_def_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_col_def_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_col_def_list(s) } } func (s *Opt_col_def_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_col_def_list(s) } } func (s *Opt_col_def_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_col_def_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_col_def_list() (localctx IOpt_col_def_listContext) { localctx = NewOpt_col_def_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1090, PostgreSQLParserRULE_opt_col_def_list) p.SetState(8494) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAS: p.EnterOuterAlt(localctx, 1) { p.SetState(8488) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8489) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8490) p.Tablefuncelementlist() } { p.SetState(8491) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_ordinalityContext is an interface to support dynamic dispatch. type IOpt_ordinalityContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITH() antlr.TerminalNode ORDINALITY() antlr.TerminalNode // IsOpt_ordinalityContext differentiates from other interfaces. IsOpt_ordinalityContext() } type Opt_ordinalityContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_ordinalityContext() *Opt_ordinalityContext { var p = new(Opt_ordinalityContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_ordinality return p } func InitEmptyOpt_ordinalityContext(p *Opt_ordinalityContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_ordinality } func (*Opt_ordinalityContext) IsOpt_ordinalityContext() {} func NewOpt_ordinalityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_ordinalityContext { var p = new(Opt_ordinalityContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_ordinality return p } func (s *Opt_ordinalityContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_ordinalityContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *Opt_ordinalityContext) ORDINALITY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserORDINALITY, 0) } func (s *Opt_ordinalityContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_ordinalityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_ordinalityContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_ordinality(s) } } func (s *Opt_ordinalityContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_ordinality(s) } } func (s *Opt_ordinalityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_ordinality(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_ordinality() (localctx IOpt_ordinalityContext) { localctx = NewOpt_ordinalityContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1092, PostgreSQLParserRULE_opt_ordinality) p.SetState(8499) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 500, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8496) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8497) p.Match(PostgreSQLParserORDINALITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IWhere_clauseContext is an interface to support dynamic dispatch. type IWhere_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WHERE() antlr.TerminalNode A_expr() IA_exprContext // IsWhere_clauseContext differentiates from other interfaces. IsWhere_clauseContext() } type Where_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyWhere_clauseContext() *Where_clauseContext { var p = new(Where_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_where_clause return p } func InitEmptyWhere_clauseContext(p *Where_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_where_clause } func (*Where_clauseContext) IsWhere_clauseContext() {} func NewWhere_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Where_clauseContext { var p = new(Where_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_where_clause return p } func (s *Where_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Where_clauseContext) WHERE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHERE, 0) } func (s *Where_clauseContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Where_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Where_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Where_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterWhere_clause(s) } } func (s *Where_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitWhere_clause(s) } } func (s *Where_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitWhere_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Where_clause() (localctx IWhere_clauseContext) { localctx = NewWhere_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1094, PostgreSQLParserRULE_where_clause) p.SetState(8504) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserWHERE: p.EnterOuterAlt(localctx, 1) { p.SetState(8501) p.Match(PostgreSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8502) p.A_expr() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserUNION, PostgreSQLParserUSING, PostgreSQLParserWHEN, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IWhere_or_current_clauseContext is an interface to support dynamic dispatch. type IWhere_or_current_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WHERE() antlr.TerminalNode CURRENT_P() antlr.TerminalNode OF() antlr.TerminalNode Cursor_name() ICursor_nameContext A_expr() IA_exprContext // IsWhere_or_current_clauseContext differentiates from other interfaces. IsWhere_or_current_clauseContext() } type Where_or_current_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyWhere_or_current_clauseContext() *Where_or_current_clauseContext { var p = new(Where_or_current_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_where_or_current_clause return p } func InitEmptyWhere_or_current_clauseContext(p *Where_or_current_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_where_or_current_clause } func (*Where_or_current_clauseContext) IsWhere_or_current_clauseContext() {} func NewWhere_or_current_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Where_or_current_clauseContext { var p = new(Where_or_current_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_where_or_current_clause return p } func (s *Where_or_current_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Where_or_current_clauseContext) WHERE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHERE, 0) } func (s *Where_or_current_clauseContext) CURRENT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_P, 0) } func (s *Where_or_current_clauseContext) OF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOF, 0) } func (s *Where_or_current_clauseContext) Cursor_name() ICursor_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICursor_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICursor_nameContext) } func (s *Where_or_current_clauseContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Where_or_current_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Where_or_current_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Where_or_current_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterWhere_or_current_clause(s) } } func (s *Where_or_current_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitWhere_or_current_clause(s) } } func (s *Where_or_current_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitWhere_or_current_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Where_or_current_clause() (localctx IWhere_or_current_clauseContext) { localctx = NewWhere_or_current_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1096, PostgreSQLParserRULE_where_or_current_clause) p.SetState(8514) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserWHERE: p.EnterOuterAlt(localctx, 1) { p.SetState(8506) p.Match(PostgreSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8511) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 502, p.GetParserRuleContext()) { case 1: { p.SetState(8507) p.Match(PostgreSQLParserCURRENT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8508) p.Match(PostgreSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8509) p.Cursor_name() } case 2: { p.SetState(8510) p.A_expr() } case antlr.ATNInvalidAltNumber: goto errorExit } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserGRANT, PostgreSQLParserINTO, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpttablefuncelementlistContext is an interface to support dynamic dispatch. type IOpttablefuncelementlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Tablefuncelementlist() ITablefuncelementlistContext // IsOpttablefuncelementlistContext differentiates from other interfaces. IsOpttablefuncelementlistContext() } type OpttablefuncelementlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpttablefuncelementlistContext() *OpttablefuncelementlistContext { var p = new(OpttablefuncelementlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opttablefuncelementlist return p } func InitEmptyOpttablefuncelementlistContext(p *OpttablefuncelementlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opttablefuncelementlist } func (*OpttablefuncelementlistContext) IsOpttablefuncelementlistContext() {} func NewOpttablefuncelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttablefuncelementlistContext { var p = new(OpttablefuncelementlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opttablefuncelementlist return p } func (s *OpttablefuncelementlistContext) GetParser() antlr.Parser { return s.parser } func (s *OpttablefuncelementlistContext) Tablefuncelementlist() ITablefuncelementlistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITablefuncelementlistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITablefuncelementlistContext) } func (s *OpttablefuncelementlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *OpttablefuncelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OpttablefuncelementlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpttablefuncelementlist(s) } } func (s *OpttablefuncelementlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpttablefuncelementlist(s) } } func (s *OpttablefuncelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpttablefuncelementlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opttablefuncelementlist() (localctx IOpttablefuncelementlistContext) { localctx = NewOpttablefuncelementlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1098, PostgreSQLParserRULE_opttablefuncelementlist) p.SetState(8518) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(8516) p.Tablefuncelementlist() } case PostgreSQLParserCLOSE_PAREN: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITablefuncelementlistContext is an interface to support dynamic dispatch. type ITablefuncelementlistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllTablefuncelement() []ITablefuncelementContext Tablefuncelement(i int) ITablefuncelementContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsTablefuncelementlistContext differentiates from other interfaces. IsTablefuncelementlistContext() } type TablefuncelementlistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTablefuncelementlistContext() *TablefuncelementlistContext { var p = new(TablefuncelementlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tablefuncelementlist return p } func InitEmptyTablefuncelementlistContext(p *TablefuncelementlistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tablefuncelementlist } func (*TablefuncelementlistContext) IsTablefuncelementlistContext() {} func NewTablefuncelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablefuncelementlistContext { var p = new(TablefuncelementlistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_tablefuncelementlist return p } func (s *TablefuncelementlistContext) GetParser() antlr.Parser { return s.parser } func (s *TablefuncelementlistContext) AllTablefuncelement() []ITablefuncelementContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITablefuncelementContext); ok { len++ } } tst := make([]ITablefuncelementContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITablefuncelementContext); ok { tst[i] = t.(ITablefuncelementContext) i++ } } return tst } func (s *TablefuncelementlistContext) Tablefuncelement(i int) ITablefuncelementContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITablefuncelementContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITablefuncelementContext) } func (s *TablefuncelementlistContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *TablefuncelementlistContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *TablefuncelementlistContext) GetRuleContext() antlr.RuleContext { return s } func (s *TablefuncelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TablefuncelementlistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTablefuncelementlist(s) } } func (s *TablefuncelementlistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTablefuncelementlist(s) } } func (s *TablefuncelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTablefuncelementlist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Tablefuncelementlist() (localctx ITablefuncelementlistContext) { localctx = NewTablefuncelementlistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1100, PostgreSQLParserRULE_tablefuncelementlist) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8520) p.Tablefuncelement() } p.SetState(8525) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(8521) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8522) p.Tablefuncelement() } p.SetState(8527) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITablefuncelementContext is an interface to support dynamic dispatch. type ITablefuncelementContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext Typename() ITypenameContext Opt_collate_clause() IOpt_collate_clauseContext // IsTablefuncelementContext differentiates from other interfaces. IsTablefuncelementContext() } type TablefuncelementContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTablefuncelementContext() *TablefuncelementContext { var p = new(TablefuncelementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tablefuncelement return p } func InitEmptyTablefuncelementContext(p *TablefuncelementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_tablefuncelement } func (*TablefuncelementContext) IsTablefuncelementContext() {} func NewTablefuncelementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablefuncelementContext { var p = new(TablefuncelementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_tablefuncelement return p } func (s *TablefuncelementContext) GetParser() antlr.Parser { return s.parser } func (s *TablefuncelementContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *TablefuncelementContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *TablefuncelementContext) Opt_collate_clause() IOpt_collate_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_collate_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_collate_clauseContext) } func (s *TablefuncelementContext) GetRuleContext() antlr.RuleContext { return s } func (s *TablefuncelementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TablefuncelementContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTablefuncelement(s) } } func (s *TablefuncelementContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTablefuncelement(s) } } func (s *TablefuncelementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTablefuncelement(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Tablefuncelement() (localctx ITablefuncelementContext) { localctx = NewTablefuncelementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1102, PostgreSQLParserRULE_tablefuncelement) p.EnterOuterAlt(localctx, 1) { p.SetState(8528) p.Colid() } { p.SetState(8529) p.Typename() } { p.SetState(8530) p.Opt_collate_clause() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXmltableContext is an interface to support dynamic dispatch. type IXmltableContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures XMLTABLE() antlr.TerminalNode AllOPEN_PAREN() []antlr.TerminalNode OPEN_PAREN(i int) antlr.TerminalNode AllCLOSE_PAREN() []antlr.TerminalNode CLOSE_PAREN(i int) antlr.TerminalNode C_expr() IC_exprContext Xmlexists_argument() IXmlexists_argumentContext COLUMNS() antlr.TerminalNode Xmltable_column_list() IXmltable_column_listContext XMLNAMESPACES() antlr.TerminalNode Xml_namespace_list() IXml_namespace_listContext COMMA() antlr.TerminalNode // IsXmltableContext differentiates from other interfaces. IsXmltableContext() } type XmltableContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXmltableContext() *XmltableContext { var p = new(XmltableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xmltable return p } func InitEmptyXmltableContext(p *XmltableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xmltable } func (*XmltableContext) IsXmltableContext() {} func NewXmltableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XmltableContext { var p = new(XmltableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xmltable return p } func (s *XmltableContext) GetParser() antlr.Parser { return s.parser } func (s *XmltableContext) XMLTABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLTABLE, 0) } func (s *XmltableContext) AllOPEN_PAREN() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserOPEN_PAREN) } func (s *XmltableContext) OPEN_PAREN(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, i) } func (s *XmltableContext) AllCLOSE_PAREN() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCLOSE_PAREN) } func (s *XmltableContext) CLOSE_PAREN(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, i) } func (s *XmltableContext) C_expr() IC_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IC_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IC_exprContext) } func (s *XmltableContext) Xmlexists_argument() IXmlexists_argumentContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXmlexists_argumentContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IXmlexists_argumentContext) } func (s *XmltableContext) COLUMNS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLUMNS, 0) } func (s *XmltableContext) Xmltable_column_list() IXmltable_column_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXmltable_column_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IXmltable_column_listContext) } func (s *XmltableContext) XMLNAMESPACES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLNAMESPACES, 0) } func (s *XmltableContext) Xml_namespace_list() IXml_namespace_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXml_namespace_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IXml_namespace_listContext) } func (s *XmltableContext) COMMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, 0) } func (s *XmltableContext) GetRuleContext() antlr.RuleContext { return s } func (s *XmltableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *XmltableContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXmltable(s) } } func (s *XmltableContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXmltable(s) } } func (s *XmltableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXmltable(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xmltable() (localctx IXmltableContext) { localctx = NewXmltableContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1104, PostgreSQLParserRULE_xmltable) p.EnterOuterAlt(localctx, 1) { p.SetState(8532) p.Match(PostgreSQLParserXMLTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8533) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8549) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 506, p.GetParserRuleContext()) { case 1: { p.SetState(8534) p.C_expr() } { p.SetState(8535) p.Xmlexists_argument() } { p.SetState(8536) p.Match(PostgreSQLParserCOLUMNS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8537) p.Xmltable_column_list() } case 2: { p.SetState(8539) p.Match(PostgreSQLParserXMLNAMESPACES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8540) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8541) p.Xml_namespace_list() } { p.SetState(8542) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8543) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8544) p.C_expr() } { p.SetState(8545) p.Xmlexists_argument() } { p.SetState(8546) p.Match(PostgreSQLParserCOLUMNS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8547) p.Xmltable_column_list() } case antlr.ATNInvalidAltNumber: goto errorExit } { p.SetState(8551) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXmltable_column_listContext is an interface to support dynamic dispatch. type IXmltable_column_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllXmltable_column_el() []IXmltable_column_elContext Xmltable_column_el(i int) IXmltable_column_elContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsXmltable_column_listContext differentiates from other interfaces. IsXmltable_column_listContext() } type Xmltable_column_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXmltable_column_listContext() *Xmltable_column_listContext { var p = new(Xmltable_column_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xmltable_column_list return p } func InitEmptyXmltable_column_listContext(p *Xmltable_column_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xmltable_column_list } func (*Xmltable_column_listContext) IsXmltable_column_listContext() {} func NewXmltable_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltable_column_listContext { var p = new(Xmltable_column_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xmltable_column_list return p } func (s *Xmltable_column_listContext) GetParser() antlr.Parser { return s.parser } func (s *Xmltable_column_listContext) AllXmltable_column_el() []IXmltable_column_elContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IXmltable_column_elContext); ok { len++ } } tst := make([]IXmltable_column_elContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IXmltable_column_elContext); ok { tst[i] = t.(IXmltable_column_elContext) i++ } } return tst } func (s *Xmltable_column_listContext) Xmltable_column_el(i int) IXmltable_column_elContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXmltable_column_elContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IXmltable_column_elContext) } func (s *Xmltable_column_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Xmltable_column_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Xmltable_column_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Xmltable_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Xmltable_column_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXmltable_column_list(s) } } func (s *Xmltable_column_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXmltable_column_list(s) } } func (s *Xmltable_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXmltable_column_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xmltable_column_list() (localctx IXmltable_column_listContext) { localctx = NewXmltable_column_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1106, PostgreSQLParserRULE_xmltable_column_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8553) p.Xmltable_column_el() } p.SetState(8558) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(8554) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8555) p.Xmltable_column_el() } p.SetState(8560) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXmltable_column_elContext is an interface to support dynamic dispatch. type IXmltable_column_elContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext Typename() ITypenameContext FOR() antlr.TerminalNode ORDINALITY() antlr.TerminalNode Xmltable_column_option_list() IXmltable_column_option_listContext // IsXmltable_column_elContext differentiates from other interfaces. IsXmltable_column_elContext() } type Xmltable_column_elContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXmltable_column_elContext() *Xmltable_column_elContext { var p = new(Xmltable_column_elContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xmltable_column_el return p } func InitEmptyXmltable_column_elContext(p *Xmltable_column_elContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xmltable_column_el } func (*Xmltable_column_elContext) IsXmltable_column_elContext() {} func NewXmltable_column_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltable_column_elContext { var p = new(Xmltable_column_elContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xmltable_column_el return p } func (s *Xmltable_column_elContext) GetParser() antlr.Parser { return s.parser } func (s *Xmltable_column_elContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Xmltable_column_elContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *Xmltable_column_elContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *Xmltable_column_elContext) ORDINALITY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserORDINALITY, 0) } func (s *Xmltable_column_elContext) Xmltable_column_option_list() IXmltable_column_option_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXmltable_column_option_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IXmltable_column_option_listContext) } func (s *Xmltable_column_elContext) GetRuleContext() antlr.RuleContext { return s } func (s *Xmltable_column_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Xmltable_column_elContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXmltable_column_el(s) } } func (s *Xmltable_column_elContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXmltable_column_el(s) } } func (s *Xmltable_column_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXmltable_column_el(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xmltable_column_el() (localctx IXmltable_column_elContext) { localctx = NewXmltable_column_elContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1108, PostgreSQLParserRULE_xmltable_column_el) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8561) p.Colid() } p.SetState(8568) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: { p.SetState(8562) p.Typename() } p.SetState(8564) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&576513529147825157) != 0) || ((int64((_la-116)) & ^0x3f) == 0 && ((int64(1)<<(_la-116))&74346914954363009) != 0) || ((int64((_la-207)) & ^0x3f) == 0 && ((int64(1)<<(_la-207))&56295003965620233) != 0) || ((int64((_la-272)) & ^0x3f) == 0 && ((int64(1)<<(_la-272))&18068292027564033) != 0) || _la == PostgreSQLParserTYPE_P || ((int64((_la-433)) & ^0x3f) == 0 && ((int64(1)<<(_la-433))&-144097595889811453) != 0) || ((int64((_la-497)) & ^0x3f) == 0 && ((int64(1)<<(_la-497))&12516927) != 0) || ((int64((_la-636)) & ^0x3f) == 0 && ((int64(1)<<(_la-636))&100663331) != 0) { { p.SetState(8563) p.Xmltable_column_option_list() } } case PostgreSQLParserFOR: { p.SetState(8566) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8567) p.Match(PostgreSQLParserORDINALITY) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXmltable_column_option_listContext is an interface to support dynamic dispatch. type IXmltable_column_option_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllXmltable_column_option_el() []IXmltable_column_option_elContext Xmltable_column_option_el(i int) IXmltable_column_option_elContext // IsXmltable_column_option_listContext differentiates from other interfaces. IsXmltable_column_option_listContext() } type Xmltable_column_option_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXmltable_column_option_listContext() *Xmltable_column_option_listContext { var p = new(Xmltable_column_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xmltable_column_option_list return p } func InitEmptyXmltable_column_option_listContext(p *Xmltable_column_option_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xmltable_column_option_list } func (*Xmltable_column_option_listContext) IsXmltable_column_option_listContext() {} func NewXmltable_column_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltable_column_option_listContext { var p = new(Xmltable_column_option_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xmltable_column_option_list return p } func (s *Xmltable_column_option_listContext) GetParser() antlr.Parser { return s.parser } func (s *Xmltable_column_option_listContext) AllXmltable_column_option_el() []IXmltable_column_option_elContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IXmltable_column_option_elContext); ok { len++ } } tst := make([]IXmltable_column_option_elContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IXmltable_column_option_elContext); ok { tst[i] = t.(IXmltable_column_option_elContext) i++ } } return tst } func (s *Xmltable_column_option_listContext) Xmltable_column_option_el(i int) IXmltable_column_option_elContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXmltable_column_option_elContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IXmltable_column_option_elContext) } func (s *Xmltable_column_option_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Xmltable_column_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Xmltable_column_option_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXmltable_column_option_list(s) } } func (s *Xmltable_column_option_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXmltable_column_option_list(s) } } func (s *Xmltable_column_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXmltable_column_option_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xmltable_column_option_list() (localctx IXmltable_column_option_listContext) { localctx = NewXmltable_column_option_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1110, PostgreSQLParserRULE_xmltable_column_option_list) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(8571) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ok := true; ok; ok = ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&576513529147825157) != 0) || ((int64((_la-116)) & ^0x3f) == 0 && ((int64(1)<<(_la-116))&74346914954363009) != 0) || ((int64((_la-207)) & ^0x3f) == 0 && ((int64(1)<<(_la-207))&56295003965620233) != 0) || ((int64((_la-272)) & ^0x3f) == 0 && ((int64(1)<<(_la-272))&18068292027564033) != 0) || _la == PostgreSQLParserTYPE_P || ((int64((_la-433)) & ^0x3f) == 0 && ((int64(1)<<(_la-433))&-144097595889811453) != 0) || ((int64((_la-497)) & ^0x3f) == 0 && ((int64(1)<<(_la-497))&12516927) != 0) || ((int64((_la-636)) & ^0x3f) == 0 && ((int64(1)<<(_la-636))&100663331) != 0) { { p.SetState(8570) p.Xmltable_column_option_el() } p.SetState(8573) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXmltable_column_option_elContext is an interface to support dynamic dispatch. type IXmltable_column_option_elContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DEFAULT() antlr.TerminalNode A_expr() IA_exprContext Identifier() IIdentifierContext NOT() antlr.TerminalNode NULL_P() antlr.TerminalNode // IsXmltable_column_option_elContext differentiates from other interfaces. IsXmltable_column_option_elContext() } type Xmltable_column_option_elContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXmltable_column_option_elContext() *Xmltable_column_option_elContext { var p = new(Xmltable_column_option_elContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xmltable_column_option_el return p } func InitEmptyXmltable_column_option_elContext(p *Xmltable_column_option_elContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xmltable_column_option_el } func (*Xmltable_column_option_elContext) IsXmltable_column_option_elContext() {} func NewXmltable_column_option_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltable_column_option_elContext { var p = new(Xmltable_column_option_elContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xmltable_column_option_el return p } func (s *Xmltable_column_option_elContext) GetParser() antlr.Parser { return s.parser } func (s *Xmltable_column_option_elContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Xmltable_column_option_elContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Xmltable_column_option_elContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *Xmltable_column_option_elContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *Xmltable_column_option_elContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *Xmltable_column_option_elContext) GetRuleContext() antlr.RuleContext { return s } func (s *Xmltable_column_option_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Xmltable_column_option_elContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXmltable_column_option_el(s) } } func (s *Xmltable_column_option_elContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXmltable_column_option_el(s) } } func (s *Xmltable_column_option_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXmltable_column_option_el(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xmltable_column_option_el() (localctx IXmltable_column_option_elContext) { localctx = NewXmltable_column_option_elContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1112, PostgreSQLParserRULE_xmltable_column_option_el) p.SetState(8583) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 511, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8575) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8576) p.A_expr() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(8577) p.Identifier() } { p.SetState(8578) p.A_expr() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(8580) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8581) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(8582) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXml_namespace_listContext is an interface to support dynamic dispatch. type IXml_namespace_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllXml_namespace_el() []IXml_namespace_elContext Xml_namespace_el(i int) IXml_namespace_elContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsXml_namespace_listContext differentiates from other interfaces. IsXml_namespace_listContext() } type Xml_namespace_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXml_namespace_listContext() *Xml_namespace_listContext { var p = new(Xml_namespace_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_namespace_list return p } func InitEmptyXml_namespace_listContext(p *Xml_namespace_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_namespace_list } func (*Xml_namespace_listContext) IsXml_namespace_listContext() {} func NewXml_namespace_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_namespace_listContext { var p = new(Xml_namespace_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xml_namespace_list return p } func (s *Xml_namespace_listContext) GetParser() antlr.Parser { return s.parser } func (s *Xml_namespace_listContext) AllXml_namespace_el() []IXml_namespace_elContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IXml_namespace_elContext); ok { len++ } } tst := make([]IXml_namespace_elContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IXml_namespace_elContext); ok { tst[i] = t.(IXml_namespace_elContext) i++ } } return tst } func (s *Xml_namespace_listContext) Xml_namespace_el(i int) IXml_namespace_elContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXml_namespace_elContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IXml_namespace_elContext) } func (s *Xml_namespace_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Xml_namespace_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Xml_namespace_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Xml_namespace_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Xml_namespace_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXml_namespace_list(s) } } func (s *Xml_namespace_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXml_namespace_list(s) } } func (s *Xml_namespace_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXml_namespace_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xml_namespace_list() (localctx IXml_namespace_listContext) { localctx = NewXml_namespace_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1114, PostgreSQLParserRULE_xml_namespace_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8585) p.Xml_namespace_el() } p.SetState(8590) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(8586) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8587) p.Xml_namespace_el() } p.SetState(8592) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXml_namespace_elContext is an interface to support dynamic dispatch. type IXml_namespace_elContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures B_expr() IB_exprContext AS() antlr.TerminalNode Collabel() ICollabelContext DEFAULT() antlr.TerminalNode // IsXml_namespace_elContext differentiates from other interfaces. IsXml_namespace_elContext() } type Xml_namespace_elContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXml_namespace_elContext() *Xml_namespace_elContext { var p = new(Xml_namespace_elContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_namespace_el return p } func InitEmptyXml_namespace_elContext(p *Xml_namespace_elContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_namespace_el } func (*Xml_namespace_elContext) IsXml_namespace_elContext() {} func NewXml_namespace_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_namespace_elContext { var p = new(Xml_namespace_elContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xml_namespace_el return p } func (s *Xml_namespace_elContext) GetParser() antlr.Parser { return s.parser } func (s *Xml_namespace_elContext) B_expr() IB_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IB_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IB_exprContext) } func (s *Xml_namespace_elContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Xml_namespace_elContext) Collabel() ICollabelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICollabelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICollabelContext) } func (s *Xml_namespace_elContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Xml_namespace_elContext) GetRuleContext() antlr.RuleContext { return s } func (s *Xml_namespace_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Xml_namespace_elContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXml_namespace_el(s) } } func (s *Xml_namespace_elContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXml_namespace_el(s) } } func (s *Xml_namespace_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXml_namespace_el(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xml_namespace_el() (localctx IXml_namespace_elContext) { localctx = NewXml_namespace_elContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1116, PostgreSQLParserRULE_xml_namespace_el) p.SetState(8599) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 513, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8593) p.b_expr(0) } { p.SetState(8594) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8595) p.Collabel() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(8597) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8598) p.b_expr(0) } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITypenameContext is an interface to support dynamic dispatch. type ITypenameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Simpletypename() ISimpletypenameContext Opt_array_bounds() IOpt_array_boundsContext ARRAY() antlr.TerminalNode SETOF() antlr.TerminalNode OPEN_BRACKET() antlr.TerminalNode Iconst() IIconstContext CLOSE_BRACKET() antlr.TerminalNode Qualified_name() IQualified_nameContext PERCENT() antlr.TerminalNode ROWTYPE() antlr.TerminalNode TYPE_P() antlr.TerminalNode // IsTypenameContext differentiates from other interfaces. IsTypenameContext() } type TypenameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTypenameContext() *TypenameContext { var p = new(TypenameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_typename return p } func InitEmptyTypenameContext(p *TypenameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_typename } func (*TypenameContext) IsTypenameContext() {} func NewTypenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypenameContext { var p = new(TypenameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_typename return p } func (s *TypenameContext) GetParser() antlr.Parser { return s.parser } func (s *TypenameContext) Simpletypename() ISimpletypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISimpletypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISimpletypenameContext) } func (s *TypenameContext) Opt_array_bounds() IOpt_array_boundsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_array_boundsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_array_boundsContext) } func (s *TypenameContext) ARRAY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserARRAY, 0) } func (s *TypenameContext) SETOF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSETOF, 0) } func (s *TypenameContext) OPEN_BRACKET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_BRACKET, 0) } func (s *TypenameContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *TypenameContext) CLOSE_BRACKET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_BRACKET, 0) } func (s *TypenameContext) Qualified_name() IQualified_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *TypenameContext) PERCENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPERCENT, 0) } func (s *TypenameContext) ROWTYPE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROWTYPE, 0) } func (s *TypenameContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *TypenameContext) GetRuleContext() antlr.RuleContext { return s } func (s *TypenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *TypenameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTypename(s) } } func (s *TypenameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTypename(s) } } func (s *TypenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTypename(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Typename() (localctx ITypenameContext) { localctx = NewTypenameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1118, PostgreSQLParserRULE_typename) var _la int p.SetState(8619) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 517, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) p.SetState(8602) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserSETOF { { p.SetState(8601) p.Match(PostgreSQLParserSETOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(8604) p.Simpletypename() } p.SetState(8613) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 516, p.GetParserRuleContext()) { case 1: { p.SetState(8605) p.Opt_array_bounds() } case 2: { p.SetState(8606) p.Match(PostgreSQLParserARRAY) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8611) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 515, p.GetParserRuleContext()) == 1 { { p.SetState(8607) p.Match(PostgreSQLParserOPEN_BRACKET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8608) p.Iconst() } { p.SetState(8609) p.Match(PostgreSQLParserCLOSE_BRACKET) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } case antlr.ATNInvalidAltNumber: goto errorExit } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(8615) p.Qualified_name() } { p.SetState(8616) p.Match(PostgreSQLParserPERCENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8617) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserTYPE_P || _la == PostgreSQLParserROWTYPE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_array_boundsContext is an interface to support dynamic dispatch. type IOpt_array_boundsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllOPEN_BRACKET() []antlr.TerminalNode OPEN_BRACKET(i int) antlr.TerminalNode AllCLOSE_BRACKET() []antlr.TerminalNode CLOSE_BRACKET(i int) antlr.TerminalNode AllIconst() []IIconstContext Iconst(i int) IIconstContext // IsOpt_array_boundsContext differentiates from other interfaces. IsOpt_array_boundsContext() } type Opt_array_boundsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_array_boundsContext() *Opt_array_boundsContext { var p = new(Opt_array_boundsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_array_bounds return p } func InitEmptyOpt_array_boundsContext(p *Opt_array_boundsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_array_bounds } func (*Opt_array_boundsContext) IsOpt_array_boundsContext() {} func NewOpt_array_boundsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_array_boundsContext { var p = new(Opt_array_boundsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_array_bounds return p } func (s *Opt_array_boundsContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_array_boundsContext) AllOPEN_BRACKET() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserOPEN_BRACKET) } func (s *Opt_array_boundsContext) OPEN_BRACKET(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_BRACKET, i) } func (s *Opt_array_boundsContext) AllCLOSE_BRACKET() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCLOSE_BRACKET) } func (s *Opt_array_boundsContext) CLOSE_BRACKET(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_BRACKET, i) } func (s *Opt_array_boundsContext) AllIconst() []IIconstContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IIconstContext); ok { len++ } } tst := make([]IIconstContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IIconstContext); ok { tst[i] = t.(IIconstContext) i++ } } return tst } func (s *Opt_array_boundsContext) Iconst(i int) IIconstContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IIconstContext) } func (s *Opt_array_boundsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_array_boundsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_array_boundsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_array_bounds(s) } } func (s *Opt_array_boundsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_array_bounds(s) } } func (s *Opt_array_boundsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_array_bounds(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_array_bounds() (localctx IOpt_array_boundsContext) { localctx = NewOpt_array_boundsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1120, PostgreSQLParserRULE_opt_array_bounds) var _la int var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(8628) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 519, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(8621) p.Match(PostgreSQLParserOPEN_BRACKET) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8623) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserIntegral { { p.SetState(8622) p.Iconst() } } { p.SetState(8625) p.Match(PostgreSQLParserCLOSE_BRACKET) if p.HasError() { // Recognition error - abort rule goto errorExit } } } p.SetState(8630) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 519, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISimpletypenameContext is an interface to support dynamic dispatch. type ISimpletypenameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Generictype() IGenerictypeContext Numeric() INumericContext Bit() IBitContext Character() ICharacterContext Constdatetime() IConstdatetimeContext Constinterval() IConstintervalContext Opt_interval() IOpt_intervalContext OPEN_PAREN() antlr.TerminalNode Iconst() IIconstContext CLOSE_PAREN() antlr.TerminalNode // IsSimpletypenameContext differentiates from other interfaces. IsSimpletypenameContext() } type SimpletypenameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySimpletypenameContext() *SimpletypenameContext { var p = new(SimpletypenameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_simpletypename return p } func InitEmptySimpletypenameContext(p *SimpletypenameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_simpletypename } func (*SimpletypenameContext) IsSimpletypenameContext() {} func NewSimpletypenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpletypenameContext { var p = new(SimpletypenameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_simpletypename return p } func (s *SimpletypenameContext) GetParser() antlr.Parser { return s.parser } func (s *SimpletypenameContext) Generictype() IGenerictypeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGenerictypeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGenerictypeContext) } func (s *SimpletypenameContext) Numeric() INumericContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericContext) } func (s *SimpletypenameContext) Bit() IBitContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IBitContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IBitContext) } func (s *SimpletypenameContext) Character() ICharacterContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICharacterContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICharacterContext) } func (s *SimpletypenameContext) Constdatetime() IConstdatetimeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstdatetimeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstdatetimeContext) } func (s *SimpletypenameContext) Constinterval() IConstintervalContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstintervalContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstintervalContext) } func (s *SimpletypenameContext) Opt_interval() IOpt_intervalContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_intervalContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_intervalContext) } func (s *SimpletypenameContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *SimpletypenameContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *SimpletypenameContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *SimpletypenameContext) GetRuleContext() antlr.RuleContext { return s } func (s *SimpletypenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SimpletypenameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSimpletypename(s) } } func (s *SimpletypenameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSimpletypename(s) } } func (s *SimpletypenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSimpletypename(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Simpletypename() (localctx ISimpletypenameContext) { localctx = NewSimpletypenameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1122, PostgreSQLParserRULE_simpletypename) p.SetState(8644) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 521, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8631) p.Generictype() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(8632) p.Numeric() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(8633) p.Bit() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(8634) p.Character() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(8635) p.Constdatetime() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(8636) p.Constinterval() } p.SetState(8642) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 520, p.GetParserRuleContext()) { case 1: { p.SetState(8637) p.Opt_interval() } case 2: { p.SetState(8638) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8639) p.Iconst() } { p.SetState(8640) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IConsttypenameContext is an interface to support dynamic dispatch. type IConsttypenameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Numeric() INumericContext Constbit() IConstbitContext Constcharacter() IConstcharacterContext Constdatetime() IConstdatetimeContext // IsConsttypenameContext differentiates from other interfaces. IsConsttypenameContext() } type ConsttypenameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyConsttypenameContext() *ConsttypenameContext { var p = new(ConsttypenameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_consttypename return p } func InitEmptyConsttypenameContext(p *ConsttypenameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_consttypename } func (*ConsttypenameContext) IsConsttypenameContext() {} func NewConsttypenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConsttypenameContext { var p = new(ConsttypenameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_consttypename return p } func (s *ConsttypenameContext) GetParser() antlr.Parser { return s.parser } func (s *ConsttypenameContext) Numeric() INumericContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericContext) } func (s *ConsttypenameContext) Constbit() IConstbitContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstbitContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstbitContext) } func (s *ConsttypenameContext) Constcharacter() IConstcharacterContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstcharacterContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstcharacterContext) } func (s *ConsttypenameContext) Constdatetime() IConstdatetimeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstdatetimeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstdatetimeContext) } func (s *ConsttypenameContext) GetRuleContext() antlr.RuleContext { return s } func (s *ConsttypenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ConsttypenameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterConsttypename(s) } } func (s *ConsttypenameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitConsttypename(s) } } func (s *ConsttypenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitConsttypename(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Consttypename() (localctx IConsttypenameContext) { localctx = NewConsttypenameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1124, PostgreSQLParserRULE_consttypename) p.SetState(8650) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserDOUBLE_P, PostgreSQLParserBIGINT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserFLOAT_P, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserNUMERIC, PostgreSQLParserREAL, PostgreSQLParserSMALLINT: p.EnterOuterAlt(localctx, 1) { p.SetState(8646) p.Numeric() } case PostgreSQLParserBIT: p.EnterOuterAlt(localctx, 2) { p.SetState(8647) p.Constbit() } case PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserVARCHAR: p.EnterOuterAlt(localctx, 3) { p.SetState(8648) p.Constcharacter() } case PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP: p.EnterOuterAlt(localctx, 4) { p.SetState(8649) p.Constdatetime() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGenerictypeContext is an interface to support dynamic dispatch. type IGenerictypeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_type_modifiers() IOpt_type_modifiersContext Builtin_function_name() IBuiltin_function_nameContext Type_function_name() IType_function_nameContext LEFT() antlr.TerminalNode RIGHT() antlr.TerminalNode Attrs() IAttrsContext // IsGenerictypeContext differentiates from other interfaces. IsGenerictypeContext() } type GenerictypeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGenerictypeContext() *GenerictypeContext { var p = new(GenerictypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generictype return p } func InitEmptyGenerictypeContext(p *GenerictypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_generictype } func (*GenerictypeContext) IsGenerictypeContext() {} func NewGenerictypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GenerictypeContext { var p = new(GenerictypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_generictype return p } func (s *GenerictypeContext) GetParser() antlr.Parser { return s.parser } func (s *GenerictypeContext) Opt_type_modifiers() IOpt_type_modifiersContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_type_modifiersContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_type_modifiersContext) } func (s *GenerictypeContext) Builtin_function_name() IBuiltin_function_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IBuiltin_function_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IBuiltin_function_nameContext) } func (s *GenerictypeContext) Type_function_name() IType_function_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IType_function_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IType_function_nameContext) } func (s *GenerictypeContext) LEFT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEFT, 0) } func (s *GenerictypeContext) RIGHT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRIGHT, 0) } func (s *GenerictypeContext) Attrs() IAttrsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAttrsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAttrsContext) } func (s *GenerictypeContext) GetRuleContext() antlr.RuleContext { return s } func (s *GenerictypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *GenerictypeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGenerictype(s) } } func (s *GenerictypeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGenerictype(s) } } func (s *GenerictypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGenerictype(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Generictype() (localctx IGenerictypeContext) { localctx = NewGenerictypeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1126, PostgreSQLParserRULE_generictype) p.EnterOuterAlt(localctx, 1) p.SetState(8656) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserREPLACE, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserREVERSE, PostgreSQLParserLOG, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER: { p.SetState(8652) p.Builtin_function_name() } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserCOLUMNS, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: { p.SetState(8653) p.Type_function_name() } case PostgreSQLParserLEFT: { p.SetState(8654) p.Match(PostgreSQLParserLEFT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserRIGHT: { p.SetState(8655) p.Match(PostgreSQLParserRIGHT) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.SetState(8659) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 524, p.GetParserRuleContext()) == 1 { { p.SetState(8658) p.Attrs() } } else if p.HasError() { // JIM goto errorExit } { p.SetState(8661) p.Opt_type_modifiers() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_type_modifiersContext is an interface to support dynamic dispatch. type IOpt_type_modifiersContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Expr_list() IExpr_listContext CLOSE_PAREN() antlr.TerminalNode // IsOpt_type_modifiersContext differentiates from other interfaces. IsOpt_type_modifiersContext() } type Opt_type_modifiersContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_type_modifiersContext() *Opt_type_modifiersContext { var p = new(Opt_type_modifiersContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_type_modifiers return p } func InitEmptyOpt_type_modifiersContext(p *Opt_type_modifiersContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_type_modifiers } func (*Opt_type_modifiersContext) IsOpt_type_modifiersContext() {} func NewOpt_type_modifiersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_type_modifiersContext { var p = new(Opt_type_modifiersContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_type_modifiers return p } func (s *Opt_type_modifiersContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_type_modifiersContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Opt_type_modifiersContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Opt_type_modifiersContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Opt_type_modifiersContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_type_modifiersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_type_modifiersContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_type_modifiers(s) } } func (s *Opt_type_modifiersContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_type_modifiers(s) } } func (s *Opt_type_modifiersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_type_modifiers(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_type_modifiers() (localctx IOpt_type_modifiersContext) { localctx = NewOpt_type_modifiersContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1128, PostgreSQLParserRULE_opt_type_modifiers) p.SetState(8668) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 525, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8663) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8664) p.Expr_list() } { p.SetState(8665) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // INumericContext is an interface to support dynamic dispatch. type INumericContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures INT_P() antlr.TerminalNode INTEGER() antlr.TerminalNode SMALLINT() antlr.TerminalNode BIGINT() antlr.TerminalNode REAL() antlr.TerminalNode FLOAT_P() antlr.TerminalNode Opt_float() IOpt_floatContext DOUBLE_P() antlr.TerminalNode PRECISION() antlr.TerminalNode DECIMAL_P() antlr.TerminalNode Opt_type_modifiers() IOpt_type_modifiersContext DEC() antlr.TerminalNode NUMERIC() antlr.TerminalNode BOOLEAN_P() antlr.TerminalNode // IsNumericContext differentiates from other interfaces. IsNumericContext() } type NumericContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyNumericContext() *NumericContext { var p = new(NumericContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_numeric return p } func InitEmptyNumericContext(p *NumericContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_numeric } func (*NumericContext) IsNumericContext() {} func NewNumericContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumericContext { var p = new(NumericContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_numeric return p } func (s *NumericContext) GetParser() antlr.Parser { return s.parser } func (s *NumericContext) INT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINT_P, 0) } func (s *NumericContext) INTEGER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINTEGER, 0) } func (s *NumericContext) SMALLINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSMALLINT, 0) } func (s *NumericContext) BIGINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBIGINT, 0) } func (s *NumericContext) REAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREAL, 0) } func (s *NumericContext) FLOAT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFLOAT_P, 0) } func (s *NumericContext) Opt_float() IOpt_floatContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_floatContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_floatContext) } func (s *NumericContext) DOUBLE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOUBLE_P, 0) } func (s *NumericContext) PRECISION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRECISION, 0) } func (s *NumericContext) DECIMAL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDECIMAL_P, 0) } func (s *NumericContext) Opt_type_modifiers() IOpt_type_modifiersContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_type_modifiersContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_type_modifiersContext) } func (s *NumericContext) DEC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEC, 0) } func (s *NumericContext) NUMERIC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNUMERIC, 0) } func (s *NumericContext) BOOLEAN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBOOLEAN_P, 0) } func (s *NumericContext) GetRuleContext() antlr.RuleContext { return s } func (s *NumericContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *NumericContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterNumeric(s) } } func (s *NumericContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitNumeric(s) } } func (s *NumericContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitNumeric(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Numeric() (localctx INumericContext) { localctx = NewNumericContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1130, PostgreSQLParserRULE_numeric) p.SetState(8686) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserINT_P: p.EnterOuterAlt(localctx, 1) { p.SetState(8670) p.Match(PostgreSQLParserINT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserINTEGER: p.EnterOuterAlt(localctx, 2) { p.SetState(8671) p.Match(PostgreSQLParserINTEGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSMALLINT: p.EnterOuterAlt(localctx, 3) { p.SetState(8672) p.Match(PostgreSQLParserSMALLINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserBIGINT: p.EnterOuterAlt(localctx, 4) { p.SetState(8673) p.Match(PostgreSQLParserBIGINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserREAL: p.EnterOuterAlt(localctx, 5) { p.SetState(8674) p.Match(PostgreSQLParserREAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserFLOAT_P: p.EnterOuterAlt(localctx, 6) { p.SetState(8675) p.Match(PostgreSQLParserFLOAT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8676) p.Opt_float() } case PostgreSQLParserDOUBLE_P: p.EnterOuterAlt(localctx, 7) { p.SetState(8677) p.Match(PostgreSQLParserDOUBLE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8678) p.Match(PostgreSQLParserPRECISION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserDECIMAL_P: p.EnterOuterAlt(localctx, 8) { p.SetState(8679) p.Match(PostgreSQLParserDECIMAL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8680) p.Opt_type_modifiers() } case PostgreSQLParserDEC: p.EnterOuterAlt(localctx, 9) { p.SetState(8681) p.Match(PostgreSQLParserDEC) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8682) p.Opt_type_modifiers() } case PostgreSQLParserNUMERIC: p.EnterOuterAlt(localctx, 10) { p.SetState(8683) p.Match(PostgreSQLParserNUMERIC) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8684) p.Opt_type_modifiers() } case PostgreSQLParserBOOLEAN_P: p.EnterOuterAlt(localctx, 11) { p.SetState(8685) p.Match(PostgreSQLParserBOOLEAN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_floatContext is an interface to support dynamic dispatch. type IOpt_floatContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Iconst() IIconstContext CLOSE_PAREN() antlr.TerminalNode // IsOpt_floatContext differentiates from other interfaces. IsOpt_floatContext() } type Opt_floatContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_floatContext() *Opt_floatContext { var p = new(Opt_floatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_float return p } func InitEmptyOpt_floatContext(p *Opt_floatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_float } func (*Opt_floatContext) IsOpt_floatContext() {} func NewOpt_floatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_floatContext { var p = new(Opt_floatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_float return p } func (s *Opt_floatContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_floatContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Opt_floatContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *Opt_floatContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Opt_floatContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_floatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_floatContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_float(s) } } func (s *Opt_floatContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_float(s) } } func (s *Opt_floatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_float(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_float() (localctx IOpt_floatContext) { localctx = NewOpt_floatContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1132, PostgreSQLParserRULE_opt_float) p.SetState(8693) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 527, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8688) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8689) p.Iconst() } { p.SetState(8690) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IBitContext is an interface to support dynamic dispatch. type IBitContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Bitwithlength() IBitwithlengthContext Bitwithoutlength() IBitwithoutlengthContext // IsBitContext differentiates from other interfaces. IsBitContext() } type BitContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyBitContext() *BitContext { var p = new(BitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_bit return p } func InitEmptyBitContext(p *BitContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_bit } func (*BitContext) IsBitContext() {} func NewBitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitContext { var p = new(BitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_bit return p } func (s *BitContext) GetParser() antlr.Parser { return s.parser } func (s *BitContext) Bitwithlength() IBitwithlengthContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IBitwithlengthContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IBitwithlengthContext) } func (s *BitContext) Bitwithoutlength() IBitwithoutlengthContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IBitwithoutlengthContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IBitwithoutlengthContext) } func (s *BitContext) GetRuleContext() antlr.RuleContext { return s } func (s *BitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *BitContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterBit(s) } } func (s *BitContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitBit(s) } } func (s *BitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitBit(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Bit() (localctx IBitContext) { localctx = NewBitContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1134, PostgreSQLParserRULE_bit) p.SetState(8697) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 528, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8695) p.Bitwithlength() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(8696) p.Bitwithoutlength() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IConstbitContext is an interface to support dynamic dispatch. type IConstbitContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Bitwithlength() IBitwithlengthContext Bitwithoutlength() IBitwithoutlengthContext // IsConstbitContext differentiates from other interfaces. IsConstbitContext() } type ConstbitContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyConstbitContext() *ConstbitContext { var p = new(ConstbitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constbit return p } func InitEmptyConstbitContext(p *ConstbitContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constbit } func (*ConstbitContext) IsConstbitContext() {} func NewConstbitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstbitContext { var p = new(ConstbitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_constbit return p } func (s *ConstbitContext) GetParser() antlr.Parser { return s.parser } func (s *ConstbitContext) Bitwithlength() IBitwithlengthContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IBitwithlengthContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IBitwithlengthContext) } func (s *ConstbitContext) Bitwithoutlength() IBitwithoutlengthContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IBitwithoutlengthContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IBitwithoutlengthContext) } func (s *ConstbitContext) GetRuleContext() antlr.RuleContext { return s } func (s *ConstbitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ConstbitContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterConstbit(s) } } func (s *ConstbitContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitConstbit(s) } } func (s *ConstbitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitConstbit(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Constbit() (localctx IConstbitContext) { localctx = NewConstbitContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1136, PostgreSQLParserRULE_constbit) p.SetState(8701) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 529, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8699) p.Bitwithlength() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(8700) p.Bitwithoutlength() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IBitwithlengthContext is an interface to support dynamic dispatch. type IBitwithlengthContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures BIT() antlr.TerminalNode Opt_varying() IOpt_varyingContext OPEN_PAREN() antlr.TerminalNode Expr_list() IExpr_listContext CLOSE_PAREN() antlr.TerminalNode // IsBitwithlengthContext differentiates from other interfaces. IsBitwithlengthContext() } type BitwithlengthContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyBitwithlengthContext() *BitwithlengthContext { var p = new(BitwithlengthContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_bitwithlength return p } func InitEmptyBitwithlengthContext(p *BitwithlengthContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_bitwithlength } func (*BitwithlengthContext) IsBitwithlengthContext() {} func NewBitwithlengthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitwithlengthContext { var p = new(BitwithlengthContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_bitwithlength return p } func (s *BitwithlengthContext) GetParser() antlr.Parser { return s.parser } func (s *BitwithlengthContext) BIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBIT, 0) } func (s *BitwithlengthContext) Opt_varying() IOpt_varyingContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_varyingContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_varyingContext) } func (s *BitwithlengthContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *BitwithlengthContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *BitwithlengthContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *BitwithlengthContext) GetRuleContext() antlr.RuleContext { return s } func (s *BitwithlengthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *BitwithlengthContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterBitwithlength(s) } } func (s *BitwithlengthContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitBitwithlength(s) } } func (s *BitwithlengthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitBitwithlength(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Bitwithlength() (localctx IBitwithlengthContext) { localctx = NewBitwithlengthContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1138, PostgreSQLParserRULE_bitwithlength) p.EnterOuterAlt(localctx, 1) { p.SetState(8703) p.Match(PostgreSQLParserBIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8704) p.Opt_varying() } { p.SetState(8705) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8706) p.Expr_list() } { p.SetState(8707) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IBitwithoutlengthContext is an interface to support dynamic dispatch. type IBitwithoutlengthContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures BIT() antlr.TerminalNode Opt_varying() IOpt_varyingContext // IsBitwithoutlengthContext differentiates from other interfaces. IsBitwithoutlengthContext() } type BitwithoutlengthContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyBitwithoutlengthContext() *BitwithoutlengthContext { var p = new(BitwithoutlengthContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_bitwithoutlength return p } func InitEmptyBitwithoutlengthContext(p *BitwithoutlengthContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_bitwithoutlength } func (*BitwithoutlengthContext) IsBitwithoutlengthContext() {} func NewBitwithoutlengthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitwithoutlengthContext { var p = new(BitwithoutlengthContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_bitwithoutlength return p } func (s *BitwithoutlengthContext) GetParser() antlr.Parser { return s.parser } func (s *BitwithoutlengthContext) BIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBIT, 0) } func (s *BitwithoutlengthContext) Opt_varying() IOpt_varyingContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_varyingContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_varyingContext) } func (s *BitwithoutlengthContext) GetRuleContext() antlr.RuleContext { return s } func (s *BitwithoutlengthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *BitwithoutlengthContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterBitwithoutlength(s) } } func (s *BitwithoutlengthContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitBitwithoutlength(s) } } func (s *BitwithoutlengthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitBitwithoutlength(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Bitwithoutlength() (localctx IBitwithoutlengthContext) { localctx = NewBitwithoutlengthContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1140, PostgreSQLParserRULE_bitwithoutlength) p.EnterOuterAlt(localctx, 1) { p.SetState(8709) p.Match(PostgreSQLParserBIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8710) p.Opt_varying() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICharacterContext is an interface to support dynamic dispatch. type ICharacterContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Character_c() ICharacter_cContext OPEN_PAREN() antlr.TerminalNode Iconst() IIconstContext CLOSE_PAREN() antlr.TerminalNode // IsCharacterContext differentiates from other interfaces. IsCharacterContext() } type CharacterContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCharacterContext() *CharacterContext { var p = new(CharacterContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_character return p } func InitEmptyCharacterContext(p *CharacterContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_character } func (*CharacterContext) IsCharacterContext() {} func NewCharacterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CharacterContext { var p = new(CharacterContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_character return p } func (s *CharacterContext) GetParser() antlr.Parser { return s.parser } func (s *CharacterContext) Character_c() ICharacter_cContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICharacter_cContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICharacter_cContext) } func (s *CharacterContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *CharacterContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *CharacterContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *CharacterContext) GetRuleContext() antlr.RuleContext { return s } func (s *CharacterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CharacterContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCharacter(s) } } func (s *CharacterContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCharacter(s) } } func (s *CharacterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCharacter(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Character() (localctx ICharacterContext) { localctx = NewCharacterContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1142, PostgreSQLParserRULE_character) p.EnterOuterAlt(localctx, 1) { p.SetState(8712) p.Character_c() } p.SetState(8717) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 530, p.GetParserRuleContext()) == 1 { { p.SetState(8713) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8714) p.Iconst() } { p.SetState(8715) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IConstcharacterContext is an interface to support dynamic dispatch. type IConstcharacterContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Character_c() ICharacter_cContext OPEN_PAREN() antlr.TerminalNode Iconst() IIconstContext CLOSE_PAREN() antlr.TerminalNode // IsConstcharacterContext differentiates from other interfaces. IsConstcharacterContext() } type ConstcharacterContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyConstcharacterContext() *ConstcharacterContext { var p = new(ConstcharacterContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constcharacter return p } func InitEmptyConstcharacterContext(p *ConstcharacterContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constcharacter } func (*ConstcharacterContext) IsConstcharacterContext() {} func NewConstcharacterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstcharacterContext { var p = new(ConstcharacterContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_constcharacter return p } func (s *ConstcharacterContext) GetParser() antlr.Parser { return s.parser } func (s *ConstcharacterContext) Character_c() ICharacter_cContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICharacter_cContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICharacter_cContext) } func (s *ConstcharacterContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *ConstcharacterContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *ConstcharacterContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *ConstcharacterContext) GetRuleContext() antlr.RuleContext { return s } func (s *ConstcharacterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ConstcharacterContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterConstcharacter(s) } } func (s *ConstcharacterContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitConstcharacter(s) } } func (s *ConstcharacterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitConstcharacter(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Constcharacter() (localctx IConstcharacterContext) { localctx = NewConstcharacterContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1144, PostgreSQLParserRULE_constcharacter) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8719) p.Character_c() } p.SetState(8724) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserOPEN_PAREN { { p.SetState(8720) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8721) p.Iconst() } { p.SetState(8722) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICharacter_cContext is an interface to support dynamic dispatch. type ICharacter_cContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_varying() IOpt_varyingContext CHARACTER() antlr.TerminalNode CHAR_P() antlr.TerminalNode NCHAR() antlr.TerminalNode VARCHAR() antlr.TerminalNode NATIONAL() antlr.TerminalNode // IsCharacter_cContext differentiates from other interfaces. IsCharacter_cContext() } type Character_cContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCharacter_cContext() *Character_cContext { var p = new(Character_cContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_character_c return p } func InitEmptyCharacter_cContext(p *Character_cContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_character_c } func (*Character_cContext) IsCharacter_cContext() {} func NewCharacter_cContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Character_cContext { var p = new(Character_cContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_character_c return p } func (s *Character_cContext) GetParser() antlr.Parser { return s.parser } func (s *Character_cContext) Opt_varying() IOpt_varyingContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_varyingContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_varyingContext) } func (s *Character_cContext) CHARACTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHARACTER, 0) } func (s *Character_cContext) CHAR_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHAR_P, 0) } func (s *Character_cContext) NCHAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNCHAR, 0) } func (s *Character_cContext) VARCHAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVARCHAR, 0) } func (s *Character_cContext) NATIONAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNATIONAL, 0) } func (s *Character_cContext) GetRuleContext() antlr.RuleContext { return s } func (s *Character_cContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Character_cContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCharacter_c(s) } } func (s *Character_cContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCharacter_c(s) } } func (s *Character_cContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCharacter_c(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Character_c() (localctx ICharacter_cContext) { localctx = NewCharacter_cContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1146, PostgreSQLParserRULE_character_c) var _la int p.SetState(8732) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserNCHAR: p.EnterOuterAlt(localctx, 1) { p.SetState(8726) _la = p.GetTokenStream().LA(1) if !((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&32771) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(8727) p.Opt_varying() } case PostgreSQLParserVARCHAR: p.EnterOuterAlt(localctx, 2) { p.SetState(8728) p.Match(PostgreSQLParserVARCHAR) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserNATIONAL: p.EnterOuterAlt(localctx, 3) { p.SetState(8729) p.Match(PostgreSQLParserNATIONAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8730) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserCHAR_P || _la == PostgreSQLParserCHARACTER) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(8731) p.Opt_varying() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_varyingContext is an interface to support dynamic dispatch. type IOpt_varyingContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures VARYING() antlr.TerminalNode // IsOpt_varyingContext differentiates from other interfaces. IsOpt_varyingContext() } type Opt_varyingContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_varyingContext() *Opt_varyingContext { var p = new(Opt_varyingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_varying return p } func InitEmptyOpt_varyingContext(p *Opt_varyingContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_varying } func (*Opt_varyingContext) IsOpt_varyingContext() {} func NewOpt_varyingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_varyingContext { var p = new(Opt_varyingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_varying return p } func (s *Opt_varyingContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_varyingContext) VARYING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVARYING, 0) } func (s *Opt_varyingContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_varyingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_varyingContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_varying(s) } } func (s *Opt_varyingContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_varying(s) } } func (s *Opt_varyingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_varying(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_varying() (localctx IOpt_varyingContext) { localctx = NewOpt_varyingContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1148, PostgreSQLParserRULE_opt_varying) p.SetState(8736) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 533, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8734) p.Match(PostgreSQLParserVARYING) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IConstdatetimeContext is an interface to support dynamic dispatch. type IConstdatetimeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_timezone() IOpt_timezoneContext TIMESTAMP() antlr.TerminalNode TIME() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Iconst() IIconstContext CLOSE_PAREN() antlr.TerminalNode // IsConstdatetimeContext differentiates from other interfaces. IsConstdatetimeContext() } type ConstdatetimeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyConstdatetimeContext() *ConstdatetimeContext { var p = new(ConstdatetimeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constdatetime return p } func InitEmptyConstdatetimeContext(p *ConstdatetimeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constdatetime } func (*ConstdatetimeContext) IsConstdatetimeContext() {} func NewConstdatetimeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstdatetimeContext { var p = new(ConstdatetimeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_constdatetime return p } func (s *ConstdatetimeContext) GetParser() antlr.Parser { return s.parser } func (s *ConstdatetimeContext) Opt_timezone() IOpt_timezoneContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_timezoneContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_timezoneContext) } func (s *ConstdatetimeContext) TIMESTAMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTIMESTAMP, 0) } func (s *ConstdatetimeContext) TIME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTIME, 0) } func (s *ConstdatetimeContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *ConstdatetimeContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *ConstdatetimeContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *ConstdatetimeContext) GetRuleContext() antlr.RuleContext { return s } func (s *ConstdatetimeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ConstdatetimeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterConstdatetime(s) } } func (s *ConstdatetimeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitConstdatetime(s) } } func (s *ConstdatetimeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitConstdatetime(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Constdatetime() (localctx IConstdatetimeContext) { localctx = NewConstdatetimeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1150, PostgreSQLParserRULE_constdatetime) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8738) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserTIME || _la == PostgreSQLParserTIMESTAMP) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } p.SetState(8743) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 534, p.GetParserRuleContext()) == 1 { { p.SetState(8739) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8740) p.Iconst() } { p.SetState(8741) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(8745) p.Opt_timezone() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IConstintervalContext is an interface to support dynamic dispatch. type IConstintervalContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures INTERVAL() antlr.TerminalNode // IsConstintervalContext differentiates from other interfaces. IsConstintervalContext() } type ConstintervalContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyConstintervalContext() *ConstintervalContext { var p = new(ConstintervalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constinterval return p } func InitEmptyConstintervalContext(p *ConstintervalContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_constinterval } func (*ConstintervalContext) IsConstintervalContext() {} func NewConstintervalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstintervalContext { var p = new(ConstintervalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_constinterval return p } func (s *ConstintervalContext) GetParser() antlr.Parser { return s.parser } func (s *ConstintervalContext) INTERVAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINTERVAL, 0) } func (s *ConstintervalContext) GetRuleContext() antlr.RuleContext { return s } func (s *ConstintervalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ConstintervalContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterConstinterval(s) } } func (s *ConstintervalContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitConstinterval(s) } } func (s *ConstintervalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitConstinterval(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Constinterval() (localctx IConstintervalContext) { localctx = NewConstintervalContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1152, PostgreSQLParserRULE_constinterval) p.EnterOuterAlt(localctx, 1) { p.SetState(8747) p.Match(PostgreSQLParserINTERVAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_timezoneContext is an interface to support dynamic dispatch. type IOpt_timezoneContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITH() antlr.TerminalNode TIME() antlr.TerminalNode ZONE() antlr.TerminalNode WITHOUT() antlr.TerminalNode // IsOpt_timezoneContext differentiates from other interfaces. IsOpt_timezoneContext() } type Opt_timezoneContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_timezoneContext() *Opt_timezoneContext { var p = new(Opt_timezoneContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_timezone return p } func InitEmptyOpt_timezoneContext(p *Opt_timezoneContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_timezone } func (*Opt_timezoneContext) IsOpt_timezoneContext() {} func NewOpt_timezoneContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_timezoneContext { var p = new(Opt_timezoneContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_timezone return p } func (s *Opt_timezoneContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_timezoneContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *Opt_timezoneContext) TIME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTIME, 0) } func (s *Opt_timezoneContext) ZONE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserZONE, 0) } func (s *Opt_timezoneContext) WITHOUT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITHOUT, 0) } func (s *Opt_timezoneContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_timezoneContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_timezoneContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_timezone(s) } } func (s *Opt_timezoneContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_timezone(s) } } func (s *Opt_timezoneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_timezone(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_timezone() (localctx IOpt_timezoneContext) { localctx = NewOpt_timezoneContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1154, PostgreSQLParserRULE_opt_timezone) p.SetState(8756) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 535, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8749) p.Match(PostgreSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8750) p.Match(PostgreSQLParserTIME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8751) p.Match(PostgreSQLParserZONE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(8752) p.Match(PostgreSQLParserWITHOUT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8753) p.Match(PostgreSQLParserTIME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8754) p.Match(PostgreSQLParserZONE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_intervalContext is an interface to support dynamic dispatch. type IOpt_intervalContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures YEAR_P() antlr.TerminalNode MONTH_P() antlr.TerminalNode DAY_P() antlr.TerminalNode HOUR_P() antlr.TerminalNode MINUTE_P() antlr.TerminalNode Interval_second() IInterval_secondContext TO() antlr.TerminalNode // IsOpt_intervalContext differentiates from other interfaces. IsOpt_intervalContext() } type Opt_intervalContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_intervalContext() *Opt_intervalContext { var p = new(Opt_intervalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_interval return p } func InitEmptyOpt_intervalContext(p *Opt_intervalContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_interval } func (*Opt_intervalContext) IsOpt_intervalContext() {} func NewOpt_intervalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_intervalContext { var p = new(Opt_intervalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_interval return p } func (s *Opt_intervalContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_intervalContext) YEAR_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserYEAR_P, 0) } func (s *Opt_intervalContext) MONTH_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMONTH_P, 0) } func (s *Opt_intervalContext) DAY_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDAY_P, 0) } func (s *Opt_intervalContext) HOUR_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserHOUR_P, 0) } func (s *Opt_intervalContext) MINUTE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMINUTE_P, 0) } func (s *Opt_intervalContext) Interval_second() IInterval_secondContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInterval_secondContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IInterval_secondContext) } func (s *Opt_intervalContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *Opt_intervalContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_intervalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_intervalContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_interval(s) } } func (s *Opt_intervalContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_interval(s) } } func (s *Opt_intervalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_interval(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_interval() (localctx IOpt_intervalContext) { localctx = NewOpt_intervalContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1156, PostgreSQLParserRULE_opt_interval) p.SetState(8784) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 538, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8758) p.Match(PostgreSQLParserYEAR_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(8759) p.Match(PostgreSQLParserMONTH_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(8760) p.Match(PostgreSQLParserDAY_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(8761) p.Match(PostgreSQLParserHOUR_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(8762) p.Match(PostgreSQLParserMINUTE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(8763) p.Interval_second() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(8764) p.Match(PostgreSQLParserYEAR_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8765) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8766) p.Match(PostgreSQLParserMONTH_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(8767) p.Match(PostgreSQLParserDAY_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8768) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8772) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserHOUR_P: { p.SetState(8769) p.Match(PostgreSQLParserHOUR_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserMINUTE_P: { p.SetState(8770) p.Match(PostgreSQLParserMINUTE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSECOND_P: { p.SetState(8771) p.Interval_second() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(8774) p.Match(PostgreSQLParserHOUR_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8775) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8778) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserMINUTE_P: { p.SetState(8776) p.Match(PostgreSQLParserMINUTE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSECOND_P: { p.SetState(8777) p.Interval_second() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(8780) p.Match(PostgreSQLParserMINUTE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8781) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8782) p.Interval_second() } case 11: p.EnterOuterAlt(localctx, 11) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IInterval_secondContext is an interface to support dynamic dispatch. type IInterval_secondContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SECOND_P() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Iconst() IIconstContext CLOSE_PAREN() antlr.TerminalNode // IsInterval_secondContext differentiates from other interfaces. IsInterval_secondContext() } type Interval_secondContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyInterval_secondContext() *Interval_secondContext { var p = new(Interval_secondContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_interval_second return p } func InitEmptyInterval_secondContext(p *Interval_secondContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_interval_second } func (*Interval_secondContext) IsInterval_secondContext() {} func NewInterval_secondContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Interval_secondContext { var p = new(Interval_secondContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_interval_second return p } func (s *Interval_secondContext) GetParser() antlr.Parser { return s.parser } func (s *Interval_secondContext) SECOND_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSECOND_P, 0) } func (s *Interval_secondContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Interval_secondContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *Interval_secondContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Interval_secondContext) GetRuleContext() antlr.RuleContext { return s } func (s *Interval_secondContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Interval_secondContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterInterval_second(s) } } func (s *Interval_secondContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitInterval_second(s) } } func (s *Interval_secondContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitInterval_second(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Interval_second() (localctx IInterval_secondContext) { localctx = NewInterval_secondContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1158, PostgreSQLParserRULE_interval_second) p.EnterOuterAlt(localctx, 1) { p.SetState(8786) p.Match(PostgreSQLParserSECOND_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8791) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 539, p.GetParserRuleContext()) == 1 { { p.SetState(8787) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8788) p.Iconst() } { p.SetState(8789) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_escapeContext is an interface to support dynamic dispatch. type IOpt_escapeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ESCAPE() antlr.TerminalNode A_expr() IA_exprContext // IsOpt_escapeContext differentiates from other interfaces. IsOpt_escapeContext() } type Opt_escapeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_escapeContext() *Opt_escapeContext { var p = new(Opt_escapeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_escape return p } func InitEmptyOpt_escapeContext(p *Opt_escapeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_escape } func (*Opt_escapeContext) IsOpt_escapeContext() {} func NewOpt_escapeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_escapeContext { var p = new(Opt_escapeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_escape return p } func (s *Opt_escapeContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_escapeContext) ESCAPE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserESCAPE, 0) } func (s *Opt_escapeContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Opt_escapeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_escapeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_escapeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_escape(s) } } func (s *Opt_escapeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_escape(s) } } func (s *Opt_escapeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_escape(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_escape() (localctx IOpt_escapeContext) { localctx = NewOpt_escapeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1160, PostgreSQLParserRULE_opt_escape) p.SetState(8796) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 540, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(8793) p.Match(PostgreSQLParserESCAPE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8794) p.A_expr() } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_exprContext is an interface to support dynamic dispatch. type IA_exprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr_qual() IA_expr_qualContext // IsA_exprContext differentiates from other interfaces. IsA_exprContext() } type A_exprContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_exprContext() *A_exprContext { var p = new(A_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr return p } func InitEmptyA_exprContext(p *A_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr } func (*A_exprContext) IsA_exprContext() {} func NewA_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_exprContext { var p = new(A_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr return p } func (s *A_exprContext) GetParser() antlr.Parser { return s.parser } func (s *A_exprContext) A_expr_qual() IA_expr_qualContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_qualContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_expr_qualContext) } func (s *A_exprContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_exprContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr(s) } } func (s *A_exprContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr(s) } } func (s *A_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr() (localctx IA_exprContext) { localctx = NewA_exprContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1162, PostgreSQLParserRULE_a_expr) p.EnterOuterAlt(localctx, 1) { p.SetState(8798) p.A_expr_qual() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_qualContext is an interface to support dynamic dispatch. type IA_expr_qualContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr_lessless() IA_expr_lesslessContext Qual_op() IQual_opContext // IsA_expr_qualContext differentiates from other interfaces. IsA_expr_qualContext() } type A_expr_qualContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_qualContext() *A_expr_qualContext { var p = new(A_expr_qualContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_qual return p } func InitEmptyA_expr_qualContext(p *A_expr_qualContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_qual } func (*A_expr_qualContext) IsA_expr_qualContext() {} func NewA_expr_qualContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_qualContext { var p = new(A_expr_qualContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_qual return p } func (s *A_expr_qualContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_qualContext) A_expr_lessless() IA_expr_lesslessContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_lesslessContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_expr_lesslessContext) } func (s *A_expr_qualContext) Qual_op() IQual_opContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQual_opContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQual_opContext) } func (s *A_expr_qualContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_qualContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_qualContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_qual(s) } } func (s *A_expr_qualContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_qual(s) } } func (s *A_expr_qualContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_qual(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_qual() (localctx IA_expr_qualContext) { localctx = NewA_expr_qualContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1164, PostgreSQLParserRULE_a_expr_qual) p.EnterOuterAlt(localctx, 1) { p.SetState(8800) p.A_expr_lessless() } p.SetState(8802) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 541, p.GetParserRuleContext()) == 1 { { p.SetState(8801) p.Qual_op() } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_lesslessContext is an interface to support dynamic dispatch. type IA_expr_lesslessContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllA_expr_or() []IA_expr_orContext A_expr_or(i int) IA_expr_orContext AllLESS_LESS() []antlr.TerminalNode LESS_LESS(i int) antlr.TerminalNode AllGREATER_GREATER() []antlr.TerminalNode GREATER_GREATER(i int) antlr.TerminalNode // IsA_expr_lesslessContext differentiates from other interfaces. IsA_expr_lesslessContext() } type A_expr_lesslessContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_lesslessContext() *A_expr_lesslessContext { var p = new(A_expr_lesslessContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_lessless return p } func InitEmptyA_expr_lesslessContext(p *A_expr_lesslessContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_lessless } func (*A_expr_lesslessContext) IsA_expr_lesslessContext() {} func NewA_expr_lesslessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_lesslessContext { var p = new(A_expr_lesslessContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_lessless return p } func (s *A_expr_lesslessContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_lesslessContext) AllA_expr_or() []IA_expr_orContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_expr_orContext); ok { len++ } } tst := make([]IA_expr_orContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_expr_orContext); ok { tst[i] = t.(IA_expr_orContext) i++ } } return tst } func (s *A_expr_lesslessContext) A_expr_or(i int) IA_expr_orContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_orContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_expr_orContext) } func (s *A_expr_lesslessContext) AllLESS_LESS() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserLESS_LESS) } func (s *A_expr_lesslessContext) LESS_LESS(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserLESS_LESS, i) } func (s *A_expr_lesslessContext) AllGREATER_GREATER() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserGREATER_GREATER) } func (s *A_expr_lesslessContext) GREATER_GREATER(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserGREATER_GREATER, i) } func (s *A_expr_lesslessContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_lesslessContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_lesslessContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_lessless(s) } } func (s *A_expr_lesslessContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_lessless(s) } } func (s *A_expr_lesslessContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_lessless(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_lessless() (localctx IA_expr_lesslessContext) { localctx = NewA_expr_lesslessContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1166, PostgreSQLParserRULE_a_expr_lessless) var _la int var _alt int p.EnterOuterAlt(localctx, 1) { p.SetState(8804) p.A_expr_or() } p.SetState(8809) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 542, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(8805) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserLESS_LESS || _la == PostgreSQLParserGREATER_GREATER) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(8806) p.A_expr_or() } } p.SetState(8811) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 542, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_orContext is an interface to support dynamic dispatch. type IA_expr_orContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllA_expr_and() []IA_expr_andContext A_expr_and(i int) IA_expr_andContext AllOR() []antlr.TerminalNode OR(i int) antlr.TerminalNode // IsA_expr_orContext differentiates from other interfaces. IsA_expr_orContext() } type A_expr_orContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_orContext() *A_expr_orContext { var p = new(A_expr_orContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_or return p } func InitEmptyA_expr_orContext(p *A_expr_orContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_or } func (*A_expr_orContext) IsA_expr_orContext() {} func NewA_expr_orContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_orContext { var p = new(A_expr_orContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_or return p } func (s *A_expr_orContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_orContext) AllA_expr_and() []IA_expr_andContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_expr_andContext); ok { len++ } } tst := make([]IA_expr_andContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_expr_andContext); ok { tst[i] = t.(IA_expr_andContext) i++ } } return tst } func (s *A_expr_orContext) A_expr_and(i int) IA_expr_andContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_andContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_expr_andContext) } func (s *A_expr_orContext) AllOR() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserOR) } func (s *A_expr_orContext) OR(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserOR, i) } func (s *A_expr_orContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_orContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_orContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_or(s) } } func (s *A_expr_orContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_or(s) } } func (s *A_expr_orContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_or(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_or() (localctx IA_expr_orContext) { localctx = NewA_expr_orContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1168, PostgreSQLParserRULE_a_expr_or) var _alt int p.EnterOuterAlt(localctx, 1) { p.SetState(8812) p.A_expr_and() } p.SetState(8817) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 543, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(8813) p.Match(PostgreSQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8814) p.A_expr_and() } } p.SetState(8819) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 543, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_andContext is an interface to support dynamic dispatch. type IA_expr_andContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllA_expr_between() []IA_expr_betweenContext A_expr_between(i int) IA_expr_betweenContext AllAND() []antlr.TerminalNode AND(i int) antlr.TerminalNode // IsA_expr_andContext differentiates from other interfaces. IsA_expr_andContext() } type A_expr_andContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_andContext() *A_expr_andContext { var p = new(A_expr_andContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_and return p } func InitEmptyA_expr_andContext(p *A_expr_andContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_and } func (*A_expr_andContext) IsA_expr_andContext() {} func NewA_expr_andContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_andContext { var p = new(A_expr_andContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_and return p } func (s *A_expr_andContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_andContext) AllA_expr_between() []IA_expr_betweenContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_expr_betweenContext); ok { len++ } } tst := make([]IA_expr_betweenContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_expr_betweenContext); ok { tst[i] = t.(IA_expr_betweenContext) i++ } } return tst } func (s *A_expr_andContext) A_expr_between(i int) IA_expr_betweenContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_betweenContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_expr_betweenContext) } func (s *A_expr_andContext) AllAND() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserAND) } func (s *A_expr_andContext) AND(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserAND, i) } func (s *A_expr_andContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_andContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_andContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_and(s) } } func (s *A_expr_andContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_and(s) } } func (s *A_expr_andContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_and(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_and() (localctx IA_expr_andContext) { localctx = NewA_expr_andContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1170, PostgreSQLParserRULE_a_expr_and) var _alt int p.EnterOuterAlt(localctx, 1) { p.SetState(8820) p.A_expr_between() } p.SetState(8825) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 544, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(8821) p.Match(PostgreSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8822) p.A_expr_between() } } p.SetState(8827) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 544, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_betweenContext is an interface to support dynamic dispatch. type IA_expr_betweenContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllA_expr_in() []IA_expr_inContext A_expr_in(i int) IA_expr_inContext BETWEEN() antlr.TerminalNode AND() antlr.TerminalNode NOT() antlr.TerminalNode SYMMETRIC() antlr.TerminalNode // IsA_expr_betweenContext differentiates from other interfaces. IsA_expr_betweenContext() } type A_expr_betweenContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_betweenContext() *A_expr_betweenContext { var p = new(A_expr_betweenContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_between return p } func InitEmptyA_expr_betweenContext(p *A_expr_betweenContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_between } func (*A_expr_betweenContext) IsA_expr_betweenContext() {} func NewA_expr_betweenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_betweenContext { var p = new(A_expr_betweenContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_between return p } func (s *A_expr_betweenContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_betweenContext) AllA_expr_in() []IA_expr_inContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_expr_inContext); ok { len++ } } tst := make([]IA_expr_inContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_expr_inContext); ok { tst[i] = t.(IA_expr_inContext) i++ } } return tst } func (s *A_expr_betweenContext) A_expr_in(i int) IA_expr_inContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_inContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_expr_inContext) } func (s *A_expr_betweenContext) BETWEEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBETWEEN, 0) } func (s *A_expr_betweenContext) AND() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAND, 0) } func (s *A_expr_betweenContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *A_expr_betweenContext) SYMMETRIC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSYMMETRIC, 0) } func (s *A_expr_betweenContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_betweenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_betweenContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_between(s) } } func (s *A_expr_betweenContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_between(s) } } func (s *A_expr_betweenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_between(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_between() (localctx IA_expr_betweenContext) { localctx = NewA_expr_betweenContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1172, PostgreSQLParserRULE_a_expr_between) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8828) p.A_expr_in() } p.SetState(8840) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 547, p.GetParserRuleContext()) == 1 { p.SetState(8830) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserNOT { { p.SetState(8829) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(8832) p.Match(PostgreSQLParserBETWEEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8834) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserSYMMETRIC { { p.SetState(8833) p.Match(PostgreSQLParserSYMMETRIC) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(8836) p.A_expr_in() } { p.SetState(8837) p.Match(PostgreSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8838) p.A_expr_in() } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_inContext is an interface to support dynamic dispatch. type IA_expr_inContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr_unary_not() IA_expr_unary_notContext IN_P() antlr.TerminalNode In_expr() IIn_exprContext NOT() antlr.TerminalNode // IsA_expr_inContext differentiates from other interfaces. IsA_expr_inContext() } type A_expr_inContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_inContext() *A_expr_inContext { var p = new(A_expr_inContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_in return p } func InitEmptyA_expr_inContext(p *A_expr_inContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_in } func (*A_expr_inContext) IsA_expr_inContext() {} func NewA_expr_inContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_inContext { var p = new(A_expr_inContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_in return p } func (s *A_expr_inContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_inContext) A_expr_unary_not() IA_expr_unary_notContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_unary_notContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_expr_unary_notContext) } func (s *A_expr_inContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *A_expr_inContext) In_expr() IIn_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIn_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIn_exprContext) } func (s *A_expr_inContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *A_expr_inContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_inContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_inContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_in(s) } } func (s *A_expr_inContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_in(s) } } func (s *A_expr_inContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_in(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_in() (localctx IA_expr_inContext) { localctx = NewA_expr_inContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1174, PostgreSQLParserRULE_a_expr_in) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8842) p.A_expr_unary_not() } p.SetState(8848) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 549, p.GetParserRuleContext()) == 1 { p.SetState(8844) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserNOT { { p.SetState(8843) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(8846) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8847) p.In_expr() } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_unary_notContext is an interface to support dynamic dispatch. type IA_expr_unary_notContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr_isnull() IA_expr_isnullContext NOT() antlr.TerminalNode // IsA_expr_unary_notContext differentiates from other interfaces. IsA_expr_unary_notContext() } type A_expr_unary_notContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_unary_notContext() *A_expr_unary_notContext { var p = new(A_expr_unary_notContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_not return p } func InitEmptyA_expr_unary_notContext(p *A_expr_unary_notContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_not } func (*A_expr_unary_notContext) IsA_expr_unary_notContext() {} func NewA_expr_unary_notContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_unary_notContext { var p = new(A_expr_unary_notContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_not return p } func (s *A_expr_unary_notContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_unary_notContext) A_expr_isnull() IA_expr_isnullContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_isnullContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_expr_isnullContext) } func (s *A_expr_unary_notContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *A_expr_unary_notContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_unary_notContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_unary_notContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_unary_not(s) } } func (s *A_expr_unary_notContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_unary_not(s) } } func (s *A_expr_unary_notContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_unary_not(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_unary_not() (localctx IA_expr_unary_notContext) { localctx = NewA_expr_unary_notContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1176, PostgreSQLParserRULE_a_expr_unary_not) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(8851) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserNOT { { p.SetState(8850) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(8853) p.A_expr_isnull() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_isnullContext is an interface to support dynamic dispatch. type IA_expr_isnullContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr_is_not() IA_expr_is_notContext ISNULL() antlr.TerminalNode NOTNULL() antlr.TerminalNode // IsA_expr_isnullContext differentiates from other interfaces. IsA_expr_isnullContext() } type A_expr_isnullContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_isnullContext() *A_expr_isnullContext { var p = new(A_expr_isnullContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_isnull return p } func InitEmptyA_expr_isnullContext(p *A_expr_isnullContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_isnull } func (*A_expr_isnullContext) IsA_expr_isnullContext() {} func NewA_expr_isnullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_isnullContext { var p = new(A_expr_isnullContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_isnull return p } func (s *A_expr_isnullContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_isnullContext) A_expr_is_not() IA_expr_is_notContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_is_notContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_expr_is_notContext) } func (s *A_expr_isnullContext) ISNULL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserISNULL, 0) } func (s *A_expr_isnullContext) NOTNULL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOTNULL, 0) } func (s *A_expr_isnullContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_isnullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_isnullContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_isnull(s) } } func (s *A_expr_isnullContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_isnull(s) } } func (s *A_expr_isnullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_isnull(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_isnull() (localctx IA_expr_isnullContext) { localctx = NewA_expr_isnullContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1178, PostgreSQLParserRULE_a_expr_isnull) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8855) p.A_expr_is_not() } p.SetState(8857) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 551, p.GetParserRuleContext()) == 1 { { p.SetState(8856) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserISNULL || _la == PostgreSQLParserNOTNULL) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_is_notContext is an interface to support dynamic dispatch. type IA_expr_is_notContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr_compare() IA_expr_compareContext IS() antlr.TerminalNode NULL_P() antlr.TerminalNode TRUE_P() antlr.TerminalNode FALSE_P() antlr.TerminalNode UNKNOWN() antlr.TerminalNode DISTINCT() antlr.TerminalNode FROM() antlr.TerminalNode A_expr() IA_exprContext OF() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Type_list() IType_listContext CLOSE_PAREN() antlr.TerminalNode DOCUMENT_P() antlr.TerminalNode NORMALIZED() antlr.TerminalNode NOT() antlr.TerminalNode Unicode_normal_form() IUnicode_normal_formContext // IsA_expr_is_notContext differentiates from other interfaces. IsA_expr_is_notContext() } type A_expr_is_notContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_is_notContext() *A_expr_is_notContext { var p = new(A_expr_is_notContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_is_not return p } func InitEmptyA_expr_is_notContext(p *A_expr_is_notContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_is_not } func (*A_expr_is_notContext) IsA_expr_is_notContext() {} func NewA_expr_is_notContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_is_notContext { var p = new(A_expr_is_notContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_is_not return p } func (s *A_expr_is_notContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_is_notContext) A_expr_compare() IA_expr_compareContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_compareContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_expr_compareContext) } func (s *A_expr_is_notContext) IS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIS, 0) } func (s *A_expr_is_notContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *A_expr_is_notContext) TRUE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRUE_P, 0) } func (s *A_expr_is_notContext) FALSE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFALSE_P, 0) } func (s *A_expr_is_notContext) UNKNOWN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNKNOWN, 0) } func (s *A_expr_is_notContext) DISTINCT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDISTINCT, 0) } func (s *A_expr_is_notContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *A_expr_is_notContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *A_expr_is_notContext) OF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOF, 0) } func (s *A_expr_is_notContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *A_expr_is_notContext) Type_list() IType_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IType_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IType_listContext) } func (s *A_expr_is_notContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *A_expr_is_notContext) DOCUMENT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOCUMENT_P, 0) } func (s *A_expr_is_notContext) NORMALIZED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNORMALIZED, 0) } func (s *A_expr_is_notContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *A_expr_is_notContext) Unicode_normal_form() IUnicode_normal_formContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUnicode_normal_formContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUnicode_normal_formContext) } func (s *A_expr_is_notContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_is_notContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_is_notContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_is_not(s) } } func (s *A_expr_is_notContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_is_not(s) } } func (s *A_expr_is_notContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_is_not(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_is_not() (localctx IA_expr_is_notContext) { localctx = NewA_expr_is_notContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1180, PostgreSQLParserRULE_a_expr_is_not) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8859) p.A_expr_compare() } p.SetState(8883) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 555, p.GetParserRuleContext()) == 1 { { p.SetState(8860) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(8862) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserNOT { { p.SetState(8861) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } } p.SetState(8881) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserNULL_P: { p.SetState(8864) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserTRUE_P: { p.SetState(8865) p.Match(PostgreSQLParserTRUE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserFALSE_P: { p.SetState(8866) p.Match(PostgreSQLParserFALSE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserUNKNOWN: { p.SetState(8867) p.Match(PostgreSQLParserUNKNOWN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserDISTINCT: { p.SetState(8868) p.Match(PostgreSQLParserDISTINCT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8869) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8870) p.A_expr() } case PostgreSQLParserOF: { p.SetState(8871) p.Match(PostgreSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8872) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8873) p.Type_list() } { p.SetState(8874) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserDOCUMENT_P: { p.SetState(8876) p.Match(PostgreSQLParserDOCUMENT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserNORMALIZED, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD: p.SetState(8878) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if (int64((_la-483)) & ^0x3f) == 0 && ((int64(1)<<(_la-483))&15) != 0 { { p.SetState(8877) p.Unicode_normal_form() } } { p.SetState(8880) p.Match(PostgreSQLParserNORMALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_compareContext is an interface to support dynamic dispatch. type IA_expr_compareContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllA_expr_like() []IA_expr_likeContext A_expr_like(i int) IA_expr_likeContext Subquery_Op() ISubquery_OpContext Sub_type() ISub_typeContext LT() antlr.TerminalNode GT() antlr.TerminalNode EQUAL() antlr.TerminalNode LESS_EQUALS() antlr.TerminalNode GREATER_EQUALS() antlr.TerminalNode NOT_EQUALS() antlr.TerminalNode Select_with_parens() ISelect_with_parensContext OPEN_PAREN() antlr.TerminalNode A_expr() IA_exprContext CLOSE_PAREN() antlr.TerminalNode // IsA_expr_compareContext differentiates from other interfaces. IsA_expr_compareContext() } type A_expr_compareContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_compareContext() *A_expr_compareContext { var p = new(A_expr_compareContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_compare return p } func InitEmptyA_expr_compareContext(p *A_expr_compareContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_compare } func (*A_expr_compareContext) IsA_expr_compareContext() {} func NewA_expr_compareContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_compareContext { var p = new(A_expr_compareContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_compare return p } func (s *A_expr_compareContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_compareContext) AllA_expr_like() []IA_expr_likeContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_expr_likeContext); ok { len++ } } tst := make([]IA_expr_likeContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_expr_likeContext); ok { tst[i] = t.(IA_expr_likeContext) i++ } } return tst } func (s *A_expr_compareContext) A_expr_like(i int) IA_expr_likeContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_likeContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_expr_likeContext) } func (s *A_expr_compareContext) Subquery_Op() ISubquery_OpContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISubquery_OpContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISubquery_OpContext) } func (s *A_expr_compareContext) Sub_type() ISub_typeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISub_typeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISub_typeContext) } func (s *A_expr_compareContext) LT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLT, 0) } func (s *A_expr_compareContext) GT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGT, 0) } func (s *A_expr_compareContext) EQUAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEQUAL, 0) } func (s *A_expr_compareContext) LESS_EQUALS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLESS_EQUALS, 0) } func (s *A_expr_compareContext) GREATER_EQUALS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGREATER_EQUALS, 0) } func (s *A_expr_compareContext) NOT_EQUALS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT_EQUALS, 0) } func (s *A_expr_compareContext) Select_with_parens() ISelect_with_parensContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_with_parensContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_with_parensContext) } func (s *A_expr_compareContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *A_expr_compareContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *A_expr_compareContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *A_expr_compareContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_compareContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_compareContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_compare(s) } } func (s *A_expr_compareContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_compare(s) } } func (s *A_expr_compareContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_compare(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_compare() (localctx IA_expr_compareContext) { localctx = NewA_expr_compareContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1182, PostgreSQLParserRULE_a_expr_compare) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8885) p.A_expr_like() } p.SetState(8897) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 557, p.GetParserRuleContext()) == 1 { { p.SetState(8886) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&44237824) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(8887) p.A_expr_like() } } else if p.HasError() { // JIM goto errorExit } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 557, p.GetParserRuleContext()) == 2 { { p.SetState(8888) p.Subquery_Op() } { p.SetState(8889) p.Sub_type() } p.SetState(8895) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 556, p.GetParserRuleContext()) { case 1: { p.SetState(8890) p.Select_with_parens() } case 2: { p.SetState(8891) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8892) p.A_expr() } { p.SetState(8893) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_likeContext is an interface to support dynamic dispatch. type IA_expr_likeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllA_expr_qual_op() []IA_expr_qual_opContext A_expr_qual_op(i int) IA_expr_qual_opContext Opt_escape() IOpt_escapeContext LIKE() antlr.TerminalNode ILIKE() antlr.TerminalNode SIMILAR() antlr.TerminalNode TO() antlr.TerminalNode NOT() antlr.TerminalNode // IsA_expr_likeContext differentiates from other interfaces. IsA_expr_likeContext() } type A_expr_likeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_likeContext() *A_expr_likeContext { var p = new(A_expr_likeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_like return p } func InitEmptyA_expr_likeContext(p *A_expr_likeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_like } func (*A_expr_likeContext) IsA_expr_likeContext() {} func NewA_expr_likeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_likeContext { var p = new(A_expr_likeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_like return p } func (s *A_expr_likeContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_likeContext) AllA_expr_qual_op() []IA_expr_qual_opContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_expr_qual_opContext); ok { len++ } } tst := make([]IA_expr_qual_opContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_expr_qual_opContext); ok { tst[i] = t.(IA_expr_qual_opContext) i++ } } return tst } func (s *A_expr_likeContext) A_expr_qual_op(i int) IA_expr_qual_opContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_qual_opContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_expr_qual_opContext) } func (s *A_expr_likeContext) Opt_escape() IOpt_escapeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_escapeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_escapeContext) } func (s *A_expr_likeContext) LIKE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLIKE, 0) } func (s *A_expr_likeContext) ILIKE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserILIKE, 0) } func (s *A_expr_likeContext) SIMILAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSIMILAR, 0) } func (s *A_expr_likeContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *A_expr_likeContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *A_expr_likeContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_likeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_likeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_like(s) } } func (s *A_expr_likeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_like(s) } } func (s *A_expr_likeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_like(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_like() (localctx IA_expr_likeContext) { localctx = NewA_expr_likeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1184, PostgreSQLParserRULE_a_expr_like) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8899) p.A_expr_qual_op() } p.SetState(8912) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 560, p.GetParserRuleContext()) == 1 { p.SetState(8901) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserNOT { { p.SetState(8900) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } } p.SetState(8907) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserLIKE: { p.SetState(8903) p.Match(PostgreSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserILIKE: { p.SetState(8904) p.Match(PostgreSQLParserILIKE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSIMILAR: { p.SetState(8905) p.Match(PostgreSQLParserSIMILAR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8906) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } { p.SetState(8909) p.A_expr_qual_op() } { p.SetState(8910) p.Opt_escape() } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_qual_opContext is an interface to support dynamic dispatch. type IA_expr_qual_opContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllA_expr_unary_qualop() []IA_expr_unary_qualopContext A_expr_unary_qualop(i int) IA_expr_unary_qualopContext AllQual_op() []IQual_opContext Qual_op(i int) IQual_opContext // IsA_expr_qual_opContext differentiates from other interfaces. IsA_expr_qual_opContext() } type A_expr_qual_opContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_qual_opContext() *A_expr_qual_opContext { var p = new(A_expr_qual_opContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_qual_op return p } func InitEmptyA_expr_qual_opContext(p *A_expr_qual_opContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_qual_op } func (*A_expr_qual_opContext) IsA_expr_qual_opContext() {} func NewA_expr_qual_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_qual_opContext { var p = new(A_expr_qual_opContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_qual_op return p } func (s *A_expr_qual_opContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_qual_opContext) AllA_expr_unary_qualop() []IA_expr_unary_qualopContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_expr_unary_qualopContext); ok { len++ } } tst := make([]IA_expr_unary_qualopContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_expr_unary_qualopContext); ok { tst[i] = t.(IA_expr_unary_qualopContext) i++ } } return tst } func (s *A_expr_qual_opContext) A_expr_unary_qualop(i int) IA_expr_unary_qualopContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_unary_qualopContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_expr_unary_qualopContext) } func (s *A_expr_qual_opContext) AllQual_op() []IQual_opContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IQual_opContext); ok { len++ } } tst := make([]IQual_opContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IQual_opContext); ok { tst[i] = t.(IQual_opContext) i++ } } return tst } func (s *A_expr_qual_opContext) Qual_op(i int) IQual_opContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQual_opContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IQual_opContext) } func (s *A_expr_qual_opContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_qual_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_qual_opContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_qual_op(s) } } func (s *A_expr_qual_opContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_qual_op(s) } } func (s *A_expr_qual_opContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_qual_op(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_qual_op() (localctx IA_expr_qual_opContext) { localctx = NewA_expr_qual_opContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1186, PostgreSQLParserRULE_a_expr_qual_op) var _alt int p.EnterOuterAlt(localctx, 1) { p.SetState(8914) p.A_expr_unary_qualop() } p.SetState(8920) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 561, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(8915) p.Qual_op() } { p.SetState(8916) p.A_expr_unary_qualop() } } p.SetState(8922) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 561, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_unary_qualopContext is an interface to support dynamic dispatch. type IA_expr_unary_qualopContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr_add() IA_expr_addContext Qual_op() IQual_opContext // IsA_expr_unary_qualopContext differentiates from other interfaces. IsA_expr_unary_qualopContext() } type A_expr_unary_qualopContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_unary_qualopContext() *A_expr_unary_qualopContext { var p = new(A_expr_unary_qualopContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_qualop return p } func InitEmptyA_expr_unary_qualopContext(p *A_expr_unary_qualopContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_qualop } func (*A_expr_unary_qualopContext) IsA_expr_unary_qualopContext() {} func NewA_expr_unary_qualopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_unary_qualopContext { var p = new(A_expr_unary_qualopContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_qualop return p } func (s *A_expr_unary_qualopContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_unary_qualopContext) A_expr_add() IA_expr_addContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_addContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_expr_addContext) } func (s *A_expr_unary_qualopContext) Qual_op() IQual_opContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQual_opContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQual_opContext) } func (s *A_expr_unary_qualopContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_unary_qualopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_unary_qualopContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_unary_qualop(s) } } func (s *A_expr_unary_qualopContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_unary_qualop(s) } } func (s *A_expr_unary_qualopContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_unary_qualop(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_unary_qualop() (localctx IA_expr_unary_qualopContext) { localctx = NewA_expr_unary_qualopContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1188, PostgreSQLParserRULE_a_expr_unary_qualop) p.EnterOuterAlt(localctx, 1) p.SetState(8924) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 562, p.GetParserRuleContext()) == 1 { { p.SetState(8923) p.Qual_op() } } else if p.HasError() { // JIM goto errorExit } { p.SetState(8926) p.A_expr_add() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_addContext is an interface to support dynamic dispatch. type IA_expr_addContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllA_expr_mul() []IA_expr_mulContext A_expr_mul(i int) IA_expr_mulContext AllMINUS() []antlr.TerminalNode MINUS(i int) antlr.TerminalNode AllPLUS() []antlr.TerminalNode PLUS(i int) antlr.TerminalNode // IsA_expr_addContext differentiates from other interfaces. IsA_expr_addContext() } type A_expr_addContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_addContext() *A_expr_addContext { var p = new(A_expr_addContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_add return p } func InitEmptyA_expr_addContext(p *A_expr_addContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_add } func (*A_expr_addContext) IsA_expr_addContext() {} func NewA_expr_addContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_addContext { var p = new(A_expr_addContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_add return p } func (s *A_expr_addContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_addContext) AllA_expr_mul() []IA_expr_mulContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_expr_mulContext); ok { len++ } } tst := make([]IA_expr_mulContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_expr_mulContext); ok { tst[i] = t.(IA_expr_mulContext) i++ } } return tst } func (s *A_expr_addContext) A_expr_mul(i int) IA_expr_mulContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_mulContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_expr_mulContext) } func (s *A_expr_addContext) AllMINUS() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserMINUS) } func (s *A_expr_addContext) MINUS(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserMINUS, i) } func (s *A_expr_addContext) AllPLUS() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserPLUS) } func (s *A_expr_addContext) PLUS(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserPLUS, i) } func (s *A_expr_addContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_addContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_addContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_add(s) } } func (s *A_expr_addContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_add(s) } } func (s *A_expr_addContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_add(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_add() (localctx IA_expr_addContext) { localctx = NewA_expr_addContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1190, PostgreSQLParserRULE_a_expr_add) var _la int var _alt int p.EnterOuterAlt(localctx, 1) { p.SetState(8928) p.A_expr_mul() } p.SetState(8933) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 563, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(8929) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserPLUS || _la == PostgreSQLParserMINUS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(8930) p.A_expr_mul() } } p.SetState(8935) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 563, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_mulContext is an interface to support dynamic dispatch. type IA_expr_mulContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllA_expr_caret() []IA_expr_caretContext A_expr_caret(i int) IA_expr_caretContext AllSTAR() []antlr.TerminalNode STAR(i int) antlr.TerminalNode AllSLASH() []antlr.TerminalNode SLASH(i int) antlr.TerminalNode AllPERCENT() []antlr.TerminalNode PERCENT(i int) antlr.TerminalNode // IsA_expr_mulContext differentiates from other interfaces. IsA_expr_mulContext() } type A_expr_mulContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_mulContext() *A_expr_mulContext { var p = new(A_expr_mulContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_mul return p } func InitEmptyA_expr_mulContext(p *A_expr_mulContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_mul } func (*A_expr_mulContext) IsA_expr_mulContext() {} func NewA_expr_mulContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_mulContext { var p = new(A_expr_mulContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_mul return p } func (s *A_expr_mulContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_mulContext) AllA_expr_caret() []IA_expr_caretContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_expr_caretContext); ok { len++ } } tst := make([]IA_expr_caretContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_expr_caretContext); ok { tst[i] = t.(IA_expr_caretContext) i++ } } return tst } func (s *A_expr_mulContext) A_expr_caret(i int) IA_expr_caretContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_caretContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_expr_caretContext) } func (s *A_expr_mulContext) AllSTAR() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserSTAR) } func (s *A_expr_mulContext) STAR(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTAR, i) } func (s *A_expr_mulContext) AllSLASH() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserSLASH) } func (s *A_expr_mulContext) SLASH(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserSLASH, i) } func (s *A_expr_mulContext) AllPERCENT() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserPERCENT) } func (s *A_expr_mulContext) PERCENT(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserPERCENT, i) } func (s *A_expr_mulContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_mulContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_mulContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_mul(s) } } func (s *A_expr_mulContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_mul(s) } } func (s *A_expr_mulContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_mul(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_mul() (localctx IA_expr_mulContext) { localctx = NewA_expr_mulContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1192, PostgreSQLParserRULE_a_expr_mul) var _la int var _alt int p.EnterOuterAlt(localctx, 1) { p.SetState(8936) p.A_expr_caret() } p.SetState(8941) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 564, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(8937) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&134234624) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(8938) p.A_expr_caret() } } p.SetState(8943) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 564, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_caretContext is an interface to support dynamic dispatch. type IA_expr_caretContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr_unary_sign() IA_expr_unary_signContext CARET() antlr.TerminalNode A_expr() IA_exprContext // IsA_expr_caretContext differentiates from other interfaces. IsA_expr_caretContext() } type A_expr_caretContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_caretContext() *A_expr_caretContext { var p = new(A_expr_caretContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_caret return p } func InitEmptyA_expr_caretContext(p *A_expr_caretContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_caret } func (*A_expr_caretContext) IsA_expr_caretContext() {} func NewA_expr_caretContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_caretContext { var p = new(A_expr_caretContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_caret return p } func (s *A_expr_caretContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_caretContext) A_expr_unary_sign() IA_expr_unary_signContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_unary_signContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_expr_unary_signContext) } func (s *A_expr_caretContext) CARET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCARET, 0) } func (s *A_expr_caretContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *A_expr_caretContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_caretContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_caretContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_caret(s) } } func (s *A_expr_caretContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_caret(s) } } func (s *A_expr_caretContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_caret(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_caret() (localctx IA_expr_caretContext) { localctx = NewA_expr_caretContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1194, PostgreSQLParserRULE_a_expr_caret) p.EnterOuterAlt(localctx, 1) { p.SetState(8944) p.A_expr_unary_sign() } p.SetState(8947) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 565, p.GetParserRuleContext()) == 1 { { p.SetState(8945) p.Match(PostgreSQLParserCARET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8946) p.A_expr() } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_unary_signContext is an interface to support dynamic dispatch. type IA_expr_unary_signContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr_at_time_zone() IA_expr_at_time_zoneContext MINUS() antlr.TerminalNode PLUS() antlr.TerminalNode // IsA_expr_unary_signContext differentiates from other interfaces. IsA_expr_unary_signContext() } type A_expr_unary_signContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_unary_signContext() *A_expr_unary_signContext { var p = new(A_expr_unary_signContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_sign return p } func InitEmptyA_expr_unary_signContext(p *A_expr_unary_signContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_sign } func (*A_expr_unary_signContext) IsA_expr_unary_signContext() {} func NewA_expr_unary_signContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_unary_signContext { var p = new(A_expr_unary_signContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_unary_sign return p } func (s *A_expr_unary_signContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_unary_signContext) A_expr_at_time_zone() IA_expr_at_time_zoneContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_at_time_zoneContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_expr_at_time_zoneContext) } func (s *A_expr_unary_signContext) MINUS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMINUS, 0) } func (s *A_expr_unary_signContext) PLUS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPLUS, 0) } func (s *A_expr_unary_signContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_unary_signContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_unary_signContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_unary_sign(s) } } func (s *A_expr_unary_signContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_unary_sign(s) } } func (s *A_expr_unary_signContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_unary_sign(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_unary_sign() (localctx IA_expr_unary_signContext) { localctx = NewA_expr_unary_signContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1196, PostgreSQLParserRULE_a_expr_unary_sign) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(8950) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserPLUS || _la == PostgreSQLParserMINUS { { p.SetState(8949) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserPLUS || _la == PostgreSQLParserMINUS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } } { p.SetState(8952) p.A_expr_at_time_zone() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_at_time_zoneContext is an interface to support dynamic dispatch. type IA_expr_at_time_zoneContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr_collate() IA_expr_collateContext AT() antlr.TerminalNode TIME() antlr.TerminalNode ZONE() antlr.TerminalNode A_expr() IA_exprContext // IsA_expr_at_time_zoneContext differentiates from other interfaces. IsA_expr_at_time_zoneContext() } type A_expr_at_time_zoneContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_at_time_zoneContext() *A_expr_at_time_zoneContext { var p = new(A_expr_at_time_zoneContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_at_time_zone return p } func InitEmptyA_expr_at_time_zoneContext(p *A_expr_at_time_zoneContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_at_time_zone } func (*A_expr_at_time_zoneContext) IsA_expr_at_time_zoneContext() {} func NewA_expr_at_time_zoneContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_at_time_zoneContext { var p = new(A_expr_at_time_zoneContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_at_time_zone return p } func (s *A_expr_at_time_zoneContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_at_time_zoneContext) A_expr_collate() IA_expr_collateContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_collateContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_expr_collateContext) } func (s *A_expr_at_time_zoneContext) AT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAT, 0) } func (s *A_expr_at_time_zoneContext) TIME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTIME, 0) } func (s *A_expr_at_time_zoneContext) ZONE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserZONE, 0) } func (s *A_expr_at_time_zoneContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *A_expr_at_time_zoneContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_at_time_zoneContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_at_time_zoneContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_at_time_zone(s) } } func (s *A_expr_at_time_zoneContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_at_time_zone(s) } } func (s *A_expr_at_time_zoneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_at_time_zone(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_at_time_zone() (localctx IA_expr_at_time_zoneContext) { localctx = NewA_expr_at_time_zoneContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1198, PostgreSQLParserRULE_a_expr_at_time_zone) p.EnterOuterAlt(localctx, 1) { p.SetState(8954) p.A_expr_collate() } p.SetState(8959) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 567, p.GetParserRuleContext()) == 1 { { p.SetState(8955) p.Match(PostgreSQLParserAT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8956) p.Match(PostgreSQLParserTIME) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8957) p.Match(PostgreSQLParserZONE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8958) p.A_expr() } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_collateContext is an interface to support dynamic dispatch. type IA_expr_collateContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr_typecast() IA_expr_typecastContext COLLATE() antlr.TerminalNode Any_name() IAny_nameContext // IsA_expr_collateContext differentiates from other interfaces. IsA_expr_collateContext() } type A_expr_collateContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_collateContext() *A_expr_collateContext { var p = new(A_expr_collateContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_collate return p } func InitEmptyA_expr_collateContext(p *A_expr_collateContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_collate } func (*A_expr_collateContext) IsA_expr_collateContext() {} func NewA_expr_collateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_collateContext { var p = new(A_expr_collateContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_collate return p } func (s *A_expr_collateContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_collateContext) A_expr_typecast() IA_expr_typecastContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_expr_typecastContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_expr_typecastContext) } func (s *A_expr_collateContext) COLLATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATE, 0) } func (s *A_expr_collateContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *A_expr_collateContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_collateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_collateContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_collate(s) } } func (s *A_expr_collateContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_collate(s) } } func (s *A_expr_collateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_collate(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_collate() (localctx IA_expr_collateContext) { localctx = NewA_expr_collateContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1200, PostgreSQLParserRULE_a_expr_collate) p.EnterOuterAlt(localctx, 1) { p.SetState(8961) p.A_expr_typecast() } p.SetState(8964) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 568, p.GetParserRuleContext()) == 1 { { p.SetState(8962) p.Match(PostgreSQLParserCOLLATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8963) p.Any_name() } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IA_expr_typecastContext is an interface to support dynamic dispatch. type IA_expr_typecastContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures C_expr() IC_exprContext AllTYPECAST() []antlr.TerminalNode TYPECAST(i int) antlr.TerminalNode AllTypename() []ITypenameContext Typename(i int) ITypenameContext // IsA_expr_typecastContext differentiates from other interfaces. IsA_expr_typecastContext() } type A_expr_typecastContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyA_expr_typecastContext() *A_expr_typecastContext { var p = new(A_expr_typecastContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_typecast return p } func InitEmptyA_expr_typecastContext(p *A_expr_typecastContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_a_expr_typecast } func (*A_expr_typecastContext) IsA_expr_typecastContext() {} func NewA_expr_typecastContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_typecastContext { var p = new(A_expr_typecastContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_a_expr_typecast return p } func (s *A_expr_typecastContext) GetParser() antlr.Parser { return s.parser } func (s *A_expr_typecastContext) C_expr() IC_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IC_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IC_exprContext) } func (s *A_expr_typecastContext) AllTYPECAST() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserTYPECAST) } func (s *A_expr_typecastContext) TYPECAST(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPECAST, i) } func (s *A_expr_typecastContext) AllTypename() []ITypenameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITypenameContext); ok { len++ } } tst := make([]ITypenameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITypenameContext); ok { tst[i] = t.(ITypenameContext) i++ } } return tst } func (s *A_expr_typecastContext) Typename(i int) ITypenameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITypenameContext) } func (s *A_expr_typecastContext) GetRuleContext() antlr.RuleContext { return s } func (s *A_expr_typecastContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *A_expr_typecastContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterA_expr_typecast(s) } } func (s *A_expr_typecastContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitA_expr_typecast(s) } } func (s *A_expr_typecastContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitA_expr_typecast(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) A_expr_typecast() (localctx IA_expr_typecastContext) { localctx = NewA_expr_typecastContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1202, PostgreSQLParserRULE_a_expr_typecast) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8966) p.C_expr() } p.SetState(8971) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserTYPECAST { { p.SetState(8967) p.Match(PostgreSQLParserTYPECAST) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8968) p.Typename() } p.SetState(8973) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IB_exprContext is an interface to support dynamic dispatch. type IB_exprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures C_expr() IC_exprContext AllB_expr() []IB_exprContext B_expr(i int) IB_exprContext PLUS() antlr.TerminalNode MINUS() antlr.TerminalNode Qual_op() IQual_opContext CARET() antlr.TerminalNode STAR() antlr.TerminalNode SLASH() antlr.TerminalNode PERCENT() antlr.TerminalNode LT() antlr.TerminalNode GT() antlr.TerminalNode EQUAL() antlr.TerminalNode LESS_EQUALS() antlr.TerminalNode GREATER_EQUALS() antlr.TerminalNode NOT_EQUALS() antlr.TerminalNode TYPECAST() antlr.TerminalNode Typename() ITypenameContext IS() antlr.TerminalNode DISTINCT() antlr.TerminalNode FROM() antlr.TerminalNode OF() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Type_list() IType_listContext CLOSE_PAREN() antlr.TerminalNode DOCUMENT_P() antlr.TerminalNode NOT() antlr.TerminalNode // IsB_exprContext differentiates from other interfaces. IsB_exprContext() } type B_exprContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyB_exprContext() *B_exprContext { var p = new(B_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_b_expr return p } func InitEmptyB_exprContext(p *B_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_b_expr } func (*B_exprContext) IsB_exprContext() {} func NewB_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *B_exprContext { var p = new(B_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_b_expr return p } func (s *B_exprContext) GetParser() antlr.Parser { return s.parser } func (s *B_exprContext) C_expr() IC_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IC_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IC_exprContext) } func (s *B_exprContext) AllB_expr() []IB_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IB_exprContext); ok { len++ } } tst := make([]IB_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IB_exprContext); ok { tst[i] = t.(IB_exprContext) i++ } } return tst } func (s *B_exprContext) B_expr(i int) IB_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IB_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IB_exprContext) } func (s *B_exprContext) PLUS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPLUS, 0) } func (s *B_exprContext) MINUS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMINUS, 0) } func (s *B_exprContext) Qual_op() IQual_opContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQual_opContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IQual_opContext) } func (s *B_exprContext) CARET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCARET, 0) } func (s *B_exprContext) STAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTAR, 0) } func (s *B_exprContext) SLASH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSLASH, 0) } func (s *B_exprContext) PERCENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPERCENT, 0) } func (s *B_exprContext) LT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLT, 0) } func (s *B_exprContext) GT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGT, 0) } func (s *B_exprContext) EQUAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEQUAL, 0) } func (s *B_exprContext) LESS_EQUALS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLESS_EQUALS, 0) } func (s *B_exprContext) GREATER_EQUALS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGREATER_EQUALS, 0) } func (s *B_exprContext) NOT_EQUALS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT_EQUALS, 0) } func (s *B_exprContext) TYPECAST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPECAST, 0) } func (s *B_exprContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *B_exprContext) IS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIS, 0) } func (s *B_exprContext) DISTINCT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDISTINCT, 0) } func (s *B_exprContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *B_exprContext) OF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOF, 0) } func (s *B_exprContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *B_exprContext) Type_list() IType_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IType_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IType_listContext) } func (s *B_exprContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *B_exprContext) DOCUMENT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOCUMENT_P, 0) } func (s *B_exprContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *B_exprContext) GetRuleContext() antlr.RuleContext { return s } func (s *B_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *B_exprContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterB_expr(s) } } func (s *B_exprContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitB_expr(s) } } func (s *B_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitB_expr(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) B_expr() (localctx IB_exprContext) { return p.b_expr(0) } func (p *PostgreSQLParser) b_expr(_p int) (localctx IB_exprContext) { var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() _parentState := p.GetState() localctx = NewB_exprContext(p, p.GetParserRuleContext(), _parentState) var _prevctx IB_exprContext = localctx var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. _startState := 1204 p.EnterRecursionRule(localctx, 1204, PostgreSQLParserRULE_b_expr, _p) var _la int var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(8981) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 570, p.GetParserRuleContext()) { case 1: { p.SetState(8975) p.C_expr() } case 2: { p.SetState(8976) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserPLUS || _la == PostgreSQLParserMINUS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(8977) p.b_expr(9) } case 3: { p.SetState(8978) p.Qual_op() } { p.SetState(8979) p.b_expr(3) } case antlr.ATNInvalidAltNumber: goto errorExit } p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) p.SetState(9022) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 574, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { if p.GetParseListeners() != nil { p.TriggerExitRuleEvent() } _prevctx = localctx p.SetState(9020) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 573, p.GetParserRuleContext()) { case 1: localctx = NewB_exprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr) p.SetState(8983) if !(p.Precpred(p.GetParserRuleContext(), 8)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", "")) goto errorExit } { p.SetState(8984) p.Match(PostgreSQLParserCARET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(8985) p.b_expr(9) } case 2: localctx = NewB_exprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr) p.SetState(8986) if !(p.Precpred(p.GetParserRuleContext(), 7)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", "")) goto errorExit } { p.SetState(8987) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&134234624) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(8988) p.b_expr(8) } case 3: localctx = NewB_exprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr) p.SetState(8989) if !(p.Precpred(p.GetParserRuleContext(), 6)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", "")) goto errorExit } { p.SetState(8990) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserPLUS || _la == PostgreSQLParserMINUS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(8991) p.b_expr(7) } case 4: localctx = NewB_exprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr) p.SetState(8992) if !(p.Precpred(p.GetParserRuleContext(), 5)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", "")) goto errorExit } { p.SetState(8993) p.Qual_op() } { p.SetState(8994) p.b_expr(6) } case 5: localctx = NewB_exprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr) p.SetState(8996) if !(p.Precpred(p.GetParserRuleContext(), 4)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", "")) goto errorExit } { p.SetState(8997) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&44237824) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(8998) p.b_expr(5) } case 6: localctx = NewB_exprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr) p.SetState(8999) if !(p.Precpred(p.GetParserRuleContext(), 10)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", "")) goto errorExit } { p.SetState(9000) p.Match(PostgreSQLParserTYPECAST) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9001) p.Typename() } case 7: localctx = NewB_exprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr) p.SetState(9002) if !(p.Precpred(p.GetParserRuleContext(), 2)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) goto errorExit } { p.SetState(9003) p.Qual_op() } case 8: localctx = NewB_exprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, PostgreSQLParserRULE_b_expr) p.SetState(9004) if !(p.Precpred(p.GetParserRuleContext(), 1)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) goto errorExit } { p.SetState(9005) p.Match(PostgreSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9007) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserNOT { { p.SetState(9006) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } } p.SetState(9018) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserDISTINCT: { p.SetState(9009) p.Match(PostgreSQLParserDISTINCT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9010) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9011) p.b_expr(0) } case PostgreSQLParserOF: { p.SetState(9012) p.Match(PostgreSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9013) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9014) p.Type_list() } { p.SetState(9015) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserDOCUMENT_P: { p.SetState(9017) p.Match(PostgreSQLParserDOCUMENT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case antlr.ATNInvalidAltNumber: goto errorExit } } p.SetState(9024) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 574, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.UnrollRecursionContexts(_parentctx) return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IC_exprContext is an interface to support dynamic dispatch. type IC_exprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsC_exprContext differentiates from other interfaces. IsC_exprContext() } type C_exprContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyC_exprContext() *C_exprContext { var p = new(C_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_c_expr return p } func InitEmptyC_exprContext(p *C_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_c_expr } func (*C_exprContext) IsC_exprContext() {} func NewC_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *C_exprContext { var p = new(C_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_c_expr return p } func (s *C_exprContext) GetParser() antlr.Parser { return s.parser } func (s *C_exprContext) CopyAll(ctx *C_exprContext) { s.CopyFrom(&ctx.BaseParserRuleContext) } func (s *C_exprContext) GetRuleContext() antlr.RuleContext { return s } func (s *C_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } type C_expr_existsContext struct { C_exprContext } func NewC_expr_existsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *C_expr_existsContext { var p = new(C_expr_existsContext) InitEmptyC_exprContext(&p.C_exprContext) p.parser = parser p.CopyAll(ctx.(*C_exprContext)) return p } func (s *C_expr_existsContext) GetRuleContext() antlr.RuleContext { return s } func (s *C_expr_existsContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *C_expr_existsContext) Select_with_parens() ISelect_with_parensContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_with_parensContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_with_parensContext) } func (s *C_expr_existsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterC_expr_exists(s) } } func (s *C_expr_existsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitC_expr_exists(s) } } func (s *C_expr_existsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitC_expr_exists(s) default: return t.VisitChildren(s) } } type C_expr_caseContext struct { C_exprContext } func NewC_expr_caseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *C_expr_caseContext { var p = new(C_expr_caseContext) InitEmptyC_exprContext(&p.C_exprContext) p.parser = parser p.CopyAll(ctx.(*C_exprContext)) return p } func (s *C_expr_caseContext) GetRuleContext() antlr.RuleContext { return s } func (s *C_expr_caseContext) Case_expr() ICase_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICase_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICase_exprContext) } func (s *C_expr_caseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterC_expr_case(s) } } func (s *C_expr_caseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitC_expr_case(s) } } func (s *C_expr_caseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitC_expr_case(s) default: return t.VisitChildren(s) } } type C_expr_exprContext struct { C_exprContext a_expr_in_parens IA_exprContext } func NewC_expr_exprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *C_expr_exprContext { var p = new(C_expr_exprContext) InitEmptyC_exprContext(&p.C_exprContext) p.parser = parser p.CopyAll(ctx.(*C_exprContext)) return p } func (s *C_expr_exprContext) GetA_expr_in_parens() IA_exprContext { return s.a_expr_in_parens } func (s *C_expr_exprContext) SetA_expr_in_parens(v IA_exprContext) { s.a_expr_in_parens = v } func (s *C_expr_exprContext) GetRuleContext() antlr.RuleContext { return s } func (s *C_expr_exprContext) ARRAY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserARRAY, 0) } func (s *C_expr_exprContext) Select_with_parens() ISelect_with_parensContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_with_parensContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_with_parensContext) } func (s *C_expr_exprContext) Array_expr() IArray_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IArray_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IArray_exprContext) } func (s *C_expr_exprContext) PARAM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARAM, 0) } func (s *C_expr_exprContext) Opt_indirection() IOpt_indirectionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_indirectionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_indirectionContext) } func (s *C_expr_exprContext) GROUPING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUPING, 0) } func (s *C_expr_exprContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *C_expr_exprContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *C_expr_exprContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *C_expr_exprContext) UNIQUE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNIQUE, 0) } func (s *C_expr_exprContext) Columnref() IColumnrefContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColumnrefContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColumnrefContext) } func (s *C_expr_exprContext) Aexprconst() IAexprconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAexprconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAexprconstContext) } func (s *C_expr_exprContext) Plsqlvariablename() IPlsqlvariablenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPlsqlvariablenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPlsqlvariablenameContext) } func (s *C_expr_exprContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *C_expr_exprContext) Func_expr() IFunc_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_exprContext) } func (s *C_expr_exprContext) Indirection() IIndirectionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndirectionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIndirectionContext) } func (s *C_expr_exprContext) Explicit_row() IExplicit_rowContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExplicit_rowContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExplicit_rowContext) } func (s *C_expr_exprContext) Implicit_row() IImplicit_rowContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IImplicit_rowContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IImplicit_rowContext) } func (s *C_expr_exprContext) AllRow() []IRowContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IRowContext); ok { len++ } } tst := make([]IRowContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IRowContext); ok { tst[i] = t.(IRowContext) i++ } } return tst } func (s *C_expr_exprContext) Row(i int) IRowContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRowContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IRowContext) } func (s *C_expr_exprContext) OVERLAPS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOVERLAPS, 0) } func (s *C_expr_exprContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterC_expr_expr(s) } } func (s *C_expr_exprContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitC_expr_expr(s) } } func (s *C_expr_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitC_expr_expr(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) C_expr() (localctx IC_exprContext) { localctx = NewC_exprContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1206, PostgreSQLParserRULE_c_expr) p.SetState(9061) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 577, p.GetParserRuleContext()) { case 1: localctx = NewC_expr_existsContext(p, localctx) p.EnterOuterAlt(localctx, 1) { p.SetState(9025) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9026) p.Select_with_parens() } case 2: localctx = NewC_expr_exprContext(p, localctx) p.EnterOuterAlt(localctx, 2) { p.SetState(9027) p.Match(PostgreSQLParserARRAY) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9030) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN: { p.SetState(9028) p.Select_with_parens() } case PostgreSQLParserOPEN_BRACKET: { p.SetState(9029) p.Array_expr() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case 3: localctx = NewC_expr_exprContext(p, localctx) p.EnterOuterAlt(localctx, 3) { p.SetState(9032) p.Match(PostgreSQLParserPARAM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9033) p.Opt_indirection() } case 4: localctx = NewC_expr_exprContext(p, localctx) p.EnterOuterAlt(localctx, 4) { p.SetState(9034) p.Match(PostgreSQLParserGROUPING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9035) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9036) p.Expr_list() } { p.SetState(9037) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: localctx = NewC_expr_exprContext(p, localctx) p.EnterOuterAlt(localctx, 5) { p.SetState(9039) p.Match(PostgreSQLParserUNIQUE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9040) p.Select_with_parens() } case 6: localctx = NewC_expr_exprContext(p, localctx) p.EnterOuterAlt(localctx, 6) { p.SetState(9041) p.Columnref() } case 7: localctx = NewC_expr_exprContext(p, localctx) p.EnterOuterAlt(localctx, 7) { p.SetState(9042) p.Aexprconst() } case 8: localctx = NewC_expr_exprContext(p, localctx) p.EnterOuterAlt(localctx, 8) { p.SetState(9043) p.Plsqlvariablename() } case 9: localctx = NewC_expr_exprContext(p, localctx) p.EnterOuterAlt(localctx, 9) { p.SetState(9044) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9045) var _x = p.A_expr() localctx.(*C_expr_exprContext).a_expr_in_parens = _x } { p.SetState(9046) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9047) p.Opt_indirection() } case 10: localctx = NewC_expr_caseContext(p, localctx) p.EnterOuterAlt(localctx, 10) { p.SetState(9049) p.Case_expr() } case 11: localctx = NewC_expr_exprContext(p, localctx) p.EnterOuterAlt(localctx, 11) { p.SetState(9050) p.Func_expr() } case 12: localctx = NewC_expr_exprContext(p, localctx) p.EnterOuterAlt(localctx, 12) { p.SetState(9051) p.Select_with_parens() } p.SetState(9053) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 576, p.GetParserRuleContext()) == 1 { { p.SetState(9052) p.Indirection() } } else if p.HasError() { // JIM goto errorExit } case 13: localctx = NewC_expr_exprContext(p, localctx) p.EnterOuterAlt(localctx, 13) { p.SetState(9055) p.Explicit_row() } case 14: localctx = NewC_expr_exprContext(p, localctx) p.EnterOuterAlt(localctx, 14) { p.SetState(9056) p.Implicit_row() } case 15: localctx = NewC_expr_exprContext(p, localctx) p.EnterOuterAlt(localctx, 15) { p.SetState(9057) p.Row() } { p.SetState(9058) p.Match(PostgreSQLParserOVERLAPS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9059) p.Row() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPlsqlvariablenameContext is an interface to support dynamic dispatch. type IPlsqlvariablenameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures PLSQLVARIABLENAME() antlr.TerminalNode // IsPlsqlvariablenameContext differentiates from other interfaces. IsPlsqlvariablenameContext() } type PlsqlvariablenameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPlsqlvariablenameContext() *PlsqlvariablenameContext { var p = new(PlsqlvariablenameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_plsqlvariablename return p } func InitEmptyPlsqlvariablenameContext(p *PlsqlvariablenameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_plsqlvariablename } func (*PlsqlvariablenameContext) IsPlsqlvariablenameContext() {} func NewPlsqlvariablenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PlsqlvariablenameContext { var p = new(PlsqlvariablenameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_plsqlvariablename return p } func (s *PlsqlvariablenameContext) GetParser() antlr.Parser { return s.parser } func (s *PlsqlvariablenameContext) PLSQLVARIABLENAME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPLSQLVARIABLENAME, 0) } func (s *PlsqlvariablenameContext) GetRuleContext() antlr.RuleContext { return s } func (s *PlsqlvariablenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *PlsqlvariablenameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPlsqlvariablename(s) } } func (s *PlsqlvariablenameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPlsqlvariablename(s) } } func (s *PlsqlvariablenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPlsqlvariablename(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Plsqlvariablename() (localctx IPlsqlvariablenameContext) { localctx = NewPlsqlvariablenameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1208, PostgreSQLParserRULE_plsqlvariablename) p.EnterOuterAlt(localctx, 1) { p.SetState(9063) p.Match(PostgreSQLParserPLSQLVARIABLENAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_applicationContext is an interface to support dynamic dispatch. type IFunc_applicationContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Func_name() IFunc_nameContext OPEN_PAREN() antlr.TerminalNode CLOSE_PAREN() antlr.TerminalNode Func_arg_list() IFunc_arg_listContext Opt_sort_clause() IOpt_sort_clauseContext VARIADIC() antlr.TerminalNode Func_arg_expr() IFunc_arg_exprContext STAR() antlr.TerminalNode ALL() antlr.TerminalNode DISTINCT() antlr.TerminalNode COMMA() antlr.TerminalNode // IsFunc_applicationContext differentiates from other interfaces. IsFunc_applicationContext() } type Func_applicationContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_applicationContext() *Func_applicationContext { var p = new(Func_applicationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_application return p } func InitEmptyFunc_applicationContext(p *Func_applicationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_application } func (*Func_applicationContext) IsFunc_applicationContext() {} func NewFunc_applicationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_applicationContext { var p = new(Func_applicationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_application return p } func (s *Func_applicationContext) GetParser() antlr.Parser { return s.parser } func (s *Func_applicationContext) Func_name() IFunc_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_nameContext) } func (s *Func_applicationContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Func_applicationContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Func_applicationContext) Func_arg_list() IFunc_arg_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_arg_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_arg_listContext) } func (s *Func_applicationContext) Opt_sort_clause() IOpt_sort_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_sort_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_sort_clauseContext) } func (s *Func_applicationContext) VARIADIC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVARIADIC, 0) } func (s *Func_applicationContext) Func_arg_expr() IFunc_arg_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_arg_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_arg_exprContext) } func (s *Func_applicationContext) STAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTAR, 0) } func (s *Func_applicationContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *Func_applicationContext) DISTINCT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDISTINCT, 0) } func (s *Func_applicationContext) COMMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, 0) } func (s *Func_applicationContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_applicationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_applicationContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_application(s) } } func (s *Func_applicationContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_application(s) } } func (s *Func_applicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_application(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_application() (localctx IFunc_applicationContext) { localctx = NewFunc_applicationContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1210, PostgreSQLParserRULE_func_application) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9065) p.Func_name() } { p.SetState(9066) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9085) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: { p.SetState(9067) p.Func_arg_list() } p.SetState(9071) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserCOMMA { { p.SetState(9068) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9069) p.Match(PostgreSQLParserVARIADIC) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9070) p.Func_arg_expr() } } { p.SetState(9073) p.Opt_sort_clause() } case PostgreSQLParserVARIADIC: { p.SetState(9075) p.Match(PostgreSQLParserVARIADIC) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9076) p.Func_arg_expr() } { p.SetState(9077) p.Opt_sort_clause() } case PostgreSQLParserALL, PostgreSQLParserDISTINCT: { p.SetState(9079) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserALL || _la == PostgreSQLParserDISTINCT) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(9080) p.Func_arg_list() } { p.SetState(9081) p.Opt_sort_clause() } case PostgreSQLParserSTAR: { p.SetState(9083) p.Match(PostgreSQLParserSTAR) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserCLOSE_PAREN: default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } { p.SetState(9087) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_exprContext is an interface to support dynamic dispatch. type IFunc_exprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Func_application() IFunc_applicationContext Within_group_clause() IWithin_group_clauseContext Filter_clause() IFilter_clauseContext Over_clause() IOver_clauseContext Func_expr_common_subexpr() IFunc_expr_common_subexprContext // IsFunc_exprContext differentiates from other interfaces. IsFunc_exprContext() } type Func_exprContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_exprContext() *Func_exprContext { var p = new(Func_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_expr return p } func InitEmptyFunc_exprContext(p *Func_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_expr } func (*Func_exprContext) IsFunc_exprContext() {} func NewFunc_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_exprContext { var p = new(Func_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_expr return p } func (s *Func_exprContext) GetParser() antlr.Parser { return s.parser } func (s *Func_exprContext) Func_application() IFunc_applicationContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_applicationContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_applicationContext) } func (s *Func_exprContext) Within_group_clause() IWithin_group_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWithin_group_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWithin_group_clauseContext) } func (s *Func_exprContext) Filter_clause() IFilter_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFilter_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFilter_clauseContext) } func (s *Func_exprContext) Over_clause() IOver_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOver_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOver_clauseContext) } func (s *Func_exprContext) Func_expr_common_subexpr() IFunc_expr_common_subexprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_expr_common_subexprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_expr_common_subexprContext) } func (s *Func_exprContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_exprContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_expr(s) } } func (s *Func_exprContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_expr(s) } } func (s *Func_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_expr(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_expr() (localctx IFunc_exprContext) { localctx = NewFunc_exprContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1212, PostgreSQLParserRULE_func_expr) p.SetState(9095) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 580, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9089) p.Func_application() } { p.SetState(9090) p.Within_group_clause() } { p.SetState(9091) p.Filter_clause() } { p.SetState(9092) p.Over_clause() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9094) p.Func_expr_common_subexpr() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_expr_windowlessContext is an interface to support dynamic dispatch. type IFunc_expr_windowlessContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Func_application() IFunc_applicationContext Func_expr_common_subexpr() IFunc_expr_common_subexprContext // IsFunc_expr_windowlessContext differentiates from other interfaces. IsFunc_expr_windowlessContext() } type Func_expr_windowlessContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_expr_windowlessContext() *Func_expr_windowlessContext { var p = new(Func_expr_windowlessContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_expr_windowless return p } func InitEmptyFunc_expr_windowlessContext(p *Func_expr_windowlessContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_expr_windowless } func (*Func_expr_windowlessContext) IsFunc_expr_windowlessContext() {} func NewFunc_expr_windowlessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_expr_windowlessContext { var p = new(Func_expr_windowlessContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_expr_windowless return p } func (s *Func_expr_windowlessContext) GetParser() antlr.Parser { return s.parser } func (s *Func_expr_windowlessContext) Func_application() IFunc_applicationContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_applicationContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_applicationContext) } func (s *Func_expr_windowlessContext) Func_expr_common_subexpr() IFunc_expr_common_subexprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_expr_common_subexprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_expr_common_subexprContext) } func (s *Func_expr_windowlessContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_expr_windowlessContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_expr_windowlessContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_expr_windowless(s) } } func (s *Func_expr_windowlessContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_expr_windowless(s) } } func (s *Func_expr_windowlessContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_expr_windowless(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_expr_windowless() (localctx IFunc_expr_windowlessContext) { localctx = NewFunc_expr_windowlessContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1214, PostgreSQLParserRULE_func_expr_windowless) p.SetState(9099) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 581, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9097) p.Func_application() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9098) p.Func_expr_common_subexpr() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_expr_common_subexprContext is an interface to support dynamic dispatch. type IFunc_expr_common_subexprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures COLLATION() antlr.TerminalNode FOR() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode AllA_expr() []IA_exprContext A_expr(i int) IA_exprContext CLOSE_PAREN() antlr.TerminalNode CURRENT_DATE() antlr.TerminalNode CURRENT_TIME() antlr.TerminalNode Iconst() IIconstContext CURRENT_TIMESTAMP() antlr.TerminalNode LOCALTIME() antlr.TerminalNode LOCALTIMESTAMP() antlr.TerminalNode CURRENT_ROLE() antlr.TerminalNode CURRENT_USER() antlr.TerminalNode SESSION_USER() antlr.TerminalNode USER() antlr.TerminalNode CURRENT_CATALOG() antlr.TerminalNode CURRENT_SCHEMA() antlr.TerminalNode CAST() antlr.TerminalNode AS() antlr.TerminalNode Typename() ITypenameContext EXTRACT() antlr.TerminalNode Extract_list() IExtract_listContext NORMALIZE() antlr.TerminalNode COMMA() antlr.TerminalNode Unicode_normal_form() IUnicode_normal_formContext OVERLAY() antlr.TerminalNode Overlay_list() IOverlay_listContext POSITION() antlr.TerminalNode Position_list() IPosition_listContext SUBSTRING() antlr.TerminalNode Substr_list() ISubstr_listContext TREAT() antlr.TerminalNode TRIM() antlr.TerminalNode Trim_list() ITrim_listContext BOTH() antlr.TerminalNode LEADING() antlr.TerminalNode TRAILING() antlr.TerminalNode NULLIF() antlr.TerminalNode COALESCE() antlr.TerminalNode Expr_list() IExpr_listContext GREATEST() antlr.TerminalNode LEAST() antlr.TerminalNode XMLCONCAT() antlr.TerminalNode XMLELEMENT() antlr.TerminalNode NAME_P() antlr.TerminalNode Collabel() ICollabelContext Xml_attributes() IXml_attributesContext XMLEXISTS() antlr.TerminalNode C_expr() IC_exprContext Xmlexists_argument() IXmlexists_argumentContext XMLFOREST() antlr.TerminalNode Xml_attribute_list() IXml_attribute_listContext XMLPARSE() antlr.TerminalNode Document_or_content() IDocument_or_contentContext Xml_whitespace_option() IXml_whitespace_optionContext XMLPI() antlr.TerminalNode XMLROOT() antlr.TerminalNode XML_P() antlr.TerminalNode Xml_root_version() IXml_root_versionContext Opt_xml_root_standalone() IOpt_xml_root_standaloneContext XMLSERIALIZE() antlr.TerminalNode Simpletypename() ISimpletypenameContext // IsFunc_expr_common_subexprContext differentiates from other interfaces. IsFunc_expr_common_subexprContext() } type Func_expr_common_subexprContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_expr_common_subexprContext() *Func_expr_common_subexprContext { var p = new(Func_expr_common_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_expr_common_subexpr return p } func InitEmptyFunc_expr_common_subexprContext(p *Func_expr_common_subexprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_expr_common_subexpr } func (*Func_expr_common_subexprContext) IsFunc_expr_common_subexprContext() {} func NewFunc_expr_common_subexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_expr_common_subexprContext { var p = new(Func_expr_common_subexprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_expr_common_subexpr return p } func (s *Func_expr_common_subexprContext) GetParser() antlr.Parser { return s.parser } func (s *Func_expr_common_subexprContext) COLLATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATION, 0) } func (s *Func_expr_common_subexprContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *Func_expr_common_subexprContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Func_expr_common_subexprContext) AllA_expr() []IA_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_exprContext); ok { len++ } } tst := make([]IA_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_exprContext); ok { tst[i] = t.(IA_exprContext) i++ } } return tst } func (s *Func_expr_common_subexprContext) A_expr(i int) IA_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Func_expr_common_subexprContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Func_expr_common_subexprContext) CURRENT_DATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_DATE, 0) } func (s *Func_expr_common_subexprContext) CURRENT_TIME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_TIME, 0) } func (s *Func_expr_common_subexprContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *Func_expr_common_subexprContext) CURRENT_TIMESTAMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_TIMESTAMP, 0) } func (s *Func_expr_common_subexprContext) LOCALTIME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCALTIME, 0) } func (s *Func_expr_common_subexprContext) LOCALTIMESTAMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCALTIMESTAMP, 0) } func (s *Func_expr_common_subexprContext) CURRENT_ROLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_ROLE, 0) } func (s *Func_expr_common_subexprContext) CURRENT_USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_USER, 0) } func (s *Func_expr_common_subexprContext) SESSION_USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSESSION_USER, 0) } func (s *Func_expr_common_subexprContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *Func_expr_common_subexprContext) CURRENT_CATALOG() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_CATALOG, 0) } func (s *Func_expr_common_subexprContext) CURRENT_SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_SCHEMA, 0) } func (s *Func_expr_common_subexprContext) CAST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCAST, 0) } func (s *Func_expr_common_subexprContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Func_expr_common_subexprContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *Func_expr_common_subexprContext) EXTRACT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXTRACT, 0) } func (s *Func_expr_common_subexprContext) Extract_list() IExtract_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExtract_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExtract_listContext) } func (s *Func_expr_common_subexprContext) NORMALIZE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNORMALIZE, 0) } func (s *Func_expr_common_subexprContext) COMMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, 0) } func (s *Func_expr_common_subexprContext) Unicode_normal_form() IUnicode_normal_formContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUnicode_normal_formContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUnicode_normal_formContext) } func (s *Func_expr_common_subexprContext) OVERLAY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOVERLAY, 0) } func (s *Func_expr_common_subexprContext) Overlay_list() IOverlay_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOverlay_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOverlay_listContext) } func (s *Func_expr_common_subexprContext) POSITION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPOSITION, 0) } func (s *Func_expr_common_subexprContext) Position_list() IPosition_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPosition_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPosition_listContext) } func (s *Func_expr_common_subexprContext) SUBSTRING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSUBSTRING, 0) } func (s *Func_expr_common_subexprContext) Substr_list() ISubstr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISubstr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISubstr_listContext) } func (s *Func_expr_common_subexprContext) TREAT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTREAT, 0) } func (s *Func_expr_common_subexprContext) TRIM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRIM, 0) } func (s *Func_expr_common_subexprContext) Trim_list() ITrim_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITrim_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITrim_listContext) } func (s *Func_expr_common_subexprContext) BOTH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBOTH, 0) } func (s *Func_expr_common_subexprContext) LEADING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEADING, 0) } func (s *Func_expr_common_subexprContext) TRAILING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRAILING, 0) } func (s *Func_expr_common_subexprContext) NULLIF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULLIF, 0) } func (s *Func_expr_common_subexprContext) COALESCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOALESCE, 0) } func (s *Func_expr_common_subexprContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Func_expr_common_subexprContext) GREATEST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGREATEST, 0) } func (s *Func_expr_common_subexprContext) LEAST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEAST, 0) } func (s *Func_expr_common_subexprContext) XMLCONCAT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLCONCAT, 0) } func (s *Func_expr_common_subexprContext) XMLELEMENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLELEMENT, 0) } func (s *Func_expr_common_subexprContext) NAME_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNAME_P, 0) } func (s *Func_expr_common_subexprContext) Collabel() ICollabelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICollabelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICollabelContext) } func (s *Func_expr_common_subexprContext) Xml_attributes() IXml_attributesContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXml_attributesContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IXml_attributesContext) } func (s *Func_expr_common_subexprContext) XMLEXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLEXISTS, 0) } func (s *Func_expr_common_subexprContext) C_expr() IC_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IC_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IC_exprContext) } func (s *Func_expr_common_subexprContext) Xmlexists_argument() IXmlexists_argumentContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXmlexists_argumentContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IXmlexists_argumentContext) } func (s *Func_expr_common_subexprContext) XMLFOREST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLFOREST, 0) } func (s *Func_expr_common_subexprContext) Xml_attribute_list() IXml_attribute_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXml_attribute_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IXml_attribute_listContext) } func (s *Func_expr_common_subexprContext) XMLPARSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLPARSE, 0) } func (s *Func_expr_common_subexprContext) Document_or_content() IDocument_or_contentContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDocument_or_contentContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDocument_or_contentContext) } func (s *Func_expr_common_subexprContext) Xml_whitespace_option() IXml_whitespace_optionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXml_whitespace_optionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IXml_whitespace_optionContext) } func (s *Func_expr_common_subexprContext) XMLPI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLPI, 0) } func (s *Func_expr_common_subexprContext) XMLROOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLROOT, 0) } func (s *Func_expr_common_subexprContext) XML_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXML_P, 0) } func (s *Func_expr_common_subexprContext) Xml_root_version() IXml_root_versionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXml_root_versionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IXml_root_versionContext) } func (s *Func_expr_common_subexprContext) Opt_xml_root_standalone() IOpt_xml_root_standaloneContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_xml_root_standaloneContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_xml_root_standaloneContext) } func (s *Func_expr_common_subexprContext) XMLSERIALIZE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLSERIALIZE, 0) } func (s *Func_expr_common_subexprContext) Simpletypename() ISimpletypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISimpletypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISimpletypenameContext) } func (s *Func_expr_common_subexprContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_expr_common_subexprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_expr_common_subexprContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_expr_common_subexpr(s) } } func (s *Func_expr_common_subexprContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_expr_common_subexpr(s) } } func (s *Func_expr_common_subexprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_expr_common_subexpr(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_expr_common_subexpr() (localctx IFunc_expr_common_subexprContext) { localctx = NewFunc_expr_common_subexprContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1216, PostgreSQLParserRULE_func_expr_common_subexpr) var _la int p.SetState(9278) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCOLLATION: p.EnterOuterAlt(localctx, 1) { p.SetState(9101) p.Match(PostgreSQLParserCOLLATION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9102) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9103) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9104) p.A_expr() } { p.SetState(9105) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserCURRENT_DATE: p.EnterOuterAlt(localctx, 2) { p.SetState(9107) p.Match(PostgreSQLParserCURRENT_DATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserCURRENT_TIME: p.EnterOuterAlt(localctx, 3) { p.SetState(9108) p.Match(PostgreSQLParserCURRENT_TIME) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9113) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 582, p.GetParserRuleContext()) == 1 { { p.SetState(9109) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9110) p.Iconst() } { p.SetState(9111) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } case PostgreSQLParserCURRENT_TIMESTAMP: p.EnterOuterAlt(localctx, 4) { p.SetState(9115) p.Match(PostgreSQLParserCURRENT_TIMESTAMP) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9120) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 583, p.GetParserRuleContext()) == 1 { { p.SetState(9116) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9117) p.Iconst() } { p.SetState(9118) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } case PostgreSQLParserLOCALTIME: p.EnterOuterAlt(localctx, 5) { p.SetState(9122) p.Match(PostgreSQLParserLOCALTIME) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9127) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 584, p.GetParserRuleContext()) == 1 { { p.SetState(9123) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9124) p.Iconst() } { p.SetState(9125) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } case PostgreSQLParserLOCALTIMESTAMP: p.EnterOuterAlt(localctx, 6) { p.SetState(9129) p.Match(PostgreSQLParserLOCALTIMESTAMP) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9134) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 585, p.GetParserRuleContext()) == 1 { { p.SetState(9130) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9131) p.Iconst() } { p.SetState(9132) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } case PostgreSQLParserCURRENT_ROLE: p.EnterOuterAlt(localctx, 7) { p.SetState(9136) p.Match(PostgreSQLParserCURRENT_ROLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserCURRENT_USER: p.EnterOuterAlt(localctx, 8) { p.SetState(9137) p.Match(PostgreSQLParserCURRENT_USER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSESSION_USER: p.EnterOuterAlt(localctx, 9) { p.SetState(9138) p.Match(PostgreSQLParserSESSION_USER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserUSER: p.EnterOuterAlt(localctx, 10) { p.SetState(9139) p.Match(PostgreSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserCURRENT_CATALOG: p.EnterOuterAlt(localctx, 11) { p.SetState(9140) p.Match(PostgreSQLParserCURRENT_CATALOG) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserCURRENT_SCHEMA: p.EnterOuterAlt(localctx, 12) { p.SetState(9141) p.Match(PostgreSQLParserCURRENT_SCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserCAST: p.EnterOuterAlt(localctx, 13) { p.SetState(9142) p.Match(PostgreSQLParserCAST) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9143) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9144) p.A_expr() } { p.SetState(9145) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9146) p.Typename() } { p.SetState(9147) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEXTRACT: p.EnterOuterAlt(localctx, 14) { p.SetState(9149) p.Match(PostgreSQLParserEXTRACT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9150) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9151) p.Extract_list() } { p.SetState(9152) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserNORMALIZE: p.EnterOuterAlt(localctx, 15) { p.SetState(9154) p.Match(PostgreSQLParserNORMALIZE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9155) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9156) p.A_expr() } p.SetState(9159) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserCOMMA { { p.SetState(9157) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9158) p.Unicode_normal_form() } } { p.SetState(9161) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserOVERLAY: p.EnterOuterAlt(localctx, 16) { p.SetState(9163) p.Match(PostgreSQLParserOVERLAY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9164) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9165) p.Overlay_list() } { p.SetState(9166) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserPOSITION: p.EnterOuterAlt(localctx, 17) { p.SetState(9168) p.Match(PostgreSQLParserPOSITION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9169) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9170) p.Position_list() } { p.SetState(9171) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSUBSTRING: p.EnterOuterAlt(localctx, 18) { p.SetState(9173) p.Match(PostgreSQLParserSUBSTRING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9174) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9175) p.Substr_list() } { p.SetState(9176) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserTREAT: p.EnterOuterAlt(localctx, 19) { p.SetState(9178) p.Match(PostgreSQLParserTREAT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9179) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9180) p.A_expr() } { p.SetState(9181) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9182) p.Typename() } { p.SetState(9183) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserTRIM: p.EnterOuterAlt(localctx, 20) { p.SetState(9185) p.Match(PostgreSQLParserTRIM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9186) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9188) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if (int64((_la-39)) & ^0x3f) == 0 && ((int64(1)<<(_la-39))&72057611217797121) != 0 { { p.SetState(9187) _la = p.GetTokenStream().LA(1) if !((int64((_la-39)) & ^0x3f) == 0 && ((int64(1)<<(_la-39))&72057611217797121) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } } { p.SetState(9190) p.Trim_list() } { p.SetState(9191) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserNULLIF: p.EnterOuterAlt(localctx, 21) { p.SetState(9193) p.Match(PostgreSQLParserNULLIF) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9194) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9195) p.A_expr() } { p.SetState(9196) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9197) p.A_expr() } { p.SetState(9198) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserCOALESCE: p.EnterOuterAlt(localctx, 22) { p.SetState(9200) p.Match(PostgreSQLParserCOALESCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9201) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9202) p.Expr_list() } { p.SetState(9203) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserGREATEST: p.EnterOuterAlt(localctx, 23) { p.SetState(9205) p.Match(PostgreSQLParserGREATEST) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9206) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9207) p.Expr_list() } { p.SetState(9208) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserLEAST: p.EnterOuterAlt(localctx, 24) { p.SetState(9210) p.Match(PostgreSQLParserLEAST) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9211) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9212) p.Expr_list() } { p.SetState(9213) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserXMLCONCAT: p.EnterOuterAlt(localctx, 25) { p.SetState(9215) p.Match(PostgreSQLParserXMLCONCAT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9216) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9217) p.Expr_list() } { p.SetState(9218) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserXMLELEMENT: p.EnterOuterAlt(localctx, 26) { p.SetState(9220) p.Match(PostgreSQLParserXMLELEMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9221) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9222) p.Match(PostgreSQLParserNAME_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9223) p.Collabel() } p.SetState(9229) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserCOMMA { { p.SetState(9224) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9227) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 588, p.GetParserRuleContext()) { case 1: { p.SetState(9225) p.Xml_attributes() } case 2: { p.SetState(9226) p.Expr_list() } case antlr.ATNInvalidAltNumber: goto errorExit } } { p.SetState(9231) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserXMLEXISTS: p.EnterOuterAlt(localctx, 27) { p.SetState(9233) p.Match(PostgreSQLParserXMLEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9234) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9235) p.C_expr() } { p.SetState(9236) p.Xmlexists_argument() } { p.SetState(9237) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserXMLFOREST: p.EnterOuterAlt(localctx, 28) { p.SetState(9239) p.Match(PostgreSQLParserXMLFOREST) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9240) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9241) p.Xml_attribute_list() } { p.SetState(9242) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserXMLPARSE: p.EnterOuterAlt(localctx, 29) { p.SetState(9244) p.Match(PostgreSQLParserXMLPARSE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9245) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9246) p.Document_or_content() } { p.SetState(9247) p.A_expr() } { p.SetState(9248) p.Xml_whitespace_option() } { p.SetState(9249) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserXMLPI: p.EnterOuterAlt(localctx, 30) { p.SetState(9251) p.Match(PostgreSQLParserXMLPI) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9252) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9253) p.Match(PostgreSQLParserNAME_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9254) p.Collabel() } p.SetState(9257) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserCOMMA { { p.SetState(9255) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9256) p.A_expr() } } { p.SetState(9259) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserXMLROOT: p.EnterOuterAlt(localctx, 31) { p.SetState(9261) p.Match(PostgreSQLParserXMLROOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9262) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9263) p.Match(PostgreSQLParserXML_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9264) p.A_expr() } { p.SetState(9265) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9266) p.Xml_root_version() } { p.SetState(9267) p.Opt_xml_root_standalone() } { p.SetState(9268) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserXMLSERIALIZE: p.EnterOuterAlt(localctx, 32) { p.SetState(9270) p.Match(PostgreSQLParserXMLSERIALIZE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9271) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9272) p.Document_or_content() } { p.SetState(9273) p.A_expr() } { p.SetState(9274) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9275) p.Simpletypename() } { p.SetState(9276) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXml_root_versionContext is an interface to support dynamic dispatch. type IXml_root_versionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures VERSION_P() antlr.TerminalNode A_expr() IA_exprContext NO() antlr.TerminalNode VALUE_P() antlr.TerminalNode // IsXml_root_versionContext differentiates from other interfaces. IsXml_root_versionContext() } type Xml_root_versionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXml_root_versionContext() *Xml_root_versionContext { var p = new(Xml_root_versionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_root_version return p } func InitEmptyXml_root_versionContext(p *Xml_root_versionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_root_version } func (*Xml_root_versionContext) IsXml_root_versionContext() {} func NewXml_root_versionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_root_versionContext { var p = new(Xml_root_versionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xml_root_version return p } func (s *Xml_root_versionContext) GetParser() antlr.Parser { return s.parser } func (s *Xml_root_versionContext) VERSION_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVERSION_P, 0) } func (s *Xml_root_versionContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Xml_root_versionContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Xml_root_versionContext) VALUE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALUE_P, 0) } func (s *Xml_root_versionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Xml_root_versionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Xml_root_versionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXml_root_version(s) } } func (s *Xml_root_versionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXml_root_version(s) } } func (s *Xml_root_versionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXml_root_version(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xml_root_version() (localctx IXml_root_versionContext) { localctx = NewXml_root_versionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1218, PostgreSQLParserRULE_xml_root_version) p.SetState(9285) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 592, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9280) p.Match(PostgreSQLParserVERSION_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9281) p.A_expr() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9282) p.Match(PostgreSQLParserVERSION_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9283) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9284) p.Match(PostgreSQLParserVALUE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_xml_root_standaloneContext is an interface to support dynamic dispatch. type IOpt_xml_root_standaloneContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures COMMA() antlr.TerminalNode STANDALONE_P() antlr.TerminalNode YES_P() antlr.TerminalNode NO() antlr.TerminalNode VALUE_P() antlr.TerminalNode // IsOpt_xml_root_standaloneContext differentiates from other interfaces. IsOpt_xml_root_standaloneContext() } type Opt_xml_root_standaloneContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_xml_root_standaloneContext() *Opt_xml_root_standaloneContext { var p = new(Opt_xml_root_standaloneContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_xml_root_standalone return p } func InitEmptyOpt_xml_root_standaloneContext(p *Opt_xml_root_standaloneContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_xml_root_standalone } func (*Opt_xml_root_standaloneContext) IsOpt_xml_root_standaloneContext() {} func NewOpt_xml_root_standaloneContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_xml_root_standaloneContext { var p = new(Opt_xml_root_standaloneContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_xml_root_standalone return p } func (s *Opt_xml_root_standaloneContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_xml_root_standaloneContext) COMMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, 0) } func (s *Opt_xml_root_standaloneContext) STANDALONE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTANDALONE_P, 0) } func (s *Opt_xml_root_standaloneContext) YES_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserYES_P, 0) } func (s *Opt_xml_root_standaloneContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Opt_xml_root_standaloneContext) VALUE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALUE_P, 0) } func (s *Opt_xml_root_standaloneContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_xml_root_standaloneContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_xml_root_standaloneContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_xml_root_standalone(s) } } func (s *Opt_xml_root_standaloneContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_xml_root_standalone(s) } } func (s *Opt_xml_root_standaloneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_xml_root_standalone(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_xml_root_standalone() (localctx IOpt_xml_root_standaloneContext) { localctx = NewOpt_xml_root_standaloneContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1220, PostgreSQLParserRULE_opt_xml_root_standalone) p.SetState(9298) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 593, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9287) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9288) p.Match(PostgreSQLParserSTANDALONE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9289) p.Match(PostgreSQLParserYES_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9290) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9291) p.Match(PostgreSQLParserSTANDALONE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9292) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9293) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9294) p.Match(PostgreSQLParserSTANDALONE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9295) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9296) p.Match(PostgreSQLParserVALUE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXml_attributesContext is an interface to support dynamic dispatch. type IXml_attributesContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures XMLATTRIBUTES() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Xml_attribute_list() IXml_attribute_listContext CLOSE_PAREN() antlr.TerminalNode // IsXml_attributesContext differentiates from other interfaces. IsXml_attributesContext() } type Xml_attributesContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXml_attributesContext() *Xml_attributesContext { var p = new(Xml_attributesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_attributes return p } func InitEmptyXml_attributesContext(p *Xml_attributesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_attributes } func (*Xml_attributesContext) IsXml_attributesContext() {} func NewXml_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_attributesContext { var p = new(Xml_attributesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xml_attributes return p } func (s *Xml_attributesContext) GetParser() antlr.Parser { return s.parser } func (s *Xml_attributesContext) XMLATTRIBUTES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLATTRIBUTES, 0) } func (s *Xml_attributesContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Xml_attributesContext) Xml_attribute_list() IXml_attribute_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXml_attribute_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IXml_attribute_listContext) } func (s *Xml_attributesContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Xml_attributesContext) GetRuleContext() antlr.RuleContext { return s } func (s *Xml_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Xml_attributesContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXml_attributes(s) } } func (s *Xml_attributesContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXml_attributes(s) } } func (s *Xml_attributesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXml_attributes(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xml_attributes() (localctx IXml_attributesContext) { localctx = NewXml_attributesContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1222, PostgreSQLParserRULE_xml_attributes) p.EnterOuterAlt(localctx, 1) { p.SetState(9300) p.Match(PostgreSQLParserXMLATTRIBUTES) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9301) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9302) p.Xml_attribute_list() } { p.SetState(9303) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXml_attribute_listContext is an interface to support dynamic dispatch. type IXml_attribute_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllXml_attribute_el() []IXml_attribute_elContext Xml_attribute_el(i int) IXml_attribute_elContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsXml_attribute_listContext differentiates from other interfaces. IsXml_attribute_listContext() } type Xml_attribute_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXml_attribute_listContext() *Xml_attribute_listContext { var p = new(Xml_attribute_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_attribute_list return p } func InitEmptyXml_attribute_listContext(p *Xml_attribute_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_attribute_list } func (*Xml_attribute_listContext) IsXml_attribute_listContext() {} func NewXml_attribute_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_attribute_listContext { var p = new(Xml_attribute_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xml_attribute_list return p } func (s *Xml_attribute_listContext) GetParser() antlr.Parser { return s.parser } func (s *Xml_attribute_listContext) AllXml_attribute_el() []IXml_attribute_elContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IXml_attribute_elContext); ok { len++ } } tst := make([]IXml_attribute_elContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IXml_attribute_elContext); ok { tst[i] = t.(IXml_attribute_elContext) i++ } } return tst } func (s *Xml_attribute_listContext) Xml_attribute_el(i int) IXml_attribute_elContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXml_attribute_elContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IXml_attribute_elContext) } func (s *Xml_attribute_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Xml_attribute_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Xml_attribute_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Xml_attribute_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Xml_attribute_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXml_attribute_list(s) } } func (s *Xml_attribute_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXml_attribute_list(s) } } func (s *Xml_attribute_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXml_attribute_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xml_attribute_list() (localctx IXml_attribute_listContext) { localctx = NewXml_attribute_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1224, PostgreSQLParserRULE_xml_attribute_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9305) p.Xml_attribute_el() } p.SetState(9310) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(9306) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9307) p.Xml_attribute_el() } p.SetState(9312) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXml_attribute_elContext is an interface to support dynamic dispatch. type IXml_attribute_elContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr() IA_exprContext AS() antlr.TerminalNode Collabel() ICollabelContext // IsXml_attribute_elContext differentiates from other interfaces. IsXml_attribute_elContext() } type Xml_attribute_elContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXml_attribute_elContext() *Xml_attribute_elContext { var p = new(Xml_attribute_elContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_attribute_el return p } func InitEmptyXml_attribute_elContext(p *Xml_attribute_elContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_attribute_el } func (*Xml_attribute_elContext) IsXml_attribute_elContext() {} func NewXml_attribute_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_attribute_elContext { var p = new(Xml_attribute_elContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xml_attribute_el return p } func (s *Xml_attribute_elContext) GetParser() antlr.Parser { return s.parser } func (s *Xml_attribute_elContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Xml_attribute_elContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Xml_attribute_elContext) Collabel() ICollabelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICollabelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICollabelContext) } func (s *Xml_attribute_elContext) GetRuleContext() antlr.RuleContext { return s } func (s *Xml_attribute_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Xml_attribute_elContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXml_attribute_el(s) } } func (s *Xml_attribute_elContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXml_attribute_el(s) } } func (s *Xml_attribute_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXml_attribute_el(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xml_attribute_el() (localctx IXml_attribute_elContext) { localctx = NewXml_attribute_elContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1226, PostgreSQLParserRULE_xml_attribute_el) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9313) p.A_expr() } p.SetState(9316) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserAS { { p.SetState(9314) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9315) p.Collabel() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDocument_or_contentContext is an interface to support dynamic dispatch. type IDocument_or_contentContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DOCUMENT_P() antlr.TerminalNode CONTENT_P() antlr.TerminalNode // IsDocument_or_contentContext differentiates from other interfaces. IsDocument_or_contentContext() } type Document_or_contentContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDocument_or_contentContext() *Document_or_contentContext { var p = new(Document_or_contentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_document_or_content return p } func InitEmptyDocument_or_contentContext(p *Document_or_contentContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_document_or_content } func (*Document_or_contentContext) IsDocument_or_contentContext() {} func NewDocument_or_contentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Document_or_contentContext { var p = new(Document_or_contentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_document_or_content return p } func (s *Document_or_contentContext) GetParser() antlr.Parser { return s.parser } func (s *Document_or_contentContext) DOCUMENT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOCUMENT_P, 0) } func (s *Document_or_contentContext) CONTENT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONTENT_P, 0) } func (s *Document_or_contentContext) GetRuleContext() antlr.RuleContext { return s } func (s *Document_or_contentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Document_or_contentContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDocument_or_content(s) } } func (s *Document_or_contentContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDocument_or_content(s) } } func (s *Document_or_contentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDocument_or_content(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Document_or_content() (localctx IDocument_or_contentContext) { localctx = NewDocument_or_contentContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1228, PostgreSQLParserRULE_document_or_content) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9318) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserCONTENT_P || _la == PostgreSQLParserDOCUMENT_P) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXml_whitespace_optionContext is an interface to support dynamic dispatch. type IXml_whitespace_optionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures PRESERVE() antlr.TerminalNode WHITESPACE_P() antlr.TerminalNode STRIP_P() antlr.TerminalNode // IsXml_whitespace_optionContext differentiates from other interfaces. IsXml_whitespace_optionContext() } type Xml_whitespace_optionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXml_whitespace_optionContext() *Xml_whitespace_optionContext { var p = new(Xml_whitespace_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_whitespace_option return p } func InitEmptyXml_whitespace_optionContext(p *Xml_whitespace_optionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_whitespace_option } func (*Xml_whitespace_optionContext) IsXml_whitespace_optionContext() {} func NewXml_whitespace_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_whitespace_optionContext { var p = new(Xml_whitespace_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xml_whitespace_option return p } func (s *Xml_whitespace_optionContext) GetParser() antlr.Parser { return s.parser } func (s *Xml_whitespace_optionContext) PRESERVE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRESERVE, 0) } func (s *Xml_whitespace_optionContext) WHITESPACE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHITESPACE_P, 0) } func (s *Xml_whitespace_optionContext) STRIP_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTRIP_P, 0) } func (s *Xml_whitespace_optionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Xml_whitespace_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Xml_whitespace_optionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXml_whitespace_option(s) } } func (s *Xml_whitespace_optionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXml_whitespace_option(s) } } func (s *Xml_whitespace_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXml_whitespace_option(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xml_whitespace_option() (localctx IXml_whitespace_optionContext) { localctx = NewXml_whitespace_optionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1230, PostgreSQLParserRULE_xml_whitespace_option) p.SetState(9325) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserPRESERVE: p.EnterOuterAlt(localctx, 1) { p.SetState(9320) p.Match(PostgreSQLParserPRESERVE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9321) p.Match(PostgreSQLParserWHITESPACE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSTRIP_P: p.EnterOuterAlt(localctx, 2) { p.SetState(9322) p.Match(PostgreSQLParserSTRIP_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9323) p.Match(PostgreSQLParserWHITESPACE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserCLOSE_PAREN: p.EnterOuterAlt(localctx, 3) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXmlexists_argumentContext is an interface to support dynamic dispatch. type IXmlexists_argumentContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures PASSING() antlr.TerminalNode C_expr() IC_exprContext AllXml_passing_mech() []IXml_passing_mechContext Xml_passing_mech(i int) IXml_passing_mechContext // IsXmlexists_argumentContext differentiates from other interfaces. IsXmlexists_argumentContext() } type Xmlexists_argumentContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXmlexists_argumentContext() *Xmlexists_argumentContext { var p = new(Xmlexists_argumentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xmlexists_argument return p } func InitEmptyXmlexists_argumentContext(p *Xmlexists_argumentContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xmlexists_argument } func (*Xmlexists_argumentContext) IsXmlexists_argumentContext() {} func NewXmlexists_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlexists_argumentContext { var p = new(Xmlexists_argumentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xmlexists_argument return p } func (s *Xmlexists_argumentContext) GetParser() antlr.Parser { return s.parser } func (s *Xmlexists_argumentContext) PASSING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPASSING, 0) } func (s *Xmlexists_argumentContext) C_expr() IC_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IC_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IC_exprContext) } func (s *Xmlexists_argumentContext) AllXml_passing_mech() []IXml_passing_mechContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IXml_passing_mechContext); ok { len++ } } tst := make([]IXml_passing_mechContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IXml_passing_mechContext); ok { tst[i] = t.(IXml_passing_mechContext) i++ } } return tst } func (s *Xmlexists_argumentContext) Xml_passing_mech(i int) IXml_passing_mechContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXml_passing_mechContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IXml_passing_mechContext) } func (s *Xmlexists_argumentContext) GetRuleContext() antlr.RuleContext { return s } func (s *Xmlexists_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Xmlexists_argumentContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXmlexists_argument(s) } } func (s *Xmlexists_argumentContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXmlexists_argument(s) } } func (s *Xmlexists_argumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXmlexists_argument(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xmlexists_argument() (localctx IXmlexists_argumentContext) { localctx = NewXmlexists_argumentContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1232, PostgreSQLParserRULE_xmlexists_argument) p.SetState(9342) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 597, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9327) p.Match(PostgreSQLParserPASSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9328) p.C_expr() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9329) p.Match(PostgreSQLParserPASSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9330) p.C_expr() } { p.SetState(9331) p.Xml_passing_mech() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9333) p.Match(PostgreSQLParserPASSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9334) p.Xml_passing_mech() } { p.SetState(9335) p.C_expr() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(9337) p.Match(PostgreSQLParserPASSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9338) p.Xml_passing_mech() } { p.SetState(9339) p.C_expr() } { p.SetState(9340) p.Xml_passing_mech() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXml_passing_mechContext is an interface to support dynamic dispatch. type IXml_passing_mechContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures BY() antlr.TerminalNode REF() antlr.TerminalNode VALUE_P() antlr.TerminalNode // IsXml_passing_mechContext differentiates from other interfaces. IsXml_passing_mechContext() } type Xml_passing_mechContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXml_passing_mechContext() *Xml_passing_mechContext { var p = new(Xml_passing_mechContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_passing_mech return p } func InitEmptyXml_passing_mechContext(p *Xml_passing_mechContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xml_passing_mech } func (*Xml_passing_mechContext) IsXml_passing_mechContext() {} func NewXml_passing_mechContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_passing_mechContext { var p = new(Xml_passing_mechContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xml_passing_mech return p } func (s *Xml_passing_mechContext) GetParser() antlr.Parser { return s.parser } func (s *Xml_passing_mechContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *Xml_passing_mechContext) REF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREF, 0) } func (s *Xml_passing_mechContext) VALUE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALUE_P, 0) } func (s *Xml_passing_mechContext) GetRuleContext() antlr.RuleContext { return s } func (s *Xml_passing_mechContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Xml_passing_mechContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXml_passing_mech(s) } } func (s *Xml_passing_mechContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXml_passing_mech(s) } } func (s *Xml_passing_mechContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXml_passing_mech(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xml_passing_mech() (localctx IXml_passing_mechContext) { localctx = NewXml_passing_mechContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1234, PostgreSQLParserRULE_xml_passing_mech) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9344) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9345) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserREF || _la == PostgreSQLParserVALUE_P) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IWithin_group_clauseContext is an interface to support dynamic dispatch. type IWithin_group_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WITHIN() antlr.TerminalNode GROUP_P() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Sort_clause() ISort_clauseContext CLOSE_PAREN() antlr.TerminalNode // IsWithin_group_clauseContext differentiates from other interfaces. IsWithin_group_clauseContext() } type Within_group_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyWithin_group_clauseContext() *Within_group_clauseContext { var p = new(Within_group_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_within_group_clause return p } func InitEmptyWithin_group_clauseContext(p *Within_group_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_within_group_clause } func (*Within_group_clauseContext) IsWithin_group_clauseContext() {} func NewWithin_group_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Within_group_clauseContext { var p = new(Within_group_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_within_group_clause return p } func (s *Within_group_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Within_group_clauseContext) WITHIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITHIN, 0) } func (s *Within_group_clauseContext) GROUP_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUP_P, 0) } func (s *Within_group_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Within_group_clauseContext) Sort_clause() ISort_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISort_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISort_clauseContext) } func (s *Within_group_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Within_group_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Within_group_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Within_group_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterWithin_group_clause(s) } } func (s *Within_group_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitWithin_group_clause(s) } } func (s *Within_group_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitWithin_group_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Within_group_clause() (localctx IWithin_group_clauseContext) { localctx = NewWithin_group_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1236, PostgreSQLParserRULE_within_group_clause) p.SetState(9354) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 598, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9347) p.Match(PostgreSQLParserWITHIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9348) p.Match(PostgreSQLParserGROUP_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9349) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9350) p.Sort_clause() } { p.SetState(9351) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFilter_clauseContext is an interface to support dynamic dispatch. type IFilter_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FILTER() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode WHERE() antlr.TerminalNode A_expr() IA_exprContext CLOSE_PAREN() antlr.TerminalNode // IsFilter_clauseContext differentiates from other interfaces. IsFilter_clauseContext() } type Filter_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFilter_clauseContext() *Filter_clauseContext { var p = new(Filter_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_filter_clause return p } func InitEmptyFilter_clauseContext(p *Filter_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_filter_clause } func (*Filter_clauseContext) IsFilter_clauseContext() {} func NewFilter_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Filter_clauseContext { var p = new(Filter_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_filter_clause return p } func (s *Filter_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Filter_clauseContext) FILTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFILTER, 0) } func (s *Filter_clauseContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Filter_clauseContext) WHERE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHERE, 0) } func (s *Filter_clauseContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Filter_clauseContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Filter_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Filter_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Filter_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFilter_clause(s) } } func (s *Filter_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFilter_clause(s) } } func (s *Filter_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFilter_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Filter_clause() (localctx IFilter_clauseContext) { localctx = NewFilter_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1238, PostgreSQLParserRULE_filter_clause) p.SetState(9363) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 599, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9356) p.Match(PostgreSQLParserFILTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9357) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9358) p.Match(PostgreSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9359) p.A_expr() } { p.SetState(9360) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IWindow_clauseContext is an interface to support dynamic dispatch. type IWindow_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WINDOW() antlr.TerminalNode Window_definition_list() IWindow_definition_listContext // IsWindow_clauseContext differentiates from other interfaces. IsWindow_clauseContext() } type Window_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyWindow_clauseContext() *Window_clauseContext { var p = new(Window_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_window_clause return p } func InitEmptyWindow_clauseContext(p *Window_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_window_clause } func (*Window_clauseContext) IsWindow_clauseContext() {} func NewWindow_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_clauseContext { var p = new(Window_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_window_clause return p } func (s *Window_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Window_clauseContext) WINDOW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWINDOW, 0) } func (s *Window_clauseContext) Window_definition_list() IWindow_definition_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWindow_definition_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWindow_definition_listContext) } func (s *Window_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Window_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Window_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterWindow_clause(s) } } func (s *Window_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitWindow_clause(s) } } func (s *Window_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitWindow_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Window_clause() (localctx IWindow_clauseContext) { localctx = NewWindow_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1240, PostgreSQLParserRULE_window_clause) p.SetState(9368) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserWINDOW: p.EnterOuterAlt(localctx, 1) { p.SetState(9365) p.Match(PostgreSQLParserWINDOW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9366) p.Window_definition_list() } case PostgreSQLParserEOF, PostgreSQLParserOPEN_PAREN, PostgreSQLParserCLOSE_PAREN, PostgreSQLParserCOMMA, PostgreSQLParserSEMI, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserCREATE, PostgreSQLParserDO, PostgreSQLParserEXCEPT, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserGRANT, PostgreSQLParserINTERSECT, PostgreSQLParserINTO, PostgreSQLParserLIMIT, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserORDER, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserUNION, PostgreSQLParserUSING, PostgreSQLParserWHEN, PostgreSQLParserWITH, PostgreSQLParserABORT_P, PostgreSQLParserALTER, PostgreSQLParserBEGIN_P, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMIT, PostgreSQLParserCOPY, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDELETE_P, PostgreSQLParserDISCARD, PostgreSQLParserDROP, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserINSERT, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCK_P, PostgreSQLParserMERGE, PostgreSQLParserMOVE, PostgreSQLParserNOTIFY, PostgreSQLParserPREPARE, PostgreSQLParserREASSIGN, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELEASE, PostgreSQLParserRESET, PostgreSQLParserREVOKE, PostgreSQLParserROLLBACK, PostgreSQLParserSAVEPOINT, PostgreSQLParserSECURITY, PostgreSQLParserSET, PostgreSQLParserSHOW, PostgreSQLParserSTART, PostgreSQLParserTRUNCATE, PostgreSQLParserUNLISTEN, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALUES, PostgreSQLParserCALL, PostgreSQLParserIMPORT_P, PostgreSQLParserEND_P, PostgreSQLParserLOOP, PostgreSQLParserMetaCommand: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IWindow_definition_listContext is an interface to support dynamic dispatch. type IWindow_definition_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllWindow_definition() []IWindow_definitionContext Window_definition(i int) IWindow_definitionContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsWindow_definition_listContext differentiates from other interfaces. IsWindow_definition_listContext() } type Window_definition_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyWindow_definition_listContext() *Window_definition_listContext { var p = new(Window_definition_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_window_definition_list return p } func InitEmptyWindow_definition_listContext(p *Window_definition_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_window_definition_list } func (*Window_definition_listContext) IsWindow_definition_listContext() {} func NewWindow_definition_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_definition_listContext { var p = new(Window_definition_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_window_definition_list return p } func (s *Window_definition_listContext) GetParser() antlr.Parser { return s.parser } func (s *Window_definition_listContext) AllWindow_definition() []IWindow_definitionContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IWindow_definitionContext); ok { len++ } } tst := make([]IWindow_definitionContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IWindow_definitionContext); ok { tst[i] = t.(IWindow_definitionContext) i++ } } return tst } func (s *Window_definition_listContext) Window_definition(i int) IWindow_definitionContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWindow_definitionContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IWindow_definitionContext) } func (s *Window_definition_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Window_definition_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Window_definition_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Window_definition_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Window_definition_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterWindow_definition_list(s) } } func (s *Window_definition_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitWindow_definition_list(s) } } func (s *Window_definition_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitWindow_definition_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Window_definition_list() (localctx IWindow_definition_listContext) { localctx = NewWindow_definition_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1242, PostgreSQLParserRULE_window_definition_list) var _alt int p.EnterOuterAlt(localctx, 1) { p.SetState(9370) p.Window_definition() } p.SetState(9375) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 601, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(9371) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9372) p.Window_definition() } } p.SetState(9377) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 601, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IWindow_definitionContext is an interface to support dynamic dispatch. type IWindow_definitionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext AS() antlr.TerminalNode Window_specification() IWindow_specificationContext // IsWindow_definitionContext differentiates from other interfaces. IsWindow_definitionContext() } type Window_definitionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyWindow_definitionContext() *Window_definitionContext { var p = new(Window_definitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_window_definition return p } func InitEmptyWindow_definitionContext(p *Window_definitionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_window_definition } func (*Window_definitionContext) IsWindow_definitionContext() {} func NewWindow_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_definitionContext { var p = new(Window_definitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_window_definition return p } func (s *Window_definitionContext) GetParser() antlr.Parser { return s.parser } func (s *Window_definitionContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Window_definitionContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Window_definitionContext) Window_specification() IWindow_specificationContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWindow_specificationContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWindow_specificationContext) } func (s *Window_definitionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Window_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Window_definitionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterWindow_definition(s) } } func (s *Window_definitionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitWindow_definition(s) } } func (s *Window_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitWindow_definition(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Window_definition() (localctx IWindow_definitionContext) { localctx = NewWindow_definitionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1244, PostgreSQLParserRULE_window_definition) p.EnterOuterAlt(localctx, 1) { p.SetState(9378) p.Colid() } { p.SetState(9379) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9380) p.Window_specification() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOver_clauseContext is an interface to support dynamic dispatch. type IOver_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OVER() antlr.TerminalNode Window_specification() IWindow_specificationContext Colid() IColidContext // IsOver_clauseContext differentiates from other interfaces. IsOver_clauseContext() } type Over_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOver_clauseContext() *Over_clauseContext { var p = new(Over_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_over_clause return p } func InitEmptyOver_clauseContext(p *Over_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_over_clause } func (*Over_clauseContext) IsOver_clauseContext() {} func NewOver_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Over_clauseContext { var p = new(Over_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_over_clause return p } func (s *Over_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Over_clauseContext) OVER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOVER, 0) } func (s *Over_clauseContext) Window_specification() IWindow_specificationContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWindow_specificationContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWindow_specificationContext) } func (s *Over_clauseContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Over_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Over_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Over_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOver_clause(s) } } func (s *Over_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOver_clause(s) } } func (s *Over_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOver_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Over_clause() (localctx IOver_clauseContext) { localctx = NewOver_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1246, PostgreSQLParserRULE_over_clause) p.SetState(9388) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 603, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9382) p.Match(PostgreSQLParserOVER) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9385) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN: { p.SetState(9383) p.Window_specification() } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: { p.SetState(9384) p.Colid() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IWindow_specificationContext is an interface to support dynamic dispatch. type IWindow_specificationContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Opt_existing_window_name() IOpt_existing_window_nameContext Opt_partition_clause() IOpt_partition_clauseContext Opt_sort_clause() IOpt_sort_clauseContext Opt_frame_clause() IOpt_frame_clauseContext CLOSE_PAREN() antlr.TerminalNode // IsWindow_specificationContext differentiates from other interfaces. IsWindow_specificationContext() } type Window_specificationContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyWindow_specificationContext() *Window_specificationContext { var p = new(Window_specificationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_window_specification return p } func InitEmptyWindow_specificationContext(p *Window_specificationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_window_specification } func (*Window_specificationContext) IsWindow_specificationContext() {} func NewWindow_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_specificationContext { var p = new(Window_specificationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_window_specification return p } func (s *Window_specificationContext) GetParser() antlr.Parser { return s.parser } func (s *Window_specificationContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Window_specificationContext) Opt_existing_window_name() IOpt_existing_window_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_existing_window_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_existing_window_nameContext) } func (s *Window_specificationContext) Opt_partition_clause() IOpt_partition_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_partition_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_partition_clauseContext) } func (s *Window_specificationContext) Opt_sort_clause() IOpt_sort_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_sort_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_sort_clauseContext) } func (s *Window_specificationContext) Opt_frame_clause() IOpt_frame_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_frame_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_frame_clauseContext) } func (s *Window_specificationContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Window_specificationContext) GetRuleContext() antlr.RuleContext { return s } func (s *Window_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Window_specificationContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterWindow_specification(s) } } func (s *Window_specificationContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitWindow_specification(s) } } func (s *Window_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitWindow_specification(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Window_specification() (localctx IWindow_specificationContext) { localctx = NewWindow_specificationContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1248, PostgreSQLParserRULE_window_specification) p.EnterOuterAlt(localctx, 1) { p.SetState(9390) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9391) p.Opt_existing_window_name() } { p.SetState(9392) p.Opt_partition_clause() } { p.SetState(9393) p.Opt_sort_clause() } { p.SetState(9394) p.Opt_frame_clause() } { p.SetState(9395) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_existing_window_nameContext is an interface to support dynamic dispatch. type IOpt_existing_window_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext // IsOpt_existing_window_nameContext differentiates from other interfaces. IsOpt_existing_window_nameContext() } type Opt_existing_window_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_existing_window_nameContext() *Opt_existing_window_nameContext { var p = new(Opt_existing_window_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_existing_window_name return p } func InitEmptyOpt_existing_window_nameContext(p *Opt_existing_window_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_existing_window_name } func (*Opt_existing_window_nameContext) IsOpt_existing_window_nameContext() {} func NewOpt_existing_window_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_existing_window_nameContext { var p = new(Opt_existing_window_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_existing_window_name return p } func (s *Opt_existing_window_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_existing_window_nameContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Opt_existing_window_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_existing_window_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_existing_window_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_existing_window_name(s) } } func (s *Opt_existing_window_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_existing_window_name(s) } } func (s *Opt_existing_window_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_existing_window_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_existing_window_name() (localctx IOpt_existing_window_nameContext) { localctx = NewOpt_existing_window_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1250, PostgreSQLParserRULE_opt_existing_window_name) p.SetState(9399) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 604, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9397) p.Colid() } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_partition_clauseContext is an interface to support dynamic dispatch. type IOpt_partition_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures PARTITION() antlr.TerminalNode BY() antlr.TerminalNode Expr_list() IExpr_listContext // IsOpt_partition_clauseContext differentiates from other interfaces. IsOpt_partition_clauseContext() } type Opt_partition_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_partition_clauseContext() *Opt_partition_clauseContext { var p = new(Opt_partition_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_partition_clause return p } func InitEmptyOpt_partition_clauseContext(p *Opt_partition_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_partition_clause } func (*Opt_partition_clauseContext) IsOpt_partition_clauseContext() {} func NewOpt_partition_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_partition_clauseContext { var p = new(Opt_partition_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_partition_clause return p } func (s *Opt_partition_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_partition_clauseContext) PARTITION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARTITION, 0) } func (s *Opt_partition_clauseContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *Opt_partition_clauseContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Opt_partition_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_partition_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_partition_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_partition_clause(s) } } func (s *Opt_partition_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_partition_clause(s) } } func (s *Opt_partition_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_partition_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_partition_clause() (localctx IOpt_partition_clauseContext) { localctx = NewOpt_partition_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1252, PostgreSQLParserRULE_opt_partition_clause) p.SetState(9405) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserPARTITION: p.EnterOuterAlt(localctx, 1) { p.SetState(9401) p.Match(PostgreSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9402) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9403) p.Expr_list() } case PostgreSQLParserCLOSE_PAREN, PostgreSQLParserORDER, PostgreSQLParserRANGE, PostgreSQLParserROWS, PostgreSQLParserGROUPS: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_frame_clauseContext is an interface to support dynamic dispatch. type IOpt_frame_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures RANGE() antlr.TerminalNode Frame_extent() IFrame_extentContext Opt_window_exclusion_clause() IOpt_window_exclusion_clauseContext ROWS() antlr.TerminalNode GROUPS() antlr.TerminalNode // IsOpt_frame_clauseContext differentiates from other interfaces. IsOpt_frame_clauseContext() } type Opt_frame_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_frame_clauseContext() *Opt_frame_clauseContext { var p = new(Opt_frame_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_frame_clause return p } func InitEmptyOpt_frame_clauseContext(p *Opt_frame_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_frame_clause } func (*Opt_frame_clauseContext) IsOpt_frame_clauseContext() {} func NewOpt_frame_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_frame_clauseContext { var p = new(Opt_frame_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_frame_clause return p } func (s *Opt_frame_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_frame_clauseContext) RANGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRANGE, 0) } func (s *Opt_frame_clauseContext) Frame_extent() IFrame_extentContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFrame_extentContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFrame_extentContext) } func (s *Opt_frame_clauseContext) Opt_window_exclusion_clause() IOpt_window_exclusion_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_window_exclusion_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_window_exclusion_clauseContext) } func (s *Opt_frame_clauseContext) ROWS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROWS, 0) } func (s *Opt_frame_clauseContext) GROUPS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUPS, 0) } func (s *Opt_frame_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_frame_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_frame_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_frame_clause(s) } } func (s *Opt_frame_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_frame_clause(s) } } func (s *Opt_frame_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_frame_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_frame_clause() (localctx IOpt_frame_clauseContext) { localctx = NewOpt_frame_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1254, PostgreSQLParserRULE_opt_frame_clause) p.SetState(9420) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserRANGE: p.EnterOuterAlt(localctx, 1) { p.SetState(9407) p.Match(PostgreSQLParserRANGE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9408) p.Frame_extent() } { p.SetState(9409) p.Opt_window_exclusion_clause() } case PostgreSQLParserROWS: p.EnterOuterAlt(localctx, 2) { p.SetState(9411) p.Match(PostgreSQLParserROWS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9412) p.Frame_extent() } { p.SetState(9413) p.Opt_window_exclusion_clause() } case PostgreSQLParserGROUPS: p.EnterOuterAlt(localctx, 3) { p.SetState(9415) p.Match(PostgreSQLParserGROUPS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9416) p.Frame_extent() } { p.SetState(9417) p.Opt_window_exclusion_clause() } case PostgreSQLParserCLOSE_PAREN: p.EnterOuterAlt(localctx, 4) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFrame_extentContext is an interface to support dynamic dispatch. type IFrame_extentContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllFrame_bound() []IFrame_boundContext Frame_bound(i int) IFrame_boundContext BETWEEN() antlr.TerminalNode AND() antlr.TerminalNode // IsFrame_extentContext differentiates from other interfaces. IsFrame_extentContext() } type Frame_extentContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFrame_extentContext() *Frame_extentContext { var p = new(Frame_extentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_frame_extent return p } func InitEmptyFrame_extentContext(p *Frame_extentContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_frame_extent } func (*Frame_extentContext) IsFrame_extentContext() {} func NewFrame_extentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_extentContext { var p = new(Frame_extentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_frame_extent return p } func (s *Frame_extentContext) GetParser() antlr.Parser { return s.parser } func (s *Frame_extentContext) AllFrame_bound() []IFrame_boundContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IFrame_boundContext); ok { len++ } } tst := make([]IFrame_boundContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IFrame_boundContext); ok { tst[i] = t.(IFrame_boundContext) i++ } } return tst } func (s *Frame_extentContext) Frame_bound(i int) IFrame_boundContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFrame_boundContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IFrame_boundContext) } func (s *Frame_extentContext) BETWEEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBETWEEN, 0) } func (s *Frame_extentContext) AND() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAND, 0) } func (s *Frame_extentContext) GetRuleContext() antlr.RuleContext { return s } func (s *Frame_extentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Frame_extentContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFrame_extent(s) } } func (s *Frame_extentContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFrame_extent(s) } } func (s *Frame_extentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFrame_extent(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Frame_extent() (localctx IFrame_extentContext) { localctx = NewFrame_extentContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1256, PostgreSQLParserRULE_frame_extent) p.SetState(9428) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 607, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9422) p.Frame_bound() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9423) p.Match(PostgreSQLParserBETWEEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9424) p.Frame_bound() } { p.SetState(9425) p.Match(PostgreSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9426) p.Frame_bound() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFrame_boundContext is an interface to support dynamic dispatch. type IFrame_boundContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures UNBOUNDED() antlr.TerminalNode PRECEDING() antlr.TerminalNode FOLLOWING() antlr.TerminalNode CURRENT_P() antlr.TerminalNode ROW() antlr.TerminalNode A_expr() IA_exprContext // IsFrame_boundContext differentiates from other interfaces. IsFrame_boundContext() } type Frame_boundContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFrame_boundContext() *Frame_boundContext { var p = new(Frame_boundContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_frame_bound return p } func InitEmptyFrame_boundContext(p *Frame_boundContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_frame_bound } func (*Frame_boundContext) IsFrame_boundContext() {} func NewFrame_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_boundContext { var p = new(Frame_boundContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_frame_bound return p } func (s *Frame_boundContext) GetParser() antlr.Parser { return s.parser } func (s *Frame_boundContext) UNBOUNDED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNBOUNDED, 0) } func (s *Frame_boundContext) PRECEDING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRECEDING, 0) } func (s *Frame_boundContext) FOLLOWING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOLLOWING, 0) } func (s *Frame_boundContext) CURRENT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_P, 0) } func (s *Frame_boundContext) ROW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROW, 0) } func (s *Frame_boundContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Frame_boundContext) GetRuleContext() antlr.RuleContext { return s } func (s *Frame_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Frame_boundContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFrame_bound(s) } } func (s *Frame_boundContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFrame_bound(s) } } func (s *Frame_boundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFrame_bound(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Frame_bound() (localctx IFrame_boundContext) { localctx = NewFrame_boundContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1258, PostgreSQLParserRULE_frame_bound) var _la int p.SetState(9437) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 608, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9430) p.Match(PostgreSQLParserUNBOUNDED) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9431) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserFOLLOWING || _la == PostgreSQLParserPRECEDING) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9432) p.Match(PostgreSQLParserCURRENT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9433) p.Match(PostgreSQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9434) p.A_expr() } { p.SetState(9435) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserFOLLOWING || _la == PostgreSQLParserPRECEDING) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_window_exclusion_clauseContext is an interface to support dynamic dispatch. type IOpt_window_exclusion_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures EXCLUDE() antlr.TerminalNode CURRENT_P() antlr.TerminalNode ROW() antlr.TerminalNode GROUP_P() antlr.TerminalNode TIES() antlr.TerminalNode NO() antlr.TerminalNode OTHERS() antlr.TerminalNode // IsOpt_window_exclusion_clauseContext differentiates from other interfaces. IsOpt_window_exclusion_clauseContext() } type Opt_window_exclusion_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_window_exclusion_clauseContext() *Opt_window_exclusion_clauseContext { var p = new(Opt_window_exclusion_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_window_exclusion_clause return p } func InitEmptyOpt_window_exclusion_clauseContext(p *Opt_window_exclusion_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_window_exclusion_clause } func (*Opt_window_exclusion_clauseContext) IsOpt_window_exclusion_clauseContext() {} func NewOpt_window_exclusion_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_window_exclusion_clauseContext { var p = new(Opt_window_exclusion_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_window_exclusion_clause return p } func (s *Opt_window_exclusion_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_window_exclusion_clauseContext) EXCLUDE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXCLUDE, 0) } func (s *Opt_window_exclusion_clauseContext) CURRENT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_P, 0) } func (s *Opt_window_exclusion_clauseContext) ROW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROW, 0) } func (s *Opt_window_exclusion_clauseContext) GROUP_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUP_P, 0) } func (s *Opt_window_exclusion_clauseContext) TIES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTIES, 0) } func (s *Opt_window_exclusion_clauseContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Opt_window_exclusion_clauseContext) OTHERS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOTHERS, 0) } func (s *Opt_window_exclusion_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_window_exclusion_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_window_exclusion_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_window_exclusion_clause(s) } } func (s *Opt_window_exclusion_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_window_exclusion_clause(s) } } func (s *Opt_window_exclusion_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_window_exclusion_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_window_exclusion_clause() (localctx IOpt_window_exclusion_clauseContext) { localctx = NewOpt_window_exclusion_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1260, PostgreSQLParserRULE_opt_window_exclusion_clause) p.SetState(9449) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserEXCLUDE: p.EnterOuterAlt(localctx, 1) { p.SetState(9439) p.Match(PostgreSQLParserEXCLUDE) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9446) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCURRENT_P: { p.SetState(9440) p.Match(PostgreSQLParserCURRENT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9441) p.Match(PostgreSQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserGROUP_P: { p.SetState(9442) p.Match(PostgreSQLParserGROUP_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserTIES: { p.SetState(9443) p.Match(PostgreSQLParserTIES) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserNO: { p.SetState(9444) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9445) p.Match(PostgreSQLParserOTHERS) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case PostgreSQLParserCLOSE_PAREN: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRowContext is an interface to support dynamic dispatch. type IRowContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ROW() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode CLOSE_PAREN() antlr.TerminalNode Expr_list() IExpr_listContext COMMA() antlr.TerminalNode A_expr() IA_exprContext // IsRowContext differentiates from other interfaces. IsRowContext() } type RowContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRowContext() *RowContext { var p = new(RowContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_row return p } func InitEmptyRowContext(p *RowContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_row } func (*RowContext) IsRowContext() {} func NewRowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowContext { var p = new(RowContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_row return p } func (s *RowContext) GetParser() antlr.Parser { return s.parser } func (s *RowContext) ROW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROW, 0) } func (s *RowContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *RowContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *RowContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *RowContext) COMMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, 0) } func (s *RowContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *RowContext) GetRuleContext() antlr.RuleContext { return s } func (s *RowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RowContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRow(s) } } func (s *RowContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRow(s) } } func (s *RowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRow(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Row() (localctx IRowContext) { localctx = NewRowContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1262, PostgreSQLParserRULE_row) var _la int p.SetState(9463) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserROW: p.EnterOuterAlt(localctx, 1) { p.SetState(9451) p.Match(PostgreSQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9452) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9454) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3620818277858553860) != 0) || ((int64((_la-75)) & ^0x3f) == 0 && ((int64(1)<<(_la-75))&-2120073201) != 0) || ((int64((_la-139)) & ^0x3f) == 0 && ((int64(1)<<(_la-139))&-1) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&-1266637395197953) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-1) != 0) || ((int64((_la-331)) & ^0x3f) == 0 && ((int64(1)<<(_la-331))&-1) != 0) || ((int64((_la-395)) & ^0x3f) == 0 && ((int64(1)<<(_la-395))&-576460752303423489) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&-1153009465537069057) != 0) || ((int64((_la-523)) & ^0x3f) == 0 && ((int64(1)<<(_la-523))&-1) != 0) || ((int64((_la-587)) & ^0x3f) == 0 && ((int64(1)<<(_la-587))&-3150267939345661953) != 0) || ((int64((_la-654)) & ^0x3f) == 0 && ((int64(1)<<(_la-654))&131537) != 0) { { p.SetState(9453) p.Expr_list() } } { p.SetState(9456) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserOPEN_PAREN: p.EnterOuterAlt(localctx, 2) { p.SetState(9457) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9458) p.Expr_list() } { p.SetState(9459) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9460) p.A_expr() } { p.SetState(9461) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExplicit_rowContext is an interface to support dynamic dispatch. type IExplicit_rowContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ROW() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode CLOSE_PAREN() antlr.TerminalNode Expr_list() IExpr_listContext // IsExplicit_rowContext differentiates from other interfaces. IsExplicit_rowContext() } type Explicit_rowContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExplicit_rowContext() *Explicit_rowContext { var p = new(Explicit_rowContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_explicit_row return p } func InitEmptyExplicit_rowContext(p *Explicit_rowContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_explicit_row } func (*Explicit_rowContext) IsExplicit_rowContext() {} func NewExplicit_rowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explicit_rowContext { var p = new(Explicit_rowContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_explicit_row return p } func (s *Explicit_rowContext) GetParser() antlr.Parser { return s.parser } func (s *Explicit_rowContext) ROW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROW, 0) } func (s *Explicit_rowContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Explicit_rowContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Explicit_rowContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Explicit_rowContext) GetRuleContext() antlr.RuleContext { return s } func (s *Explicit_rowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Explicit_rowContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExplicit_row(s) } } func (s *Explicit_rowContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExplicit_row(s) } } func (s *Explicit_rowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExplicit_row(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Explicit_row() (localctx IExplicit_rowContext) { localctx = NewExplicit_rowContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1264, PostgreSQLParserRULE_explicit_row) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9465) p.Match(PostgreSQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9466) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9468) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3620818277858553860) != 0) || ((int64((_la-75)) & ^0x3f) == 0 && ((int64(1)<<(_la-75))&-2120073201) != 0) || ((int64((_la-139)) & ^0x3f) == 0 && ((int64(1)<<(_la-139))&-1) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&-1266637395197953) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-1) != 0) || ((int64((_la-331)) & ^0x3f) == 0 && ((int64(1)<<(_la-331))&-1) != 0) || ((int64((_la-395)) & ^0x3f) == 0 && ((int64(1)<<(_la-395))&-576460752303423489) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&-1153009465537069057) != 0) || ((int64((_la-523)) & ^0x3f) == 0 && ((int64(1)<<(_la-523))&-1) != 0) || ((int64((_la-587)) & ^0x3f) == 0 && ((int64(1)<<(_la-587))&-3150267939345661953) != 0) || ((int64((_la-654)) & ^0x3f) == 0 && ((int64(1)<<(_la-654))&131537) != 0) { { p.SetState(9467) p.Expr_list() } } { p.SetState(9470) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IImplicit_rowContext is an interface to support dynamic dispatch. type IImplicit_rowContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Expr_list() IExpr_listContext COMMA() antlr.TerminalNode A_expr() IA_exprContext CLOSE_PAREN() antlr.TerminalNode // IsImplicit_rowContext differentiates from other interfaces. IsImplicit_rowContext() } type Implicit_rowContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyImplicit_rowContext() *Implicit_rowContext { var p = new(Implicit_rowContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_implicit_row return p } func InitEmptyImplicit_rowContext(p *Implicit_rowContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_implicit_row } func (*Implicit_rowContext) IsImplicit_rowContext() {} func NewImplicit_rowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Implicit_rowContext { var p = new(Implicit_rowContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_implicit_row return p } func (s *Implicit_rowContext) GetParser() antlr.Parser { return s.parser } func (s *Implicit_rowContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Implicit_rowContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Implicit_rowContext) COMMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, 0) } func (s *Implicit_rowContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Implicit_rowContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Implicit_rowContext) GetRuleContext() antlr.RuleContext { return s } func (s *Implicit_rowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Implicit_rowContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterImplicit_row(s) } } func (s *Implicit_rowContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitImplicit_row(s) } } func (s *Implicit_rowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitImplicit_row(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Implicit_row() (localctx IImplicit_rowContext) { localctx = NewImplicit_rowContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1266, PostgreSQLParserRULE_implicit_row) p.EnterOuterAlt(localctx, 1) { p.SetState(9472) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9473) p.Expr_list() } { p.SetState(9474) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9475) p.A_expr() } { p.SetState(9476) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISub_typeContext is an interface to support dynamic dispatch. type ISub_typeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ANY() antlr.TerminalNode SOME() antlr.TerminalNode ALL() antlr.TerminalNode // IsSub_typeContext differentiates from other interfaces. IsSub_typeContext() } type Sub_typeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySub_typeContext() *Sub_typeContext { var p = new(Sub_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_sub_type return p } func InitEmptySub_typeContext(p *Sub_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_sub_type } func (*Sub_typeContext) IsSub_typeContext() {} func NewSub_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sub_typeContext { var p = new(Sub_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_sub_type return p } func (s *Sub_typeContext) GetParser() antlr.Parser { return s.parser } func (s *Sub_typeContext) ANY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserANY, 0) } func (s *Sub_typeContext) SOME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSOME, 0) } func (s *Sub_typeContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *Sub_typeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Sub_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Sub_typeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSub_type(s) } } func (s *Sub_typeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSub_type(s) } } func (s *Sub_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSub_type(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Sub_type() (localctx ISub_typeContext) { localctx = NewSub_typeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1268, PostgreSQLParserRULE_sub_type) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9478) _la = p.GetTokenStream().LA(1) if !((int64((_la-30)) & ^0x3f) == 0 && ((int64(1)<<(_la-30))&1152921504606846993) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAll_opContext is an interface to support dynamic dispatch. type IAll_opContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Operator() antlr.TerminalNode Mathop() IMathopContext // IsAll_opContext differentiates from other interfaces. IsAll_opContext() } type All_opContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAll_opContext() *All_opContext { var p = new(All_opContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_all_op return p } func InitEmptyAll_opContext(p *All_opContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_all_op } func (*All_opContext) IsAll_opContext() {} func NewAll_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_opContext { var p = new(All_opContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_all_op return p } func (s *All_opContext) GetParser() antlr.Parser { return s.parser } func (s *All_opContext) Operator() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOperator, 0) } func (s *All_opContext) Mathop() IMathopContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IMathopContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IMathopContext) } func (s *All_opContext) GetRuleContext() antlr.RuleContext { return s } func (s *All_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *All_opContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAll_op(s) } } func (s *All_opContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAll_op(s) } } func (s *All_opContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAll_op(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) All_op() (localctx IAll_opContext) { localctx = NewAll_opContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1270, PostgreSQLParserRULE_all_op) p.SetState(9482) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOperator: p.EnterOuterAlt(localctx, 1) { p.SetState(9480) p.Match(PostgreSQLParserOperator) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSTAR, PostgreSQLParserEQUAL, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserSLASH, PostgreSQLParserCARET, PostgreSQLParserLT, PostgreSQLParserGT, PostgreSQLParserLESS_EQUALS, PostgreSQLParserGREATER_EQUALS, PostgreSQLParserNOT_EQUALS, PostgreSQLParserPERCENT: p.EnterOuterAlt(localctx, 2) { p.SetState(9481) p.Mathop() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IMathopContext is an interface to support dynamic dispatch. type IMathopContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures PLUS() antlr.TerminalNode MINUS() antlr.TerminalNode STAR() antlr.TerminalNode SLASH() antlr.TerminalNode PERCENT() antlr.TerminalNode CARET() antlr.TerminalNode LT() antlr.TerminalNode GT() antlr.TerminalNode EQUAL() antlr.TerminalNode LESS_EQUALS() antlr.TerminalNode GREATER_EQUALS() antlr.TerminalNode NOT_EQUALS() antlr.TerminalNode // IsMathopContext differentiates from other interfaces. IsMathopContext() } type MathopContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyMathopContext() *MathopContext { var p = new(MathopContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_mathop return p } func InitEmptyMathopContext(p *MathopContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_mathop } func (*MathopContext) IsMathopContext() {} func NewMathopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MathopContext { var p = new(MathopContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_mathop return p } func (s *MathopContext) GetParser() antlr.Parser { return s.parser } func (s *MathopContext) PLUS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPLUS, 0) } func (s *MathopContext) MINUS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMINUS, 0) } func (s *MathopContext) STAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTAR, 0) } func (s *MathopContext) SLASH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSLASH, 0) } func (s *MathopContext) PERCENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPERCENT, 0) } func (s *MathopContext) CARET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCARET, 0) } func (s *MathopContext) LT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLT, 0) } func (s *MathopContext) GT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGT, 0) } func (s *MathopContext) EQUAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEQUAL, 0) } func (s *MathopContext) LESS_EQUALS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLESS_EQUALS, 0) } func (s *MathopContext) GREATER_EQUALS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGREATER_EQUALS, 0) } func (s *MathopContext) NOT_EQUALS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT_EQUALS, 0) } func (s *MathopContext) GetRuleContext() antlr.RuleContext { return s } func (s *MathopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *MathopContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterMathop(s) } } func (s *MathopContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitMathop(s) } } func (s *MathopContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitMathop(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Mathop() (localctx IMathopContext) { localctx = NewMathopContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1272, PostgreSQLParserRULE_mathop) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9484) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&178517504) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IQual_opContext is an interface to support dynamic dispatch. type IQual_opContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Operator() antlr.TerminalNode OPERATOR() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Any_operator() IAny_operatorContext CLOSE_PAREN() antlr.TerminalNode // IsQual_opContext differentiates from other interfaces. IsQual_opContext() } type Qual_opContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyQual_opContext() *Qual_opContext { var p = new(Qual_opContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_qual_op return p } func InitEmptyQual_opContext(p *Qual_opContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_qual_op } func (*Qual_opContext) IsQual_opContext() {} func NewQual_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qual_opContext { var p = new(Qual_opContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_qual_op return p } func (s *Qual_opContext) GetParser() antlr.Parser { return s.parser } func (s *Qual_opContext) Operator() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOperator, 0) } func (s *Qual_opContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *Qual_opContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Qual_opContext) Any_operator() IAny_operatorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_operatorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_operatorContext) } func (s *Qual_opContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Qual_opContext) GetRuleContext() antlr.RuleContext { return s } func (s *Qual_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Qual_opContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterQual_op(s) } } func (s *Qual_opContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitQual_op(s) } } func (s *Qual_opContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitQual_op(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Qual_op() (localctx IQual_opContext) { localctx = NewQual_opContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1274, PostgreSQLParserRULE_qual_op) p.SetState(9492) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOperator: p.EnterOuterAlt(localctx, 1) { p.SetState(9486) p.Match(PostgreSQLParserOperator) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserOPERATOR: p.EnterOuterAlt(localctx, 2) { p.SetState(9487) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9488) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9489) p.Any_operator() } { p.SetState(9490) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IQual_all_opContext is an interface to support dynamic dispatch. type IQual_all_opContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures All_op() IAll_opContext OPERATOR() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Any_operator() IAny_operatorContext CLOSE_PAREN() antlr.TerminalNode // IsQual_all_opContext differentiates from other interfaces. IsQual_all_opContext() } type Qual_all_opContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyQual_all_opContext() *Qual_all_opContext { var p = new(Qual_all_opContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_qual_all_op return p } func InitEmptyQual_all_opContext(p *Qual_all_opContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_qual_all_op } func (*Qual_all_opContext) IsQual_all_opContext() {} func NewQual_all_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qual_all_opContext { var p = new(Qual_all_opContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_qual_all_op return p } func (s *Qual_all_opContext) GetParser() antlr.Parser { return s.parser } func (s *Qual_all_opContext) All_op() IAll_opContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAll_opContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAll_opContext) } func (s *Qual_all_opContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *Qual_all_opContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Qual_all_opContext) Any_operator() IAny_operatorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_operatorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_operatorContext) } func (s *Qual_all_opContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Qual_all_opContext) GetRuleContext() antlr.RuleContext { return s } func (s *Qual_all_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Qual_all_opContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterQual_all_op(s) } } func (s *Qual_all_opContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitQual_all_op(s) } } func (s *Qual_all_opContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitQual_all_op(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Qual_all_op() (localctx IQual_all_opContext) { localctx = NewQual_all_opContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1276, PostgreSQLParserRULE_qual_all_op) p.SetState(9500) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSTAR, PostgreSQLParserEQUAL, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserSLASH, PostgreSQLParserCARET, PostgreSQLParserLT, PostgreSQLParserGT, PostgreSQLParserLESS_EQUALS, PostgreSQLParserGREATER_EQUALS, PostgreSQLParserNOT_EQUALS, PostgreSQLParserPERCENT, PostgreSQLParserOperator: p.EnterOuterAlt(localctx, 1) { p.SetState(9494) p.All_op() } case PostgreSQLParserOPERATOR: p.EnterOuterAlt(localctx, 2) { p.SetState(9495) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9496) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9497) p.Any_operator() } { p.SetState(9498) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISubquery_OpContext is an interface to support dynamic dispatch. type ISubquery_OpContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures All_op() IAll_opContext OPERATOR() antlr.TerminalNode OPEN_PAREN() antlr.TerminalNode Any_operator() IAny_operatorContext CLOSE_PAREN() antlr.TerminalNode LIKE() antlr.TerminalNode NOT() antlr.TerminalNode ILIKE() antlr.TerminalNode // IsSubquery_OpContext differentiates from other interfaces. IsSubquery_OpContext() } type Subquery_OpContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySubquery_OpContext() *Subquery_OpContext { var p = new(Subquery_OpContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_subquery_Op return p } func InitEmptySubquery_OpContext(p *Subquery_OpContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_subquery_Op } func (*Subquery_OpContext) IsSubquery_OpContext() {} func NewSubquery_OpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subquery_OpContext { var p = new(Subquery_OpContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_subquery_Op return p } func (s *Subquery_OpContext) GetParser() antlr.Parser { return s.parser } func (s *Subquery_OpContext) All_op() IAll_opContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAll_opContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAll_opContext) } func (s *Subquery_OpContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *Subquery_OpContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Subquery_OpContext) Any_operator() IAny_operatorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_operatorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_operatorContext) } func (s *Subquery_OpContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Subquery_OpContext) LIKE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLIKE, 0) } func (s *Subquery_OpContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *Subquery_OpContext) ILIKE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserILIKE, 0) } func (s *Subquery_OpContext) GetRuleContext() antlr.RuleContext { return s } func (s *Subquery_OpContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Subquery_OpContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSubquery_Op(s) } } func (s *Subquery_OpContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSubquery_Op(s) } } func (s *Subquery_OpContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSubquery_Op(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Subquery_Op() (localctx ISubquery_OpContext) { localctx = NewSubquery_OpContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1278, PostgreSQLParserRULE_subquery_Op) p.SetState(9514) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 617, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9502) p.All_op() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9503) p.Match(PostgreSQLParserOPERATOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9504) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9505) p.Any_operator() } { p.SetState(9506) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9508) p.Match(PostgreSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(9509) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9510) p.Match(PostgreSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(9511) p.Match(PostgreSQLParserILIKE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(9512) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9513) p.Match(PostgreSQLParserILIKE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExpr_listContext is an interface to support dynamic dispatch. type IExpr_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllA_expr() []IA_exprContext A_expr(i int) IA_exprContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsExpr_listContext differentiates from other interfaces. IsExpr_listContext() } type Expr_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExpr_listContext() *Expr_listContext { var p = new(Expr_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_expr_list return p } func InitEmptyExpr_listContext(p *Expr_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_expr_list } func (*Expr_listContext) IsExpr_listContext() {} func NewExpr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_listContext { var p = new(Expr_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_expr_list return p } func (s *Expr_listContext) GetParser() antlr.Parser { return s.parser } func (s *Expr_listContext) AllA_expr() []IA_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_exprContext); ok { len++ } } tst := make([]IA_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_exprContext); ok { tst[i] = t.(IA_exprContext) i++ } } return tst } func (s *Expr_listContext) A_expr(i int) IA_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Expr_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Expr_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Expr_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Expr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Expr_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExpr_list(s) } } func (s *Expr_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExpr_list(s) } } func (s *Expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExpr_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Expr_list() (localctx IExpr_listContext) { localctx = NewExpr_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1280, PostgreSQLParserRULE_expr_list) var _alt int p.EnterOuterAlt(localctx, 1) { p.SetState(9516) p.A_expr() } p.SetState(9521) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 618, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(9517) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9518) p.A_expr() } } p.SetState(9523) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 618, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_arg_listContext is an interface to support dynamic dispatch. type IFunc_arg_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllFunc_arg_expr() []IFunc_arg_exprContext Func_arg_expr(i int) IFunc_arg_exprContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsFunc_arg_listContext differentiates from other interfaces. IsFunc_arg_listContext() } type Func_arg_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_arg_listContext() *Func_arg_listContext { var p = new(Func_arg_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_arg_list return p } func InitEmptyFunc_arg_listContext(p *Func_arg_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_arg_list } func (*Func_arg_listContext) IsFunc_arg_listContext() {} func NewFunc_arg_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_arg_listContext { var p = new(Func_arg_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_arg_list return p } func (s *Func_arg_listContext) GetParser() antlr.Parser { return s.parser } func (s *Func_arg_listContext) AllFunc_arg_expr() []IFunc_arg_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IFunc_arg_exprContext); ok { len++ } } tst := make([]IFunc_arg_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IFunc_arg_exprContext); ok { tst[i] = t.(IFunc_arg_exprContext) i++ } } return tst } func (s *Func_arg_listContext) Func_arg_expr(i int) IFunc_arg_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_arg_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IFunc_arg_exprContext) } func (s *Func_arg_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Func_arg_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Func_arg_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_arg_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_arg_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_arg_list(s) } } func (s *Func_arg_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_arg_list(s) } } func (s *Func_arg_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_arg_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_arg_list() (localctx IFunc_arg_listContext) { localctx = NewFunc_arg_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1282, PostgreSQLParserRULE_func_arg_list) var _alt int p.EnterOuterAlt(localctx, 1) { p.SetState(9524) p.Func_arg_expr() } p.SetState(9529) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 619, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(9525) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9526) p.Func_arg_expr() } } p.SetState(9531) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 619, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_arg_exprContext is an interface to support dynamic dispatch. type IFunc_arg_exprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr() IA_exprContext Param_name() IParam_nameContext COLON_EQUALS() antlr.TerminalNode EQUALS_GREATER() antlr.TerminalNode // IsFunc_arg_exprContext differentiates from other interfaces. IsFunc_arg_exprContext() } type Func_arg_exprContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_arg_exprContext() *Func_arg_exprContext { var p = new(Func_arg_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_arg_expr return p } func InitEmptyFunc_arg_exprContext(p *Func_arg_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_arg_expr } func (*Func_arg_exprContext) IsFunc_arg_exprContext() {} func NewFunc_arg_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_arg_exprContext { var p = new(Func_arg_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_arg_expr return p } func (s *Func_arg_exprContext) GetParser() antlr.Parser { return s.parser } func (s *Func_arg_exprContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Func_arg_exprContext) Param_name() IParam_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IParam_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IParam_nameContext) } func (s *Func_arg_exprContext) COLON_EQUALS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLON_EQUALS, 0) } func (s *Func_arg_exprContext) EQUALS_GREATER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEQUALS_GREATER, 0) } func (s *Func_arg_exprContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_arg_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_arg_exprContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_arg_expr(s) } } func (s *Func_arg_exprContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_arg_expr(s) } } func (s *Func_arg_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_arg_expr(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_arg_expr() (localctx IFunc_arg_exprContext) { localctx = NewFunc_arg_exprContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1284, PostgreSQLParserRULE_func_arg_expr) var _la int p.SetState(9537) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 620, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9532) p.A_expr() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9533) p.Param_name() } { p.SetState(9534) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserCOLON_EQUALS || _la == PostgreSQLParserEQUALS_GREATER) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(9535) p.A_expr() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IType_listContext is an interface to support dynamic dispatch. type IType_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllTypename() []ITypenameContext Typename(i int) ITypenameContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsType_listContext differentiates from other interfaces. IsType_listContext() } type Type_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyType_listContext() *Type_listContext { var p = new(Type_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_type_list return p } func InitEmptyType_listContext(p *Type_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_type_list } func (*Type_listContext) IsType_listContext() {} func NewType_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_listContext { var p = new(Type_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_type_list return p } func (s *Type_listContext) GetParser() antlr.Parser { return s.parser } func (s *Type_listContext) AllTypename() []ITypenameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITypenameContext); ok { len++ } } tst := make([]ITypenameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITypenameContext); ok { tst[i] = t.(ITypenameContext) i++ } } return tst } func (s *Type_listContext) Typename(i int) ITypenameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITypenameContext) } func (s *Type_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Type_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Type_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Type_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Type_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterType_list(s) } } func (s *Type_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitType_list(s) } } func (s *Type_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitType_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Type_list() (localctx IType_listContext) { localctx = NewType_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1286, PostgreSQLParserRULE_type_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9539) p.Typename() } p.SetState(9544) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(9540) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9541) p.Typename() } p.SetState(9546) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IArray_exprContext is an interface to support dynamic dispatch. type IArray_exprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_BRACKET() antlr.TerminalNode CLOSE_BRACKET() antlr.TerminalNode Expr_list() IExpr_listContext Array_expr_list() IArray_expr_listContext // IsArray_exprContext differentiates from other interfaces. IsArray_exprContext() } type Array_exprContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyArray_exprContext() *Array_exprContext { var p = new(Array_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_array_expr return p } func InitEmptyArray_exprContext(p *Array_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_array_expr } func (*Array_exprContext) IsArray_exprContext() {} func NewArray_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_exprContext { var p = new(Array_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_array_expr return p } func (s *Array_exprContext) GetParser() antlr.Parser { return s.parser } func (s *Array_exprContext) OPEN_BRACKET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_BRACKET, 0) } func (s *Array_exprContext) CLOSE_BRACKET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_BRACKET, 0) } func (s *Array_exprContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Array_exprContext) Array_expr_list() IArray_expr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IArray_expr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IArray_expr_listContext) } func (s *Array_exprContext) GetRuleContext() antlr.RuleContext { return s } func (s *Array_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Array_exprContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterArray_expr(s) } } func (s *Array_exprContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitArray_expr(s) } } func (s *Array_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitArray_expr(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Array_expr() (localctx IArray_exprContext) { localctx = NewArray_exprContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1288, PostgreSQLParserRULE_array_expr) p.EnterOuterAlt(localctx, 1) { p.SetState(9547) p.Match(PostgreSQLParserOPEN_BRACKET) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9550) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: { p.SetState(9548) p.Expr_list() } case PostgreSQLParserOPEN_BRACKET: { p.SetState(9549) p.Array_expr_list() } case PostgreSQLParserCLOSE_BRACKET: default: } { p.SetState(9552) p.Match(PostgreSQLParserCLOSE_BRACKET) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IArray_expr_listContext is an interface to support dynamic dispatch. type IArray_expr_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllArray_expr() []IArray_exprContext Array_expr(i int) IArray_exprContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsArray_expr_listContext differentiates from other interfaces. IsArray_expr_listContext() } type Array_expr_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyArray_expr_listContext() *Array_expr_listContext { var p = new(Array_expr_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_array_expr_list return p } func InitEmptyArray_expr_listContext(p *Array_expr_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_array_expr_list } func (*Array_expr_listContext) IsArray_expr_listContext() {} func NewArray_expr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_expr_listContext { var p = new(Array_expr_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_array_expr_list return p } func (s *Array_expr_listContext) GetParser() antlr.Parser { return s.parser } func (s *Array_expr_listContext) AllArray_expr() []IArray_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IArray_exprContext); ok { len++ } } tst := make([]IArray_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IArray_exprContext); ok { tst[i] = t.(IArray_exprContext) i++ } } return tst } func (s *Array_expr_listContext) Array_expr(i int) IArray_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IArray_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IArray_exprContext) } func (s *Array_expr_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Array_expr_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Array_expr_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Array_expr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Array_expr_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterArray_expr_list(s) } } func (s *Array_expr_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitArray_expr_list(s) } } func (s *Array_expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitArray_expr_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Array_expr_list() (localctx IArray_expr_listContext) { localctx = NewArray_expr_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1290, PostgreSQLParserRULE_array_expr_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9554) p.Array_expr() } p.SetState(9559) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(9555) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9556) p.Array_expr() } p.SetState(9561) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExtract_listContext is an interface to support dynamic dispatch. type IExtract_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Extract_arg() IExtract_argContext FROM() antlr.TerminalNode A_expr() IA_exprContext // IsExtract_listContext differentiates from other interfaces. IsExtract_listContext() } type Extract_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExtract_listContext() *Extract_listContext { var p = new(Extract_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_extract_list return p } func InitEmptyExtract_listContext(p *Extract_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_extract_list } func (*Extract_listContext) IsExtract_listContext() {} func NewExtract_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extract_listContext { var p = new(Extract_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_extract_list return p } func (s *Extract_listContext) GetParser() antlr.Parser { return s.parser } func (s *Extract_listContext) Extract_arg() IExtract_argContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExtract_argContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExtract_argContext) } func (s *Extract_listContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *Extract_listContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Extract_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Extract_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Extract_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExtract_list(s) } } func (s *Extract_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExtract_list(s) } } func (s *Extract_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExtract_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Extract_list() (localctx IExtract_listContext) { localctx = NewExtract_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1292, PostgreSQLParserRULE_extract_list) p.SetState(9567) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserOUTER_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserBACKWARD, PostgreSQLParserCHAIN, PostgreSQLParserCLOSE, PostgreSQLParserCOMMIT, PostgreSQLParserCONTINUE_P, PostgreSQLParserCURSOR, PostgreSQLParserDAY_P, PostgreSQLParserFIRST_P, PostgreSQLParserFORWARD, PostgreSQLParserHOUR_P, PostgreSQLParserINSERT, PostgreSQLParserLAST_P, PostgreSQLParserMINUTE_P, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserOPTION, PostgreSQLParserPRIOR, PostgreSQLParserRELATIVE_P, PostgreSQLParserRESET, PostgreSQLParserROLLBACK, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSECOND_P, PostgreSQLParserSET, PostgreSQLParserTYPE_P, PostgreSQLParserYEAR_P, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserROWTYPE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(9562) p.Extract_arg() } { p.SetState(9563) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9564) p.A_expr() } case PostgreSQLParserCLOSE_PAREN: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExtract_argContext is an interface to support dynamic dispatch. type IExtract_argContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Identifier() IIdentifierContext YEAR_P() antlr.TerminalNode MONTH_P() antlr.TerminalNode DAY_P() antlr.TerminalNode HOUR_P() antlr.TerminalNode MINUTE_P() antlr.TerminalNode SECOND_P() antlr.TerminalNode Sconst() ISconstContext // IsExtract_argContext differentiates from other interfaces. IsExtract_argContext() } type Extract_argContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExtract_argContext() *Extract_argContext { var p = new(Extract_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_extract_arg return p } func InitEmptyExtract_argContext(p *Extract_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_extract_arg } func (*Extract_argContext) IsExtract_argContext() {} func NewExtract_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extract_argContext { var p = new(Extract_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_extract_arg return p } func (s *Extract_argContext) GetParser() antlr.Parser { return s.parser } func (s *Extract_argContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *Extract_argContext) YEAR_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserYEAR_P, 0) } func (s *Extract_argContext) MONTH_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMONTH_P, 0) } func (s *Extract_argContext) DAY_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDAY_P, 0) } func (s *Extract_argContext) HOUR_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserHOUR_P, 0) } func (s *Extract_argContext) MINUTE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMINUTE_P, 0) } func (s *Extract_argContext) SECOND_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSECOND_P, 0) } func (s *Extract_argContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Extract_argContext) GetRuleContext() antlr.RuleContext { return s } func (s *Extract_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Extract_argContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExtract_arg(s) } } func (s *Extract_argContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExtract_arg(s) } } func (s *Extract_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExtract_arg(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Extract_arg() (localctx IExtract_argContext) { localctx = NewExtract_argContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1294, PostgreSQLParserRULE_extract_arg) p.SetState(9577) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserOUTER_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserBACKWARD, PostgreSQLParserCHAIN, PostgreSQLParserCLOSE, PostgreSQLParserCOMMIT, PostgreSQLParserCONTINUE_P, PostgreSQLParserCURSOR, PostgreSQLParserFIRST_P, PostgreSQLParserFORWARD, PostgreSQLParserINSERT, PostgreSQLParserLAST_P, PostgreSQLParserMOVE, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserOPTION, PostgreSQLParserPRIOR, PostgreSQLParserRELATIVE_P, PostgreSQLParserRESET, PostgreSQLParserROLLBACK, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSET, PostgreSQLParserTYPE_P, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserROWTYPE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(9569) p.Identifier() } case PostgreSQLParserYEAR_P: p.EnterOuterAlt(localctx, 2) { p.SetState(9570) p.Match(PostgreSQLParserYEAR_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserMONTH_P: p.EnterOuterAlt(localctx, 3) { p.SetState(9571) p.Match(PostgreSQLParserMONTH_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserDAY_P: p.EnterOuterAlt(localctx, 4) { p.SetState(9572) p.Match(PostgreSQLParserDAY_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserHOUR_P: p.EnterOuterAlt(localctx, 5) { p.SetState(9573) p.Match(PostgreSQLParserHOUR_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserMINUTE_P: p.EnterOuterAlt(localctx, 6) { p.SetState(9574) p.Match(PostgreSQLParserMINUTE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSECOND_P: p.EnterOuterAlt(localctx, 7) { p.SetState(9575) p.Match(PostgreSQLParserSECOND_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 8) { p.SetState(9576) p.Sconst() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IUnicode_normal_formContext is an interface to support dynamic dispatch. type IUnicode_normal_formContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NFC() antlr.TerminalNode NFD() antlr.TerminalNode NFKC() antlr.TerminalNode NFKD() antlr.TerminalNode // IsUnicode_normal_formContext differentiates from other interfaces. IsUnicode_normal_formContext() } type Unicode_normal_formContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyUnicode_normal_formContext() *Unicode_normal_formContext { var p = new(Unicode_normal_formContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_unicode_normal_form return p } func InitEmptyUnicode_normal_formContext(p *Unicode_normal_formContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_unicode_normal_form } func (*Unicode_normal_formContext) IsUnicode_normal_formContext() {} func NewUnicode_normal_formContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unicode_normal_formContext { var p = new(Unicode_normal_formContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_unicode_normal_form return p } func (s *Unicode_normal_formContext) GetParser() antlr.Parser { return s.parser } func (s *Unicode_normal_formContext) NFC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNFC, 0) } func (s *Unicode_normal_formContext) NFD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNFD, 0) } func (s *Unicode_normal_formContext) NFKC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNFKC, 0) } func (s *Unicode_normal_formContext) NFKD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNFKD, 0) } func (s *Unicode_normal_formContext) GetRuleContext() antlr.RuleContext { return s } func (s *Unicode_normal_formContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Unicode_normal_formContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterUnicode_normal_form(s) } } func (s *Unicode_normal_formContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitUnicode_normal_form(s) } } func (s *Unicode_normal_formContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitUnicode_normal_form(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Unicode_normal_form() (localctx IUnicode_normal_formContext) { localctx = NewUnicode_normal_formContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1296, PostgreSQLParserRULE_unicode_normal_form) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9579) _la = p.GetTokenStream().LA(1) if !((int64((_la-483)) & ^0x3f) == 0 && ((int64(1)<<(_la-483))&15) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOverlay_listContext is an interface to support dynamic dispatch. type IOverlay_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllA_expr() []IA_exprContext A_expr(i int) IA_exprContext PLACING() antlr.TerminalNode FROM() antlr.TerminalNode FOR() antlr.TerminalNode // IsOverlay_listContext differentiates from other interfaces. IsOverlay_listContext() } type Overlay_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOverlay_listContext() *Overlay_listContext { var p = new(Overlay_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_overlay_list return p } func InitEmptyOverlay_listContext(p *Overlay_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_overlay_list } func (*Overlay_listContext) IsOverlay_listContext() {} func NewOverlay_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Overlay_listContext { var p = new(Overlay_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_overlay_list return p } func (s *Overlay_listContext) GetParser() antlr.Parser { return s.parser } func (s *Overlay_listContext) AllA_expr() []IA_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_exprContext); ok { len++ } } tst := make([]IA_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_exprContext); ok { tst[i] = t.(IA_exprContext) i++ } } return tst } func (s *Overlay_listContext) A_expr(i int) IA_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Overlay_listContext) PLACING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPLACING, 0) } func (s *Overlay_listContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *Overlay_listContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *Overlay_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Overlay_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Overlay_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOverlay_list(s) } } func (s *Overlay_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOverlay_list(s) } } func (s *Overlay_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOverlay_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Overlay_list() (localctx IOverlay_listContext) { localctx = NewOverlay_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1298, PostgreSQLParserRULE_overlay_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9581) p.A_expr() } { p.SetState(9582) p.Match(PostgreSQLParserPLACING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9583) p.A_expr() } { p.SetState(9584) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9585) p.A_expr() } p.SetState(9588) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserFOR { { p.SetState(9586) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9587) p.A_expr() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPosition_listContext is an interface to support dynamic dispatch. type IPosition_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllB_expr() []IB_exprContext B_expr(i int) IB_exprContext IN_P() antlr.TerminalNode // IsPosition_listContext differentiates from other interfaces. IsPosition_listContext() } type Position_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPosition_listContext() *Position_listContext { var p = new(Position_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_position_list return p } func InitEmptyPosition_listContext(p *Position_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_position_list } func (*Position_listContext) IsPosition_listContext() {} func NewPosition_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Position_listContext { var p = new(Position_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_position_list return p } func (s *Position_listContext) GetParser() antlr.Parser { return s.parser } func (s *Position_listContext) AllB_expr() []IB_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IB_exprContext); ok { len++ } } tst := make([]IB_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IB_exprContext); ok { tst[i] = t.(IB_exprContext) i++ } } return tst } func (s *Position_listContext) B_expr(i int) IB_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IB_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IB_exprContext) } func (s *Position_listContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *Position_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Position_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Position_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPosition_list(s) } } func (s *Position_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPosition_list(s) } } func (s *Position_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPosition_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Position_list() (localctx IPosition_listContext) { localctx = NewPosition_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1300, PostgreSQLParserRULE_position_list) p.SetState(9595) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(9590) p.b_expr(0) } { p.SetState(9591) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9592) p.b_expr(0) } case PostgreSQLParserCLOSE_PAREN: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISubstr_listContext is an interface to support dynamic dispatch. type ISubstr_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllA_expr() []IA_exprContext A_expr(i int) IA_exprContext FROM() antlr.TerminalNode FOR() antlr.TerminalNode SIMILAR() antlr.TerminalNode ESCAPE() antlr.TerminalNode Expr_list() IExpr_listContext // IsSubstr_listContext differentiates from other interfaces. IsSubstr_listContext() } type Substr_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySubstr_listContext() *Substr_listContext { var p = new(Substr_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_substr_list return p } func InitEmptySubstr_listContext(p *Substr_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_substr_list } func (*Substr_listContext) IsSubstr_listContext() {} func NewSubstr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Substr_listContext { var p = new(Substr_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_substr_list return p } func (s *Substr_listContext) GetParser() antlr.Parser { return s.parser } func (s *Substr_listContext) AllA_expr() []IA_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_exprContext); ok { len++ } } tst := make([]IA_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_exprContext); ok { tst[i] = t.(IA_exprContext) i++ } } return tst } func (s *Substr_listContext) A_expr(i int) IA_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Substr_listContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *Substr_listContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *Substr_listContext) SIMILAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSIMILAR, 0) } func (s *Substr_listContext) ESCAPE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserESCAPE, 0) } func (s *Substr_listContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Substr_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Substr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Substr_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSubstr_list(s) } } func (s *Substr_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSubstr_list(s) } } func (s *Substr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSubstr_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Substr_list() (localctx ISubstr_listContext) { localctx = NewSubstr_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1302, PostgreSQLParserRULE_substr_list) p.SetState(9624) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 628, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9597) p.A_expr() } { p.SetState(9598) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9599) p.A_expr() } { p.SetState(9600) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9601) p.A_expr() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9603) p.A_expr() } { p.SetState(9604) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9605) p.A_expr() } { p.SetState(9606) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9607) p.A_expr() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9609) p.A_expr() } { p.SetState(9610) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9611) p.A_expr() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(9613) p.A_expr() } { p.SetState(9614) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9615) p.A_expr() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(9617) p.A_expr() } { p.SetState(9618) p.Match(PostgreSQLParserSIMILAR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9619) p.A_expr() } { p.SetState(9620) p.Match(PostgreSQLParserESCAPE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9621) p.A_expr() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(9623) p.Expr_list() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITrim_listContext is an interface to support dynamic dispatch. type ITrim_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr() IA_exprContext FROM() antlr.TerminalNode Expr_list() IExpr_listContext // IsTrim_listContext differentiates from other interfaces. IsTrim_listContext() } type Trim_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTrim_listContext() *Trim_listContext { var p = new(Trim_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_trim_list return p } func InitEmptyTrim_listContext(p *Trim_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_trim_list } func (*Trim_listContext) IsTrim_listContext() {} func NewTrim_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trim_listContext { var p = new(Trim_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_trim_list return p } func (s *Trim_listContext) GetParser() antlr.Parser { return s.parser } func (s *Trim_listContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Trim_listContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *Trim_listContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Trim_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Trim_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Trim_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTrim_list(s) } } func (s *Trim_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTrim_list(s) } } func (s *Trim_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTrim_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Trim_list() (localctx ITrim_listContext) { localctx = NewTrim_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1304, PostgreSQLParserRULE_trim_list) p.SetState(9633) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 629, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9626) p.A_expr() } { p.SetState(9627) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9628) p.Expr_list() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9630) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9631) p.Expr_list() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9632) p.Expr_list() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IIn_exprContext is an interface to support dynamic dispatch. type IIn_exprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsIn_exprContext differentiates from other interfaces. IsIn_exprContext() } type In_exprContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyIn_exprContext() *In_exprContext { var p = new(In_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_in_expr return p } func InitEmptyIn_exprContext(p *In_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_in_expr } func (*In_exprContext) IsIn_exprContext() {} func NewIn_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *In_exprContext { var p = new(In_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_in_expr return p } func (s *In_exprContext) GetParser() antlr.Parser { return s.parser } func (s *In_exprContext) CopyAll(ctx *In_exprContext) { s.CopyFrom(&ctx.BaseParserRuleContext) } func (s *In_exprContext) GetRuleContext() antlr.RuleContext { return s } func (s *In_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } type In_expr_listContext struct { In_exprContext } func NewIn_expr_listContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *In_expr_listContext { var p = new(In_expr_listContext) InitEmptyIn_exprContext(&p.In_exprContext) p.parser = parser p.CopyAll(ctx.(*In_exprContext)) return p } func (s *In_expr_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *In_expr_listContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *In_expr_listContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *In_expr_listContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *In_expr_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterIn_expr_list(s) } } func (s *In_expr_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitIn_expr_list(s) } } func (s *In_expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitIn_expr_list(s) default: return t.VisitChildren(s) } } type In_expr_selectContext struct { In_exprContext } func NewIn_expr_selectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *In_expr_selectContext { var p = new(In_expr_selectContext) InitEmptyIn_exprContext(&p.In_exprContext) p.parser = parser p.CopyAll(ctx.(*In_exprContext)) return p } func (s *In_expr_selectContext) GetRuleContext() antlr.RuleContext { return s } func (s *In_expr_selectContext) Select_with_parens() ISelect_with_parensContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelect_with_parensContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelect_with_parensContext) } func (s *In_expr_selectContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterIn_expr_select(s) } } func (s *In_expr_selectContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitIn_expr_select(s) } } func (s *In_expr_selectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitIn_expr_select(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) In_expr() (localctx IIn_exprContext) { localctx = NewIn_exprContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1306, PostgreSQLParserRULE_in_expr) p.SetState(9640) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 630, p.GetParserRuleContext()) { case 1: localctx = NewIn_expr_selectContext(p, localctx) p.EnterOuterAlt(localctx, 1) { p.SetState(9635) p.Select_with_parens() } case 2: localctx = NewIn_expr_listContext(p, localctx) p.EnterOuterAlt(localctx, 2) { p.SetState(9636) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9637) p.Expr_list() } { p.SetState(9638) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICase_exprContext is an interface to support dynamic dispatch. type ICase_exprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CASE() antlr.TerminalNode Case_arg() ICase_argContext When_clause_list() IWhen_clause_listContext Case_default() ICase_defaultContext END_P() antlr.TerminalNode // IsCase_exprContext differentiates from other interfaces. IsCase_exprContext() } type Case_exprContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCase_exprContext() *Case_exprContext { var p = new(Case_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_case_expr return p } func InitEmptyCase_exprContext(p *Case_exprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_case_expr } func (*Case_exprContext) IsCase_exprContext() {} func NewCase_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_exprContext { var p = new(Case_exprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_case_expr return p } func (s *Case_exprContext) GetParser() antlr.Parser { return s.parser } func (s *Case_exprContext) CASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCASE, 0) } func (s *Case_exprContext) Case_arg() ICase_argContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICase_argContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICase_argContext) } func (s *Case_exprContext) When_clause_list() IWhen_clause_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWhen_clause_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWhen_clause_listContext) } func (s *Case_exprContext) Case_default() ICase_defaultContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICase_defaultContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICase_defaultContext) } func (s *Case_exprContext) END_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEND_P, 0) } func (s *Case_exprContext) GetRuleContext() antlr.RuleContext { return s } func (s *Case_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Case_exprContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCase_expr(s) } } func (s *Case_exprContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCase_expr(s) } } func (s *Case_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCase_expr(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Case_expr() (localctx ICase_exprContext) { localctx = NewCase_exprContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1308, PostgreSQLParserRULE_case_expr) p.EnterOuterAlt(localctx, 1) { p.SetState(9642) p.Match(PostgreSQLParserCASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9643) p.Case_arg() } { p.SetState(9644) p.When_clause_list() } { p.SetState(9645) p.Case_default() } { p.SetState(9646) p.Match(PostgreSQLParserEND_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IWhen_clause_listContext is an interface to support dynamic dispatch. type IWhen_clause_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllWhen_clause() []IWhen_clauseContext When_clause(i int) IWhen_clauseContext // IsWhen_clause_listContext differentiates from other interfaces. IsWhen_clause_listContext() } type When_clause_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyWhen_clause_listContext() *When_clause_listContext { var p = new(When_clause_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_when_clause_list return p } func InitEmptyWhen_clause_listContext(p *When_clause_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_when_clause_list } func (*When_clause_listContext) IsWhen_clause_listContext() {} func NewWhen_clause_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *When_clause_listContext { var p = new(When_clause_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_when_clause_list return p } func (s *When_clause_listContext) GetParser() antlr.Parser { return s.parser } func (s *When_clause_listContext) AllWhen_clause() []IWhen_clauseContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IWhen_clauseContext); ok { len++ } } tst := make([]IWhen_clauseContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IWhen_clauseContext); ok { tst[i] = t.(IWhen_clauseContext) i++ } } return tst } func (s *When_clause_listContext) When_clause(i int) IWhen_clauseContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWhen_clauseContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IWhen_clauseContext) } func (s *When_clause_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *When_clause_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *When_clause_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterWhen_clause_list(s) } } func (s *When_clause_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitWhen_clause_list(s) } } func (s *When_clause_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitWhen_clause_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) When_clause_list() (localctx IWhen_clause_listContext) { localctx = NewWhen_clause_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1310, PostgreSQLParserRULE_when_clause_list) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(9649) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ok := true; ok; ok = _la == PostgreSQLParserWHEN { { p.SetState(9648) p.When_clause() } p.SetState(9651) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IWhen_clauseContext is an interface to support dynamic dispatch. type IWhen_clauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WHEN() antlr.TerminalNode AllA_expr() []IA_exprContext A_expr(i int) IA_exprContext THEN() antlr.TerminalNode // IsWhen_clauseContext differentiates from other interfaces. IsWhen_clauseContext() } type When_clauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyWhen_clauseContext() *When_clauseContext { var p = new(When_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_when_clause return p } func InitEmptyWhen_clauseContext(p *When_clauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_when_clause } func (*When_clauseContext) IsWhen_clauseContext() {} func NewWhen_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *When_clauseContext { var p = new(When_clauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_when_clause return p } func (s *When_clauseContext) GetParser() antlr.Parser { return s.parser } func (s *When_clauseContext) WHEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHEN, 0) } func (s *When_clauseContext) AllA_expr() []IA_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_exprContext); ok { len++ } } tst := make([]IA_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_exprContext); ok { tst[i] = t.(IA_exprContext) i++ } } return tst } func (s *When_clauseContext) A_expr(i int) IA_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_exprContext) } func (s *When_clauseContext) THEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTHEN, 0) } func (s *When_clauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *When_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *When_clauseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterWhen_clause(s) } } func (s *When_clauseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitWhen_clause(s) } } func (s *When_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitWhen_clause(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) When_clause() (localctx IWhen_clauseContext) { localctx = NewWhen_clauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1312, PostgreSQLParserRULE_when_clause) p.EnterOuterAlt(localctx, 1) { p.SetState(9653) p.Match(PostgreSQLParserWHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9654) p.A_expr() } { p.SetState(9655) p.Match(PostgreSQLParserTHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9656) p.A_expr() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICase_defaultContext is an interface to support dynamic dispatch. type ICase_defaultContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ELSE() antlr.TerminalNode A_expr() IA_exprContext // IsCase_defaultContext differentiates from other interfaces. IsCase_defaultContext() } type Case_defaultContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCase_defaultContext() *Case_defaultContext { var p = new(Case_defaultContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_case_default return p } func InitEmptyCase_defaultContext(p *Case_defaultContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_case_default } func (*Case_defaultContext) IsCase_defaultContext() {} func NewCase_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_defaultContext { var p = new(Case_defaultContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_case_default return p } func (s *Case_defaultContext) GetParser() antlr.Parser { return s.parser } func (s *Case_defaultContext) ELSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserELSE, 0) } func (s *Case_defaultContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Case_defaultContext) GetRuleContext() antlr.RuleContext { return s } func (s *Case_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Case_defaultContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCase_default(s) } } func (s *Case_defaultContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCase_default(s) } } func (s *Case_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCase_default(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Case_default() (localctx ICase_defaultContext) { localctx = NewCase_defaultContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1314, PostgreSQLParserRULE_case_default) p.SetState(9661) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserELSE: p.EnterOuterAlt(localctx, 1) { p.SetState(9658) p.Match(PostgreSQLParserELSE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9659) p.A_expr() } case PostgreSQLParserEND_P: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICase_argContext is an interface to support dynamic dispatch. type ICase_argContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr() IA_exprContext // IsCase_argContext differentiates from other interfaces. IsCase_argContext() } type Case_argContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCase_argContext() *Case_argContext { var p = new(Case_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_case_arg return p } func InitEmptyCase_argContext(p *Case_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_case_arg } func (*Case_argContext) IsCase_argContext() {} func NewCase_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_argContext { var p = new(Case_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_case_arg return p } func (s *Case_argContext) GetParser() antlr.Parser { return s.parser } func (s *Case_argContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Case_argContext) GetRuleContext() antlr.RuleContext { return s } func (s *Case_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Case_argContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCase_arg(s) } } func (s *Case_argContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCase_arg(s) } } func (s *Case_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCase_arg(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Case_arg() (localctx ICase_argContext) { localctx = NewCase_argContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1316, PostgreSQLParserRULE_case_arg) p.SetState(9665) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(9663) p.A_expr() } case PostgreSQLParserWHEN: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IColumnrefContext is an interface to support dynamic dispatch. type IColumnrefContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext Indirection() IIndirectionContext // IsColumnrefContext differentiates from other interfaces. IsColumnrefContext() } type ColumnrefContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyColumnrefContext() *ColumnrefContext { var p = new(ColumnrefContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_columnref return p } func InitEmptyColumnrefContext(p *ColumnrefContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_columnref } func (*ColumnrefContext) IsColumnrefContext() {} func NewColumnrefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnrefContext { var p = new(ColumnrefContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_columnref return p } func (s *ColumnrefContext) GetParser() antlr.Parser { return s.parser } func (s *ColumnrefContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *ColumnrefContext) Indirection() IIndirectionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndirectionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIndirectionContext) } func (s *ColumnrefContext) GetRuleContext() antlr.RuleContext { return s } func (s *ColumnrefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ColumnrefContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterColumnref(s) } } func (s *ColumnrefContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitColumnref(s) } } func (s *ColumnrefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitColumnref(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Columnref() (localctx IColumnrefContext) { localctx = NewColumnrefContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1318, PostgreSQLParserRULE_columnref) p.EnterOuterAlt(localctx, 1) { p.SetState(9667) p.Colid() } p.SetState(9669) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 634, p.GetParserRuleContext()) == 1 { { p.SetState(9668) p.Indirection() } } else if p.HasError() { // JIM goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IIndirection_elContext is an interface to support dynamic dispatch. type IIndirection_elContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DOT() antlr.TerminalNode Attr_name() IAttr_nameContext STAR() antlr.TerminalNode OPEN_BRACKET() antlr.TerminalNode CLOSE_BRACKET() antlr.TerminalNode A_expr() IA_exprContext AllOpt_slice_bound() []IOpt_slice_boundContext Opt_slice_bound(i int) IOpt_slice_boundContext COLON() antlr.TerminalNode // IsIndirection_elContext differentiates from other interfaces. IsIndirection_elContext() } type Indirection_elContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyIndirection_elContext() *Indirection_elContext { var p = new(Indirection_elContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_indirection_el return p } func InitEmptyIndirection_elContext(p *Indirection_elContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_indirection_el } func (*Indirection_elContext) IsIndirection_elContext() {} func NewIndirection_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Indirection_elContext { var p = new(Indirection_elContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_indirection_el return p } func (s *Indirection_elContext) GetParser() antlr.Parser { return s.parser } func (s *Indirection_elContext) DOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOT, 0) } func (s *Indirection_elContext) Attr_name() IAttr_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAttr_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAttr_nameContext) } func (s *Indirection_elContext) STAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTAR, 0) } func (s *Indirection_elContext) OPEN_BRACKET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_BRACKET, 0) } func (s *Indirection_elContext) CLOSE_BRACKET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_BRACKET, 0) } func (s *Indirection_elContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Indirection_elContext) AllOpt_slice_bound() []IOpt_slice_boundContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IOpt_slice_boundContext); ok { len++ } } tst := make([]IOpt_slice_boundContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IOpt_slice_boundContext); ok { tst[i] = t.(IOpt_slice_boundContext) i++ } } return tst } func (s *Indirection_elContext) Opt_slice_bound(i int) IOpt_slice_boundContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_slice_boundContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IOpt_slice_boundContext) } func (s *Indirection_elContext) COLON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLON, 0) } func (s *Indirection_elContext) GetRuleContext() antlr.RuleContext { return s } func (s *Indirection_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Indirection_elContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterIndirection_el(s) } } func (s *Indirection_elContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitIndirection_el(s) } } func (s *Indirection_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitIndirection_el(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Indirection_el() (localctx IIndirection_elContext) { localctx = NewIndirection_elContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1320, PostgreSQLParserRULE_indirection_el) p.SetState(9686) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserDOT: p.EnterOuterAlt(localctx, 1) { p.SetState(9671) p.Match(PostgreSQLParserDOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9674) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserALL, PostgreSQLParserANALYSE, PostgreSQLParserANALYZE, PostgreSQLParserAND, PostgreSQLParserANY, PostgreSQLParserARRAY, PostgreSQLParserAS, PostgreSQLParserASC, PostgreSQLParserASYMMETRIC, PostgreSQLParserBOTH, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCHECK, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCREATE, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDEFERRABLE, PostgreSQLParserDESC, PostgreSQLParserDISTINCT, PostgreSQLParserDO, PostgreSQLParserELSE, PostgreSQLParserEXCEPT, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserFOR, PostgreSQLParserFOREIGN, PostgreSQLParserFROM, PostgreSQLParserGRANT, PostgreSQLParserGROUP_P, PostgreSQLParserHAVING, PostgreSQLParserIN_P, PostgreSQLParserINITIALLY, PostgreSQLParserINTERSECT, PostgreSQLParserLATERAL_P, PostgreSQLParserLEADING, PostgreSQLParserLIMIT, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserOFFSET, PostgreSQLParserON, PostgreSQLParserONLY, PostgreSQLParserOR, PostgreSQLParserORDER, PostgreSQLParserPLACING, PostgreSQLParserPRIMARY, PostgreSQLParserREFERENCES, PostgreSQLParserRETURNING, PostgreSQLParserSELECT, PostgreSQLParserSESSION_USER, PostgreSQLParserSOME, PostgreSQLParserSYMMETRIC, PostgreSQLParserTABLE, PostgreSQLParserTHEN, PostgreSQLParserTO, PostgreSQLParserTRAILING, PostgreSQLParserTRUE_P, PostgreSQLParserUNION, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserUSING, PostgreSQLParserVARIADIC, PostgreSQLParserWHEN, PostgreSQLParserWHERE, PostgreSQLParserWINDOW, PostgreSQLParserWITH, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserEND_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: { p.SetState(9672) p.Attr_name() } case PostgreSQLParserSTAR: { p.SetState(9673) p.Match(PostgreSQLParserSTAR) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case PostgreSQLParserOPEN_BRACKET: p.EnterOuterAlt(localctx, 2) { p.SetState(9676) p.Match(PostgreSQLParserOPEN_BRACKET) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9682) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 636, p.GetParserRuleContext()) { case 1: { p.SetState(9677) p.A_expr() } case 2: { p.SetState(9678) p.Opt_slice_bound() } { p.SetState(9679) p.Match(PostgreSQLParserCOLON) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9680) p.Opt_slice_bound() } case antlr.ATNInvalidAltNumber: goto errorExit } { p.SetState(9684) p.Match(PostgreSQLParserCLOSE_BRACKET) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_slice_boundContext is an interface to support dynamic dispatch. type IOpt_slice_boundContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr() IA_exprContext // IsOpt_slice_boundContext differentiates from other interfaces. IsOpt_slice_boundContext() } type Opt_slice_boundContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_slice_boundContext() *Opt_slice_boundContext { var p = new(Opt_slice_boundContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_slice_bound return p } func InitEmptyOpt_slice_boundContext(p *Opt_slice_boundContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_slice_bound } func (*Opt_slice_boundContext) IsOpt_slice_boundContext() {} func NewOpt_slice_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_slice_boundContext { var p = new(Opt_slice_boundContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_slice_bound return p } func (s *Opt_slice_boundContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_slice_boundContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Opt_slice_boundContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_slice_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_slice_boundContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_slice_bound(s) } } func (s *Opt_slice_boundContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_slice_bound(s) } } func (s *Opt_slice_boundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_slice_bound(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_slice_bound() (localctx IOpt_slice_boundContext) { localctx = NewOpt_slice_boundContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1322, PostgreSQLParserRULE_opt_slice_bound) p.SetState(9690) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(9688) p.A_expr() } case PostgreSQLParserCLOSE_BRACKET, PostgreSQLParserCOLON: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IIndirectionContext is an interface to support dynamic dispatch. type IIndirectionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllIndirection_el() []IIndirection_elContext Indirection_el(i int) IIndirection_elContext // IsIndirectionContext differentiates from other interfaces. IsIndirectionContext() } type IndirectionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyIndirectionContext() *IndirectionContext { var p = new(IndirectionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_indirection return p } func InitEmptyIndirectionContext(p *IndirectionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_indirection } func (*IndirectionContext) IsIndirectionContext() {} func NewIndirectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndirectionContext { var p = new(IndirectionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_indirection return p } func (s *IndirectionContext) GetParser() antlr.Parser { return s.parser } func (s *IndirectionContext) AllIndirection_el() []IIndirection_elContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IIndirection_elContext); ok { len++ } } tst := make([]IIndirection_elContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IIndirection_elContext); ok { tst[i] = t.(IIndirection_elContext) i++ } } return tst } func (s *IndirectionContext) Indirection_el(i int) IIndirection_elContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndirection_elContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IIndirection_elContext) } func (s *IndirectionContext) GetRuleContext() antlr.RuleContext { return s } func (s *IndirectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *IndirectionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterIndirection(s) } } func (s *IndirectionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitIndirection(s) } } func (s *IndirectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitIndirection(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Indirection() (localctx IIndirectionContext) { localctx = NewIndirectionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1324, PostgreSQLParserRULE_indirection) var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(9693) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = 1 for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { switch _alt { case 1: { p.SetState(9692) p.Indirection_el() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.SetState(9695) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 639, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_indirectionContext is an interface to support dynamic dispatch. type IOpt_indirectionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllIndirection_el() []IIndirection_elContext Indirection_el(i int) IIndirection_elContext // IsOpt_indirectionContext differentiates from other interfaces. IsOpt_indirectionContext() } type Opt_indirectionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_indirectionContext() *Opt_indirectionContext { var p = new(Opt_indirectionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_indirection return p } func InitEmptyOpt_indirectionContext(p *Opt_indirectionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_indirection } func (*Opt_indirectionContext) IsOpt_indirectionContext() {} func NewOpt_indirectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_indirectionContext { var p = new(Opt_indirectionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_indirection return p } func (s *Opt_indirectionContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_indirectionContext) AllIndirection_el() []IIndirection_elContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IIndirection_elContext); ok { len++ } } tst := make([]IIndirection_elContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IIndirection_elContext); ok { tst[i] = t.(IIndirection_elContext) i++ } } return tst } func (s *Opt_indirectionContext) Indirection_el(i int) IIndirection_elContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndirection_elContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IIndirection_elContext) } func (s *Opt_indirectionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_indirectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_indirectionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_indirection(s) } } func (s *Opt_indirectionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_indirection(s) } } func (s *Opt_indirectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_indirection(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_indirection() (localctx IOpt_indirectionContext) { localctx = NewOpt_indirectionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1326, PostgreSQLParserRULE_opt_indirection) var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(9700) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 640, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(9697) p.Indirection_el() } } p.SetState(9702) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 640, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_target_listContext is an interface to support dynamic dispatch. type IOpt_target_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Target_list() ITarget_listContext // IsOpt_target_listContext differentiates from other interfaces. IsOpt_target_listContext() } type Opt_target_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_target_listContext() *Opt_target_listContext { var p = new(Opt_target_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_target_list return p } func InitEmptyOpt_target_listContext(p *Opt_target_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_target_list } func (*Opt_target_listContext) IsOpt_target_listContext() {} func NewOpt_target_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_target_listContext { var p = new(Opt_target_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_target_list return p } func (s *Opt_target_listContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_target_listContext) Target_list() ITarget_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITarget_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITarget_listContext) } func (s *Opt_target_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_target_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_target_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_target_list(s) } } func (s *Opt_target_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_target_list(s) } } func (s *Opt_target_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_target_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_target_list() (localctx IOpt_target_listContext) { localctx = NewOpt_target_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1328, PostgreSQLParserRULE_opt_target_list) p.SetState(9705) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 641, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9703) p.Target_list() } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITarget_listContext is an interface to support dynamic dispatch. type ITarget_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllTarget_el() []ITarget_elContext Target_el(i int) ITarget_elContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsTarget_listContext differentiates from other interfaces. IsTarget_listContext() } type Target_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTarget_listContext() *Target_listContext { var p = new(Target_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_target_list return p } func InitEmptyTarget_listContext(p *Target_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_target_list } func (*Target_listContext) IsTarget_listContext() {} func NewTarget_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Target_listContext { var p = new(Target_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_target_list return p } func (s *Target_listContext) GetParser() antlr.Parser { return s.parser } func (s *Target_listContext) AllTarget_el() []ITarget_elContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ITarget_elContext); ok { len++ } } tst := make([]ITarget_elContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ITarget_elContext); ok { tst[i] = t.(ITarget_elContext) i++ } } return tst } func (s *Target_listContext) Target_el(i int) ITarget_elContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITarget_elContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ITarget_elContext) } func (s *Target_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Target_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Target_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Target_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Target_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTarget_list(s) } } func (s *Target_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTarget_list(s) } } func (s *Target_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTarget_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Target_list() (localctx ITarget_listContext) { localctx = NewTarget_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1330, PostgreSQLParserRULE_target_list) var _alt int p.EnterOuterAlt(localctx, 1) { p.SetState(9707) p.Target_el() } p.SetState(9712) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 642, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(9708) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9709) p.Target_el() } } p.SetState(9714) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 642, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITarget_elContext is an interface to support dynamic dispatch. type ITarget_elContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsTarget_elContext differentiates from other interfaces. IsTarget_elContext() } type Target_elContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTarget_elContext() *Target_elContext { var p = new(Target_elContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_target_el return p } func InitEmptyTarget_elContext(p *Target_elContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_target_el } func (*Target_elContext) IsTarget_elContext() {} func NewTarget_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Target_elContext { var p = new(Target_elContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_target_el return p } func (s *Target_elContext) GetParser() antlr.Parser { return s.parser } func (s *Target_elContext) CopyAll(ctx *Target_elContext) { s.CopyFrom(&ctx.BaseParserRuleContext) } func (s *Target_elContext) GetRuleContext() antlr.RuleContext { return s } func (s *Target_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } type Target_labelContext struct { Target_elContext } func NewTarget_labelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Target_labelContext { var p = new(Target_labelContext) InitEmptyTarget_elContext(&p.Target_elContext) p.parser = parser p.CopyAll(ctx.(*Target_elContext)) return p } func (s *Target_labelContext) GetRuleContext() antlr.RuleContext { return s } func (s *Target_labelContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Target_labelContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Target_labelContext) Collabel() ICollabelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICollabelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICollabelContext) } func (s *Target_labelContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *Target_labelContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTarget_label(s) } } func (s *Target_labelContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTarget_label(s) } } func (s *Target_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTarget_label(s) default: return t.VisitChildren(s) } } type Target_starContext struct { Target_elContext } func NewTarget_starContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Target_starContext { var p = new(Target_starContext) InitEmptyTarget_elContext(&p.Target_elContext) p.parser = parser p.CopyAll(ctx.(*Target_elContext)) return p } func (s *Target_starContext) GetRuleContext() antlr.RuleContext { return s } func (s *Target_starContext) STAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTAR, 0) } func (s *Target_starContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTarget_star(s) } } func (s *Target_starContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTarget_star(s) } } func (s *Target_starContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTarget_star(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Target_el() (localctx ITarget_elContext) { localctx = NewTarget_elContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1332, PostgreSQLParserRULE_target_el) p.SetState(9723) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: localctx = NewTarget_labelContext(p, localctx) p.EnterOuterAlt(localctx, 1) { p.SetState(9715) p.A_expr() } p.SetState(9720) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 643, p.GetParserRuleContext()) { case 1: { p.SetState(9716) p.Match(PostgreSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9717) p.Collabel() } case 2: { p.SetState(9718) p.Identifier() } case 3: case antlr.ATNInvalidAltNumber: goto errorExit } case PostgreSQLParserSTAR: localctx = NewTarget_starContext(p, localctx) p.EnterOuterAlt(localctx, 2) { p.SetState(9722) p.Match(PostgreSQLParserSTAR) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IQualified_name_listContext is an interface to support dynamic dispatch. type IQualified_name_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllQualified_name() []IQualified_nameContext Qualified_name(i int) IQualified_nameContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsQualified_name_listContext differentiates from other interfaces. IsQualified_name_listContext() } type Qualified_name_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyQualified_name_listContext() *Qualified_name_listContext { var p = new(Qualified_name_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_qualified_name_list return p } func InitEmptyQualified_name_listContext(p *Qualified_name_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_qualified_name_list } func (*Qualified_name_listContext) IsQualified_name_listContext() {} func NewQualified_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_name_listContext { var p = new(Qualified_name_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_qualified_name_list return p } func (s *Qualified_name_listContext) GetParser() antlr.Parser { return s.parser } func (s *Qualified_name_listContext) AllQualified_name() []IQualified_nameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IQualified_nameContext); ok { len++ } } tst := make([]IQualified_nameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IQualified_nameContext); ok { tst[i] = t.(IQualified_nameContext) i++ } } return tst } func (s *Qualified_name_listContext) Qualified_name(i int) IQualified_nameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQualified_nameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IQualified_nameContext) } func (s *Qualified_name_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Qualified_name_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Qualified_name_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Qualified_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Qualified_name_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterQualified_name_list(s) } } func (s *Qualified_name_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitQualified_name_list(s) } } func (s *Qualified_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitQualified_name_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Qualified_name_list() (localctx IQualified_name_listContext) { localctx = NewQualified_name_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1334, PostgreSQLParserRULE_qualified_name_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9725) p.Qualified_name() } p.SetState(9730) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(9726) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9727) p.Qualified_name() } p.SetState(9732) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IQualified_nameContext is an interface to support dynamic dispatch. type IQualified_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext Indirection() IIndirectionContext // IsQualified_nameContext differentiates from other interfaces. IsQualified_nameContext() } type Qualified_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyQualified_nameContext() *Qualified_nameContext { var p = new(Qualified_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_qualified_name return p } func InitEmptyQualified_nameContext(p *Qualified_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_qualified_name } func (*Qualified_nameContext) IsQualified_nameContext() {} func NewQualified_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_nameContext { var p = new(Qualified_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_qualified_name return p } func (s *Qualified_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Qualified_nameContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Qualified_nameContext) Indirection() IIndirectionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndirectionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIndirectionContext) } func (s *Qualified_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Qualified_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Qualified_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterQualified_name(s) } } func (s *Qualified_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitQualified_name(s) } } func (s *Qualified_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitQualified_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Qualified_name() (localctx IQualified_nameContext) { localctx = NewQualified_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1336, PostgreSQLParserRULE_qualified_name) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9733) p.Colid() } p.SetState(9735) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserOPEN_BRACKET || _la == PostgreSQLParserDOT { { p.SetState(9734) p.Indirection() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IName_listContext is an interface to support dynamic dispatch. type IName_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllName() []INameContext Name(i int) INameContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsName_listContext differentiates from other interfaces. IsName_listContext() } type Name_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyName_listContext() *Name_listContext { var p = new(Name_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_name_list return p } func InitEmptyName_listContext(p *Name_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_name_list } func (*Name_listContext) IsName_listContext() {} func NewName_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Name_listContext { var p = new(Name_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_name_list return p } func (s *Name_listContext) GetParser() antlr.Parser { return s.parser } func (s *Name_listContext) AllName() []INameContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(INameContext); ok { len++ } } tst := make([]INameContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(INameContext); ok { tst[i] = t.(INameContext) i++ } } return tst } func (s *Name_listContext) Name(i int) INameContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(INameContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(INameContext) } func (s *Name_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Name_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Name_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Name_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterName_list(s) } } func (s *Name_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitName_list(s) } } func (s *Name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitName_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Name_list() (localctx IName_listContext) { localctx = NewName_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1338, PostgreSQLParserRULE_name_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9737) p.Name() } p.SetState(9742) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(9738) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9739) p.Name() } p.SetState(9744) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // INameContext is an interface to support dynamic dispatch. type INameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext // IsNameContext differentiates from other interfaces. IsNameContext() } type NameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyNameContext() *NameContext { var p = new(NameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_name return p } func InitEmptyNameContext(p *NameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_name } func (*NameContext) IsNameContext() {} func NewNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NameContext { var p = new(NameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_name return p } func (s *NameContext) GetParser() antlr.Parser { return s.parser } func (s *NameContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *NameContext) GetRuleContext() antlr.RuleContext { return s } func (s *NameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *NameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterName(s) } } func (s *NameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitName(s) } } func (s *NameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitName(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Name() (localctx INameContext) { localctx = NewNameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1340, PostgreSQLParserRULE_name) p.EnterOuterAlt(localctx, 1) { p.SetState(9745) p.Colid() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAttr_nameContext is an interface to support dynamic dispatch. type IAttr_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Collabel() ICollabelContext // IsAttr_nameContext differentiates from other interfaces. IsAttr_nameContext() } type Attr_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAttr_nameContext() *Attr_nameContext { var p = new(Attr_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_attr_name return p } func InitEmptyAttr_nameContext(p *Attr_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_attr_name } func (*Attr_nameContext) IsAttr_nameContext() {} func NewAttr_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attr_nameContext { var p = new(Attr_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_attr_name return p } func (s *Attr_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Attr_nameContext) Collabel() ICollabelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICollabelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICollabelContext) } func (s *Attr_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Attr_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Attr_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAttr_name(s) } } func (s *Attr_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAttr_name(s) } } func (s *Attr_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAttr_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Attr_name() (localctx IAttr_nameContext) { localctx = NewAttr_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1342, PostgreSQLParserRULE_attr_name) p.EnterOuterAlt(localctx, 1) { p.SetState(9747) p.Collabel() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFile_nameContext is an interface to support dynamic dispatch. type IFile_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sconst() ISconstContext // IsFile_nameContext differentiates from other interfaces. IsFile_nameContext() } type File_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFile_nameContext() *File_nameContext { var p = new(File_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_file_name return p } func InitEmptyFile_nameContext(p *File_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_file_name } func (*File_nameContext) IsFile_nameContext() {} func NewFile_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_nameContext { var p = new(File_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_file_name return p } func (s *File_nameContext) GetParser() antlr.Parser { return s.parser } func (s *File_nameContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *File_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *File_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *File_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFile_name(s) } } func (s *File_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFile_name(s) } } func (s *File_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFile_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) File_name() (localctx IFile_nameContext) { localctx = NewFile_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1344, PostgreSQLParserRULE_file_name) p.EnterOuterAlt(localctx, 1) { p.SetState(9749) p.Sconst() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFunc_nameContext is an interface to support dynamic dispatch. type IFunc_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Builtin_function_name() IBuiltin_function_nameContext Type_function_name() IType_function_nameContext Colid() IColidContext Indirection() IIndirectionContext LEFT() antlr.TerminalNode RIGHT() antlr.TerminalNode // IsFunc_nameContext differentiates from other interfaces. IsFunc_nameContext() } type Func_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFunc_nameContext() *Func_nameContext { var p = new(Func_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_name return p } func InitEmptyFunc_nameContext(p *Func_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_func_name } func (*Func_nameContext) IsFunc_nameContext() {} func NewFunc_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_nameContext { var p = new(Func_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_func_name return p } func (s *Func_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Func_nameContext) Builtin_function_name() IBuiltin_function_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IBuiltin_function_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IBuiltin_function_nameContext) } func (s *Func_nameContext) Type_function_name() IType_function_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IType_function_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IType_function_nameContext) } func (s *Func_nameContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Func_nameContext) Indirection() IIndirectionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIndirectionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIndirectionContext) } func (s *Func_nameContext) LEFT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEFT, 0) } func (s *Func_nameContext) RIGHT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRIGHT, 0) } func (s *Func_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Func_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Func_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFunc_name(s) } } func (s *Func_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFunc_name(s) } } func (s *Func_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFunc_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Func_name() (localctx IFunc_nameContext) { localctx = NewFunc_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1346, PostgreSQLParserRULE_func_name) p.SetState(9758) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 648, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9751) p.Builtin_function_name() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9752) p.Type_function_name() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9753) p.Colid() } { p.SetState(9754) p.Indirection() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(9756) p.Match(PostgreSQLParserLEFT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(9757) p.Match(PostgreSQLParserRIGHT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAexprconstContext is an interface to support dynamic dispatch. type IAexprconstContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Iconst() IIconstContext Fconst() IFconstContext Sconst() ISconstContext Bconst() IBconstContext Xconst() IXconstContext Func_name() IFunc_nameContext OPEN_PAREN() antlr.TerminalNode Func_arg_list() IFunc_arg_listContext Opt_sort_clause() IOpt_sort_clauseContext CLOSE_PAREN() antlr.TerminalNode Consttypename() IConsttypenameContext Constinterval() IConstintervalContext Opt_interval() IOpt_intervalContext TRUE_P() antlr.TerminalNode FALSE_P() antlr.TerminalNode NULL_P() antlr.TerminalNode // IsAexprconstContext differentiates from other interfaces. IsAexprconstContext() } type AexprconstContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAexprconstContext() *AexprconstContext { var p = new(AexprconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_aexprconst return p } func InitEmptyAexprconstContext(p *AexprconstContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_aexprconst } func (*AexprconstContext) IsAexprconstContext() {} func NewAexprconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AexprconstContext { var p = new(AexprconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_aexprconst return p } func (s *AexprconstContext) GetParser() antlr.Parser { return s.parser } func (s *AexprconstContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *AexprconstContext) Fconst() IFconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFconstContext) } func (s *AexprconstContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *AexprconstContext) Bconst() IBconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IBconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IBconstContext) } func (s *AexprconstContext) Xconst() IXconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IXconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IXconstContext) } func (s *AexprconstContext) Func_name() IFunc_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_nameContext) } func (s *AexprconstContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *AexprconstContext) Func_arg_list() IFunc_arg_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFunc_arg_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFunc_arg_listContext) } func (s *AexprconstContext) Opt_sort_clause() IOpt_sort_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_sort_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_sort_clauseContext) } func (s *AexprconstContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *AexprconstContext) Consttypename() IConsttypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConsttypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConsttypenameContext) } func (s *AexprconstContext) Constinterval() IConstintervalContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IConstintervalContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IConstintervalContext) } func (s *AexprconstContext) Opt_interval() IOpt_intervalContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_intervalContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_intervalContext) } func (s *AexprconstContext) TRUE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRUE_P, 0) } func (s *AexprconstContext) FALSE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFALSE_P, 0) } func (s *AexprconstContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *AexprconstContext) GetRuleContext() antlr.RuleContext { return s } func (s *AexprconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AexprconstContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAexprconst(s) } } func (s *AexprconstContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAexprconst(s) } } func (s *AexprconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAexprconst(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Aexprconst() (localctx IAexprconstContext) { localctx = NewAexprconstContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1348, PostgreSQLParserRULE_aexprconst) p.SetState(9792) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 651, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9760) p.Iconst() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9761) p.Fconst() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9762) p.Sconst() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(9763) p.Bconst() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(9764) p.Xconst() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(9765) p.Func_name() } p.SetState(9773) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: { p.SetState(9766) p.Sconst() } case PostgreSQLParserOPEN_PAREN: { p.SetState(9767) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9768) p.Func_arg_list() } { p.SetState(9769) p.Opt_sort_clause() } { p.SetState(9770) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9771) p.Sconst() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(9775) p.Consttypename() } { p.SetState(9776) p.Sconst() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(9778) p.Constinterval() } p.SetState(9787) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserEscapeStringConstant: { p.SetState(9779) p.Sconst() } { p.SetState(9780) p.Opt_interval() } case PostgreSQLParserOPEN_PAREN: { p.SetState(9782) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9783) p.Iconst() } { p.SetState(9784) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9785) p.Sconst() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(9789) p.Match(PostgreSQLParserTRUE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(9790) p.Match(PostgreSQLParserFALSE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(9791) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IXconstContext is an interface to support dynamic dispatch. type IXconstContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures HexadecimalStringConstant() antlr.TerminalNode // IsXconstContext differentiates from other interfaces. IsXconstContext() } type XconstContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyXconstContext() *XconstContext { var p = new(XconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xconst return p } func InitEmptyXconstContext(p *XconstContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_xconst } func (*XconstContext) IsXconstContext() {} func NewXconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XconstContext { var p = new(XconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_xconst return p } func (s *XconstContext) GetParser() antlr.Parser { return s.parser } func (s *XconstContext) HexadecimalStringConstant() antlr.TerminalNode { return s.GetToken(PostgreSQLParserHexadecimalStringConstant, 0) } func (s *XconstContext) GetRuleContext() antlr.RuleContext { return s } func (s *XconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *XconstContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterXconst(s) } } func (s *XconstContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitXconst(s) } } func (s *XconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitXconst(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Xconst() (localctx IXconstContext) { localctx = NewXconstContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1350, PostgreSQLParserRULE_xconst) p.EnterOuterAlt(localctx, 1) { p.SetState(9794) p.Match(PostgreSQLParserHexadecimalStringConstant) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IBconstContext is an interface to support dynamic dispatch. type IBconstContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures BinaryStringConstant() antlr.TerminalNode // IsBconstContext differentiates from other interfaces. IsBconstContext() } type BconstContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyBconstContext() *BconstContext { var p = new(BconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_bconst return p } func InitEmptyBconstContext(p *BconstContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_bconst } func (*BconstContext) IsBconstContext() {} func NewBconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BconstContext { var p = new(BconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_bconst return p } func (s *BconstContext) GetParser() antlr.Parser { return s.parser } func (s *BconstContext) BinaryStringConstant() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBinaryStringConstant, 0) } func (s *BconstContext) GetRuleContext() antlr.RuleContext { return s } func (s *BconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *BconstContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterBconst(s) } } func (s *BconstContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitBconst(s) } } func (s *BconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitBconst(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Bconst() (localctx IBconstContext) { localctx = NewBconstContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1352, PostgreSQLParserRULE_bconst) p.EnterOuterAlt(localctx, 1) { p.SetState(9796) p.Match(PostgreSQLParserBinaryStringConstant) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFconstContext is an interface to support dynamic dispatch. type IFconstContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Numeric() antlr.TerminalNode // IsFconstContext differentiates from other interfaces. IsFconstContext() } type FconstContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFconstContext() *FconstContext { var p = new(FconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_fconst return p } func InitEmptyFconstContext(p *FconstContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_fconst } func (*FconstContext) IsFconstContext() {} func NewFconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FconstContext { var p = new(FconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_fconst return p } func (s *FconstContext) GetParser() antlr.Parser { return s.parser } func (s *FconstContext) Numeric() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNumeric, 0) } func (s *FconstContext) GetRuleContext() antlr.RuleContext { return s } func (s *FconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *FconstContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFconst(s) } } func (s *FconstContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFconst(s) } } func (s *FconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFconst(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Fconst() (localctx IFconstContext) { localctx = NewFconstContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1354, PostgreSQLParserRULE_fconst) p.EnterOuterAlt(localctx, 1) { p.SetState(9798) p.Match(PostgreSQLParserNumeric) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IIconstContext is an interface to support dynamic dispatch. type IIconstContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Integral() antlr.TerminalNode // IsIconstContext differentiates from other interfaces. IsIconstContext() } type IconstContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyIconstContext() *IconstContext { var p = new(IconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_iconst return p } func InitEmptyIconstContext(p *IconstContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_iconst } func (*IconstContext) IsIconstContext() {} func NewIconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IconstContext { var p = new(IconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_iconst return p } func (s *IconstContext) GetParser() antlr.Parser { return s.parser } func (s *IconstContext) Integral() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIntegral, 0) } func (s *IconstContext) GetRuleContext() antlr.RuleContext { return s } func (s *IconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *IconstContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterIconst(s) } } func (s *IconstContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitIconst(s) } } func (s *IconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitIconst(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Iconst() (localctx IIconstContext) { localctx = NewIconstContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1356, PostgreSQLParserRULE_iconst) p.EnterOuterAlt(localctx, 1) { p.SetState(9800) p.Match(PostgreSQLParserIntegral) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISconstContext is an interface to support dynamic dispatch. type ISconstContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Anysconst() IAnysconstContext Opt_uescape() IOpt_uescapeContext // IsSconstContext differentiates from other interfaces. IsSconstContext() } type SconstContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySconstContext() *SconstContext { var p = new(SconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_sconst return p } func InitEmptySconstContext(p *SconstContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_sconst } func (*SconstContext) IsSconstContext() {} func NewSconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SconstContext { var p = new(SconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_sconst return p } func (s *SconstContext) GetParser() antlr.Parser { return s.parser } func (s *SconstContext) Anysconst() IAnysconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAnysconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAnysconstContext) } func (s *SconstContext) Opt_uescape() IOpt_uescapeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_uescapeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_uescapeContext) } func (s *SconstContext) GetRuleContext() antlr.RuleContext { return s } func (s *SconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SconstContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSconst(s) } } func (s *SconstContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSconst(s) } } func (s *SconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSconst(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Sconst() (localctx ISconstContext) { localctx = NewSconstContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1358, PostgreSQLParserRULE_sconst) p.EnterOuterAlt(localctx, 1) { p.SetState(9802) p.Anysconst() } { p.SetState(9803) p.Opt_uescape() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAnysconstContext is an interface to support dynamic dispatch. type IAnysconstContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures StringConstant() antlr.TerminalNode UnicodeEscapeStringConstant() antlr.TerminalNode BeginDollarStringConstant() antlr.TerminalNode EndDollarStringConstant() antlr.TerminalNode AllDollarText() []antlr.TerminalNode DollarText(i int) antlr.TerminalNode EscapeStringConstant() antlr.TerminalNode // IsAnysconstContext differentiates from other interfaces. IsAnysconstContext() } type AnysconstContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAnysconstContext() *AnysconstContext { var p = new(AnysconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_anysconst return p } func InitEmptyAnysconstContext(p *AnysconstContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_anysconst } func (*AnysconstContext) IsAnysconstContext() {} func NewAnysconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnysconstContext { var p = new(AnysconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_anysconst return p } func (s *AnysconstContext) GetParser() antlr.Parser { return s.parser } func (s *AnysconstContext) StringConstant() antlr.TerminalNode { return s.GetToken(PostgreSQLParserStringConstant, 0) } func (s *AnysconstContext) UnicodeEscapeStringConstant() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUnicodeEscapeStringConstant, 0) } func (s *AnysconstContext) BeginDollarStringConstant() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBeginDollarStringConstant, 0) } func (s *AnysconstContext) EndDollarStringConstant() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEndDollarStringConstant, 0) } func (s *AnysconstContext) AllDollarText() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserDollarText) } func (s *AnysconstContext) DollarText(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserDollarText, i) } func (s *AnysconstContext) EscapeStringConstant() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEscapeStringConstant, 0) } func (s *AnysconstContext) GetRuleContext() antlr.RuleContext { return s } func (s *AnysconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AnysconstContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAnysconst(s) } } func (s *AnysconstContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAnysconst(s) } } func (s *AnysconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAnysconst(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Anysconst() (localctx IAnysconstContext) { localctx = NewAnysconstContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1360, PostgreSQLParserRULE_anysconst) var _la int p.SetState(9816) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserStringConstant: p.EnterOuterAlt(localctx, 1) { p.SetState(9805) p.Match(PostgreSQLParserStringConstant) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserUnicodeEscapeStringConstant: p.EnterOuterAlt(localctx, 2) { p.SetState(9806) p.Match(PostgreSQLParserUnicodeEscapeStringConstant) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserBeginDollarStringConstant: p.EnterOuterAlt(localctx, 3) { p.SetState(9807) p.Match(PostgreSQLParserBeginDollarStringConstant) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9811) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserDollarText { { p.SetState(9808) p.Match(PostgreSQLParserDollarText) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(9813) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } { p.SetState(9814) p.Match(PostgreSQLParserEndDollarStringConstant) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 4) { p.SetState(9815) p.Match(PostgreSQLParserEscapeStringConstant) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_uescapeContext is an interface to support dynamic dispatch. type IOpt_uescapeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures UESCAPE() antlr.TerminalNode Anysconst() IAnysconstContext // IsOpt_uescapeContext differentiates from other interfaces. IsOpt_uescapeContext() } type Opt_uescapeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_uescapeContext() *Opt_uescapeContext { var p = new(Opt_uescapeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_uescape return p } func InitEmptyOpt_uescapeContext(p *Opt_uescapeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_uescape } func (*Opt_uescapeContext) IsOpt_uescapeContext() {} func NewOpt_uescapeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_uescapeContext { var p = new(Opt_uescapeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_uescape return p } func (s *Opt_uescapeContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_uescapeContext) UESCAPE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUESCAPE, 0) } func (s *Opt_uescapeContext) Anysconst() IAnysconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAnysconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAnysconstContext) } func (s *Opt_uescapeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_uescapeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_uescapeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_uescape(s) } } func (s *Opt_uescapeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_uescape(s) } } func (s *Opt_uescapeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_uescape(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_uescape() (localctx IOpt_uescapeContext) { localctx = NewOpt_uescapeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1362, PostgreSQLParserRULE_opt_uescape) p.SetState(9821) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 654, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9818) p.Match(PostgreSQLParserUESCAPE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9819) p.Anysconst() } case 2: p.EnterOuterAlt(localctx, 2) case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISignediconstContext is an interface to support dynamic dispatch. type ISignediconstContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Iconst() IIconstContext PLUS() antlr.TerminalNode MINUS() antlr.TerminalNode // IsSignediconstContext differentiates from other interfaces. IsSignediconstContext() } type SignediconstContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySignediconstContext() *SignediconstContext { var p = new(SignediconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_signediconst return p } func InitEmptySignediconstContext(p *SignediconstContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_signediconst } func (*SignediconstContext) IsSignediconstContext() {} func NewSignediconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SignediconstContext { var p = new(SignediconstContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_signediconst return p } func (s *SignediconstContext) GetParser() antlr.Parser { return s.parser } func (s *SignediconstContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *SignediconstContext) PLUS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPLUS, 0) } func (s *SignediconstContext) MINUS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMINUS, 0) } func (s *SignediconstContext) GetRuleContext() antlr.RuleContext { return s } func (s *SignediconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SignediconstContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSignediconst(s) } } func (s *SignediconstContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSignediconst(s) } } func (s *SignediconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSignediconst(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Signediconst() (localctx ISignediconstContext) { localctx = NewSignediconstContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1364, PostgreSQLParserRULE_signediconst) p.SetState(9828) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserIntegral: p.EnterOuterAlt(localctx, 1) { p.SetState(9823) p.Iconst() } case PostgreSQLParserPLUS: p.EnterOuterAlt(localctx, 2) { p.SetState(9824) p.Match(PostgreSQLParserPLUS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9825) p.Iconst() } case PostgreSQLParserMINUS: p.EnterOuterAlt(localctx, 3) { p.SetState(9826) p.Match(PostgreSQLParserMINUS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9827) p.Iconst() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRoleidContext is an interface to support dynamic dispatch. type IRoleidContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Rolespec() IRolespecContext // IsRoleidContext differentiates from other interfaces. IsRoleidContext() } type RoleidContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRoleidContext() *RoleidContext { var p = new(RoleidContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_roleid return p } func InitEmptyRoleidContext(p *RoleidContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_roleid } func (*RoleidContext) IsRoleidContext() {} func NewRoleidContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoleidContext { var p = new(RoleidContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_roleid return p } func (s *RoleidContext) GetParser() antlr.Parser { return s.parser } func (s *RoleidContext) Rolespec() IRolespecContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRolespecContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRolespecContext) } func (s *RoleidContext) GetRuleContext() antlr.RuleContext { return s } func (s *RoleidContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RoleidContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRoleid(s) } } func (s *RoleidContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRoleid(s) } } func (s *RoleidContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRoleid(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Roleid() (localctx IRoleidContext) { localctx = NewRoleidContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1366, PostgreSQLParserRULE_roleid) p.EnterOuterAlt(localctx, 1) { p.SetState(9830) p.Rolespec() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRolespecContext is an interface to support dynamic dispatch. type IRolespecContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Nonreservedword() INonreservedwordContext CURRENT_USER() antlr.TerminalNode SESSION_USER() antlr.TerminalNode // IsRolespecContext differentiates from other interfaces. IsRolespecContext() } type RolespecContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRolespecContext() *RolespecContext { var p = new(RolespecContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rolespec return p } func InitEmptyRolespecContext(p *RolespecContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_rolespec } func (*RolespecContext) IsRolespecContext() {} func NewRolespecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RolespecContext { var p = new(RolespecContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_rolespec return p } func (s *RolespecContext) GetParser() antlr.Parser { return s.parser } func (s *RolespecContext) Nonreservedword() INonreservedwordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INonreservedwordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INonreservedwordContext) } func (s *RolespecContext) CURRENT_USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_USER, 0) } func (s *RolespecContext) SESSION_USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSESSION_USER, 0) } func (s *RolespecContext) GetRuleContext() antlr.RuleContext { return s } func (s *RolespecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RolespecContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRolespec(s) } } func (s *RolespecContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRolespec(s) } } func (s *RolespecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRolespec(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Rolespec() (localctx IRolespecContext) { localctx = NewRolespecContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1368, PostgreSQLParserRULE_rolespec) p.SetState(9835) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(9832) p.Nonreservedword() } case PostgreSQLParserCURRENT_USER: p.EnterOuterAlt(localctx, 2) { p.SetState(9833) p.Match(PostgreSQLParserCURRENT_USER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSESSION_USER: p.EnterOuterAlt(localctx, 3) { p.SetState(9834) p.Match(PostgreSQLParserSESSION_USER) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRole_listContext is an interface to support dynamic dispatch. type IRole_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllRolespec() []IRolespecContext Rolespec(i int) IRolespecContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsRole_listContext differentiates from other interfaces. IsRole_listContext() } type Role_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRole_listContext() *Role_listContext { var p = new(Role_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_role_list return p } func InitEmptyRole_listContext(p *Role_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_role_list } func (*Role_listContext) IsRole_listContext() {} func NewRole_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Role_listContext { var p = new(Role_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_role_list return p } func (s *Role_listContext) GetParser() antlr.Parser { return s.parser } func (s *Role_listContext) AllRolespec() []IRolespecContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IRolespecContext); ok { len++ } } tst := make([]IRolespecContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IRolespecContext); ok { tst[i] = t.(IRolespecContext) i++ } } return tst } func (s *Role_listContext) Rolespec(i int) IRolespecContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRolespecContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IRolespecContext) } func (s *Role_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Role_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Role_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Role_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Role_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterRole_list(s) } } func (s *Role_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitRole_list(s) } } func (s *Role_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitRole_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Role_list() (localctx IRole_listContext) { localctx = NewRole_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1370, PostgreSQLParserRULE_role_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9837) p.Rolespec() } p.SetState(9842) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(9838) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9839) p.Rolespec() } p.SetState(9844) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IColidContext is an interface to support dynamic dispatch. type IColidContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Identifier() IIdentifierContext Unreserved_keyword() IUnreserved_keywordContext Col_name_keyword() ICol_name_keywordContext Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext LEFT() antlr.TerminalNode RIGHT() antlr.TerminalNode // IsColidContext differentiates from other interfaces. IsColidContext() } type ColidContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyColidContext() *ColidContext { var p = new(ColidContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_colid return p } func InitEmptyColidContext(p *ColidContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_colid } func (*ColidContext) IsColidContext() {} func NewColidContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColidContext { var p = new(ColidContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_colid return p } func (s *ColidContext) GetParser() antlr.Parser { return s.parser } func (s *ColidContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *ColidContext) Unreserved_keyword() IUnreserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUnreserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUnreserved_keywordContext) } func (s *ColidContext) Col_name_keyword() ICol_name_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICol_name_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICol_name_keywordContext) } func (s *ColidContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPlsql_unreserved_keywordContext) } func (s *ColidContext) LEFT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEFT, 0) } func (s *ColidContext) RIGHT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRIGHT, 0) } func (s *ColidContext) GetRuleContext() antlr.RuleContext { return s } func (s *ColidContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ColidContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterColid(s) } } func (s *ColidContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitColid(s) } } func (s *ColidContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitColid(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Colid() (localctx IColidContext) { localctx = NewColidContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1372, PostgreSQLParserRULE_colid) p.SetState(9851) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 658, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9845) p.Identifier() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9846) p.Unreserved_keyword() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9847) p.Col_name_keyword() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(9848) p.Plsql_unreserved_keyword() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(9849) p.Match(PostgreSQLParserLEFT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(9850) p.Match(PostgreSQLParserRIGHT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ITable_aliasContext is an interface to support dynamic dispatch. type ITable_aliasContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Identifier() IIdentifierContext Unreserved_keyword() IUnreserved_keywordContext Col_name_keyword() ICol_name_keywordContext Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext // IsTable_aliasContext differentiates from other interfaces. IsTable_aliasContext() } type Table_aliasContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyTable_aliasContext() *Table_aliasContext { var p = new(Table_aliasContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_table_alias return p } func InitEmptyTable_aliasContext(p *Table_aliasContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_table_alias } func (*Table_aliasContext) IsTable_aliasContext() {} func NewTable_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_aliasContext { var p = new(Table_aliasContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_table_alias return p } func (s *Table_aliasContext) GetParser() antlr.Parser { return s.parser } func (s *Table_aliasContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *Table_aliasContext) Unreserved_keyword() IUnreserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUnreserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUnreserved_keywordContext) } func (s *Table_aliasContext) Col_name_keyword() ICol_name_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICol_name_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICol_name_keywordContext) } func (s *Table_aliasContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPlsql_unreserved_keywordContext) } func (s *Table_aliasContext) GetRuleContext() antlr.RuleContext { return s } func (s *Table_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Table_aliasContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterTable_alias(s) } } func (s *Table_aliasContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitTable_alias(s) } } func (s *Table_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitTable_alias(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Table_alias() (localctx ITable_aliasContext) { localctx = NewTable_aliasContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1374, PostgreSQLParserRULE_table_alias) p.SetState(9857) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 659, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9853) p.Identifier() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9854) p.Unreserved_keyword() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9855) p.Col_name_keyword() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(9856) p.Plsql_unreserved_keyword() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IType_function_nameContext is an interface to support dynamic dispatch. type IType_function_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Identifier() IIdentifierContext Unreserved_keyword() IUnreserved_keywordContext Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext Type_func_name_keyword() IType_func_name_keywordContext // IsType_function_nameContext differentiates from other interfaces. IsType_function_nameContext() } type Type_function_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyType_function_nameContext() *Type_function_nameContext { var p = new(Type_function_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_type_function_name return p } func InitEmptyType_function_nameContext(p *Type_function_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_type_function_name } func (*Type_function_nameContext) IsType_function_nameContext() {} func NewType_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_function_nameContext { var p = new(Type_function_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_type_function_name return p } func (s *Type_function_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Type_function_nameContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *Type_function_nameContext) Unreserved_keyword() IUnreserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUnreserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUnreserved_keywordContext) } func (s *Type_function_nameContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPlsql_unreserved_keywordContext) } func (s *Type_function_nameContext) Type_func_name_keyword() IType_func_name_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IType_func_name_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IType_func_name_keywordContext) } func (s *Type_function_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Type_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Type_function_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterType_function_name(s) } } func (s *Type_function_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitType_function_name(s) } } func (s *Type_function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitType_function_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Type_function_name() (localctx IType_function_nameContext) { localctx = NewType_function_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1376, PostgreSQLParserRULE_type_function_name) p.SetState(9863) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 660, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9859) p.Identifier() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9860) p.Unreserved_keyword() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9861) p.Plsql_unreserved_keyword() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(9862) p.Type_func_name_keyword() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // INonreservedwordContext is an interface to support dynamic dispatch. type INonreservedwordContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Identifier() IIdentifierContext Unreserved_keyword() IUnreserved_keywordContext Col_name_keyword() ICol_name_keywordContext Type_func_name_keyword() IType_func_name_keywordContext // IsNonreservedwordContext differentiates from other interfaces. IsNonreservedwordContext() } type NonreservedwordContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyNonreservedwordContext() *NonreservedwordContext { var p = new(NonreservedwordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_nonreservedword return p } func InitEmptyNonreservedwordContext(p *NonreservedwordContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_nonreservedword } func (*NonreservedwordContext) IsNonreservedwordContext() {} func NewNonreservedwordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NonreservedwordContext { var p = new(NonreservedwordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_nonreservedword return p } func (s *NonreservedwordContext) GetParser() antlr.Parser { return s.parser } func (s *NonreservedwordContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *NonreservedwordContext) Unreserved_keyword() IUnreserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUnreserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUnreserved_keywordContext) } func (s *NonreservedwordContext) Col_name_keyword() ICol_name_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICol_name_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICol_name_keywordContext) } func (s *NonreservedwordContext) Type_func_name_keyword() IType_func_name_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IType_func_name_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IType_func_name_keywordContext) } func (s *NonreservedwordContext) GetRuleContext() antlr.RuleContext { return s } func (s *NonreservedwordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *NonreservedwordContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterNonreservedword(s) } } func (s *NonreservedwordContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitNonreservedword(s) } } func (s *NonreservedwordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitNonreservedword(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Nonreservedword() (localctx INonreservedwordContext) { localctx = NewNonreservedwordContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1378, PostgreSQLParserRULE_nonreservedword) p.SetState(9869) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 661, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9865) p.Identifier() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9866) p.Unreserved_keyword() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9867) p.Col_name_keyword() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(9868) p.Type_func_name_keyword() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICollabelContext is an interface to support dynamic dispatch. type ICollabelContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Identifier() IIdentifierContext Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext Unreserved_keyword() IUnreserved_keywordContext Col_name_keyword() ICol_name_keywordContext Type_func_name_keyword() IType_func_name_keywordContext Reserved_keyword() IReserved_keywordContext // IsCollabelContext differentiates from other interfaces. IsCollabelContext() } type CollabelContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCollabelContext() *CollabelContext { var p = new(CollabelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_collabel return p } func InitEmptyCollabelContext(p *CollabelContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_collabel } func (*CollabelContext) IsCollabelContext() {} func NewCollabelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollabelContext { var p = new(CollabelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_collabel return p } func (s *CollabelContext) GetParser() antlr.Parser { return s.parser } func (s *CollabelContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *CollabelContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPlsql_unreserved_keywordContext) } func (s *CollabelContext) Unreserved_keyword() IUnreserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUnreserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUnreserved_keywordContext) } func (s *CollabelContext) Col_name_keyword() ICol_name_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICol_name_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICol_name_keywordContext) } func (s *CollabelContext) Type_func_name_keyword() IType_func_name_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IType_func_name_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IType_func_name_keywordContext) } func (s *CollabelContext) Reserved_keyword() IReserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReserved_keywordContext) } func (s *CollabelContext) GetRuleContext() antlr.RuleContext { return s } func (s *CollabelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CollabelContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCollabel(s) } } func (s *CollabelContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCollabel(s) } } func (s *CollabelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCollabel(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Collabel() (localctx ICollabelContext) { localctx = NewCollabelContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1380, PostgreSQLParserRULE_collabel) p.SetState(9877) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 662, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9871) p.Identifier() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9872) p.Plsql_unreserved_keyword() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9873) p.Unreserved_keyword() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(9874) p.Col_name_keyword() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(9875) p.Type_func_name_keyword() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(9876) p.Reserved_keyword() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IIdentifierContext is an interface to support dynamic dispatch. type IIdentifierContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Identifier() antlr.TerminalNode Opt_uescape() IOpt_uescapeContext QuotedIdentifier() antlr.TerminalNode UnicodeQuotedIdentifier() antlr.TerminalNode Plsqlvariablename() IPlsqlvariablenameContext Plsqlidentifier() IPlsqlidentifierContext Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext // IsIdentifierContext differentiates from other interfaces. IsIdentifierContext() } type IdentifierContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyIdentifierContext() *IdentifierContext { var p = new(IdentifierContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_identifier return p } func InitEmptyIdentifierContext(p *IdentifierContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_identifier } func (*IdentifierContext) IsIdentifierContext() {} func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierContext { var p = new(IdentifierContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_identifier return p } func (s *IdentifierContext) GetParser() antlr.Parser { return s.parser } func (s *IdentifierContext) Identifier() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIdentifier, 0) } func (s *IdentifierContext) Opt_uescape() IOpt_uescapeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_uescapeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_uescapeContext) } func (s *IdentifierContext) QuotedIdentifier() antlr.TerminalNode { return s.GetToken(PostgreSQLParserQuotedIdentifier, 0) } func (s *IdentifierContext) UnicodeQuotedIdentifier() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUnicodeQuotedIdentifier, 0) } func (s *IdentifierContext) Plsqlvariablename() IPlsqlvariablenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPlsqlvariablenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPlsqlvariablenameContext) } func (s *IdentifierContext) Plsqlidentifier() IPlsqlidentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPlsqlidentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPlsqlidentifierContext) } func (s *IdentifierContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPlsql_unreserved_keywordContext) } func (s *IdentifierContext) GetRuleContext() antlr.RuleContext { return s } func (s *IdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *IdentifierContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterIdentifier(s) } } func (s *IdentifierContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitIdentifier(s) } } func (s *IdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitIdentifier(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Identifier() (localctx IIdentifierContext) { localctx = NewIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1382, PostgreSQLParserRULE_identifier) p.SetState(9886) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserIdentifier: p.EnterOuterAlt(localctx, 1) { p.SetState(9879) p.Match(PostgreSQLParserIdentifier) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9880) p.Opt_uescape() } case PostgreSQLParserQuotedIdentifier: p.EnterOuterAlt(localctx, 2) { p.SetState(9881) p.Match(PostgreSQLParserQuotedIdentifier) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserUnicodeQuotedIdentifier: p.EnterOuterAlt(localctx, 3) { p.SetState(9882) p.Match(PostgreSQLParserUnicodeQuotedIdentifier) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserPLSQLVARIABLENAME: p.EnterOuterAlt(localctx, 4) { p.SetState(9883) p.Plsqlvariablename() } case PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 5) { p.SetState(9884) p.Plsqlidentifier() } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserOUTER_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserBACKWARD, PostgreSQLParserCHAIN, PostgreSQLParserCLOSE, PostgreSQLParserCOMMIT, PostgreSQLParserCONTINUE_P, PostgreSQLParserCURSOR, PostgreSQLParserFIRST_P, PostgreSQLParserFORWARD, PostgreSQLParserINSERT, PostgreSQLParserLAST_P, PostgreSQLParserMOVE, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserOPTION, PostgreSQLParserPRIOR, PostgreSQLParserRELATIVE_P, PostgreSQLParserRESET, PostgreSQLParserROLLBACK, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSET, PostgreSQLParserTYPE_P, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserROWTYPE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN: p.EnterOuterAlt(localctx, 6) { p.SetState(9885) p.Plsql_unreserved_keyword() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPlsqlidentifierContext is an interface to support dynamic dispatch. type IPlsqlidentifierContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures PLSQLIDENTIFIER() antlr.TerminalNode // IsPlsqlidentifierContext differentiates from other interfaces. IsPlsqlidentifierContext() } type PlsqlidentifierContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPlsqlidentifierContext() *PlsqlidentifierContext { var p = new(PlsqlidentifierContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_plsqlidentifier return p } func InitEmptyPlsqlidentifierContext(p *PlsqlidentifierContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_plsqlidentifier } func (*PlsqlidentifierContext) IsPlsqlidentifierContext() {} func NewPlsqlidentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PlsqlidentifierContext { var p = new(PlsqlidentifierContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_plsqlidentifier return p } func (s *PlsqlidentifierContext) GetParser() antlr.Parser { return s.parser } func (s *PlsqlidentifierContext) PLSQLIDENTIFIER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPLSQLIDENTIFIER, 0) } func (s *PlsqlidentifierContext) GetRuleContext() antlr.RuleContext { return s } func (s *PlsqlidentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *PlsqlidentifierContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPlsqlidentifier(s) } } func (s *PlsqlidentifierContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPlsqlidentifier(s) } } func (s *PlsqlidentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPlsqlidentifier(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Plsqlidentifier() (localctx IPlsqlidentifierContext) { localctx = NewPlsqlidentifierContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1384, PostgreSQLParserRULE_plsqlidentifier) p.EnterOuterAlt(localctx, 1) { p.SetState(9888) p.Match(PostgreSQLParserPLSQLIDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IUnreserved_keywordContext is an interface to support dynamic dispatch. type IUnreserved_keywordContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ABORT_P() antlr.TerminalNode ABSOLUTE_P() antlr.TerminalNode ACCESS() antlr.TerminalNode ACTION() antlr.TerminalNode ADD_P() antlr.TerminalNode ADMIN() antlr.TerminalNode AFTER() antlr.TerminalNode AGGREGATE() antlr.TerminalNode ALSO() antlr.TerminalNode ALTER() antlr.TerminalNode ALWAYS() antlr.TerminalNode ASSERTION() antlr.TerminalNode ASSIGNMENT() antlr.TerminalNode AT() antlr.TerminalNode ATTACH() antlr.TerminalNode ATTRIBUTE() antlr.TerminalNode BACKWARD() antlr.TerminalNode BEFORE() antlr.TerminalNode BEGIN_P() antlr.TerminalNode BY() antlr.TerminalNode CACHE() antlr.TerminalNode CALL() antlr.TerminalNode CALLED() antlr.TerminalNode CASCADE() antlr.TerminalNode CASCADED() antlr.TerminalNode CATALOG() antlr.TerminalNode CHAIN() antlr.TerminalNode CHARACTERISTICS() antlr.TerminalNode CHECKPOINT() antlr.TerminalNode CLASS() antlr.TerminalNode CLOSE() antlr.TerminalNode CLUSTER() antlr.TerminalNode COLUMNS() antlr.TerminalNode COMMENT() antlr.TerminalNode COMMENTS() antlr.TerminalNode COMMIT() antlr.TerminalNode COMMITTED() antlr.TerminalNode CONFIGURATION() antlr.TerminalNode CONFLICT() antlr.TerminalNode CONNECTION() antlr.TerminalNode CONSTRAINTS() antlr.TerminalNode CONTENT_P() antlr.TerminalNode CONTINUE_P() antlr.TerminalNode CONVERSION_P() antlr.TerminalNode COPY() antlr.TerminalNode COST() antlr.TerminalNode CSV() antlr.TerminalNode CUBE() antlr.TerminalNode CURRENT_P() antlr.TerminalNode CURSOR() antlr.TerminalNode CYCLE() antlr.TerminalNode DATA_P() antlr.TerminalNode DATABASE() antlr.TerminalNode DAY_P() antlr.TerminalNode DEALLOCATE() antlr.TerminalNode DECLARE() antlr.TerminalNode DEFAULTS() antlr.TerminalNode DEFERRED() antlr.TerminalNode DEFINER() antlr.TerminalNode DELETE_P() antlr.TerminalNode DELIMITER() antlr.TerminalNode DELIMITERS() antlr.TerminalNode DEPENDS() antlr.TerminalNode DETACH() antlr.TerminalNode DICTIONARY() antlr.TerminalNode DISABLE_P() antlr.TerminalNode DISCARD() antlr.TerminalNode DOCUMENT_P() antlr.TerminalNode DOMAIN_P() antlr.TerminalNode DOUBLE_P() antlr.TerminalNode DROP() antlr.TerminalNode EACH() antlr.TerminalNode ENABLE_P() antlr.TerminalNode ENCODING() antlr.TerminalNode ENCRYPTED() antlr.TerminalNode ENUM_P() antlr.TerminalNode ESCAPE() antlr.TerminalNode EVENT() antlr.TerminalNode EXCLUDE() antlr.TerminalNode EXCLUDING() antlr.TerminalNode EXCLUSIVE() antlr.TerminalNode EXECUTE() antlr.TerminalNode EXPLAIN() antlr.TerminalNode EXPRESSION() antlr.TerminalNode EXTENSION() antlr.TerminalNode EXTERNAL() antlr.TerminalNode FAMILY() antlr.TerminalNode FILTER() antlr.TerminalNode FIRST_P() antlr.TerminalNode FOLLOWING() antlr.TerminalNode FORCE() antlr.TerminalNode FORWARD() antlr.TerminalNode FUNCTION() antlr.TerminalNode FUNCTIONS() antlr.TerminalNode GENERATED() antlr.TerminalNode GLOBAL() antlr.TerminalNode GRANTED() antlr.TerminalNode GROUPS() antlr.TerminalNode HANDLER() antlr.TerminalNode HEADER_P() antlr.TerminalNode HOLD() antlr.TerminalNode HOUR_P() antlr.TerminalNode IDENTITY_P() antlr.TerminalNode IF_P() antlr.TerminalNode IMMEDIATE() antlr.TerminalNode IMMUTABLE() antlr.TerminalNode IMPLICIT_P() antlr.TerminalNode IMPORT_P() antlr.TerminalNode INCLUDE() antlr.TerminalNode INCLUDING() antlr.TerminalNode INCREMENT() antlr.TerminalNode INDEX() antlr.TerminalNode INDEXES() antlr.TerminalNode INHERIT() antlr.TerminalNode INHERITS() antlr.TerminalNode INLINE_P() antlr.TerminalNode INPUT_P() antlr.TerminalNode INSENSITIVE() antlr.TerminalNode INSERT() antlr.TerminalNode INSTEAD() antlr.TerminalNode INVOKER() antlr.TerminalNode ISOLATION() antlr.TerminalNode KEY() antlr.TerminalNode LABEL() antlr.TerminalNode LANGUAGE() antlr.TerminalNode LARGE_P() antlr.TerminalNode LAST_P() antlr.TerminalNode LEAKPROOF() antlr.TerminalNode LEVEL() antlr.TerminalNode LISTEN() antlr.TerminalNode LOAD() antlr.TerminalNode LOCAL() antlr.TerminalNode LOCATION() antlr.TerminalNode LOCK_P() antlr.TerminalNode LOCKED() antlr.TerminalNode LOGGED() antlr.TerminalNode MAPPING() antlr.TerminalNode MATCH() antlr.TerminalNode MATERIALIZED() antlr.TerminalNode MAXVALUE() antlr.TerminalNode METHOD() antlr.TerminalNode MINUTE_P() antlr.TerminalNode MINVALUE() antlr.TerminalNode MODE() antlr.TerminalNode MONTH_P() antlr.TerminalNode MOVE() antlr.TerminalNode NAME_P() antlr.TerminalNode NAMES() antlr.TerminalNode NEW() antlr.TerminalNode NEXT() antlr.TerminalNode NFC() antlr.TerminalNode NFD() antlr.TerminalNode NFKC() antlr.TerminalNode NFKD() antlr.TerminalNode NO() antlr.TerminalNode NORMALIZED() antlr.TerminalNode NOTHING() antlr.TerminalNode NOTIFY() antlr.TerminalNode NOWAIT() antlr.TerminalNode NULLS_P() antlr.TerminalNode OBJECT_P() antlr.TerminalNode OF() antlr.TerminalNode OFF() antlr.TerminalNode OIDS() antlr.TerminalNode OLD() antlr.TerminalNode OPERATOR() antlr.TerminalNode OPTION() antlr.TerminalNode OPTIONS() antlr.TerminalNode ORDINALITY() antlr.TerminalNode OTHERS() antlr.TerminalNode OVER() antlr.TerminalNode OVERRIDING() antlr.TerminalNode OWNED() antlr.TerminalNode OWNER() antlr.TerminalNode PARALLEL() antlr.TerminalNode PARSER() antlr.TerminalNode PARTIAL() antlr.TerminalNode PARTITION() antlr.TerminalNode PASSING() antlr.TerminalNode PASSWORD() antlr.TerminalNode PLANS() antlr.TerminalNode POLICY() antlr.TerminalNode PRECEDING() antlr.TerminalNode PREPARE() antlr.TerminalNode PREPARED() antlr.TerminalNode PRESERVE() antlr.TerminalNode PRIOR() antlr.TerminalNode PRIVILEGES() antlr.TerminalNode PROCEDURAL() antlr.TerminalNode PROCEDURE() antlr.TerminalNode PROCEDURES() antlr.TerminalNode PROGRAM() antlr.TerminalNode PUBLICATION() antlr.TerminalNode QUOTE() antlr.TerminalNode RANGE() antlr.TerminalNode READ() antlr.TerminalNode REASSIGN() antlr.TerminalNode RECHECK() antlr.TerminalNode RECURSIVE() antlr.TerminalNode REF() antlr.TerminalNode REFERENCING() antlr.TerminalNode REFRESH() antlr.TerminalNode REINDEX() antlr.TerminalNode RELATIVE_P() antlr.TerminalNode RELEASE() antlr.TerminalNode RENAME() antlr.TerminalNode REPEATABLE() antlr.TerminalNode REPLICA() antlr.TerminalNode RESET() antlr.TerminalNode RESTART() antlr.TerminalNode RESTRICT() antlr.TerminalNode RETURNS() antlr.TerminalNode REVOKE() antlr.TerminalNode ROLE() antlr.TerminalNode ROLLBACK() antlr.TerminalNode ROLLUP() antlr.TerminalNode ROUTINE() antlr.TerminalNode ROUTINES() antlr.TerminalNode ROWS() antlr.TerminalNode RULE() antlr.TerminalNode SAVEPOINT() antlr.TerminalNode SCHEMA() antlr.TerminalNode SCHEMAS() antlr.TerminalNode SCROLL() antlr.TerminalNode SEARCH() antlr.TerminalNode SECOND_P() antlr.TerminalNode SECURITY() antlr.TerminalNode SEQUENCE() antlr.TerminalNode SEQUENCES() antlr.TerminalNode SERIALIZABLE() antlr.TerminalNode SERVER() antlr.TerminalNode SESSION() antlr.TerminalNode SET() antlr.TerminalNode SETS() antlr.TerminalNode SHARE() antlr.TerminalNode SHOW() antlr.TerminalNode SIMPLE() antlr.TerminalNode SKIP_P() antlr.TerminalNode SNAPSHOT() antlr.TerminalNode SQL_P() antlr.TerminalNode STABLE() antlr.TerminalNode STANDALONE_P() antlr.TerminalNode START() antlr.TerminalNode STATEMENT() antlr.TerminalNode STATISTICS() antlr.TerminalNode STDIN() antlr.TerminalNode STDOUT() antlr.TerminalNode STORAGE() antlr.TerminalNode STORED() antlr.TerminalNode STRICT_P() antlr.TerminalNode STRIP_P() antlr.TerminalNode SUBSCRIPTION() antlr.TerminalNode SUPPORT() antlr.TerminalNode SYSID() antlr.TerminalNode SYSTEM_P() antlr.TerminalNode TABLES() antlr.TerminalNode TABLESPACE() antlr.TerminalNode TEMP() antlr.TerminalNode TEMPLATE() antlr.TerminalNode TEMPORARY() antlr.TerminalNode TEXT_P() antlr.TerminalNode TIES() antlr.TerminalNode TRANSACTION() antlr.TerminalNode TRANSFORM() antlr.TerminalNode TRIGGER() antlr.TerminalNode TRUNCATE() antlr.TerminalNode TRUSTED() antlr.TerminalNode TYPE_P() antlr.TerminalNode TYPES_P() antlr.TerminalNode UESCAPE() antlr.TerminalNode UNBOUNDED() antlr.TerminalNode UNCOMMITTED() antlr.TerminalNode UNENCRYPTED() antlr.TerminalNode UNKNOWN() antlr.TerminalNode UNLISTEN() antlr.TerminalNode UNLOGGED() antlr.TerminalNode UNTIL() antlr.TerminalNode UPDATE() antlr.TerminalNode VACUUM() antlr.TerminalNode VALID() antlr.TerminalNode VALIDATE() antlr.TerminalNode VALIDATOR() antlr.TerminalNode VALUE_P() antlr.TerminalNode VARYING() antlr.TerminalNode VERSION_P() antlr.TerminalNode VIEW() antlr.TerminalNode VIEWS() antlr.TerminalNode VOLATILE() antlr.TerminalNode WHITESPACE_P() antlr.TerminalNode WITHIN() antlr.TerminalNode WITHOUT() antlr.TerminalNode WORK() antlr.TerminalNode WRAPPER() antlr.TerminalNode WRITE() antlr.TerminalNode XML_P() antlr.TerminalNode YEAR_P() antlr.TerminalNode YES_P() antlr.TerminalNode ZONE() antlr.TerminalNode // IsUnreserved_keywordContext differentiates from other interfaces. IsUnreserved_keywordContext() } type Unreserved_keywordContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyUnreserved_keywordContext() *Unreserved_keywordContext { var p = new(Unreserved_keywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_unreserved_keyword return p } func InitEmptyUnreserved_keywordContext(p *Unreserved_keywordContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_unreserved_keyword } func (*Unreserved_keywordContext) IsUnreserved_keywordContext() {} func NewUnreserved_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unreserved_keywordContext { var p = new(Unreserved_keywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_unreserved_keyword return p } func (s *Unreserved_keywordContext) GetParser() antlr.Parser { return s.parser } func (s *Unreserved_keywordContext) ABORT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserABORT_P, 0) } func (s *Unreserved_keywordContext) ABSOLUTE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserABSOLUTE_P, 0) } func (s *Unreserved_keywordContext) ACCESS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserACCESS, 0) } func (s *Unreserved_keywordContext) ACTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserACTION, 0) } func (s *Unreserved_keywordContext) ADD_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserADD_P, 0) } func (s *Unreserved_keywordContext) ADMIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserADMIN, 0) } func (s *Unreserved_keywordContext) AFTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAFTER, 0) } func (s *Unreserved_keywordContext) AGGREGATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAGGREGATE, 0) } func (s *Unreserved_keywordContext) ALSO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALSO, 0) } func (s *Unreserved_keywordContext) ALTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALTER, 0) } func (s *Unreserved_keywordContext) ALWAYS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALWAYS, 0) } func (s *Unreserved_keywordContext) ASSERTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserASSERTION, 0) } func (s *Unreserved_keywordContext) ASSIGNMENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserASSIGNMENT, 0) } func (s *Unreserved_keywordContext) AT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAT, 0) } func (s *Unreserved_keywordContext) ATTACH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserATTACH, 0) } func (s *Unreserved_keywordContext) ATTRIBUTE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserATTRIBUTE, 0) } func (s *Unreserved_keywordContext) BACKWARD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBACKWARD, 0) } func (s *Unreserved_keywordContext) BEFORE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBEFORE, 0) } func (s *Unreserved_keywordContext) BEGIN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBEGIN_P, 0) } func (s *Unreserved_keywordContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *Unreserved_keywordContext) CACHE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCACHE, 0) } func (s *Unreserved_keywordContext) CALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCALL, 0) } func (s *Unreserved_keywordContext) CALLED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCALLED, 0) } func (s *Unreserved_keywordContext) CASCADE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCASCADE, 0) } func (s *Unreserved_keywordContext) CASCADED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCASCADED, 0) } func (s *Unreserved_keywordContext) CATALOG() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCATALOG, 0) } func (s *Unreserved_keywordContext) CHAIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHAIN, 0) } func (s *Unreserved_keywordContext) CHARACTERISTICS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHARACTERISTICS, 0) } func (s *Unreserved_keywordContext) CHECKPOINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHECKPOINT, 0) } func (s *Unreserved_keywordContext) CLASS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLASS, 0) } func (s *Unreserved_keywordContext) CLOSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE, 0) } func (s *Unreserved_keywordContext) CLUSTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLUSTER, 0) } func (s *Unreserved_keywordContext) COLUMNS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLUMNS, 0) } func (s *Unreserved_keywordContext) COMMENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMENT, 0) } func (s *Unreserved_keywordContext) COMMENTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMENTS, 0) } func (s *Unreserved_keywordContext) COMMIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMIT, 0) } func (s *Unreserved_keywordContext) COMMITTED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMITTED, 0) } func (s *Unreserved_keywordContext) CONFIGURATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONFIGURATION, 0) } func (s *Unreserved_keywordContext) CONFLICT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONFLICT, 0) } func (s *Unreserved_keywordContext) CONNECTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONNECTION, 0) } func (s *Unreserved_keywordContext) CONSTRAINTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTRAINTS, 0) } func (s *Unreserved_keywordContext) CONTENT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONTENT_P, 0) } func (s *Unreserved_keywordContext) CONTINUE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONTINUE_P, 0) } func (s *Unreserved_keywordContext) CONVERSION_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONVERSION_P, 0) } func (s *Unreserved_keywordContext) COPY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOPY, 0) } func (s *Unreserved_keywordContext) COST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOST, 0) } func (s *Unreserved_keywordContext) CSV() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCSV, 0) } func (s *Unreserved_keywordContext) CUBE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCUBE, 0) } func (s *Unreserved_keywordContext) CURRENT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_P, 0) } func (s *Unreserved_keywordContext) CURSOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURSOR, 0) } func (s *Unreserved_keywordContext) CYCLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCYCLE, 0) } func (s *Unreserved_keywordContext) DATA_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATA_P, 0) } func (s *Unreserved_keywordContext) DATABASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATABASE, 0) } func (s *Unreserved_keywordContext) DAY_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDAY_P, 0) } func (s *Unreserved_keywordContext) DEALLOCATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEALLOCATE, 0) } func (s *Unreserved_keywordContext) DECLARE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDECLARE, 0) } func (s *Unreserved_keywordContext) DEFAULTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULTS, 0) } func (s *Unreserved_keywordContext) DEFERRED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFERRED, 0) } func (s *Unreserved_keywordContext) DEFINER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFINER, 0) } func (s *Unreserved_keywordContext) DELETE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDELETE_P, 0) } func (s *Unreserved_keywordContext) DELIMITER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDELIMITER, 0) } func (s *Unreserved_keywordContext) DELIMITERS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDELIMITERS, 0) } func (s *Unreserved_keywordContext) DEPENDS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEPENDS, 0) } func (s *Unreserved_keywordContext) DETACH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDETACH, 0) } func (s *Unreserved_keywordContext) DICTIONARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDICTIONARY, 0) } func (s *Unreserved_keywordContext) DISABLE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDISABLE_P, 0) } func (s *Unreserved_keywordContext) DISCARD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDISCARD, 0) } func (s *Unreserved_keywordContext) DOCUMENT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOCUMENT_P, 0) } func (s *Unreserved_keywordContext) DOMAIN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOMAIN_P, 0) } func (s *Unreserved_keywordContext) DOUBLE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOUBLE_P, 0) } func (s *Unreserved_keywordContext) DROP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDROP, 0) } func (s *Unreserved_keywordContext) EACH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEACH, 0) } func (s *Unreserved_keywordContext) ENABLE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserENABLE_P, 0) } func (s *Unreserved_keywordContext) ENCODING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserENCODING, 0) } func (s *Unreserved_keywordContext) ENCRYPTED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserENCRYPTED, 0) } func (s *Unreserved_keywordContext) ENUM_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserENUM_P, 0) } func (s *Unreserved_keywordContext) ESCAPE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserESCAPE, 0) } func (s *Unreserved_keywordContext) EVENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEVENT, 0) } func (s *Unreserved_keywordContext) EXCLUDE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXCLUDE, 0) } func (s *Unreserved_keywordContext) EXCLUDING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXCLUDING, 0) } func (s *Unreserved_keywordContext) EXCLUSIVE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXCLUSIVE, 0) } func (s *Unreserved_keywordContext) EXECUTE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXECUTE, 0) } func (s *Unreserved_keywordContext) EXPLAIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXPLAIN, 0) } func (s *Unreserved_keywordContext) EXPRESSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXPRESSION, 0) } func (s *Unreserved_keywordContext) EXTENSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXTENSION, 0) } func (s *Unreserved_keywordContext) EXTERNAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXTERNAL, 0) } func (s *Unreserved_keywordContext) FAMILY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFAMILY, 0) } func (s *Unreserved_keywordContext) FILTER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFILTER, 0) } func (s *Unreserved_keywordContext) FIRST_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFIRST_P, 0) } func (s *Unreserved_keywordContext) FOLLOWING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOLLOWING, 0) } func (s *Unreserved_keywordContext) FORCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFORCE, 0) } func (s *Unreserved_keywordContext) FORWARD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFORWARD, 0) } func (s *Unreserved_keywordContext) FUNCTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTION, 0) } func (s *Unreserved_keywordContext) FUNCTIONS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFUNCTIONS, 0) } func (s *Unreserved_keywordContext) GENERATED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGENERATED, 0) } func (s *Unreserved_keywordContext) GLOBAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGLOBAL, 0) } func (s *Unreserved_keywordContext) GRANTED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGRANTED, 0) } func (s *Unreserved_keywordContext) GROUPS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUPS, 0) } func (s *Unreserved_keywordContext) HANDLER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserHANDLER, 0) } func (s *Unreserved_keywordContext) HEADER_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserHEADER_P, 0) } func (s *Unreserved_keywordContext) HOLD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserHOLD, 0) } func (s *Unreserved_keywordContext) HOUR_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserHOUR_P, 0) } func (s *Unreserved_keywordContext) IDENTITY_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIDENTITY_P, 0) } func (s *Unreserved_keywordContext) IF_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, 0) } func (s *Unreserved_keywordContext) IMMEDIATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIMMEDIATE, 0) } func (s *Unreserved_keywordContext) IMMUTABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIMMUTABLE, 0) } func (s *Unreserved_keywordContext) IMPLICIT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIMPLICIT_P, 0) } func (s *Unreserved_keywordContext) IMPORT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIMPORT_P, 0) } func (s *Unreserved_keywordContext) INCLUDE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINCLUDE, 0) } func (s *Unreserved_keywordContext) INCLUDING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINCLUDING, 0) } func (s *Unreserved_keywordContext) INCREMENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINCREMENT, 0) } func (s *Unreserved_keywordContext) INDEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINDEX, 0) } func (s *Unreserved_keywordContext) INDEXES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINDEXES, 0) } func (s *Unreserved_keywordContext) INHERIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINHERIT, 0) } func (s *Unreserved_keywordContext) INHERITS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINHERITS, 0) } func (s *Unreserved_keywordContext) INLINE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINLINE_P, 0) } func (s *Unreserved_keywordContext) INPUT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINPUT_P, 0) } func (s *Unreserved_keywordContext) INSENSITIVE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINSENSITIVE, 0) } func (s *Unreserved_keywordContext) INSERT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINSERT, 0) } func (s *Unreserved_keywordContext) INSTEAD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINSTEAD, 0) } func (s *Unreserved_keywordContext) INVOKER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINVOKER, 0) } func (s *Unreserved_keywordContext) ISOLATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserISOLATION, 0) } func (s *Unreserved_keywordContext) KEY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserKEY, 0) } func (s *Unreserved_keywordContext) LABEL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLABEL, 0) } func (s *Unreserved_keywordContext) LANGUAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLANGUAGE, 0) } func (s *Unreserved_keywordContext) LARGE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLARGE_P, 0) } func (s *Unreserved_keywordContext) LAST_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLAST_P, 0) } func (s *Unreserved_keywordContext) LEAKPROOF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEAKPROOF, 0) } func (s *Unreserved_keywordContext) LEVEL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEVEL, 0) } func (s *Unreserved_keywordContext) LISTEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLISTEN, 0) } func (s *Unreserved_keywordContext) LOAD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOAD, 0) } func (s *Unreserved_keywordContext) LOCAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCAL, 0) } func (s *Unreserved_keywordContext) LOCATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCATION, 0) } func (s *Unreserved_keywordContext) LOCK_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCK_P, 0) } func (s *Unreserved_keywordContext) LOCKED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCKED, 0) } func (s *Unreserved_keywordContext) LOGGED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOGGED, 0) } func (s *Unreserved_keywordContext) MAPPING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMAPPING, 0) } func (s *Unreserved_keywordContext) MATCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMATCH, 0) } func (s *Unreserved_keywordContext) MATERIALIZED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMATERIALIZED, 0) } func (s *Unreserved_keywordContext) MAXVALUE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMAXVALUE, 0) } func (s *Unreserved_keywordContext) METHOD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMETHOD, 0) } func (s *Unreserved_keywordContext) MINUTE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMINUTE_P, 0) } func (s *Unreserved_keywordContext) MINVALUE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMINVALUE, 0) } func (s *Unreserved_keywordContext) MODE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMODE, 0) } func (s *Unreserved_keywordContext) MONTH_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMONTH_P, 0) } func (s *Unreserved_keywordContext) MOVE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMOVE, 0) } func (s *Unreserved_keywordContext) NAME_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNAME_P, 0) } func (s *Unreserved_keywordContext) NAMES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNAMES, 0) } func (s *Unreserved_keywordContext) NEW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNEW, 0) } func (s *Unreserved_keywordContext) NEXT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNEXT, 0) } func (s *Unreserved_keywordContext) NFC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNFC, 0) } func (s *Unreserved_keywordContext) NFD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNFD, 0) } func (s *Unreserved_keywordContext) NFKC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNFKC, 0) } func (s *Unreserved_keywordContext) NFKD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNFKD, 0) } func (s *Unreserved_keywordContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Unreserved_keywordContext) NORMALIZED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNORMALIZED, 0) } func (s *Unreserved_keywordContext) NOTHING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOTHING, 0) } func (s *Unreserved_keywordContext) NOTIFY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOTIFY, 0) } func (s *Unreserved_keywordContext) NOWAIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOWAIT, 0) } func (s *Unreserved_keywordContext) NULLS_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULLS_P, 0) } func (s *Unreserved_keywordContext) OBJECT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOBJECT_P, 0) } func (s *Unreserved_keywordContext) OF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOF, 0) } func (s *Unreserved_keywordContext) OFF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOFF, 0) } func (s *Unreserved_keywordContext) OIDS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOIDS, 0) } func (s *Unreserved_keywordContext) OLD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOLD, 0) } func (s *Unreserved_keywordContext) OPERATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPERATOR, 0) } func (s *Unreserved_keywordContext) OPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPTION, 0) } func (s *Unreserved_keywordContext) OPTIONS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPTIONS, 0) } func (s *Unreserved_keywordContext) ORDINALITY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserORDINALITY, 0) } func (s *Unreserved_keywordContext) OTHERS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOTHERS, 0) } func (s *Unreserved_keywordContext) OVER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOVER, 0) } func (s *Unreserved_keywordContext) OVERRIDING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOVERRIDING, 0) } func (s *Unreserved_keywordContext) OWNED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOWNED, 0) } func (s *Unreserved_keywordContext) OWNER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOWNER, 0) } func (s *Unreserved_keywordContext) PARALLEL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARALLEL, 0) } func (s *Unreserved_keywordContext) PARSER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARSER, 0) } func (s *Unreserved_keywordContext) PARTIAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARTIAL, 0) } func (s *Unreserved_keywordContext) PARTITION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARTITION, 0) } func (s *Unreserved_keywordContext) PASSING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPASSING, 0) } func (s *Unreserved_keywordContext) PASSWORD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPASSWORD, 0) } func (s *Unreserved_keywordContext) PLANS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPLANS, 0) } func (s *Unreserved_keywordContext) POLICY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPOLICY, 0) } func (s *Unreserved_keywordContext) PRECEDING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRECEDING, 0) } func (s *Unreserved_keywordContext) PREPARE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPREPARE, 0) } func (s *Unreserved_keywordContext) PREPARED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPREPARED, 0) } func (s *Unreserved_keywordContext) PRESERVE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRESERVE, 0) } func (s *Unreserved_keywordContext) PRIOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRIOR, 0) } func (s *Unreserved_keywordContext) PRIVILEGES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRIVILEGES, 0) } func (s *Unreserved_keywordContext) PROCEDURAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURAL, 0) } func (s *Unreserved_keywordContext) PROCEDURE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURE, 0) } func (s *Unreserved_keywordContext) PROCEDURES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROCEDURES, 0) } func (s *Unreserved_keywordContext) PROGRAM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPROGRAM, 0) } func (s *Unreserved_keywordContext) PUBLICATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPUBLICATION, 0) } func (s *Unreserved_keywordContext) QUOTE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserQUOTE, 0) } func (s *Unreserved_keywordContext) RANGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRANGE, 0) } func (s *Unreserved_keywordContext) READ() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREAD, 0) } func (s *Unreserved_keywordContext) REASSIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREASSIGN, 0) } func (s *Unreserved_keywordContext) RECHECK() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRECHECK, 0) } func (s *Unreserved_keywordContext) RECURSIVE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRECURSIVE, 0) } func (s *Unreserved_keywordContext) REF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREF, 0) } func (s *Unreserved_keywordContext) REFERENCING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREFERENCING, 0) } func (s *Unreserved_keywordContext) REFRESH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREFRESH, 0) } func (s *Unreserved_keywordContext) REINDEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREINDEX, 0) } func (s *Unreserved_keywordContext) RELATIVE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRELATIVE_P, 0) } func (s *Unreserved_keywordContext) RELEASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRELEASE, 0) } func (s *Unreserved_keywordContext) RENAME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRENAME, 0) } func (s *Unreserved_keywordContext) REPEATABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREPEATABLE, 0) } func (s *Unreserved_keywordContext) REPLICA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREPLICA, 0) } func (s *Unreserved_keywordContext) RESET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESET, 0) } func (s *Unreserved_keywordContext) RESTART() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESTART, 0) } func (s *Unreserved_keywordContext) RESTRICT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESTRICT, 0) } func (s *Unreserved_keywordContext) RETURNS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRETURNS, 0) } func (s *Unreserved_keywordContext) REVOKE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREVOKE, 0) } func (s *Unreserved_keywordContext) ROLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLE, 0) } func (s *Unreserved_keywordContext) ROLLBACK() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLLBACK, 0) } func (s *Unreserved_keywordContext) ROLLUP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLLUP, 0) } func (s *Unreserved_keywordContext) ROUTINE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUTINE, 0) } func (s *Unreserved_keywordContext) ROUTINES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUTINES, 0) } func (s *Unreserved_keywordContext) ROWS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROWS, 0) } func (s *Unreserved_keywordContext) RULE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRULE, 0) } func (s *Unreserved_keywordContext) SAVEPOINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSAVEPOINT, 0) } func (s *Unreserved_keywordContext) SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMA, 0) } func (s *Unreserved_keywordContext) SCHEMAS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMAS, 0) } func (s *Unreserved_keywordContext) SCROLL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCROLL, 0) } func (s *Unreserved_keywordContext) SEARCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEARCH, 0) } func (s *Unreserved_keywordContext) SECOND_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSECOND_P, 0) } func (s *Unreserved_keywordContext) SECURITY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSECURITY, 0) } func (s *Unreserved_keywordContext) SEQUENCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEQUENCE, 0) } func (s *Unreserved_keywordContext) SEQUENCES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEQUENCES, 0) } func (s *Unreserved_keywordContext) SERIALIZABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSERIALIZABLE, 0) } func (s *Unreserved_keywordContext) SERVER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSERVER, 0) } func (s *Unreserved_keywordContext) SESSION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSESSION, 0) } func (s *Unreserved_keywordContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *Unreserved_keywordContext) SETS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSETS, 0) } func (s *Unreserved_keywordContext) SHARE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSHARE, 0) } func (s *Unreserved_keywordContext) SHOW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSHOW, 0) } func (s *Unreserved_keywordContext) SIMPLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSIMPLE, 0) } func (s *Unreserved_keywordContext) SKIP_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSKIP_P, 0) } func (s *Unreserved_keywordContext) SNAPSHOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSNAPSHOT, 0) } func (s *Unreserved_keywordContext) SQL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSQL_P, 0) } func (s *Unreserved_keywordContext) STABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTABLE, 0) } func (s *Unreserved_keywordContext) STANDALONE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTANDALONE_P, 0) } func (s *Unreserved_keywordContext) START() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTART, 0) } func (s *Unreserved_keywordContext) STATEMENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTATEMENT, 0) } func (s *Unreserved_keywordContext) STATISTICS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTATISTICS, 0) } func (s *Unreserved_keywordContext) STDIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTDIN, 0) } func (s *Unreserved_keywordContext) STDOUT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTDOUT, 0) } func (s *Unreserved_keywordContext) STORAGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTORAGE, 0) } func (s *Unreserved_keywordContext) STORED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTORED, 0) } func (s *Unreserved_keywordContext) STRICT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTRICT_P, 0) } func (s *Unreserved_keywordContext) STRIP_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTRIP_P, 0) } func (s *Unreserved_keywordContext) SUBSCRIPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSUBSCRIPTION, 0) } func (s *Unreserved_keywordContext) SUPPORT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSUPPORT, 0) } func (s *Unreserved_keywordContext) SYSID() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSYSID, 0) } func (s *Unreserved_keywordContext) SYSTEM_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSYSTEM_P, 0) } func (s *Unreserved_keywordContext) TABLES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLES, 0) } func (s *Unreserved_keywordContext) TABLESPACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESPACE, 0) } func (s *Unreserved_keywordContext) TEMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEMP, 0) } func (s *Unreserved_keywordContext) TEMPLATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEMPLATE, 0) } func (s *Unreserved_keywordContext) TEMPORARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEMPORARY, 0) } func (s *Unreserved_keywordContext) TEXT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTEXT_P, 0) } func (s *Unreserved_keywordContext) TIES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTIES, 0) } func (s *Unreserved_keywordContext) TRANSACTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSACTION, 0) } func (s *Unreserved_keywordContext) TRANSFORM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSFORM, 0) } func (s *Unreserved_keywordContext) TRIGGER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRIGGER, 0) } func (s *Unreserved_keywordContext) TRUNCATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRUNCATE, 0) } func (s *Unreserved_keywordContext) TRUSTED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRUSTED, 0) } func (s *Unreserved_keywordContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *Unreserved_keywordContext) TYPES_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPES_P, 0) } func (s *Unreserved_keywordContext) UESCAPE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUESCAPE, 0) } func (s *Unreserved_keywordContext) UNBOUNDED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNBOUNDED, 0) } func (s *Unreserved_keywordContext) UNCOMMITTED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNCOMMITTED, 0) } func (s *Unreserved_keywordContext) UNENCRYPTED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNENCRYPTED, 0) } func (s *Unreserved_keywordContext) UNKNOWN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNKNOWN, 0) } func (s *Unreserved_keywordContext) UNLISTEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNLISTEN, 0) } func (s *Unreserved_keywordContext) UNLOGGED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNLOGGED, 0) } func (s *Unreserved_keywordContext) UNTIL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNTIL, 0) } func (s *Unreserved_keywordContext) UPDATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUPDATE, 0) } func (s *Unreserved_keywordContext) VACUUM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVACUUM, 0) } func (s *Unreserved_keywordContext) VALID() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALID, 0) } func (s *Unreserved_keywordContext) VALIDATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALIDATE, 0) } func (s *Unreserved_keywordContext) VALIDATOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALIDATOR, 0) } func (s *Unreserved_keywordContext) VALUE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALUE_P, 0) } func (s *Unreserved_keywordContext) VARYING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVARYING, 0) } func (s *Unreserved_keywordContext) VERSION_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVERSION_P, 0) } func (s *Unreserved_keywordContext) VIEW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVIEW, 0) } func (s *Unreserved_keywordContext) VIEWS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVIEWS, 0) } func (s *Unreserved_keywordContext) VOLATILE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVOLATILE, 0) } func (s *Unreserved_keywordContext) WHITESPACE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHITESPACE_P, 0) } func (s *Unreserved_keywordContext) WITHIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITHIN, 0) } func (s *Unreserved_keywordContext) WITHOUT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITHOUT, 0) } func (s *Unreserved_keywordContext) WORK() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWORK, 0) } func (s *Unreserved_keywordContext) WRAPPER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWRAPPER, 0) } func (s *Unreserved_keywordContext) WRITE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWRITE, 0) } func (s *Unreserved_keywordContext) XML_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXML_P, 0) } func (s *Unreserved_keywordContext) YEAR_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserYEAR_P, 0) } func (s *Unreserved_keywordContext) YES_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserYES_P, 0) } func (s *Unreserved_keywordContext) ZONE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserZONE, 0) } func (s *Unreserved_keywordContext) GetRuleContext() antlr.RuleContext { return s } func (s *Unreserved_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Unreserved_keywordContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterUnreserved_keyword(s) } } func (s *Unreserved_keywordContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitUnreserved_keyword(s) } } func (s *Unreserved_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitUnreserved_keyword(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Unreserved_keyword() (localctx IUnreserved_keywordContext) { localctx = NewUnreserved_keywordContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1386, PostgreSQLParserRULE_unreserved_keyword) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9890) _la = p.GetTokenStream().LA(1) if !(((int64((_la-124)) & ^0x3f) == 0 && ((int64(1)<<(_la-124))&-31) != 0) || ((int64((_la-188)) & ^0x3f) == 0 && ((int64(1)<<(_la-188))&-4611686018427387905) != 0) || ((int64((_la-252)) & ^0x3f) == 0 && ((int64(1)<<(_la-252))&-4503599627370499) != 0) || ((int64((_la-316)) & ^0x3f) == 0 && ((int64(1)<<(_la-316))&-1) != 0) || ((int64((_la-433)) & ^0x3f) == 0 && ((int64(1)<<(_la-433))&72028319537692671) != 0)) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICol_name_keywordContext is an interface to support dynamic dispatch. type ICol_name_keywordContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures BETWEEN() antlr.TerminalNode BIGINT() antlr.TerminalNode Bit() IBitContext BOOLEAN_P() antlr.TerminalNode CHAR_P() antlr.TerminalNode Character() ICharacterContext COALESCE() antlr.TerminalNode DEC() antlr.TerminalNode DECIMAL_P() antlr.TerminalNode EXISTS() antlr.TerminalNode EXTRACT() antlr.TerminalNode FLOAT_P() antlr.TerminalNode GREATEST() antlr.TerminalNode GROUPING() antlr.TerminalNode INOUT() antlr.TerminalNode INT_P() antlr.TerminalNode INTEGER() antlr.TerminalNode INTERVAL() antlr.TerminalNode LEAST() antlr.TerminalNode NATIONAL() antlr.TerminalNode NCHAR() antlr.TerminalNode NONE() antlr.TerminalNode NORMALIZE() antlr.TerminalNode NULLIF() antlr.TerminalNode Numeric() INumericContext OUT_P() antlr.TerminalNode OVERLAY() antlr.TerminalNode POSITION() antlr.TerminalNode PRECISION() antlr.TerminalNode REAL() antlr.TerminalNode ROW() antlr.TerminalNode SETOF() antlr.TerminalNode SMALLINT() antlr.TerminalNode SUBSTRING() antlr.TerminalNode TIME() antlr.TerminalNode TIMESTAMP() antlr.TerminalNode TREAT() antlr.TerminalNode TRIM() antlr.TerminalNode VALUES() antlr.TerminalNode VARCHAR() antlr.TerminalNode XMLATTRIBUTES() antlr.TerminalNode XMLCONCAT() antlr.TerminalNode XMLELEMENT() antlr.TerminalNode XMLEXISTS() antlr.TerminalNode XMLFOREST() antlr.TerminalNode XMLNAMESPACES() antlr.TerminalNode XMLPARSE() antlr.TerminalNode XMLPI() antlr.TerminalNode XMLROOT() antlr.TerminalNode XMLSERIALIZE() antlr.TerminalNode XMLTABLE() antlr.TerminalNode Builtin_function_name() IBuiltin_function_nameContext // IsCol_name_keywordContext differentiates from other interfaces. IsCol_name_keywordContext() } type Col_name_keywordContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCol_name_keywordContext() *Col_name_keywordContext { var p = new(Col_name_keywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_col_name_keyword return p } func InitEmptyCol_name_keywordContext(p *Col_name_keywordContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_col_name_keyword } func (*Col_name_keywordContext) IsCol_name_keywordContext() {} func NewCol_name_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Col_name_keywordContext { var p = new(Col_name_keywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_col_name_keyword return p } func (s *Col_name_keywordContext) GetParser() antlr.Parser { return s.parser } func (s *Col_name_keywordContext) BETWEEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBETWEEN, 0) } func (s *Col_name_keywordContext) BIGINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBIGINT, 0) } func (s *Col_name_keywordContext) Bit() IBitContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IBitContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IBitContext) } func (s *Col_name_keywordContext) BOOLEAN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBOOLEAN_P, 0) } func (s *Col_name_keywordContext) CHAR_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHAR_P, 0) } func (s *Col_name_keywordContext) Character() ICharacterContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICharacterContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICharacterContext) } func (s *Col_name_keywordContext) COALESCE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOALESCE, 0) } func (s *Col_name_keywordContext) DEC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEC, 0) } func (s *Col_name_keywordContext) DECIMAL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDECIMAL_P, 0) } func (s *Col_name_keywordContext) EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXISTS, 0) } func (s *Col_name_keywordContext) EXTRACT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXTRACT, 0) } func (s *Col_name_keywordContext) FLOAT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFLOAT_P, 0) } func (s *Col_name_keywordContext) GREATEST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGREATEST, 0) } func (s *Col_name_keywordContext) GROUPING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUPING, 0) } func (s *Col_name_keywordContext) INOUT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINOUT, 0) } func (s *Col_name_keywordContext) INT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINT_P, 0) } func (s *Col_name_keywordContext) INTEGER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINTEGER, 0) } func (s *Col_name_keywordContext) INTERVAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINTERVAL, 0) } func (s *Col_name_keywordContext) LEAST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEAST, 0) } func (s *Col_name_keywordContext) NATIONAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNATIONAL, 0) } func (s *Col_name_keywordContext) NCHAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNCHAR, 0) } func (s *Col_name_keywordContext) NONE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNONE, 0) } func (s *Col_name_keywordContext) NORMALIZE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNORMALIZE, 0) } func (s *Col_name_keywordContext) NULLIF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULLIF, 0) } func (s *Col_name_keywordContext) Numeric() INumericContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumericContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumericContext) } func (s *Col_name_keywordContext) OUT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOUT_P, 0) } func (s *Col_name_keywordContext) OVERLAY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOVERLAY, 0) } func (s *Col_name_keywordContext) POSITION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPOSITION, 0) } func (s *Col_name_keywordContext) PRECISION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRECISION, 0) } func (s *Col_name_keywordContext) REAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREAL, 0) } func (s *Col_name_keywordContext) ROW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROW, 0) } func (s *Col_name_keywordContext) SETOF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSETOF, 0) } func (s *Col_name_keywordContext) SMALLINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSMALLINT, 0) } func (s *Col_name_keywordContext) SUBSTRING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSUBSTRING, 0) } func (s *Col_name_keywordContext) TIME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTIME, 0) } func (s *Col_name_keywordContext) TIMESTAMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTIMESTAMP, 0) } func (s *Col_name_keywordContext) TREAT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTREAT, 0) } func (s *Col_name_keywordContext) TRIM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRIM, 0) } func (s *Col_name_keywordContext) VALUES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVALUES, 0) } func (s *Col_name_keywordContext) VARCHAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVARCHAR, 0) } func (s *Col_name_keywordContext) XMLATTRIBUTES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLATTRIBUTES, 0) } func (s *Col_name_keywordContext) XMLCONCAT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLCONCAT, 0) } func (s *Col_name_keywordContext) XMLELEMENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLELEMENT, 0) } func (s *Col_name_keywordContext) XMLEXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLEXISTS, 0) } func (s *Col_name_keywordContext) XMLFOREST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLFOREST, 0) } func (s *Col_name_keywordContext) XMLNAMESPACES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLNAMESPACES, 0) } func (s *Col_name_keywordContext) XMLPARSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLPARSE, 0) } func (s *Col_name_keywordContext) XMLPI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLPI, 0) } func (s *Col_name_keywordContext) XMLROOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLROOT, 0) } func (s *Col_name_keywordContext) XMLSERIALIZE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLSERIALIZE, 0) } func (s *Col_name_keywordContext) XMLTABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLTABLE, 0) } func (s *Col_name_keywordContext) Builtin_function_name() IBuiltin_function_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IBuiltin_function_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IBuiltin_function_nameContext) } func (s *Col_name_keywordContext) GetRuleContext() antlr.RuleContext { return s } func (s *Col_name_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Col_name_keywordContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCol_name_keyword(s) } } func (s *Col_name_keywordContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCol_name_keyword(s) } } func (s *Col_name_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCol_name_keyword(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Col_name_keyword() (localctx ICol_name_keywordContext) { localctx = NewCol_name_keywordContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1388, PostgreSQLParserRULE_col_name_keyword) p.SetState(9944) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 664, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9892) p.Match(PostgreSQLParserBETWEEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9893) p.Match(PostgreSQLParserBIGINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9894) p.Bit() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(9895) p.Match(PostgreSQLParserBOOLEAN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(9896) p.Match(PostgreSQLParserCHAR_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(9897) p.Character() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(9898) p.Match(PostgreSQLParserCOALESCE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(9899) p.Match(PostgreSQLParserDEC) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(9900) p.Match(PostgreSQLParserDECIMAL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(9901) p.Match(PostgreSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(9902) p.Match(PostgreSQLParserEXTRACT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(9903) p.Match(PostgreSQLParserFLOAT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(9904) p.Match(PostgreSQLParserGREATEST) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 14: p.EnterOuterAlt(localctx, 14) { p.SetState(9905) p.Match(PostgreSQLParserGROUPING) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 15: p.EnterOuterAlt(localctx, 15) { p.SetState(9906) p.Match(PostgreSQLParserINOUT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 16: p.EnterOuterAlt(localctx, 16) { p.SetState(9907) p.Match(PostgreSQLParserINT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 17: p.EnterOuterAlt(localctx, 17) { p.SetState(9908) p.Match(PostgreSQLParserINTEGER) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 18: p.EnterOuterAlt(localctx, 18) { p.SetState(9909) p.Match(PostgreSQLParserINTERVAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 19: p.EnterOuterAlt(localctx, 19) { p.SetState(9910) p.Match(PostgreSQLParserLEAST) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 20: p.EnterOuterAlt(localctx, 20) { p.SetState(9911) p.Match(PostgreSQLParserNATIONAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 21: p.EnterOuterAlt(localctx, 21) { p.SetState(9912) p.Match(PostgreSQLParserNCHAR) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 22: p.EnterOuterAlt(localctx, 22) { p.SetState(9913) p.Match(PostgreSQLParserNONE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 23: p.EnterOuterAlt(localctx, 23) { p.SetState(9914) p.Match(PostgreSQLParserNORMALIZE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 24: p.EnterOuterAlt(localctx, 24) { p.SetState(9915) p.Match(PostgreSQLParserNULLIF) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 25: p.EnterOuterAlt(localctx, 25) { p.SetState(9916) p.Numeric() } case 26: p.EnterOuterAlt(localctx, 26) { p.SetState(9917) p.Match(PostgreSQLParserOUT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 27: p.EnterOuterAlt(localctx, 27) { p.SetState(9918) p.Match(PostgreSQLParserOVERLAY) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 28: p.EnterOuterAlt(localctx, 28) { p.SetState(9919) p.Match(PostgreSQLParserPOSITION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 29: p.EnterOuterAlt(localctx, 29) { p.SetState(9920) p.Match(PostgreSQLParserPRECISION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 30: p.EnterOuterAlt(localctx, 30) { p.SetState(9921) p.Match(PostgreSQLParserREAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 31: p.EnterOuterAlt(localctx, 31) { p.SetState(9922) p.Match(PostgreSQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 32: p.EnterOuterAlt(localctx, 32) { p.SetState(9923) p.Match(PostgreSQLParserSETOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 33: p.EnterOuterAlt(localctx, 33) { p.SetState(9924) p.Match(PostgreSQLParserSMALLINT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 34: p.EnterOuterAlt(localctx, 34) { p.SetState(9925) p.Match(PostgreSQLParserSUBSTRING) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 35: p.EnterOuterAlt(localctx, 35) { p.SetState(9926) p.Match(PostgreSQLParserTIME) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 36: p.EnterOuterAlt(localctx, 36) { p.SetState(9927) p.Match(PostgreSQLParserTIMESTAMP) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 37: p.EnterOuterAlt(localctx, 37) { p.SetState(9928) p.Match(PostgreSQLParserTREAT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 38: p.EnterOuterAlt(localctx, 38) { p.SetState(9929) p.Match(PostgreSQLParserTRIM) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 39: p.EnterOuterAlt(localctx, 39) { p.SetState(9930) p.Match(PostgreSQLParserVALUES) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 40: p.EnterOuterAlt(localctx, 40) { p.SetState(9931) p.Match(PostgreSQLParserVARCHAR) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 41: p.EnterOuterAlt(localctx, 41) { p.SetState(9932) p.Match(PostgreSQLParserXMLATTRIBUTES) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 42: p.EnterOuterAlt(localctx, 42) { p.SetState(9933) p.Match(PostgreSQLParserXMLCONCAT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 43: p.EnterOuterAlt(localctx, 43) { p.SetState(9934) p.Match(PostgreSQLParserXMLELEMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 44: p.EnterOuterAlt(localctx, 44) { p.SetState(9935) p.Match(PostgreSQLParserXMLEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 45: p.EnterOuterAlt(localctx, 45) { p.SetState(9936) p.Match(PostgreSQLParserXMLFOREST) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 46: p.EnterOuterAlt(localctx, 46) { p.SetState(9937) p.Match(PostgreSQLParserXMLNAMESPACES) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 47: p.EnterOuterAlt(localctx, 47) { p.SetState(9938) p.Match(PostgreSQLParserXMLPARSE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 48: p.EnterOuterAlt(localctx, 48) { p.SetState(9939) p.Match(PostgreSQLParserXMLPI) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 49: p.EnterOuterAlt(localctx, 49) { p.SetState(9940) p.Match(PostgreSQLParserXMLROOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 50: p.EnterOuterAlt(localctx, 50) { p.SetState(9941) p.Match(PostgreSQLParserXMLSERIALIZE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 51: p.EnterOuterAlt(localctx, 51) { p.SetState(9942) p.Match(PostgreSQLParserXMLTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 52: p.EnterOuterAlt(localctx, 52) { p.SetState(9943) p.Builtin_function_name() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IType_func_name_keywordContext is an interface to support dynamic dispatch. type IType_func_name_keywordContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AUTHORIZATION() antlr.TerminalNode BINARY() antlr.TerminalNode COLLATION() antlr.TerminalNode CONCURRENTLY() antlr.TerminalNode CROSS() antlr.TerminalNode CURRENT_SCHEMA() antlr.TerminalNode FREEZE() antlr.TerminalNode FULL() antlr.TerminalNode ILIKE() antlr.TerminalNode INNER_P() antlr.TerminalNode IS() antlr.TerminalNode ISNULL() antlr.TerminalNode JOIN() antlr.TerminalNode LIKE() antlr.TerminalNode NATURAL() antlr.TerminalNode NOTNULL() antlr.TerminalNode OUTER_P() antlr.TerminalNode OVERLAPS() antlr.TerminalNode SIMILAR() antlr.TerminalNode TABLESAMPLE() antlr.TerminalNode VERBOSE() antlr.TerminalNode // IsType_func_name_keywordContext differentiates from other interfaces. IsType_func_name_keywordContext() } type Type_func_name_keywordContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyType_func_name_keywordContext() *Type_func_name_keywordContext { var p = new(Type_func_name_keywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_type_func_name_keyword return p } func InitEmptyType_func_name_keywordContext(p *Type_func_name_keywordContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_type_func_name_keyword } func (*Type_func_name_keywordContext) IsType_func_name_keywordContext() {} func NewType_func_name_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_func_name_keywordContext { var p = new(Type_func_name_keywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_type_func_name_keyword return p } func (s *Type_func_name_keywordContext) GetParser() antlr.Parser { return s.parser } func (s *Type_func_name_keywordContext) AUTHORIZATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAUTHORIZATION, 0) } func (s *Type_func_name_keywordContext) BINARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBINARY, 0) } func (s *Type_func_name_keywordContext) COLLATION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATION, 0) } func (s *Type_func_name_keywordContext) CONCURRENTLY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONCURRENTLY, 0) } func (s *Type_func_name_keywordContext) CROSS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCROSS, 0) } func (s *Type_func_name_keywordContext) CURRENT_SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_SCHEMA, 0) } func (s *Type_func_name_keywordContext) FREEZE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFREEZE, 0) } func (s *Type_func_name_keywordContext) FULL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFULL, 0) } func (s *Type_func_name_keywordContext) ILIKE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserILIKE, 0) } func (s *Type_func_name_keywordContext) INNER_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINNER_P, 0) } func (s *Type_func_name_keywordContext) IS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIS, 0) } func (s *Type_func_name_keywordContext) ISNULL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserISNULL, 0) } func (s *Type_func_name_keywordContext) JOIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserJOIN, 0) } func (s *Type_func_name_keywordContext) LIKE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLIKE, 0) } func (s *Type_func_name_keywordContext) NATURAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNATURAL, 0) } func (s *Type_func_name_keywordContext) NOTNULL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOTNULL, 0) } func (s *Type_func_name_keywordContext) OUTER_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOUTER_P, 0) } func (s *Type_func_name_keywordContext) OVERLAPS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOVERLAPS, 0) } func (s *Type_func_name_keywordContext) SIMILAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSIMILAR, 0) } func (s *Type_func_name_keywordContext) TABLESAMPLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLESAMPLE, 0) } func (s *Type_func_name_keywordContext) VERBOSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVERBOSE, 0) } func (s *Type_func_name_keywordContext) GetRuleContext() antlr.RuleContext { return s } func (s *Type_func_name_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Type_func_name_keywordContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterType_func_name_keyword(s) } } func (s *Type_func_name_keywordContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitType_func_name_keyword(s) } } func (s *Type_func_name_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitType_func_name_keyword(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Type_func_name_keyword() (localctx IType_func_name_keywordContext) { localctx = NewType_func_name_keywordContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1390, PostgreSQLParserRULE_type_func_name_keyword) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9946) _la = p.GetTokenStream().LA(1) if !(((int64((_la-106)) & ^0x3f) == 0 && ((int64(1)<<(_la-106))&7069695) != 0) || _la == PostgreSQLParserTABLESAMPLE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IReserved_keywordContext is an interface to support dynamic dispatch. type IReserved_keywordContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ALL() antlr.TerminalNode ANALYSE() antlr.TerminalNode ANALYZE() antlr.TerminalNode AND() antlr.TerminalNode ANY() antlr.TerminalNode ARRAY() antlr.TerminalNode AS() antlr.TerminalNode ASC() antlr.TerminalNode ASYMMETRIC() antlr.TerminalNode BOTH() antlr.TerminalNode CASE() antlr.TerminalNode CAST() antlr.TerminalNode CHECK() antlr.TerminalNode COLLATE() antlr.TerminalNode COLUMN() antlr.TerminalNode CONSTRAINT() antlr.TerminalNode CREATE() antlr.TerminalNode CURRENT_CATALOG() antlr.TerminalNode CURRENT_DATE() antlr.TerminalNode CURRENT_ROLE() antlr.TerminalNode CURRENT_TIME() antlr.TerminalNode CURRENT_TIMESTAMP() antlr.TerminalNode CURRENT_USER() antlr.TerminalNode DEFERRABLE() antlr.TerminalNode DESC() antlr.TerminalNode DISTINCT() antlr.TerminalNode DO() antlr.TerminalNode ELSE() antlr.TerminalNode END_P() antlr.TerminalNode EXCEPT() antlr.TerminalNode FALSE_P() antlr.TerminalNode FETCH() antlr.TerminalNode FOR() antlr.TerminalNode FOREIGN() antlr.TerminalNode FROM() antlr.TerminalNode GRANT() antlr.TerminalNode GROUP_P() antlr.TerminalNode HAVING() antlr.TerminalNode IN_P() antlr.TerminalNode INITIALLY() antlr.TerminalNode INTERSECT() antlr.TerminalNode LATERAL_P() antlr.TerminalNode LEADING() antlr.TerminalNode LIMIT() antlr.TerminalNode LOCALTIME() antlr.TerminalNode LOCALTIMESTAMP() antlr.TerminalNode NOT() antlr.TerminalNode NULL_P() antlr.TerminalNode OFFSET() antlr.TerminalNode ON() antlr.TerminalNode ONLY() antlr.TerminalNode OR() antlr.TerminalNode ORDER() antlr.TerminalNode PLACING() antlr.TerminalNode PRIMARY() antlr.TerminalNode REFERENCES() antlr.TerminalNode RETURNING() antlr.TerminalNode SELECT() antlr.TerminalNode SESSION_USER() antlr.TerminalNode SOME() antlr.TerminalNode SYMMETRIC() antlr.TerminalNode TABLE() antlr.TerminalNode THEN() antlr.TerminalNode TO() antlr.TerminalNode TRAILING() antlr.TerminalNode TRUE_P() antlr.TerminalNode UNION() antlr.TerminalNode UNIQUE() antlr.TerminalNode USER() antlr.TerminalNode USING() antlr.TerminalNode VARIADIC() antlr.TerminalNode WHEN() antlr.TerminalNode WHERE() antlr.TerminalNode WINDOW() antlr.TerminalNode WITH() antlr.TerminalNode // IsReserved_keywordContext differentiates from other interfaces. IsReserved_keywordContext() } type Reserved_keywordContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyReserved_keywordContext() *Reserved_keywordContext { var p = new(Reserved_keywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reserved_keyword return p } func InitEmptyReserved_keywordContext(p *Reserved_keywordContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_reserved_keyword } func (*Reserved_keywordContext) IsReserved_keywordContext() {} func NewReserved_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reserved_keywordContext { var p = new(Reserved_keywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_reserved_keyword return p } func (s *Reserved_keywordContext) GetParser() antlr.Parser { return s.parser } func (s *Reserved_keywordContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *Reserved_keywordContext) ANALYSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserANALYSE, 0) } func (s *Reserved_keywordContext) ANALYZE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserANALYZE, 0) } func (s *Reserved_keywordContext) AND() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAND, 0) } func (s *Reserved_keywordContext) ANY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserANY, 0) } func (s *Reserved_keywordContext) ARRAY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserARRAY, 0) } func (s *Reserved_keywordContext) AS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAS, 0) } func (s *Reserved_keywordContext) ASC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserASC, 0) } func (s *Reserved_keywordContext) ASYMMETRIC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserASYMMETRIC, 0) } func (s *Reserved_keywordContext) BOTH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBOTH, 0) } func (s *Reserved_keywordContext) CASE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCASE, 0) } func (s *Reserved_keywordContext) CAST() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCAST, 0) } func (s *Reserved_keywordContext) CHECK() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHECK, 0) } func (s *Reserved_keywordContext) COLLATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATE, 0) } func (s *Reserved_keywordContext) COLUMN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLUMN, 0) } func (s *Reserved_keywordContext) CONSTRAINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTRAINT, 0) } func (s *Reserved_keywordContext) CREATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCREATE, 0) } func (s *Reserved_keywordContext) CURRENT_CATALOG() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_CATALOG, 0) } func (s *Reserved_keywordContext) CURRENT_DATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_DATE, 0) } func (s *Reserved_keywordContext) CURRENT_ROLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_ROLE, 0) } func (s *Reserved_keywordContext) CURRENT_TIME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_TIME, 0) } func (s *Reserved_keywordContext) CURRENT_TIMESTAMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_TIMESTAMP, 0) } func (s *Reserved_keywordContext) CURRENT_USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_USER, 0) } func (s *Reserved_keywordContext) DEFERRABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFERRABLE, 0) } func (s *Reserved_keywordContext) DESC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDESC, 0) } func (s *Reserved_keywordContext) DISTINCT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDISTINCT, 0) } func (s *Reserved_keywordContext) DO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDO, 0) } func (s *Reserved_keywordContext) ELSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserELSE, 0) } func (s *Reserved_keywordContext) END_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEND_P, 0) } func (s *Reserved_keywordContext) EXCEPT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXCEPT, 0) } func (s *Reserved_keywordContext) FALSE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFALSE_P, 0) } func (s *Reserved_keywordContext) FETCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFETCH, 0) } func (s *Reserved_keywordContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *Reserved_keywordContext) FOREIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREIGN, 0) } func (s *Reserved_keywordContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *Reserved_keywordContext) GRANT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGRANT, 0) } func (s *Reserved_keywordContext) GROUP_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGROUP_P, 0) } func (s *Reserved_keywordContext) HAVING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserHAVING, 0) } func (s *Reserved_keywordContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *Reserved_keywordContext) INITIALLY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINITIALLY, 0) } func (s *Reserved_keywordContext) INTERSECT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINTERSECT, 0) } func (s *Reserved_keywordContext) LATERAL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLATERAL_P, 0) } func (s *Reserved_keywordContext) LEADING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLEADING, 0) } func (s *Reserved_keywordContext) LIMIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLIMIT, 0) } func (s *Reserved_keywordContext) LOCALTIME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCALTIME, 0) } func (s *Reserved_keywordContext) LOCALTIMESTAMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOCALTIMESTAMP, 0) } func (s *Reserved_keywordContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *Reserved_keywordContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *Reserved_keywordContext) OFFSET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOFFSET, 0) } func (s *Reserved_keywordContext) ON() antlr.TerminalNode { return s.GetToken(PostgreSQLParserON, 0) } func (s *Reserved_keywordContext) ONLY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserONLY, 0) } func (s *Reserved_keywordContext) OR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOR, 0) } func (s *Reserved_keywordContext) ORDER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserORDER, 0) } func (s *Reserved_keywordContext) PLACING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPLACING, 0) } func (s *Reserved_keywordContext) PRIMARY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRIMARY, 0) } func (s *Reserved_keywordContext) REFERENCES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREFERENCES, 0) } func (s *Reserved_keywordContext) RETURNING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRETURNING, 0) } func (s *Reserved_keywordContext) SELECT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSELECT, 0) } func (s *Reserved_keywordContext) SESSION_USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSESSION_USER, 0) } func (s *Reserved_keywordContext) SOME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSOME, 0) } func (s *Reserved_keywordContext) SYMMETRIC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSYMMETRIC, 0) } func (s *Reserved_keywordContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *Reserved_keywordContext) THEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTHEN, 0) } func (s *Reserved_keywordContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *Reserved_keywordContext) TRAILING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRAILING, 0) } func (s *Reserved_keywordContext) TRUE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRUE_P, 0) } func (s *Reserved_keywordContext) UNION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNION, 0) } func (s *Reserved_keywordContext) UNIQUE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNIQUE, 0) } func (s *Reserved_keywordContext) USER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSER, 0) } func (s *Reserved_keywordContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *Reserved_keywordContext) VARIADIC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVARIADIC, 0) } func (s *Reserved_keywordContext) WHEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHEN, 0) } func (s *Reserved_keywordContext) WHERE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHERE, 0) } func (s *Reserved_keywordContext) WINDOW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWINDOW, 0) } func (s *Reserved_keywordContext) WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWITH, 0) } func (s *Reserved_keywordContext) GetRuleContext() antlr.RuleContext { return s } func (s *Reserved_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Reserved_keywordContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterReserved_keyword(s) } } func (s *Reserved_keywordContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitReserved_keyword(s) } } func (s *Reserved_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitReserved_keyword(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Reserved_keyword() (localctx IReserved_keywordContext) { localctx = NewReserved_keywordContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1392, PostgreSQLParserRULE_reserved_keyword) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9948) _la = p.GetTokenStream().LA(1) if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9007200328482816) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&4398046510975) != 0) || _la == PostgreSQLParserEND_P) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IBuiltin_function_nameContext is an interface to support dynamic dispatch. type IBuiltin_function_nameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures XMLCOMMENT() antlr.TerminalNode XML_IS_WELL_FORMED() antlr.TerminalNode XML_IS_WELL_FORMED_DOCUMENT() antlr.TerminalNode XML_IS_WELL_FORMED_CONTENT() antlr.TerminalNode XMLAGG() antlr.TerminalNode XPATH() antlr.TerminalNode XPATH_EXISTS() antlr.TerminalNode ABS() antlr.TerminalNode CBRT() antlr.TerminalNode CEIL() antlr.TerminalNode CEILING() antlr.TerminalNode DEGREES() antlr.TerminalNode DIV() antlr.TerminalNode EXP() antlr.TerminalNode FACTORIAL() antlr.TerminalNode FLOOR() antlr.TerminalNode GCD() antlr.TerminalNode LCM() antlr.TerminalNode LN() antlr.TerminalNode LOG() antlr.TerminalNode LOG10() antlr.TerminalNode MIN_SCALE() antlr.TerminalNode MOD() antlr.TerminalNode PI() antlr.TerminalNode POWER() antlr.TerminalNode RADIANS() antlr.TerminalNode ROUND() antlr.TerminalNode SCALE() antlr.TerminalNode SIGN() antlr.TerminalNode SQRT() antlr.TerminalNode TRIM_SCALE() antlr.TerminalNode TRUNC() antlr.TerminalNode WIDTH_BUCKET() antlr.TerminalNode RANDOM() antlr.TerminalNode SETSEED() antlr.TerminalNode ACOS() antlr.TerminalNode ACOSD() antlr.TerminalNode ACOSH() antlr.TerminalNode ASIN() antlr.TerminalNode ASIND() antlr.TerminalNode ASINH() antlr.TerminalNode ATAN() antlr.TerminalNode ATAND() antlr.TerminalNode ATANH() antlr.TerminalNode ATAN2() antlr.TerminalNode ATAN2D() antlr.TerminalNode COS() antlr.TerminalNode COSD() antlr.TerminalNode COSH() antlr.TerminalNode COT() antlr.TerminalNode COTD() antlr.TerminalNode SIN() antlr.TerminalNode SIND() antlr.TerminalNode SINH() antlr.TerminalNode TAN() antlr.TerminalNode TAND() antlr.TerminalNode TANH() antlr.TerminalNode BIT_LENGTH() antlr.TerminalNode CHAR_LENGTH() antlr.TerminalNode CHARACTER_LENGTH() antlr.TerminalNode LOWER() antlr.TerminalNode OCTET_LENGTH() antlr.TerminalNode UPPER() antlr.TerminalNode ASCII() antlr.TerminalNode BTRIM() antlr.TerminalNode CHR() antlr.TerminalNode CONCAT() antlr.TerminalNode CONCAT_WS() antlr.TerminalNode FORMAT() antlr.TerminalNode INITCAP() antlr.TerminalNode LENGTH() antlr.TerminalNode LPAD() antlr.TerminalNode LTRIM() antlr.TerminalNode MD5() antlr.TerminalNode PARSE_IDENT() antlr.TerminalNode PG_CLIENT_ENCODING() antlr.TerminalNode QUOTE_IDENT() antlr.TerminalNode QUOTE_LITERAL() antlr.TerminalNode QUOTE_NULLABLE() antlr.TerminalNode REGEXP_COUNT() antlr.TerminalNode REGEXP_INSTR() antlr.TerminalNode REGEXP_LIKE() antlr.TerminalNode REGEXP_MATCH() antlr.TerminalNode REGEXP_MATCHES() antlr.TerminalNode REGEXP_REPLACE() antlr.TerminalNode REGEXP_SPLIT_TO_ARRAY() antlr.TerminalNode REGEXP_SPLIT_TO_TABLE() antlr.TerminalNode REGEXP_SUBSTR() antlr.TerminalNode REPEAT() antlr.TerminalNode REPLACE() antlr.TerminalNode REVERSE() antlr.TerminalNode RPAD() antlr.TerminalNode RTRIM() antlr.TerminalNode SPLIT_PART() antlr.TerminalNode STARTS_WITH() antlr.TerminalNode STRING_TO_ARRAY() antlr.TerminalNode STRING_TO_TABLE() antlr.TerminalNode STRPOS() antlr.TerminalNode SUBSTR() antlr.TerminalNode TO_ASCII() antlr.TerminalNode TO_HEX() antlr.TerminalNode TRANSLATE() antlr.TerminalNode UNISTR() antlr.TerminalNode AGE() antlr.TerminalNode DATE_BIN() antlr.TerminalNode DATE_PART() antlr.TerminalNode DATE_TRUNC() antlr.TerminalNode ISFINITE() antlr.TerminalNode JUSTIFY_DAYS() antlr.TerminalNode JUSTIFY_HOURS() antlr.TerminalNode JUSTIFY_INTERVAL() antlr.TerminalNode MAKE_DATE() antlr.TerminalNode MAKE_INTERVAL() antlr.TerminalNode MAKE_TIME() antlr.TerminalNode MAKE_TIMESTAMP() antlr.TerminalNode MAKE_TIMESTAMPTZ() antlr.TerminalNode CLOCK_TIMESTAMP() antlr.TerminalNode NOW() antlr.TerminalNode STATEMENT_TIMESTAMP() antlr.TerminalNode TIMEOFDAY() antlr.TerminalNode TRANSACTION_TIMESTAMP() antlr.TerminalNode TO_TIMESTAMP() antlr.TerminalNode TO_CHAR() antlr.TerminalNode TO_DATE() antlr.TerminalNode TO_NUMBER() antlr.TerminalNode // IsBuiltin_function_nameContext differentiates from other interfaces. IsBuiltin_function_nameContext() } type Builtin_function_nameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyBuiltin_function_nameContext() *Builtin_function_nameContext { var p = new(Builtin_function_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_builtin_function_name return p } func InitEmptyBuiltin_function_nameContext(p *Builtin_function_nameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_builtin_function_name } func (*Builtin_function_nameContext) IsBuiltin_function_nameContext() {} func NewBuiltin_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Builtin_function_nameContext { var p = new(Builtin_function_nameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_builtin_function_name return p } func (s *Builtin_function_nameContext) GetParser() antlr.Parser { return s.parser } func (s *Builtin_function_nameContext) XMLCOMMENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLCOMMENT, 0) } func (s *Builtin_function_nameContext) XML_IS_WELL_FORMED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXML_IS_WELL_FORMED, 0) } func (s *Builtin_function_nameContext) XML_IS_WELL_FORMED_DOCUMENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, 0) } func (s *Builtin_function_nameContext) XML_IS_WELL_FORMED_CONTENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, 0) } func (s *Builtin_function_nameContext) XMLAGG() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXMLAGG, 0) } func (s *Builtin_function_nameContext) XPATH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXPATH, 0) } func (s *Builtin_function_nameContext) XPATH_EXISTS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserXPATH_EXISTS, 0) } func (s *Builtin_function_nameContext) ABS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserABS, 0) } func (s *Builtin_function_nameContext) CBRT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCBRT, 0) } func (s *Builtin_function_nameContext) CEIL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCEIL, 0) } func (s *Builtin_function_nameContext) CEILING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCEILING, 0) } func (s *Builtin_function_nameContext) DEGREES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEGREES, 0) } func (s *Builtin_function_nameContext) DIV() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDIV, 0) } func (s *Builtin_function_nameContext) EXP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXP, 0) } func (s *Builtin_function_nameContext) FACTORIAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFACTORIAL, 0) } func (s *Builtin_function_nameContext) FLOOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFLOOR, 0) } func (s *Builtin_function_nameContext) GCD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGCD, 0) } func (s *Builtin_function_nameContext) LCM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLCM, 0) } func (s *Builtin_function_nameContext) LN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLN, 0) } func (s *Builtin_function_nameContext) LOG() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOG, 0) } func (s *Builtin_function_nameContext) LOG10() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOG10, 0) } func (s *Builtin_function_nameContext) MIN_SCALE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMIN_SCALE, 0) } func (s *Builtin_function_nameContext) MOD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMOD, 0) } func (s *Builtin_function_nameContext) PI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPI, 0) } func (s *Builtin_function_nameContext) POWER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPOWER, 0) } func (s *Builtin_function_nameContext) RADIANS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRADIANS, 0) } func (s *Builtin_function_nameContext) ROUND() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROUND, 0) } func (s *Builtin_function_nameContext) SCALE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCALE, 0) } func (s *Builtin_function_nameContext) SIGN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSIGN, 0) } func (s *Builtin_function_nameContext) SQRT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSQRT, 0) } func (s *Builtin_function_nameContext) TRIM_SCALE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRIM_SCALE, 0) } func (s *Builtin_function_nameContext) TRUNC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRUNC, 0) } func (s *Builtin_function_nameContext) WIDTH_BUCKET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWIDTH_BUCKET, 0) } func (s *Builtin_function_nameContext) RANDOM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRANDOM, 0) } func (s *Builtin_function_nameContext) SETSEED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSETSEED, 0) } func (s *Builtin_function_nameContext) ACOS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserACOS, 0) } func (s *Builtin_function_nameContext) ACOSD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserACOSD, 0) } func (s *Builtin_function_nameContext) ACOSH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserACOSH, 0) } func (s *Builtin_function_nameContext) ASIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserASIN, 0) } func (s *Builtin_function_nameContext) ASIND() antlr.TerminalNode { return s.GetToken(PostgreSQLParserASIND, 0) } func (s *Builtin_function_nameContext) ASINH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserASINH, 0) } func (s *Builtin_function_nameContext) ATAN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserATAN, 0) } func (s *Builtin_function_nameContext) ATAND() antlr.TerminalNode { return s.GetToken(PostgreSQLParserATAND, 0) } func (s *Builtin_function_nameContext) ATANH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserATANH, 0) } func (s *Builtin_function_nameContext) ATAN2() antlr.TerminalNode { return s.GetToken(PostgreSQLParserATAN2, 0) } func (s *Builtin_function_nameContext) ATAN2D() antlr.TerminalNode { return s.GetToken(PostgreSQLParserATAN2D, 0) } func (s *Builtin_function_nameContext) COS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOS, 0) } func (s *Builtin_function_nameContext) COSD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOSD, 0) } func (s *Builtin_function_nameContext) COSH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOSH, 0) } func (s *Builtin_function_nameContext) COT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOT, 0) } func (s *Builtin_function_nameContext) COTD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOTD, 0) } func (s *Builtin_function_nameContext) SIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSIN, 0) } func (s *Builtin_function_nameContext) SIND() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSIND, 0) } func (s *Builtin_function_nameContext) SINH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSINH, 0) } func (s *Builtin_function_nameContext) TAN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTAN, 0) } func (s *Builtin_function_nameContext) TAND() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTAND, 0) } func (s *Builtin_function_nameContext) TANH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTANH, 0) } func (s *Builtin_function_nameContext) BIT_LENGTH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBIT_LENGTH, 0) } func (s *Builtin_function_nameContext) CHAR_LENGTH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHAR_LENGTH, 0) } func (s *Builtin_function_nameContext) CHARACTER_LENGTH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHARACTER_LENGTH, 0) } func (s *Builtin_function_nameContext) LOWER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOWER, 0) } func (s *Builtin_function_nameContext) OCTET_LENGTH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOCTET_LENGTH, 0) } func (s *Builtin_function_nameContext) UPPER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUPPER, 0) } func (s *Builtin_function_nameContext) ASCII() antlr.TerminalNode { return s.GetToken(PostgreSQLParserASCII, 0) } func (s *Builtin_function_nameContext) BTRIM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBTRIM, 0) } func (s *Builtin_function_nameContext) CHR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHR, 0) } func (s *Builtin_function_nameContext) CONCAT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONCAT, 0) } func (s *Builtin_function_nameContext) CONCAT_WS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONCAT_WS, 0) } func (s *Builtin_function_nameContext) FORMAT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFORMAT, 0) } func (s *Builtin_function_nameContext) INITCAP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINITCAP, 0) } func (s *Builtin_function_nameContext) LENGTH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLENGTH, 0) } func (s *Builtin_function_nameContext) LPAD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLPAD, 0) } func (s *Builtin_function_nameContext) LTRIM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLTRIM, 0) } func (s *Builtin_function_nameContext) MD5() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMD5, 0) } func (s *Builtin_function_nameContext) PARSE_IDENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARSE_IDENT, 0) } func (s *Builtin_function_nameContext) PG_CLIENT_ENCODING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPG_CLIENT_ENCODING, 0) } func (s *Builtin_function_nameContext) QUOTE_IDENT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserQUOTE_IDENT, 0) } func (s *Builtin_function_nameContext) QUOTE_LITERAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserQUOTE_LITERAL, 0) } func (s *Builtin_function_nameContext) QUOTE_NULLABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserQUOTE_NULLABLE, 0) } func (s *Builtin_function_nameContext) REGEXP_COUNT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREGEXP_COUNT, 0) } func (s *Builtin_function_nameContext) REGEXP_INSTR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREGEXP_INSTR, 0) } func (s *Builtin_function_nameContext) REGEXP_LIKE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREGEXP_LIKE, 0) } func (s *Builtin_function_nameContext) REGEXP_MATCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREGEXP_MATCH, 0) } func (s *Builtin_function_nameContext) REGEXP_MATCHES() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREGEXP_MATCHES, 0) } func (s *Builtin_function_nameContext) REGEXP_REPLACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREGEXP_REPLACE, 0) } func (s *Builtin_function_nameContext) REGEXP_SPLIT_TO_ARRAY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, 0) } func (s *Builtin_function_nameContext) REGEXP_SPLIT_TO_TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREGEXP_SPLIT_TO_TABLE, 0) } func (s *Builtin_function_nameContext) REGEXP_SUBSTR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREGEXP_SUBSTR, 0) } func (s *Builtin_function_nameContext) REPEAT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREPEAT, 0) } func (s *Builtin_function_nameContext) REPLACE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREPLACE, 0) } func (s *Builtin_function_nameContext) REVERSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREVERSE, 0) } func (s *Builtin_function_nameContext) RPAD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRPAD, 0) } func (s *Builtin_function_nameContext) RTRIM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRTRIM, 0) } func (s *Builtin_function_nameContext) SPLIT_PART() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSPLIT_PART, 0) } func (s *Builtin_function_nameContext) STARTS_WITH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTARTS_WITH, 0) } func (s *Builtin_function_nameContext) STRING_TO_ARRAY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTRING_TO_ARRAY, 0) } func (s *Builtin_function_nameContext) STRING_TO_TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTRING_TO_TABLE, 0) } func (s *Builtin_function_nameContext) STRPOS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTRPOS, 0) } func (s *Builtin_function_nameContext) SUBSTR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSUBSTR, 0) } func (s *Builtin_function_nameContext) TO_ASCII() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO_ASCII, 0) } func (s *Builtin_function_nameContext) TO_HEX() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO_HEX, 0) } func (s *Builtin_function_nameContext) TRANSLATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSLATE, 0) } func (s *Builtin_function_nameContext) UNISTR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUNISTR, 0) } func (s *Builtin_function_nameContext) AGE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAGE, 0) } func (s *Builtin_function_nameContext) DATE_BIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATE_BIN, 0) } func (s *Builtin_function_nameContext) DATE_PART() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATE_PART, 0) } func (s *Builtin_function_nameContext) DATE_TRUNC() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDATE_TRUNC, 0) } func (s *Builtin_function_nameContext) ISFINITE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserISFINITE, 0) } func (s *Builtin_function_nameContext) JUSTIFY_DAYS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserJUSTIFY_DAYS, 0) } func (s *Builtin_function_nameContext) JUSTIFY_HOURS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserJUSTIFY_HOURS, 0) } func (s *Builtin_function_nameContext) JUSTIFY_INTERVAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserJUSTIFY_INTERVAL, 0) } func (s *Builtin_function_nameContext) MAKE_DATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMAKE_DATE, 0) } func (s *Builtin_function_nameContext) MAKE_INTERVAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMAKE_INTERVAL, 0) } func (s *Builtin_function_nameContext) MAKE_TIME() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMAKE_TIME, 0) } func (s *Builtin_function_nameContext) MAKE_TIMESTAMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMAKE_TIMESTAMP, 0) } func (s *Builtin_function_nameContext) MAKE_TIMESTAMPTZ() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMAKE_TIMESTAMPTZ, 0) } func (s *Builtin_function_nameContext) CLOCK_TIMESTAMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOCK_TIMESTAMP, 0) } func (s *Builtin_function_nameContext) NOW() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOW, 0) } func (s *Builtin_function_nameContext) STATEMENT_TIMESTAMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTATEMENT_TIMESTAMP, 0) } func (s *Builtin_function_nameContext) TIMEOFDAY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTIMEOFDAY, 0) } func (s *Builtin_function_nameContext) TRANSACTION_TIMESTAMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTRANSACTION_TIMESTAMP, 0) } func (s *Builtin_function_nameContext) TO_TIMESTAMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO_TIMESTAMP, 0) } func (s *Builtin_function_nameContext) TO_CHAR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO_CHAR, 0) } func (s *Builtin_function_nameContext) TO_DATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO_DATE, 0) } func (s *Builtin_function_nameContext) TO_NUMBER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO_NUMBER, 0) } func (s *Builtin_function_nameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Builtin_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Builtin_function_nameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterBuiltin_function_name(s) } } func (s *Builtin_function_nameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitBuiltin_function_name(s) } } func (s *Builtin_function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitBuiltin_function_name(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Builtin_function_name() (localctx IBuiltin_function_nameContext) { localctx = NewBuiltin_function_nameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1394, PostgreSQLParserRULE_builtin_function_name) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(9950) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserREPLACE || ((int64((_la-418)) & ^0x3f) == 0 && ((int64(1)<<(_la-418))&127) != 0) || ((int64((_la-504)) & ^0x3f) == 0 && ((int64(1)<<(_la-504))&-130559) != 0) || ((int64((_la-568)) & ^0x3f) == 0 && ((int64(1)<<(_la-568))&-1) != 0) || ((int64((_la-632)) & ^0x3f) == 0 && ((int64(1)<<(_la-632))&15) != 0)) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPl_functionContext is an interface to support dynamic dispatch. type IPl_functionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Comp_options() IComp_optionsContext Pl_block() IPl_blockContext Opt_semi() IOpt_semiContext // IsPl_functionContext differentiates from other interfaces. IsPl_functionContext() } type Pl_functionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPl_functionContext() *Pl_functionContext { var p = new(Pl_functionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_pl_function return p } func InitEmptyPl_functionContext(p *Pl_functionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_pl_function } func (*Pl_functionContext) IsPl_functionContext() {} func NewPl_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pl_functionContext { var p = new(Pl_functionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_pl_function return p } func (s *Pl_functionContext) GetParser() antlr.Parser { return s.parser } func (s *Pl_functionContext) Comp_options() IComp_optionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IComp_optionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IComp_optionsContext) } func (s *Pl_functionContext) Pl_block() IPl_blockContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPl_blockContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPl_blockContext) } func (s *Pl_functionContext) Opt_semi() IOpt_semiContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_semiContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_semiContext) } func (s *Pl_functionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Pl_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Pl_functionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPl_function(s) } } func (s *Pl_functionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPl_function(s) } } func (s *Pl_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPl_function(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Pl_function() (localctx IPl_functionContext) { localctx = NewPl_functionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1396, PostgreSQLParserRULE_pl_function) p.EnterOuterAlt(localctx, 1) { p.SetState(9952) p.Comp_options() } { p.SetState(9953) p.Pl_block() } { p.SetState(9954) p.Opt_semi() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IComp_optionsContext is an interface to support dynamic dispatch. type IComp_optionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllComp_option() []IComp_optionContext Comp_option(i int) IComp_optionContext // IsComp_optionsContext differentiates from other interfaces. IsComp_optionsContext() } type Comp_optionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyComp_optionsContext() *Comp_optionsContext { var p = new(Comp_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_comp_options return p } func InitEmptyComp_optionsContext(p *Comp_optionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_comp_options } func (*Comp_optionsContext) IsComp_optionsContext() {} func NewComp_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comp_optionsContext { var p = new(Comp_optionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_comp_options return p } func (s *Comp_optionsContext) GetParser() antlr.Parser { return s.parser } func (s *Comp_optionsContext) AllComp_option() []IComp_optionContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IComp_optionContext); ok { len++ } } tst := make([]IComp_optionContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IComp_optionContext); ok { tst[i] = t.(IComp_optionContext) i++ } } return tst } func (s *Comp_optionsContext) Comp_option(i int) IComp_optionContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IComp_optionContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IComp_optionContext) } func (s *Comp_optionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Comp_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Comp_optionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterComp_options(s) } } func (s *Comp_optionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitComp_options(s) } } func (s *Comp_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitComp_options(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Comp_options() (localctx IComp_optionsContext) { localctx = NewComp_optionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1398, PostgreSQLParserRULE_comp_options) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(9959) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserOperator { { p.SetState(9956) p.Comp_option() } p.SetState(9961) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IComp_optionContext is an interface to support dynamic dispatch. type IComp_optionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sharp() ISharpContext OPTION() antlr.TerminalNode DUMP() antlr.TerminalNode PRINT_STRICT_PARAMS() antlr.TerminalNode Option_value() IOption_valueContext VARIABLE_CONFLICT() antlr.TerminalNode ERROR() antlr.TerminalNode USE_VARIABLE() antlr.TerminalNode USE_COLUMN() antlr.TerminalNode // IsComp_optionContext differentiates from other interfaces. IsComp_optionContext() } type Comp_optionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyComp_optionContext() *Comp_optionContext { var p = new(Comp_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_comp_option return p } func InitEmptyComp_optionContext(p *Comp_optionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_comp_option } func (*Comp_optionContext) IsComp_optionContext() {} func NewComp_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comp_optionContext { var p = new(Comp_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_comp_option return p } func (s *Comp_optionContext) GetParser() antlr.Parser { return s.parser } func (s *Comp_optionContext) Sharp() ISharpContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISharpContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISharpContext) } func (s *Comp_optionContext) OPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPTION, 0) } func (s *Comp_optionContext) DUMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDUMP, 0) } func (s *Comp_optionContext) PRINT_STRICT_PARAMS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRINT_STRICT_PARAMS, 0) } func (s *Comp_optionContext) Option_value() IOption_valueContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOption_valueContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOption_valueContext) } func (s *Comp_optionContext) VARIABLE_CONFLICT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVARIABLE_CONFLICT, 0) } func (s *Comp_optionContext) ERROR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserERROR, 0) } func (s *Comp_optionContext) USE_VARIABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSE_VARIABLE, 0) } func (s *Comp_optionContext) USE_COLUMN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSE_COLUMN, 0) } func (s *Comp_optionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Comp_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Comp_optionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterComp_option(s) } } func (s *Comp_optionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitComp_option(s) } } func (s *Comp_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitComp_option(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Comp_option() (localctx IComp_optionContext) { localctx = NewComp_optionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1400, PostgreSQLParserRULE_comp_option) p.SetState(9982) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 666, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9962) p.Sharp() } { p.SetState(9963) p.Match(PostgreSQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9964) p.Match(PostgreSQLParserDUMP) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9966) p.Sharp() } { p.SetState(9967) p.Match(PostgreSQLParserPRINT_STRICT_PARAMS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9968) p.Option_value() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9970) p.Sharp() } { p.SetState(9971) p.Match(PostgreSQLParserVARIABLE_CONFLICT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9972) p.Match(PostgreSQLParserERROR) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(9974) p.Sharp() } { p.SetState(9975) p.Match(PostgreSQLParserVARIABLE_CONFLICT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9976) p.Match(PostgreSQLParserUSE_VARIABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(9978) p.Sharp() } { p.SetState(9979) p.Match(PostgreSQLParserVARIABLE_CONFLICT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9980) p.Match(PostgreSQLParserUSE_COLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISharpContext is an interface to support dynamic dispatch. type ISharpContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Operator() antlr.TerminalNode // IsSharpContext differentiates from other interfaces. IsSharpContext() } type SharpContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySharpContext() *SharpContext { var p = new(SharpContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_sharp return p } func InitEmptySharpContext(p *SharpContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_sharp } func (*SharpContext) IsSharpContext() {} func NewSharpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SharpContext { var p = new(SharpContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_sharp return p } func (s *SharpContext) GetParser() antlr.Parser { return s.parser } func (s *SharpContext) Operator() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOperator, 0) } func (s *SharpContext) GetRuleContext() antlr.RuleContext { return s } func (s *SharpContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SharpContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSharp(s) } } func (s *SharpContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSharp(s) } } func (s *SharpContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSharp(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Sharp() (localctx ISharpContext) { localctx = NewSharpContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1402, PostgreSQLParserRULE_sharp) p.EnterOuterAlt(localctx, 1) { p.SetState(9984) p.Match(PostgreSQLParserOperator) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOption_valueContext is an interface to support dynamic dispatch. type IOption_valueContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sconst() ISconstContext Reserved_keyword() IReserved_keywordContext Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext Unreserved_keyword() IUnreserved_keywordContext // IsOption_valueContext differentiates from other interfaces. IsOption_valueContext() } type Option_valueContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOption_valueContext() *Option_valueContext { var p = new(Option_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_option_value return p } func InitEmptyOption_valueContext(p *Option_valueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_option_value } func (*Option_valueContext) IsOption_valueContext() {} func NewOption_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Option_valueContext { var p = new(Option_valueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_option_value return p } func (s *Option_valueContext) GetParser() antlr.Parser { return s.parser } func (s *Option_valueContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Option_valueContext) Reserved_keyword() IReserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IReserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IReserved_keywordContext) } func (s *Option_valueContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPlsql_unreserved_keywordContext) } func (s *Option_valueContext) Unreserved_keyword() IUnreserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUnreserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUnreserved_keywordContext) } func (s *Option_valueContext) GetRuleContext() antlr.RuleContext { return s } func (s *Option_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Option_valueContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOption_value(s) } } func (s *Option_valueContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOption_value(s) } } func (s *Option_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOption_value(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Option_value() (localctx IOption_valueContext) { localctx = NewOption_valueContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1404, PostgreSQLParserRULE_option_value) p.SetState(9990) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 667, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(9986) p.Sconst() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(9987) p.Reserved_keyword() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(9988) p.Plsql_unreserved_keyword() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(9989) p.Unreserved_keyword() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_semiContext is an interface to support dynamic dispatch. type IOpt_semiContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SEMI() antlr.TerminalNode // IsOpt_semiContext differentiates from other interfaces. IsOpt_semiContext() } type Opt_semiContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_semiContext() *Opt_semiContext { var p = new(Opt_semiContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_semi return p } func InitEmptyOpt_semiContext(p *Opt_semiContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_semi } func (*Opt_semiContext) IsOpt_semiContext() {} func NewOpt_semiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_semiContext { var p = new(Opt_semiContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_semi return p } func (s *Opt_semiContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_semiContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Opt_semiContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_semiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_semiContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_semi(s) } } func (s *Opt_semiContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_semi(s) } } func (s *Opt_semiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_semi(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_semi() (localctx IOpt_semiContext) { localctx = NewOpt_semiContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1406, PostgreSQLParserRULE_opt_semi) p.SetState(9994) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserEOF: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserSEMI: p.EnterOuterAlt(localctx, 2) { p.SetState(9993) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPl_blockContext is an interface to support dynamic dispatch. type IPl_blockContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Decl_sect() IDecl_sectContext BEGIN_P() antlr.TerminalNode Proc_sect() IProc_sectContext Exception_sect() IException_sectContext END_P() antlr.TerminalNode Opt_label() IOpt_labelContext // IsPl_blockContext differentiates from other interfaces. IsPl_blockContext() } type Pl_blockContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPl_blockContext() *Pl_blockContext { var p = new(Pl_blockContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_pl_block return p } func InitEmptyPl_blockContext(p *Pl_blockContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_pl_block } func (*Pl_blockContext) IsPl_blockContext() {} func NewPl_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pl_blockContext { var p = new(Pl_blockContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_pl_block return p } func (s *Pl_blockContext) GetParser() antlr.Parser { return s.parser } func (s *Pl_blockContext) Decl_sect() IDecl_sectContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_sectContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_sectContext) } func (s *Pl_blockContext) BEGIN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBEGIN_P, 0) } func (s *Pl_blockContext) Proc_sect() IProc_sectContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IProc_sectContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IProc_sectContext) } func (s *Pl_blockContext) Exception_sect() IException_sectContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IException_sectContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IException_sectContext) } func (s *Pl_blockContext) END_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEND_P, 0) } func (s *Pl_blockContext) Opt_label() IOpt_labelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_labelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_labelContext) } func (s *Pl_blockContext) GetRuleContext() antlr.RuleContext { return s } func (s *Pl_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Pl_blockContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPl_block(s) } } func (s *Pl_blockContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPl_block(s) } } func (s *Pl_blockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPl_block(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Pl_block() (localctx IPl_blockContext) { localctx = NewPl_blockContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1408, PostgreSQLParserRULE_pl_block) p.EnterOuterAlt(localctx, 1) { p.SetState(9996) p.Decl_sect() } { p.SetState(9997) p.Match(PostgreSQLParserBEGIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(9998) p.Proc_sect() } { p.SetState(9999) p.Exception_sect() } { p.SetState(10000) p.Match(PostgreSQLParserEND_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10001) p.Opt_label() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_sectContext is an interface to support dynamic dispatch. type IDecl_sectContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_block_label() IOpt_block_labelContext Decl_start() IDecl_startContext Decl_stmts() IDecl_stmtsContext // IsDecl_sectContext differentiates from other interfaces. IsDecl_sectContext() } type Decl_sectContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_sectContext() *Decl_sectContext { var p = new(Decl_sectContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_sect return p } func InitEmptyDecl_sectContext(p *Decl_sectContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_sect } func (*Decl_sectContext) IsDecl_sectContext() {} func NewDecl_sectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_sectContext { var p = new(Decl_sectContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_sect return p } func (s *Decl_sectContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_sectContext) Opt_block_label() IOpt_block_labelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_block_labelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_block_labelContext) } func (s *Decl_sectContext) Decl_start() IDecl_startContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_startContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_startContext) } func (s *Decl_sectContext) Decl_stmts() IDecl_stmtsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_stmtsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_stmtsContext) } func (s *Decl_sectContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_sectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_sectContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_sect(s) } } func (s *Decl_sectContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_sect(s) } } func (s *Decl_sectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_sect(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_sect() (localctx IDecl_sectContext) { localctx = NewDecl_sectContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1410, PostgreSQLParserRULE_decl_sect) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(10003) p.Opt_block_label() } p.SetState(10008) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserDECLARE { { p.SetState(10004) p.Decl_start() } p.SetState(10006) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 669, p.GetParserRuleContext()) == 1 { { p.SetState(10005) p.Decl_stmts() } } else if p.HasError() { // JIM goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_startContext is an interface to support dynamic dispatch. type IDecl_startContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DECLARE() antlr.TerminalNode // IsDecl_startContext differentiates from other interfaces. IsDecl_startContext() } type Decl_startContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_startContext() *Decl_startContext { var p = new(Decl_startContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_start return p } func InitEmptyDecl_startContext(p *Decl_startContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_start } func (*Decl_startContext) IsDecl_startContext() {} func NewDecl_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_startContext { var p = new(Decl_startContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_start return p } func (s *Decl_startContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_startContext) DECLARE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDECLARE, 0) } func (s *Decl_startContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_startContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_start(s) } } func (s *Decl_startContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_start(s) } } func (s *Decl_startContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_start(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_start() (localctx IDecl_startContext) { localctx = NewDecl_startContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1412, PostgreSQLParserRULE_decl_start) p.EnterOuterAlt(localctx, 1) { p.SetState(10010) p.Match(PostgreSQLParserDECLARE) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_stmtsContext is an interface to support dynamic dispatch. type IDecl_stmtsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllDecl_stmt() []IDecl_stmtContext Decl_stmt(i int) IDecl_stmtContext // IsDecl_stmtsContext differentiates from other interfaces. IsDecl_stmtsContext() } type Decl_stmtsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_stmtsContext() *Decl_stmtsContext { var p = new(Decl_stmtsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_stmts return p } func InitEmptyDecl_stmtsContext(p *Decl_stmtsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_stmts } func (*Decl_stmtsContext) IsDecl_stmtsContext() {} func NewDecl_stmtsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_stmtsContext { var p = new(Decl_stmtsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_stmts return p } func (s *Decl_stmtsContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_stmtsContext) AllDecl_stmt() []IDecl_stmtContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IDecl_stmtContext); ok { len++ } } tst := make([]IDecl_stmtContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IDecl_stmtContext); ok { tst[i] = t.(IDecl_stmtContext) i++ } } return tst } func (s *Decl_stmtsContext) Decl_stmt(i int) IDecl_stmtContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_stmtContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IDecl_stmtContext) } func (s *Decl_stmtsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_stmtsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_stmtsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_stmts(s) } } func (s *Decl_stmtsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_stmts(s) } } func (s *Decl_stmtsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_stmts(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_stmts() (localctx IDecl_stmtsContext) { localctx = NewDecl_stmtsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1414, PostgreSQLParserRULE_decl_stmts) var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(10013) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = 1 for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { switch _alt { case 1: { p.SetState(10012) p.Decl_stmt() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.SetState(10015) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 671, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ILabel_declContext is an interface to support dynamic dispatch. type ILabel_declContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures LESS_LESS() antlr.TerminalNode Any_identifier() IAny_identifierContext GREATER_GREATER() antlr.TerminalNode // IsLabel_declContext differentiates from other interfaces. IsLabel_declContext() } type Label_declContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyLabel_declContext() *Label_declContext { var p = new(Label_declContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_label_decl return p } func InitEmptyLabel_declContext(p *Label_declContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_label_decl } func (*Label_declContext) IsLabel_declContext() {} func NewLabel_declContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Label_declContext { var p = new(Label_declContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_label_decl return p } func (s *Label_declContext) GetParser() antlr.Parser { return s.parser } func (s *Label_declContext) LESS_LESS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLESS_LESS, 0) } func (s *Label_declContext) Any_identifier() IAny_identifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_identifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_identifierContext) } func (s *Label_declContext) GREATER_GREATER() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGREATER_GREATER, 0) } func (s *Label_declContext) GetRuleContext() antlr.RuleContext { return s } func (s *Label_declContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Label_declContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterLabel_decl(s) } } func (s *Label_declContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitLabel_decl(s) } } func (s *Label_declContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitLabel_decl(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Label_decl() (localctx ILabel_declContext) { localctx = NewLabel_declContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1416, PostgreSQLParserRULE_label_decl) p.EnterOuterAlt(localctx, 1) { p.SetState(10017) p.Match(PostgreSQLParserLESS_LESS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10018) p.Any_identifier() } { p.SetState(10019) p.Match(PostgreSQLParserGREATER_GREATER) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_stmtContext is an interface to support dynamic dispatch. type IDecl_stmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Decl_statement() IDecl_statementContext DECLARE() antlr.TerminalNode Label_decl() ILabel_declContext // IsDecl_stmtContext differentiates from other interfaces. IsDecl_stmtContext() } type Decl_stmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_stmtContext() *Decl_stmtContext { var p = new(Decl_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_stmt return p } func InitEmptyDecl_stmtContext(p *Decl_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_stmt } func (*Decl_stmtContext) IsDecl_stmtContext() {} func NewDecl_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_stmtContext { var p = new(Decl_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_stmt return p } func (s *Decl_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_stmtContext) Decl_statement() IDecl_statementContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_statementContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_statementContext) } func (s *Decl_stmtContext) DECLARE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDECLARE, 0) } func (s *Decl_stmtContext) Label_decl() ILabel_declContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ILabel_declContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ILabel_declContext) } func (s *Decl_stmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_stmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_stmt(s) } } func (s *Decl_stmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_stmt(s) } } func (s *Decl_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_stmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_stmt() (localctx IDecl_stmtContext) { localctx = NewDecl_stmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1418, PostgreSQLParserRULE_decl_stmt) p.SetState(10024) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 672, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(10021) p.Decl_statement() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(10022) p.Match(PostgreSQLParserDECLARE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(10023) p.Label_decl() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_statementContext is an interface to support dynamic dispatch. type IDecl_statementContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Decl_varname() IDecl_varnameContext SEMI() antlr.TerminalNode ALIAS() antlr.TerminalNode FOR() antlr.TerminalNode Decl_aliasitem() IDecl_aliasitemContext Decl_const() IDecl_constContext Decl_datatype() IDecl_datatypeContext Decl_collate() IDecl_collateContext Decl_notnull() IDecl_notnullContext Decl_defval() IDecl_defvalContext Opt_scrollable() IOpt_scrollableContext CURSOR() antlr.TerminalNode Decl_cursor_args() IDecl_cursor_argsContext Decl_is_for() IDecl_is_forContext Decl_cursor_query() IDecl_cursor_queryContext // IsDecl_statementContext differentiates from other interfaces. IsDecl_statementContext() } type Decl_statementContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_statementContext() *Decl_statementContext { var p = new(Decl_statementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_statement return p } func InitEmptyDecl_statementContext(p *Decl_statementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_statement } func (*Decl_statementContext) IsDecl_statementContext() {} func NewDecl_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_statementContext { var p = new(Decl_statementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_statement return p } func (s *Decl_statementContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_statementContext) Decl_varname() IDecl_varnameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_varnameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_varnameContext) } func (s *Decl_statementContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Decl_statementContext) ALIAS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALIAS, 0) } func (s *Decl_statementContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *Decl_statementContext) Decl_aliasitem() IDecl_aliasitemContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_aliasitemContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_aliasitemContext) } func (s *Decl_statementContext) Decl_const() IDecl_constContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_constContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_constContext) } func (s *Decl_statementContext) Decl_datatype() IDecl_datatypeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_datatypeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_datatypeContext) } func (s *Decl_statementContext) Decl_collate() IDecl_collateContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_collateContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_collateContext) } func (s *Decl_statementContext) Decl_notnull() IDecl_notnullContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_notnullContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_notnullContext) } func (s *Decl_statementContext) Decl_defval() IDecl_defvalContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_defvalContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_defvalContext) } func (s *Decl_statementContext) Opt_scrollable() IOpt_scrollableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_scrollableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_scrollableContext) } func (s *Decl_statementContext) CURSOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURSOR, 0) } func (s *Decl_statementContext) Decl_cursor_args() IDecl_cursor_argsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_cursor_argsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_cursor_argsContext) } func (s *Decl_statementContext) Decl_is_for() IDecl_is_forContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_is_forContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_is_forContext) } func (s *Decl_statementContext) Decl_cursor_query() IDecl_cursor_queryContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_cursor_queryContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_cursor_queryContext) } func (s *Decl_statementContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_statementContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_statement(s) } } func (s *Decl_statementContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_statement(s) } } func (s *Decl_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_statement(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_statement() (localctx IDecl_statementContext) { localctx = NewDecl_statementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1420, PostgreSQLParserRULE_decl_statement) p.EnterOuterAlt(localctx, 1) { p.SetState(10026) p.Decl_varname() } p.SetState(10042) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 673, p.GetParserRuleContext()) { case 1: { p.SetState(10027) p.Match(PostgreSQLParserALIAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10028) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10029) p.Decl_aliasitem() } case 2: { p.SetState(10030) p.Decl_const() } { p.SetState(10031) p.Decl_datatype() } { p.SetState(10032) p.Decl_collate() } { p.SetState(10033) p.Decl_notnull() } { p.SetState(10034) p.Decl_defval() } case 3: { p.SetState(10036) p.Opt_scrollable() } { p.SetState(10037) p.Match(PostgreSQLParserCURSOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10038) p.Decl_cursor_args() } { p.SetState(10039) p.Decl_is_for() } { p.SetState(10040) p.Decl_cursor_query() } case antlr.ATNInvalidAltNumber: goto errorExit } { p.SetState(10044) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_scrollableContext is an interface to support dynamic dispatch. type IOpt_scrollableContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NO() antlr.TerminalNode SCROLL() antlr.TerminalNode // IsOpt_scrollableContext differentiates from other interfaces. IsOpt_scrollableContext() } type Opt_scrollableContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_scrollableContext() *Opt_scrollableContext { var p = new(Opt_scrollableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_scrollable return p } func InitEmptyOpt_scrollableContext(p *Opt_scrollableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_scrollable } func (*Opt_scrollableContext) IsOpt_scrollableContext() {} func NewOpt_scrollableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_scrollableContext { var p = new(Opt_scrollableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_scrollable return p } func (s *Opt_scrollableContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_scrollableContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Opt_scrollableContext) SCROLL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCROLL, 0) } func (s *Opt_scrollableContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_scrollableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_scrollableContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_scrollable(s) } } func (s *Opt_scrollableContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_scrollable(s) } } func (s *Opt_scrollableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_scrollable(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_scrollable() (localctx IOpt_scrollableContext) { localctx = NewOpt_scrollableContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1422, PostgreSQLParserRULE_opt_scrollable) p.SetState(10050) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCURSOR: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserNO: p.EnterOuterAlt(localctx, 2) { p.SetState(10047) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10048) p.Match(PostgreSQLParserSCROLL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSCROLL: p.EnterOuterAlt(localctx, 3) { p.SetState(10049) p.Match(PostgreSQLParserSCROLL) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_cursor_queryContext is an interface to support dynamic dispatch. type IDecl_cursor_queryContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Selectstmt() ISelectstmtContext // IsDecl_cursor_queryContext differentiates from other interfaces. IsDecl_cursor_queryContext() } type Decl_cursor_queryContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_cursor_queryContext() *Decl_cursor_queryContext { var p = new(Decl_cursor_queryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_cursor_query return p } func InitEmptyDecl_cursor_queryContext(p *Decl_cursor_queryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_cursor_query } func (*Decl_cursor_queryContext) IsDecl_cursor_queryContext() {} func NewDecl_cursor_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_cursor_queryContext { var p = new(Decl_cursor_queryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_cursor_query return p } func (s *Decl_cursor_queryContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_cursor_queryContext) Selectstmt() ISelectstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectstmtContext) } func (s *Decl_cursor_queryContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_cursor_queryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_cursor_queryContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_cursor_query(s) } } func (s *Decl_cursor_queryContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_cursor_query(s) } } func (s *Decl_cursor_queryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_cursor_query(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_cursor_query() (localctx IDecl_cursor_queryContext) { localctx = NewDecl_cursor_queryContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1424, PostgreSQLParserRULE_decl_cursor_query) p.EnterOuterAlt(localctx, 1) { p.SetState(10052) p.Selectstmt() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_cursor_argsContext is an interface to support dynamic dispatch. type IDecl_cursor_argsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode Decl_cursor_arglist() IDecl_cursor_arglistContext CLOSE_PAREN() antlr.TerminalNode // IsDecl_cursor_argsContext differentiates from other interfaces. IsDecl_cursor_argsContext() } type Decl_cursor_argsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_cursor_argsContext() *Decl_cursor_argsContext { var p = new(Decl_cursor_argsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_cursor_args return p } func InitEmptyDecl_cursor_argsContext(p *Decl_cursor_argsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_cursor_args } func (*Decl_cursor_argsContext) IsDecl_cursor_argsContext() {} func NewDecl_cursor_argsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_cursor_argsContext { var p = new(Decl_cursor_argsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_cursor_args return p } func (s *Decl_cursor_argsContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_cursor_argsContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Decl_cursor_argsContext) Decl_cursor_arglist() IDecl_cursor_arglistContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_cursor_arglistContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_cursor_arglistContext) } func (s *Decl_cursor_argsContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Decl_cursor_argsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_cursor_argsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_cursor_argsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_cursor_args(s) } } func (s *Decl_cursor_argsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_cursor_args(s) } } func (s *Decl_cursor_argsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_cursor_args(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_cursor_args() (localctx IDecl_cursor_argsContext) { localctx = NewDecl_cursor_argsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1426, PostgreSQLParserRULE_decl_cursor_args) p.SetState(10059) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFOR, PostgreSQLParserIS: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserOPEN_PAREN: p.EnterOuterAlt(localctx, 2) { p.SetState(10055) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10056) p.Decl_cursor_arglist() } { p.SetState(10057) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_cursor_arglistContext is an interface to support dynamic dispatch. type IDecl_cursor_arglistContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllDecl_cursor_arg() []IDecl_cursor_argContext Decl_cursor_arg(i int) IDecl_cursor_argContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsDecl_cursor_arglistContext differentiates from other interfaces. IsDecl_cursor_arglistContext() } type Decl_cursor_arglistContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_cursor_arglistContext() *Decl_cursor_arglistContext { var p = new(Decl_cursor_arglistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_cursor_arglist return p } func InitEmptyDecl_cursor_arglistContext(p *Decl_cursor_arglistContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_cursor_arglist } func (*Decl_cursor_arglistContext) IsDecl_cursor_arglistContext() {} func NewDecl_cursor_arglistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_cursor_arglistContext { var p = new(Decl_cursor_arglistContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_cursor_arglist return p } func (s *Decl_cursor_arglistContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_cursor_arglistContext) AllDecl_cursor_arg() []IDecl_cursor_argContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IDecl_cursor_argContext); ok { len++ } } tst := make([]IDecl_cursor_argContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IDecl_cursor_argContext); ok { tst[i] = t.(IDecl_cursor_argContext) i++ } } return tst } func (s *Decl_cursor_arglistContext) Decl_cursor_arg(i int) IDecl_cursor_argContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_cursor_argContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IDecl_cursor_argContext) } func (s *Decl_cursor_arglistContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Decl_cursor_arglistContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Decl_cursor_arglistContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_cursor_arglistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_cursor_arglistContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_cursor_arglist(s) } } func (s *Decl_cursor_arglistContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_cursor_arglist(s) } } func (s *Decl_cursor_arglistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_cursor_arglist(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_cursor_arglist() (localctx IDecl_cursor_arglistContext) { localctx = NewDecl_cursor_arglistContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1428, PostgreSQLParserRULE_decl_cursor_arglist) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(10061) p.Decl_cursor_arg() } p.SetState(10066) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(10062) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10063) p.Decl_cursor_arg() } p.SetState(10068) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_cursor_argContext is an interface to support dynamic dispatch. type IDecl_cursor_argContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Decl_varname() IDecl_varnameContext Decl_datatype() IDecl_datatypeContext // IsDecl_cursor_argContext differentiates from other interfaces. IsDecl_cursor_argContext() } type Decl_cursor_argContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_cursor_argContext() *Decl_cursor_argContext { var p = new(Decl_cursor_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_cursor_arg return p } func InitEmptyDecl_cursor_argContext(p *Decl_cursor_argContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_cursor_arg } func (*Decl_cursor_argContext) IsDecl_cursor_argContext() {} func NewDecl_cursor_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_cursor_argContext { var p = new(Decl_cursor_argContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_cursor_arg return p } func (s *Decl_cursor_argContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_cursor_argContext) Decl_varname() IDecl_varnameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_varnameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_varnameContext) } func (s *Decl_cursor_argContext) Decl_datatype() IDecl_datatypeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_datatypeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_datatypeContext) } func (s *Decl_cursor_argContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_cursor_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_cursor_argContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_cursor_arg(s) } } func (s *Decl_cursor_argContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_cursor_arg(s) } } func (s *Decl_cursor_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_cursor_arg(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_cursor_arg() (localctx IDecl_cursor_argContext) { localctx = NewDecl_cursor_argContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1430, PostgreSQLParserRULE_decl_cursor_arg) p.EnterOuterAlt(localctx, 1) { p.SetState(10069) p.Decl_varname() } { p.SetState(10070) p.Decl_datatype() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_is_forContext is an interface to support dynamic dispatch. type IDecl_is_forContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures IS() antlr.TerminalNode FOR() antlr.TerminalNode // IsDecl_is_forContext differentiates from other interfaces. IsDecl_is_forContext() } type Decl_is_forContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_is_forContext() *Decl_is_forContext { var p = new(Decl_is_forContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_is_for return p } func InitEmptyDecl_is_forContext(p *Decl_is_forContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_is_for } func (*Decl_is_forContext) IsDecl_is_forContext() {} func NewDecl_is_forContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_is_forContext { var p = new(Decl_is_forContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_is_for return p } func (s *Decl_is_forContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_is_forContext) IS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIS, 0) } func (s *Decl_is_forContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *Decl_is_forContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_is_forContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_is_forContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_is_for(s) } } func (s *Decl_is_forContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_is_for(s) } } func (s *Decl_is_forContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_is_for(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_is_for() (localctx IDecl_is_forContext) { localctx = NewDecl_is_forContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1432, PostgreSQLParserRULE_decl_is_for) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(10072) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserFOR || _la == PostgreSQLParserIS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_aliasitemContext is an interface to support dynamic dispatch. type IDecl_aliasitemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures PARAM() antlr.TerminalNode Colid() IColidContext // IsDecl_aliasitemContext differentiates from other interfaces. IsDecl_aliasitemContext() } type Decl_aliasitemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_aliasitemContext() *Decl_aliasitemContext { var p = new(Decl_aliasitemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_aliasitem return p } func InitEmptyDecl_aliasitemContext(p *Decl_aliasitemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_aliasitem } func (*Decl_aliasitemContext) IsDecl_aliasitemContext() {} func NewDecl_aliasitemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_aliasitemContext { var p = new(Decl_aliasitemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_aliasitem return p } func (s *Decl_aliasitemContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_aliasitemContext) PARAM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARAM, 0) } func (s *Decl_aliasitemContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Decl_aliasitemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_aliasitemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_aliasitemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_aliasitem(s) } } func (s *Decl_aliasitemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_aliasitem(s) } } func (s *Decl_aliasitemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_aliasitem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_aliasitem() (localctx IDecl_aliasitemContext) { localctx = NewDecl_aliasitemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1434, PostgreSQLParserRULE_decl_aliasitem) p.SetState(10076) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserPARAM: p.EnterOuterAlt(localctx, 1) { p.SetState(10074) p.Match(PostgreSQLParserPARAM) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 2) { p.SetState(10075) p.Colid() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_varnameContext is an interface to support dynamic dispatch. type IDecl_varnameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Any_identifier() IAny_identifierContext // IsDecl_varnameContext differentiates from other interfaces. IsDecl_varnameContext() } type Decl_varnameContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_varnameContext() *Decl_varnameContext { var p = new(Decl_varnameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_varname return p } func InitEmptyDecl_varnameContext(p *Decl_varnameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_varname } func (*Decl_varnameContext) IsDecl_varnameContext() {} func NewDecl_varnameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_varnameContext { var p = new(Decl_varnameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_varname return p } func (s *Decl_varnameContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_varnameContext) Any_identifier() IAny_identifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_identifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_identifierContext) } func (s *Decl_varnameContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_varnameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_varnameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_varname(s) } } func (s *Decl_varnameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_varname(s) } } func (s *Decl_varnameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_varname(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_varname() (localctx IDecl_varnameContext) { localctx = NewDecl_varnameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1436, PostgreSQLParserRULE_decl_varname) p.EnterOuterAlt(localctx, 1) { p.SetState(10078) p.Any_identifier() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_constContext is an interface to support dynamic dispatch. type IDecl_constContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CONSTANT() antlr.TerminalNode // IsDecl_constContext differentiates from other interfaces. IsDecl_constContext() } type Decl_constContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_constContext() *Decl_constContext { var p = new(Decl_constContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_const return p } func InitEmptyDecl_constContext(p *Decl_constContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_const } func (*Decl_constContext) IsDecl_constContext() {} func NewDecl_constContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_constContext { var p = new(Decl_constContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_const return p } func (s *Decl_constContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_constContext) CONSTANT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTANT, 0) } func (s *Decl_constContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_constContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_constContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_const(s) } } func (s *Decl_constContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_const(s) } } func (s *Decl_constContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_const(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_const() (localctx IDecl_constContext) { localctx = NewDecl_constContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1438, PostgreSQLParserRULE_decl_const) p.SetState(10082) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 678, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(10081) p.Match(PostgreSQLParserCONSTANT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_datatypeContext is an interface to support dynamic dispatch. type IDecl_datatypeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Typename() ITypenameContext // IsDecl_datatypeContext differentiates from other interfaces. IsDecl_datatypeContext() } type Decl_datatypeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_datatypeContext() *Decl_datatypeContext { var p = new(Decl_datatypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_datatype return p } func InitEmptyDecl_datatypeContext(p *Decl_datatypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_datatype } func (*Decl_datatypeContext) IsDecl_datatypeContext() {} func NewDecl_datatypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_datatypeContext { var p = new(Decl_datatypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_datatype return p } func (s *Decl_datatypeContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_datatypeContext) Typename() ITypenameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ITypenameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ITypenameContext) } func (s *Decl_datatypeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_datatypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_datatypeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_datatype(s) } } func (s *Decl_datatypeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_datatype(s) } } func (s *Decl_datatypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_datatype(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_datatype() (localctx IDecl_datatypeContext) { localctx = NewDecl_datatypeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1440, PostgreSQLParserRULE_decl_datatype) p.EnterOuterAlt(localctx, 1) { p.SetState(10084) p.Typename() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_collateContext is an interface to support dynamic dispatch. type IDecl_collateContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures COLLATE() antlr.TerminalNode Any_name() IAny_nameContext // IsDecl_collateContext differentiates from other interfaces. IsDecl_collateContext() } type Decl_collateContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_collateContext() *Decl_collateContext { var p = new(Decl_collateContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_collate return p } func InitEmptyDecl_collateContext(p *Decl_collateContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_collate } func (*Decl_collateContext) IsDecl_collateContext() {} func NewDecl_collateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_collateContext { var p = new(Decl_collateContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_collate return p } func (s *Decl_collateContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_collateContext) COLLATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATE, 0) } func (s *Decl_collateContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *Decl_collateContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_collateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_collateContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_collate(s) } } func (s *Decl_collateContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_collate(s) } } func (s *Decl_collateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_collate(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_collate() (localctx IDecl_collateContext) { localctx = NewDecl_collateContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1442, PostgreSQLParserRULE_decl_collate) p.SetState(10089) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSEMI, PostgreSQLParserEQUAL, PostgreSQLParserCOLON_EQUALS, PostgreSQLParserDEFAULT, PostgreSQLParserNOT: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserCOLLATE: p.EnterOuterAlt(localctx, 2) { p.SetState(10087) p.Match(PostgreSQLParserCOLLATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10088) p.Any_name() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_notnullContext is an interface to support dynamic dispatch. type IDecl_notnullContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NOT() antlr.TerminalNode NULL_P() antlr.TerminalNode // IsDecl_notnullContext differentiates from other interfaces. IsDecl_notnullContext() } type Decl_notnullContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_notnullContext() *Decl_notnullContext { var p = new(Decl_notnullContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_notnull return p } func InitEmptyDecl_notnullContext(p *Decl_notnullContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_notnull } func (*Decl_notnullContext) IsDecl_notnullContext() {} func NewDecl_notnullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_notnullContext { var p = new(Decl_notnullContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_notnull return p } func (s *Decl_notnullContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_notnullContext) NOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOT, 0) } func (s *Decl_notnullContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *Decl_notnullContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_notnullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_notnullContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_notnull(s) } } func (s *Decl_notnullContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_notnull(s) } } func (s *Decl_notnullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_notnull(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_notnull() (localctx IDecl_notnullContext) { localctx = NewDecl_notnullContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1444, PostgreSQLParserRULE_decl_notnull) p.SetState(10094) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSEMI, PostgreSQLParserEQUAL, PostgreSQLParserCOLON_EQUALS, PostgreSQLParserDEFAULT: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserNOT: p.EnterOuterAlt(localctx, 2) { p.SetState(10092) p.Match(PostgreSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10093) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_defvalContext is an interface to support dynamic dispatch. type IDecl_defvalContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Decl_defkey() IDecl_defkeyContext Sql_expression() ISql_expressionContext // IsDecl_defvalContext differentiates from other interfaces. IsDecl_defvalContext() } type Decl_defvalContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_defvalContext() *Decl_defvalContext { var p = new(Decl_defvalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_defval return p } func InitEmptyDecl_defvalContext(p *Decl_defvalContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_defval } func (*Decl_defvalContext) IsDecl_defvalContext() {} func NewDecl_defvalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_defvalContext { var p = new(Decl_defvalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_defval return p } func (s *Decl_defvalContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_defvalContext) Decl_defkey() IDecl_defkeyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IDecl_defkeyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IDecl_defkeyContext) } func (s *Decl_defvalContext) Sql_expression() ISql_expressionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISql_expressionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISql_expressionContext) } func (s *Decl_defvalContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_defvalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_defvalContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_defval(s) } } func (s *Decl_defvalContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_defval(s) } } func (s *Decl_defvalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_defval(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_defval() (localctx IDecl_defvalContext) { localctx = NewDecl_defvalContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1446, PostgreSQLParserRULE_decl_defval) p.SetState(10100) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSEMI: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserEQUAL, PostgreSQLParserCOLON_EQUALS, PostgreSQLParserDEFAULT: p.EnterOuterAlt(localctx, 2) { p.SetState(10097) p.Decl_defkey() } { p.SetState(10098) p.Sql_expression() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IDecl_defkeyContext is an interface to support dynamic dispatch. type IDecl_defkeyContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Assign_operator() IAssign_operatorContext DEFAULT() antlr.TerminalNode // IsDecl_defkeyContext differentiates from other interfaces. IsDecl_defkeyContext() } type Decl_defkeyContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyDecl_defkeyContext() *Decl_defkeyContext { var p = new(Decl_defkeyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_defkey return p } func InitEmptyDecl_defkeyContext(p *Decl_defkeyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_decl_defkey } func (*Decl_defkeyContext) IsDecl_defkeyContext() {} func NewDecl_defkeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_defkeyContext { var p = new(Decl_defkeyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_decl_defkey return p } func (s *Decl_defkeyContext) GetParser() antlr.Parser { return s.parser } func (s *Decl_defkeyContext) Assign_operator() IAssign_operatorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAssign_operatorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAssign_operatorContext) } func (s *Decl_defkeyContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Decl_defkeyContext) GetRuleContext() antlr.RuleContext { return s } func (s *Decl_defkeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Decl_defkeyContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterDecl_defkey(s) } } func (s *Decl_defkeyContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitDecl_defkey(s) } } func (s *Decl_defkeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitDecl_defkey(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Decl_defkey() (localctx IDecl_defkeyContext) { localctx = NewDecl_defkeyContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1448, PostgreSQLParserRULE_decl_defkey) p.SetState(10104) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserEQUAL, PostgreSQLParserCOLON_EQUALS: p.EnterOuterAlt(localctx, 1) { p.SetState(10102) p.Assign_operator() } case PostgreSQLParserDEFAULT: p.EnterOuterAlt(localctx, 2) { p.SetState(10103) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAssign_operatorContext is an interface to support dynamic dispatch. type IAssign_operatorContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures EQUAL() antlr.TerminalNode COLON_EQUALS() antlr.TerminalNode // IsAssign_operatorContext differentiates from other interfaces. IsAssign_operatorContext() } type Assign_operatorContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAssign_operatorContext() *Assign_operatorContext { var p = new(Assign_operatorContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_assign_operator return p } func InitEmptyAssign_operatorContext(p *Assign_operatorContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_assign_operator } func (*Assign_operatorContext) IsAssign_operatorContext() {} func NewAssign_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assign_operatorContext { var p = new(Assign_operatorContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_assign_operator return p } func (s *Assign_operatorContext) GetParser() antlr.Parser { return s.parser } func (s *Assign_operatorContext) EQUAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEQUAL, 0) } func (s *Assign_operatorContext) COLON_EQUALS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLON_EQUALS, 0) } func (s *Assign_operatorContext) GetRuleContext() antlr.RuleContext { return s } func (s *Assign_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Assign_operatorContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAssign_operator(s) } } func (s *Assign_operatorContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAssign_operator(s) } } func (s *Assign_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAssign_operator(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Assign_operator() (localctx IAssign_operatorContext) { localctx = NewAssign_operatorContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1450, PostgreSQLParserRULE_assign_operator) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(10106) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserEQUAL || _la == PostgreSQLParserCOLON_EQUALS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IProc_sectContext is an interface to support dynamic dispatch. type IProc_sectContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllProc_stmt() []IProc_stmtContext Proc_stmt(i int) IProc_stmtContext // IsProc_sectContext differentiates from other interfaces. IsProc_sectContext() } type Proc_sectContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyProc_sectContext() *Proc_sectContext { var p = new(Proc_sectContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_proc_sect return p } func InitEmptyProc_sectContext(p *Proc_sectContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_proc_sect } func (*Proc_sectContext) IsProc_sectContext() {} func NewProc_sectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_sectContext { var p = new(Proc_sectContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_proc_sect return p } func (s *Proc_sectContext) GetParser() antlr.Parser { return s.parser } func (s *Proc_sectContext) AllProc_stmt() []IProc_stmtContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IProc_stmtContext); ok { len++ } } tst := make([]IProc_stmtContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IProc_stmtContext); ok { tst[i] = t.(IProc_stmtContext) i++ } } return tst } func (s *Proc_sectContext) Proc_stmt(i int) IProc_stmtContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IProc_stmtContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IProc_stmtContext) } func (s *Proc_sectContext) GetRuleContext() antlr.RuleContext { return s } func (s *Proc_sectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Proc_sectContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterProc_sect(s) } } func (s *Proc_sectContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitProc_sect(s) } } func (s *Proc_sectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitProc_sect(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Proc_sect() (localctx IProc_sectContext) { localctx = NewProc_sectContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1452, PostgreSQLParserRULE_proc_sect) var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(10111) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 683, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { p.SetState(10108) p.Proc_stmt() } } p.SetState(10113) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 683, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IProc_stmtContext is an interface to support dynamic dispatch. type IProc_stmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Pl_block() IPl_blockContext SEMI() antlr.TerminalNode Stmt_return() IStmt_returnContext Stmt_raise() IStmt_raiseContext Stmt_assign() IStmt_assignContext Stmt_if() IStmt_ifContext Stmt_case() IStmt_caseContext Stmt_loop() IStmt_loopContext Stmt_while() IStmt_whileContext Stmt_for() IStmt_forContext Stmt_foreach_a() IStmt_foreach_aContext Stmt_exit() IStmt_exitContext Stmt_assert() IStmt_assertContext Stmt_execsql() IStmt_execsqlContext Stmt_dynexecute() IStmt_dynexecuteContext Stmt_perform() IStmt_performContext Stmt_call() IStmt_callContext Stmt_getdiag() IStmt_getdiagContext Stmt_open() IStmt_openContext Stmt_fetch() IStmt_fetchContext Stmt_move() IStmt_moveContext Stmt_close() IStmt_closeContext Stmt_null() IStmt_nullContext Stmt_commit() IStmt_commitContext Stmt_rollback() IStmt_rollbackContext Stmt_set() IStmt_setContext // IsProc_stmtContext differentiates from other interfaces. IsProc_stmtContext() } type Proc_stmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyProc_stmtContext() *Proc_stmtContext { var p = new(Proc_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_proc_stmt return p } func InitEmptyProc_stmtContext(p *Proc_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_proc_stmt } func (*Proc_stmtContext) IsProc_stmtContext() {} func NewProc_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_stmtContext { var p = new(Proc_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_proc_stmt return p } func (s *Proc_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Proc_stmtContext) Pl_block() IPl_blockContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPl_blockContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPl_blockContext) } func (s *Proc_stmtContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Proc_stmtContext) Stmt_return() IStmt_returnContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_returnContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_returnContext) } func (s *Proc_stmtContext) Stmt_raise() IStmt_raiseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_raiseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_raiseContext) } func (s *Proc_stmtContext) Stmt_assign() IStmt_assignContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_assignContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_assignContext) } func (s *Proc_stmtContext) Stmt_if() IStmt_ifContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_ifContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_ifContext) } func (s *Proc_stmtContext) Stmt_case() IStmt_caseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_caseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_caseContext) } func (s *Proc_stmtContext) Stmt_loop() IStmt_loopContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_loopContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_loopContext) } func (s *Proc_stmtContext) Stmt_while() IStmt_whileContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_whileContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_whileContext) } func (s *Proc_stmtContext) Stmt_for() IStmt_forContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_forContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_forContext) } func (s *Proc_stmtContext) Stmt_foreach_a() IStmt_foreach_aContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_foreach_aContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_foreach_aContext) } func (s *Proc_stmtContext) Stmt_exit() IStmt_exitContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_exitContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_exitContext) } func (s *Proc_stmtContext) Stmt_assert() IStmt_assertContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_assertContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_assertContext) } func (s *Proc_stmtContext) Stmt_execsql() IStmt_execsqlContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_execsqlContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_execsqlContext) } func (s *Proc_stmtContext) Stmt_dynexecute() IStmt_dynexecuteContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_dynexecuteContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_dynexecuteContext) } func (s *Proc_stmtContext) Stmt_perform() IStmt_performContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_performContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_performContext) } func (s *Proc_stmtContext) Stmt_call() IStmt_callContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_callContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_callContext) } func (s *Proc_stmtContext) Stmt_getdiag() IStmt_getdiagContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_getdiagContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_getdiagContext) } func (s *Proc_stmtContext) Stmt_open() IStmt_openContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_openContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_openContext) } func (s *Proc_stmtContext) Stmt_fetch() IStmt_fetchContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_fetchContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_fetchContext) } func (s *Proc_stmtContext) Stmt_move() IStmt_moveContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_moveContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_moveContext) } func (s *Proc_stmtContext) Stmt_close() IStmt_closeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_closeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_closeContext) } func (s *Proc_stmtContext) Stmt_null() IStmt_nullContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_nullContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_nullContext) } func (s *Proc_stmtContext) Stmt_commit() IStmt_commitContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_commitContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_commitContext) } func (s *Proc_stmtContext) Stmt_rollback() IStmt_rollbackContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_rollbackContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_rollbackContext) } func (s *Proc_stmtContext) Stmt_set() IStmt_setContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_setContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_setContext) } func (s *Proc_stmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *Proc_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Proc_stmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterProc_stmt(s) } } func (s *Proc_stmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitProc_stmt(s) } } func (s *Proc_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitProc_stmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Proc_stmt() (localctx IProc_stmtContext) { localctx = NewProc_stmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1454, PostgreSQLParserRULE_proc_stmt) p.SetState(10141) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 684, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(10114) p.Pl_block() } { p.SetState(10115) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(10117) p.Stmt_return() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(10118) p.Stmt_raise() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(10119) p.Stmt_assign() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(10120) p.Stmt_if() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(10121) p.Stmt_case() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(10122) p.Stmt_loop() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(10123) p.Stmt_while() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(10124) p.Stmt_for() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(10125) p.Stmt_foreach_a() } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(10126) p.Stmt_exit() } case 12: p.EnterOuterAlt(localctx, 12) { p.SetState(10127) p.Stmt_assert() } case 13: p.EnterOuterAlt(localctx, 13) { p.SetState(10128) p.Stmt_execsql() } case 14: p.EnterOuterAlt(localctx, 14) { p.SetState(10129) p.Stmt_dynexecute() } case 15: p.EnterOuterAlt(localctx, 15) { p.SetState(10130) p.Stmt_perform() } case 16: p.EnterOuterAlt(localctx, 16) { p.SetState(10131) p.Stmt_call() } case 17: p.EnterOuterAlt(localctx, 17) { p.SetState(10132) p.Stmt_getdiag() } case 18: p.EnterOuterAlt(localctx, 18) { p.SetState(10133) p.Stmt_open() } case 19: p.EnterOuterAlt(localctx, 19) { p.SetState(10134) p.Stmt_fetch() } case 20: p.EnterOuterAlt(localctx, 20) { p.SetState(10135) p.Stmt_move() } case 21: p.EnterOuterAlt(localctx, 21) { p.SetState(10136) p.Stmt_close() } case 22: p.EnterOuterAlt(localctx, 22) { p.SetState(10137) p.Stmt_null() } case 23: p.EnterOuterAlt(localctx, 23) { p.SetState(10138) p.Stmt_commit() } case 24: p.EnterOuterAlt(localctx, 24) { p.SetState(10139) p.Stmt_rollback() } case 25: p.EnterOuterAlt(localctx, 25) { p.SetState(10140) p.Stmt_set() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_performContext is an interface to support dynamic dispatch. type IStmt_performContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures PERFORM() antlr.TerminalNode Expr_until_semi() IExpr_until_semiContext SEMI() antlr.TerminalNode // IsStmt_performContext differentiates from other interfaces. IsStmt_performContext() } type Stmt_performContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_performContext() *Stmt_performContext { var p = new(Stmt_performContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_perform return p } func InitEmptyStmt_performContext(p *Stmt_performContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_perform } func (*Stmt_performContext) IsStmt_performContext() {} func NewStmt_performContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_performContext { var p = new(Stmt_performContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_perform return p } func (s *Stmt_performContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_performContext) PERFORM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPERFORM, 0) } func (s *Stmt_performContext) Expr_until_semi() IExpr_until_semiContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_until_semiContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_until_semiContext) } func (s *Stmt_performContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_performContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_performContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_performContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_perform(s) } } func (s *Stmt_performContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_perform(s) } } func (s *Stmt_performContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_perform(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_perform() (localctx IStmt_performContext) { localctx = NewStmt_performContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1456, PostgreSQLParserRULE_stmt_perform) p.EnterOuterAlt(localctx, 1) { p.SetState(10143) p.Match(PostgreSQLParserPERFORM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10144) p.Expr_until_semi() } { p.SetState(10145) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_callContext is an interface to support dynamic dispatch. type IStmt_callContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CALL() antlr.TerminalNode Any_identifier() IAny_identifierContext OPEN_PAREN() antlr.TerminalNode Opt_expr_list() IOpt_expr_listContext CLOSE_PAREN() antlr.TerminalNode SEMI() antlr.TerminalNode DO() antlr.TerminalNode // IsStmt_callContext differentiates from other interfaces. IsStmt_callContext() } type Stmt_callContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_callContext() *Stmt_callContext { var p = new(Stmt_callContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_call return p } func InitEmptyStmt_callContext(p *Stmt_callContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_call } func (*Stmt_callContext) IsStmt_callContext() {} func NewStmt_callContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_callContext { var p = new(Stmt_callContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_call return p } func (s *Stmt_callContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_callContext) CALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCALL, 0) } func (s *Stmt_callContext) Any_identifier() IAny_identifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_identifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_identifierContext) } func (s *Stmt_callContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Stmt_callContext) Opt_expr_list() IOpt_expr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_expr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_expr_listContext) } func (s *Stmt_callContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Stmt_callContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_callContext) DO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDO, 0) } func (s *Stmt_callContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_callContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_callContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_call(s) } } func (s *Stmt_callContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_call(s) } } func (s *Stmt_callContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_call(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_call() (localctx IStmt_callContext) { localctx = NewStmt_callContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1458, PostgreSQLParserRULE_stmt_call) p.SetState(10161) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCALL: p.EnterOuterAlt(localctx, 1) { p.SetState(10147) p.Match(PostgreSQLParserCALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10148) p.Any_identifier() } { p.SetState(10149) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10150) p.Opt_expr_list() } { p.SetState(10151) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10152) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserDO: p.EnterOuterAlt(localctx, 2) { p.SetState(10154) p.Match(PostgreSQLParserDO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10155) p.Any_identifier() } { p.SetState(10156) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10157) p.Opt_expr_list() } { p.SetState(10158) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10159) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_expr_listContext is an interface to support dynamic dispatch. type IOpt_expr_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Expr_list() IExpr_listContext // IsOpt_expr_listContext differentiates from other interfaces. IsOpt_expr_listContext() } type Opt_expr_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_expr_listContext() *Opt_expr_listContext { var p = new(Opt_expr_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_expr_list return p } func InitEmptyOpt_expr_listContext(p *Opt_expr_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_expr_list } func (*Opt_expr_listContext) IsOpt_expr_listContext() {} func NewOpt_expr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_expr_listContext { var p = new(Opt_expr_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_expr_list return p } func (s *Opt_expr_listContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_expr_listContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Opt_expr_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_expr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_expr_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_expr_list(s) } } func (s *Opt_expr_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_expr_list(s) } } func (s *Opt_expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_expr_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_expr_list() (localctx IOpt_expr_listContext) { localctx = NewOpt_expr_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1460, PostgreSQLParserRULE_opt_expr_list) p.SetState(10165) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserCLOSE_PAREN: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserOPEN_PAREN, PostgreSQLParserPLUS, PostgreSQLParserMINUS, PostgreSQLParserPARAM, PostgreSQLParserOperator, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCASE, PostgreSQLParserCAST, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserCURRENT_CATALOG, PostgreSQLParserCURRENT_DATE, PostgreSQLParserCURRENT_ROLE, PostgreSQLParserCURRENT_TIME, PostgreSQLParserCURRENT_TIMESTAMP, PostgreSQLParserCURRENT_USER, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFALSE_P, PostgreSQLParserFETCH, PostgreSQLParserLOCALTIME, PostgreSQLParserLOCALTIMESTAMP, PostgreSQLParserNOT, PostgreSQLParserNULL_P, PostgreSQLParserSESSION_USER, PostgreSQLParserTABLE, PostgreSQLParserTRUE_P, PostgreSQLParserUNIQUE, PostgreSQLParserUSER, PostgreSQLParserAUTHORIZATION, PostgreSQLParserBINARY, PostgreSQLParserCOLLATION, PostgreSQLParserCONCURRENTLY, PostgreSQLParserCROSS, PostgreSQLParserCURRENT_SCHEMA, PostgreSQLParserFREEZE, PostgreSQLParserFULL, PostgreSQLParserILIKE, PostgreSQLParserINNER_P, PostgreSQLParserIS, PostgreSQLParserISNULL, PostgreSQLParserJOIN, PostgreSQLParserLEFT, PostgreSQLParserLIKE, PostgreSQLParserNATURAL, PostgreSQLParserNOTNULL, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserOVERLAPS, PostgreSQLParserRIGHT, PostgreSQLParserSIMILAR, PostgreSQLParserVERBOSE, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserTABLESAMPLE, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserStringConstant, PostgreSQLParserUnicodeEscapeStringConstant, PostgreSQLParserBeginDollarStringConstant, PostgreSQLParserBinaryStringConstant, PostgreSQLParserHexadecimalStringConstant, PostgreSQLParserIntegral, PostgreSQLParserNumeric, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER, PostgreSQLParserEscapeStringConstant: p.EnterOuterAlt(localctx, 2) { p.SetState(10164) p.Expr_list() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_assignContext is an interface to support dynamic dispatch. type IStmt_assignContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Assign_var() IAssign_varContext Assign_operator() IAssign_operatorContext Sql_expression() ISql_expressionContext SEMI() antlr.TerminalNode // IsStmt_assignContext differentiates from other interfaces. IsStmt_assignContext() } type Stmt_assignContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_assignContext() *Stmt_assignContext { var p = new(Stmt_assignContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_assign return p } func InitEmptyStmt_assignContext(p *Stmt_assignContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_assign } func (*Stmt_assignContext) IsStmt_assignContext() {} func NewStmt_assignContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_assignContext { var p = new(Stmt_assignContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_assign return p } func (s *Stmt_assignContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_assignContext) Assign_var() IAssign_varContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAssign_varContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAssign_varContext) } func (s *Stmt_assignContext) Assign_operator() IAssign_operatorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAssign_operatorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAssign_operatorContext) } func (s *Stmt_assignContext) Sql_expression() ISql_expressionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISql_expressionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISql_expressionContext) } func (s *Stmt_assignContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_assignContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_assignContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_assignContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_assign(s) } } func (s *Stmt_assignContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_assign(s) } } func (s *Stmt_assignContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_assign(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_assign() (localctx IStmt_assignContext) { localctx = NewStmt_assignContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1462, PostgreSQLParserRULE_stmt_assign) p.EnterOuterAlt(localctx, 1) { p.SetState(10167) p.Assign_var() } { p.SetState(10168) p.Assign_operator() } { p.SetState(10169) p.Sql_expression() } { p.SetState(10170) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_getdiagContext is an interface to support dynamic dispatch. type IStmt_getdiagContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures GET() antlr.TerminalNode Getdiag_area_opt() IGetdiag_area_optContext DIAGNOSTICS() antlr.TerminalNode Getdiag_list() IGetdiag_listContext SEMI() antlr.TerminalNode // IsStmt_getdiagContext differentiates from other interfaces. IsStmt_getdiagContext() } type Stmt_getdiagContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_getdiagContext() *Stmt_getdiagContext { var p = new(Stmt_getdiagContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_getdiag return p } func InitEmptyStmt_getdiagContext(p *Stmt_getdiagContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_getdiag } func (*Stmt_getdiagContext) IsStmt_getdiagContext() {} func NewStmt_getdiagContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_getdiagContext { var p = new(Stmt_getdiagContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_getdiag return p } func (s *Stmt_getdiagContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_getdiagContext) GET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGET, 0) } func (s *Stmt_getdiagContext) Getdiag_area_opt() IGetdiag_area_optContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGetdiag_area_optContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGetdiag_area_optContext) } func (s *Stmt_getdiagContext) DIAGNOSTICS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDIAGNOSTICS, 0) } func (s *Stmt_getdiagContext) Getdiag_list() IGetdiag_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGetdiag_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGetdiag_listContext) } func (s *Stmt_getdiagContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_getdiagContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_getdiagContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_getdiagContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_getdiag(s) } } func (s *Stmt_getdiagContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_getdiag(s) } } func (s *Stmt_getdiagContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_getdiag(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_getdiag() (localctx IStmt_getdiagContext) { localctx = NewStmt_getdiagContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1464, PostgreSQLParserRULE_stmt_getdiag) p.EnterOuterAlt(localctx, 1) { p.SetState(10172) p.Match(PostgreSQLParserGET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10173) p.Getdiag_area_opt() } { p.SetState(10174) p.Match(PostgreSQLParserDIAGNOSTICS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10175) p.Getdiag_list() } { p.SetState(10176) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGetdiag_area_optContext is an interface to support dynamic dispatch. type IGetdiag_area_optContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CURRENT_P() antlr.TerminalNode STACKED() antlr.TerminalNode // IsGetdiag_area_optContext differentiates from other interfaces. IsGetdiag_area_optContext() } type Getdiag_area_optContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGetdiag_area_optContext() *Getdiag_area_optContext { var p = new(Getdiag_area_optContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_getdiag_area_opt return p } func InitEmptyGetdiag_area_optContext(p *Getdiag_area_optContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_getdiag_area_opt } func (*Getdiag_area_optContext) IsGetdiag_area_optContext() {} func NewGetdiag_area_optContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_area_optContext { var p = new(Getdiag_area_optContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_getdiag_area_opt return p } func (s *Getdiag_area_optContext) GetParser() antlr.Parser { return s.parser } func (s *Getdiag_area_optContext) CURRENT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_P, 0) } func (s *Getdiag_area_optContext) STACKED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTACKED, 0) } func (s *Getdiag_area_optContext) GetRuleContext() antlr.RuleContext { return s } func (s *Getdiag_area_optContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Getdiag_area_optContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGetdiag_area_opt(s) } } func (s *Getdiag_area_optContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGetdiag_area_opt(s) } } func (s *Getdiag_area_optContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGetdiag_area_opt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Getdiag_area_opt() (localctx IGetdiag_area_optContext) { localctx = NewGetdiag_area_optContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1466, PostgreSQLParserRULE_getdiag_area_opt) p.SetState(10181) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserDIAGNOSTICS: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserCURRENT_P: p.EnterOuterAlt(localctx, 2) { p.SetState(10179) p.Match(PostgreSQLParserCURRENT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSTACKED: p.EnterOuterAlt(localctx, 3) { p.SetState(10180) p.Match(PostgreSQLParserSTACKED) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGetdiag_listContext is an interface to support dynamic dispatch. type IGetdiag_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllGetdiag_list_item() []IGetdiag_list_itemContext Getdiag_list_item(i int) IGetdiag_list_itemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsGetdiag_listContext differentiates from other interfaces. IsGetdiag_listContext() } type Getdiag_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGetdiag_listContext() *Getdiag_listContext { var p = new(Getdiag_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_getdiag_list return p } func InitEmptyGetdiag_listContext(p *Getdiag_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_getdiag_list } func (*Getdiag_listContext) IsGetdiag_listContext() {} func NewGetdiag_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_listContext { var p = new(Getdiag_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_getdiag_list return p } func (s *Getdiag_listContext) GetParser() antlr.Parser { return s.parser } func (s *Getdiag_listContext) AllGetdiag_list_item() []IGetdiag_list_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IGetdiag_list_itemContext); ok { len++ } } tst := make([]IGetdiag_list_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IGetdiag_list_itemContext); ok { tst[i] = t.(IGetdiag_list_itemContext) i++ } } return tst } func (s *Getdiag_listContext) Getdiag_list_item(i int) IGetdiag_list_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGetdiag_list_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IGetdiag_list_itemContext) } func (s *Getdiag_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Getdiag_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Getdiag_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Getdiag_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Getdiag_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGetdiag_list(s) } } func (s *Getdiag_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGetdiag_list(s) } } func (s *Getdiag_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGetdiag_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Getdiag_list() (localctx IGetdiag_listContext) { localctx = NewGetdiag_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1468, PostgreSQLParserRULE_getdiag_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(10183) p.Getdiag_list_item() } p.SetState(10188) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(10184) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10185) p.Getdiag_list_item() } p.SetState(10190) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGetdiag_list_itemContext is an interface to support dynamic dispatch. type IGetdiag_list_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Getdiag_target() IGetdiag_targetContext Assign_operator() IAssign_operatorContext Getdiag_item() IGetdiag_itemContext // IsGetdiag_list_itemContext differentiates from other interfaces. IsGetdiag_list_itemContext() } type Getdiag_list_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGetdiag_list_itemContext() *Getdiag_list_itemContext { var p = new(Getdiag_list_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_getdiag_list_item return p } func InitEmptyGetdiag_list_itemContext(p *Getdiag_list_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_getdiag_list_item } func (*Getdiag_list_itemContext) IsGetdiag_list_itemContext() {} func NewGetdiag_list_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_list_itemContext { var p = new(Getdiag_list_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_getdiag_list_item return p } func (s *Getdiag_list_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Getdiag_list_itemContext) Getdiag_target() IGetdiag_targetContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGetdiag_targetContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGetdiag_targetContext) } func (s *Getdiag_list_itemContext) Assign_operator() IAssign_operatorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAssign_operatorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAssign_operatorContext) } func (s *Getdiag_list_itemContext) Getdiag_item() IGetdiag_itemContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGetdiag_itemContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGetdiag_itemContext) } func (s *Getdiag_list_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Getdiag_list_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Getdiag_list_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGetdiag_list_item(s) } } func (s *Getdiag_list_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGetdiag_list_item(s) } } func (s *Getdiag_list_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGetdiag_list_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Getdiag_list_item() (localctx IGetdiag_list_itemContext) { localctx = NewGetdiag_list_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1470, PostgreSQLParserRULE_getdiag_list_item) p.EnterOuterAlt(localctx, 1) { p.SetState(10191) p.Getdiag_target() } { p.SetState(10192) p.Assign_operator() } { p.SetState(10193) p.Getdiag_item() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGetdiag_itemContext is an interface to support dynamic dispatch. type IGetdiag_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext // IsGetdiag_itemContext differentiates from other interfaces. IsGetdiag_itemContext() } type Getdiag_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGetdiag_itemContext() *Getdiag_itemContext { var p = new(Getdiag_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_getdiag_item return p } func InitEmptyGetdiag_itemContext(p *Getdiag_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_getdiag_item } func (*Getdiag_itemContext) IsGetdiag_itemContext() {} func NewGetdiag_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_itemContext { var p = new(Getdiag_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_getdiag_item return p } func (s *Getdiag_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Getdiag_itemContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Getdiag_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Getdiag_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Getdiag_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGetdiag_item(s) } } func (s *Getdiag_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGetdiag_item(s) } } func (s *Getdiag_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGetdiag_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Getdiag_item() (localctx IGetdiag_itemContext) { localctx = NewGetdiag_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1472, PostgreSQLParserRULE_getdiag_item) p.EnterOuterAlt(localctx, 1) { p.SetState(10195) p.Colid() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IGetdiag_targetContext is an interface to support dynamic dispatch. type IGetdiag_targetContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Assign_var() IAssign_varContext // IsGetdiag_targetContext differentiates from other interfaces. IsGetdiag_targetContext() } type Getdiag_targetContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGetdiag_targetContext() *Getdiag_targetContext { var p = new(Getdiag_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_getdiag_target return p } func InitEmptyGetdiag_targetContext(p *Getdiag_targetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_getdiag_target } func (*Getdiag_targetContext) IsGetdiag_targetContext() {} func NewGetdiag_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_targetContext { var p = new(Getdiag_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_getdiag_target return p } func (s *Getdiag_targetContext) GetParser() antlr.Parser { return s.parser } func (s *Getdiag_targetContext) Assign_var() IAssign_varContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAssign_varContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAssign_varContext) } func (s *Getdiag_targetContext) GetRuleContext() antlr.RuleContext { return s } func (s *Getdiag_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Getdiag_targetContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterGetdiag_target(s) } } func (s *Getdiag_targetContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitGetdiag_target(s) } } func (s *Getdiag_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitGetdiag_target(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Getdiag_target() (localctx IGetdiag_targetContext) { localctx = NewGetdiag_targetContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1474, PostgreSQLParserRULE_getdiag_target) p.EnterOuterAlt(localctx, 1) { p.SetState(10197) p.Assign_var() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAssign_varContext is an interface to support dynamic dispatch. type IAssign_varContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Any_name() IAny_nameContext PARAM() antlr.TerminalNode AllOPEN_BRACKET() []antlr.TerminalNode OPEN_BRACKET(i int) antlr.TerminalNode AllExpr_until_rightbracket() []IExpr_until_rightbracketContext Expr_until_rightbracket(i int) IExpr_until_rightbracketContext AllCLOSE_BRACKET() []antlr.TerminalNode CLOSE_BRACKET(i int) antlr.TerminalNode // IsAssign_varContext differentiates from other interfaces. IsAssign_varContext() } type Assign_varContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAssign_varContext() *Assign_varContext { var p = new(Assign_varContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_assign_var return p } func InitEmptyAssign_varContext(p *Assign_varContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_assign_var } func (*Assign_varContext) IsAssign_varContext() {} func NewAssign_varContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assign_varContext { var p = new(Assign_varContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_assign_var return p } func (s *Assign_varContext) GetParser() antlr.Parser { return s.parser } func (s *Assign_varContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *Assign_varContext) PARAM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARAM, 0) } func (s *Assign_varContext) AllOPEN_BRACKET() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserOPEN_BRACKET) } func (s *Assign_varContext) OPEN_BRACKET(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_BRACKET, i) } func (s *Assign_varContext) AllExpr_until_rightbracket() []IExpr_until_rightbracketContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IExpr_until_rightbracketContext); ok { len++ } } tst := make([]IExpr_until_rightbracketContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IExpr_until_rightbracketContext); ok { tst[i] = t.(IExpr_until_rightbracketContext) i++ } } return tst } func (s *Assign_varContext) Expr_until_rightbracket(i int) IExpr_until_rightbracketContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_until_rightbracketContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IExpr_until_rightbracketContext) } func (s *Assign_varContext) AllCLOSE_BRACKET() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCLOSE_BRACKET) } func (s *Assign_varContext) CLOSE_BRACKET(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_BRACKET, i) } func (s *Assign_varContext) GetRuleContext() antlr.RuleContext { return s } func (s *Assign_varContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Assign_varContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAssign_var(s) } } func (s *Assign_varContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAssign_var(s) } } func (s *Assign_varContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAssign_var(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Assign_var() (localctx IAssign_varContext) { localctx = NewAssign_varContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1476, PostgreSQLParserRULE_assign_var) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(10201) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: { p.SetState(10199) p.Any_name() } case PostgreSQLParserPARAM: { p.SetState(10200) p.Match(PostgreSQLParserPARAM) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.SetState(10209) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserOPEN_BRACKET { { p.SetState(10203) p.Match(PostgreSQLParserOPEN_BRACKET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10204) p.Expr_until_rightbracket() } { p.SetState(10205) p.Match(PostgreSQLParserCLOSE_BRACKET) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(10211) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_ifContext is an interface to support dynamic dispatch. type IStmt_ifContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllIF_P() []antlr.TerminalNode IF_P(i int) antlr.TerminalNode Expr_until_then() IExpr_until_thenContext THEN() antlr.TerminalNode Proc_sect() IProc_sectContext Stmt_elsifs() IStmt_elsifsContext Stmt_else() IStmt_elseContext END_P() antlr.TerminalNode SEMI() antlr.TerminalNode // IsStmt_ifContext differentiates from other interfaces. IsStmt_ifContext() } type Stmt_ifContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_ifContext() *Stmt_ifContext { var p = new(Stmt_ifContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_if return p } func InitEmptyStmt_ifContext(p *Stmt_ifContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_if } func (*Stmt_ifContext) IsStmt_ifContext() {} func NewStmt_ifContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_ifContext { var p = new(Stmt_ifContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_if return p } func (s *Stmt_ifContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_ifContext) AllIF_P() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserIF_P) } func (s *Stmt_ifContext) IF_P(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserIF_P, i) } func (s *Stmt_ifContext) Expr_until_then() IExpr_until_thenContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_until_thenContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_until_thenContext) } func (s *Stmt_ifContext) THEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTHEN, 0) } func (s *Stmt_ifContext) Proc_sect() IProc_sectContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IProc_sectContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IProc_sectContext) } func (s *Stmt_ifContext) Stmt_elsifs() IStmt_elsifsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_elsifsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_elsifsContext) } func (s *Stmt_ifContext) Stmt_else() IStmt_elseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmt_elseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmt_elseContext) } func (s *Stmt_ifContext) END_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEND_P, 0) } func (s *Stmt_ifContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_ifContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_ifContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_ifContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_if(s) } } func (s *Stmt_ifContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_if(s) } } func (s *Stmt_ifContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_if(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_if() (localctx IStmt_ifContext) { localctx = NewStmt_ifContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1478, PostgreSQLParserRULE_stmt_if) p.EnterOuterAlt(localctx, 1) { p.SetState(10212) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10213) p.Expr_until_then() } { p.SetState(10214) p.Match(PostgreSQLParserTHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10215) p.Proc_sect() } { p.SetState(10216) p.Stmt_elsifs() } { p.SetState(10217) p.Stmt_else() } { p.SetState(10218) p.Match(PostgreSQLParserEND_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10219) p.Match(PostgreSQLParserIF_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10220) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_elsifsContext is an interface to support dynamic dispatch. type IStmt_elsifsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllELSIF() []antlr.TerminalNode ELSIF(i int) antlr.TerminalNode AllA_expr() []IA_exprContext A_expr(i int) IA_exprContext AllTHEN() []antlr.TerminalNode THEN(i int) antlr.TerminalNode AllProc_sect() []IProc_sectContext Proc_sect(i int) IProc_sectContext // IsStmt_elsifsContext differentiates from other interfaces. IsStmt_elsifsContext() } type Stmt_elsifsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_elsifsContext() *Stmt_elsifsContext { var p = new(Stmt_elsifsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_elsifs return p } func InitEmptyStmt_elsifsContext(p *Stmt_elsifsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_elsifs } func (*Stmt_elsifsContext) IsStmt_elsifsContext() {} func NewStmt_elsifsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_elsifsContext { var p = new(Stmt_elsifsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_elsifs return p } func (s *Stmt_elsifsContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_elsifsContext) AllELSIF() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserELSIF) } func (s *Stmt_elsifsContext) ELSIF(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserELSIF, i) } func (s *Stmt_elsifsContext) AllA_expr() []IA_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_exprContext); ok { len++ } } tst := make([]IA_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_exprContext); ok { tst[i] = t.(IA_exprContext) i++ } } return tst } func (s *Stmt_elsifsContext) A_expr(i int) IA_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Stmt_elsifsContext) AllTHEN() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserTHEN) } func (s *Stmt_elsifsContext) THEN(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserTHEN, i) } func (s *Stmt_elsifsContext) AllProc_sect() []IProc_sectContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IProc_sectContext); ok { len++ } } tst := make([]IProc_sectContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IProc_sectContext); ok { tst[i] = t.(IProc_sectContext) i++ } } return tst } func (s *Stmt_elsifsContext) Proc_sect(i int) IProc_sectContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IProc_sectContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IProc_sectContext) } func (s *Stmt_elsifsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_elsifsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_elsifsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_elsifs(s) } } func (s *Stmt_elsifsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_elsifs(s) } } func (s *Stmt_elsifsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_elsifs(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_elsifs() (localctx IStmt_elsifsContext) { localctx = NewStmt_elsifsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1480, PostgreSQLParserRULE_stmt_elsifs) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(10229) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserELSIF { { p.SetState(10222) p.Match(PostgreSQLParserELSIF) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10223) p.A_expr() } { p.SetState(10224) p.Match(PostgreSQLParserTHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10225) p.Proc_sect() } p.SetState(10231) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_elseContext is an interface to support dynamic dispatch. type IStmt_elseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ELSE() antlr.TerminalNode Proc_sect() IProc_sectContext // IsStmt_elseContext differentiates from other interfaces. IsStmt_elseContext() } type Stmt_elseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_elseContext() *Stmt_elseContext { var p = new(Stmt_elseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_else return p } func InitEmptyStmt_elseContext(p *Stmt_elseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_else } func (*Stmt_elseContext) IsStmt_elseContext() {} func NewStmt_elseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_elseContext { var p = new(Stmt_elseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_else return p } func (s *Stmt_elseContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_elseContext) ELSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserELSE, 0) } func (s *Stmt_elseContext) Proc_sect() IProc_sectContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IProc_sectContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IProc_sectContext) } func (s *Stmt_elseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_elseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_elseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_else(s) } } func (s *Stmt_elseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_else(s) } } func (s *Stmt_elseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_else(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_else() (localctx IStmt_elseContext) { localctx = NewStmt_elseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1482, PostgreSQLParserRULE_stmt_else) p.SetState(10235) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserEND_P: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserELSE: p.EnterOuterAlt(localctx, 2) { p.SetState(10233) p.Match(PostgreSQLParserELSE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10234) p.Proc_sect() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_caseContext is an interface to support dynamic dispatch. type IStmt_caseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllCASE() []antlr.TerminalNode CASE(i int) antlr.TerminalNode Opt_expr_until_when() IOpt_expr_until_whenContext Case_when_list() ICase_when_listContext Opt_case_else() IOpt_case_elseContext END_P() antlr.TerminalNode SEMI() antlr.TerminalNode // IsStmt_caseContext differentiates from other interfaces. IsStmt_caseContext() } type Stmt_caseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_caseContext() *Stmt_caseContext { var p = new(Stmt_caseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_case return p } func InitEmptyStmt_caseContext(p *Stmt_caseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_case } func (*Stmt_caseContext) IsStmt_caseContext() {} func NewStmt_caseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_caseContext { var p = new(Stmt_caseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_case return p } func (s *Stmt_caseContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_caseContext) AllCASE() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCASE) } func (s *Stmt_caseContext) CASE(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCASE, i) } func (s *Stmt_caseContext) Opt_expr_until_when() IOpt_expr_until_whenContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_expr_until_whenContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_expr_until_whenContext) } func (s *Stmt_caseContext) Case_when_list() ICase_when_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICase_when_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICase_when_listContext) } func (s *Stmt_caseContext) Opt_case_else() IOpt_case_elseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_case_elseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_case_elseContext) } func (s *Stmt_caseContext) END_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEND_P, 0) } func (s *Stmt_caseContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_caseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_caseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_caseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_case(s) } } func (s *Stmt_caseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_case(s) } } func (s *Stmt_caseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_case(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_case() (localctx IStmt_caseContext) { localctx = NewStmt_caseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1484, PostgreSQLParserRULE_stmt_case) p.EnterOuterAlt(localctx, 1) { p.SetState(10237) p.Match(PostgreSQLParserCASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10238) p.Opt_expr_until_when() } { p.SetState(10239) p.Case_when_list() } { p.SetState(10240) p.Opt_case_else() } { p.SetState(10241) p.Match(PostgreSQLParserEND_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10242) p.Match(PostgreSQLParserCASE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10243) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_expr_until_whenContext is an interface to support dynamic dispatch. type IOpt_expr_until_whenContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sql_expression() ISql_expressionContext // IsOpt_expr_until_whenContext differentiates from other interfaces. IsOpt_expr_until_whenContext() } type Opt_expr_until_whenContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_expr_until_whenContext() *Opt_expr_until_whenContext { var p = new(Opt_expr_until_whenContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_expr_until_when return p } func InitEmptyOpt_expr_until_whenContext(p *Opt_expr_until_whenContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_expr_until_when } func (*Opt_expr_until_whenContext) IsOpt_expr_until_whenContext() {} func NewOpt_expr_until_whenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_expr_until_whenContext { var p = new(Opt_expr_until_whenContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_expr_until_when return p } func (s *Opt_expr_until_whenContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_expr_until_whenContext) Sql_expression() ISql_expressionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISql_expressionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISql_expressionContext) } func (s *Opt_expr_until_whenContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_expr_until_whenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_expr_until_whenContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_expr_until_when(s) } } func (s *Opt_expr_until_whenContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_expr_until_when(s) } } func (s *Opt_expr_until_whenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_expr_until_when(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_expr_until_when() (localctx IOpt_expr_until_whenContext) { localctx = NewOpt_expr_until_whenContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1486, PostgreSQLParserRULE_opt_expr_until_when) p.SetState(10247) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 693, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(10246) p.Sql_expression() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICase_when_listContext is an interface to support dynamic dispatch. type ICase_when_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllCase_when() []ICase_whenContext Case_when(i int) ICase_whenContext // IsCase_when_listContext differentiates from other interfaces. IsCase_when_listContext() } type Case_when_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCase_when_listContext() *Case_when_listContext { var p = new(Case_when_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_case_when_list return p } func InitEmptyCase_when_listContext(p *Case_when_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_case_when_list } func (*Case_when_listContext) IsCase_when_listContext() {} func NewCase_when_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_when_listContext { var p = new(Case_when_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_case_when_list return p } func (s *Case_when_listContext) GetParser() antlr.Parser { return s.parser } func (s *Case_when_listContext) AllCase_when() []ICase_whenContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ICase_whenContext); ok { len++ } } tst := make([]ICase_whenContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ICase_whenContext); ok { tst[i] = t.(ICase_whenContext) i++ } } return tst } func (s *Case_when_listContext) Case_when(i int) ICase_whenContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICase_whenContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ICase_whenContext) } func (s *Case_when_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Case_when_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Case_when_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCase_when_list(s) } } func (s *Case_when_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCase_when_list(s) } } func (s *Case_when_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCase_when_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Case_when_list() (localctx ICase_when_listContext) { localctx = NewCase_when_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1488, PostgreSQLParserRULE_case_when_list) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(10250) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ok := true; ok; ok = _la == PostgreSQLParserWHEN { { p.SetState(10249) p.Case_when() } p.SetState(10252) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICase_whenContext is an interface to support dynamic dispatch. type ICase_whenContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WHEN() antlr.TerminalNode Expr_list() IExpr_listContext THEN() antlr.TerminalNode Proc_sect() IProc_sectContext // IsCase_whenContext differentiates from other interfaces. IsCase_whenContext() } type Case_whenContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCase_whenContext() *Case_whenContext { var p = new(Case_whenContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_case_when return p } func InitEmptyCase_whenContext(p *Case_whenContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_case_when } func (*Case_whenContext) IsCase_whenContext() {} func NewCase_whenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_whenContext { var p = new(Case_whenContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_case_when return p } func (s *Case_whenContext) GetParser() antlr.Parser { return s.parser } func (s *Case_whenContext) WHEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHEN, 0) } func (s *Case_whenContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Case_whenContext) THEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTHEN, 0) } func (s *Case_whenContext) Proc_sect() IProc_sectContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IProc_sectContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IProc_sectContext) } func (s *Case_whenContext) GetRuleContext() antlr.RuleContext { return s } func (s *Case_whenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Case_whenContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCase_when(s) } } func (s *Case_whenContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCase_when(s) } } func (s *Case_whenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCase_when(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Case_when() (localctx ICase_whenContext) { localctx = NewCase_whenContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1490, PostgreSQLParserRULE_case_when) p.EnterOuterAlt(localctx, 1) { p.SetState(10254) p.Match(PostgreSQLParserWHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10255) p.Expr_list() } { p.SetState(10256) p.Match(PostgreSQLParserTHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10257) p.Proc_sect() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_case_elseContext is an interface to support dynamic dispatch. type IOpt_case_elseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ELSE() antlr.TerminalNode Proc_sect() IProc_sectContext // IsOpt_case_elseContext differentiates from other interfaces. IsOpt_case_elseContext() } type Opt_case_elseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_case_elseContext() *Opt_case_elseContext { var p = new(Opt_case_elseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_case_else return p } func InitEmptyOpt_case_elseContext(p *Opt_case_elseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_case_else } func (*Opt_case_elseContext) IsOpt_case_elseContext() {} func NewOpt_case_elseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_case_elseContext { var p = new(Opt_case_elseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_case_else return p } func (s *Opt_case_elseContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_case_elseContext) ELSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserELSE, 0) } func (s *Opt_case_elseContext) Proc_sect() IProc_sectContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IProc_sectContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IProc_sectContext) } func (s *Opt_case_elseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_case_elseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_case_elseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_case_else(s) } } func (s *Opt_case_elseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_case_else(s) } } func (s *Opt_case_elseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_case_else(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_case_else() (localctx IOpt_case_elseContext) { localctx = NewOpt_case_elseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1492, PostgreSQLParserRULE_opt_case_else) p.SetState(10262) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserEND_P: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserELSE: p.EnterOuterAlt(localctx, 2) { p.SetState(10260) p.Match(PostgreSQLParserELSE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10261) p.Proc_sect() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_loopContext is an interface to support dynamic dispatch. type IStmt_loopContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_loop_label() IOpt_loop_labelContext Loop_body() ILoop_bodyContext // IsStmt_loopContext differentiates from other interfaces. IsStmt_loopContext() } type Stmt_loopContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_loopContext() *Stmt_loopContext { var p = new(Stmt_loopContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_loop return p } func InitEmptyStmt_loopContext(p *Stmt_loopContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_loop } func (*Stmt_loopContext) IsStmt_loopContext() {} func NewStmt_loopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_loopContext { var p = new(Stmt_loopContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_loop return p } func (s *Stmt_loopContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_loopContext) Opt_loop_label() IOpt_loop_labelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_loop_labelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_loop_labelContext) } func (s *Stmt_loopContext) Loop_body() ILoop_bodyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ILoop_bodyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ILoop_bodyContext) } func (s *Stmt_loopContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_loopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_loopContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_loop(s) } } func (s *Stmt_loopContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_loop(s) } } func (s *Stmt_loopContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_loop(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_loop() (localctx IStmt_loopContext) { localctx = NewStmt_loopContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1494, PostgreSQLParserRULE_stmt_loop) p.EnterOuterAlt(localctx, 1) { p.SetState(10264) p.Opt_loop_label() } { p.SetState(10265) p.Loop_body() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_whileContext is an interface to support dynamic dispatch. type IStmt_whileContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_loop_label() IOpt_loop_labelContext WHILE() antlr.TerminalNode Expr_until_loop() IExpr_until_loopContext Loop_body() ILoop_bodyContext // IsStmt_whileContext differentiates from other interfaces. IsStmt_whileContext() } type Stmt_whileContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_whileContext() *Stmt_whileContext { var p = new(Stmt_whileContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_while return p } func InitEmptyStmt_whileContext(p *Stmt_whileContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_while } func (*Stmt_whileContext) IsStmt_whileContext() {} func NewStmt_whileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_whileContext { var p = new(Stmt_whileContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_while return p } func (s *Stmt_whileContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_whileContext) Opt_loop_label() IOpt_loop_labelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_loop_labelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_loop_labelContext) } func (s *Stmt_whileContext) WHILE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHILE, 0) } func (s *Stmt_whileContext) Expr_until_loop() IExpr_until_loopContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_until_loopContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_until_loopContext) } func (s *Stmt_whileContext) Loop_body() ILoop_bodyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ILoop_bodyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ILoop_bodyContext) } func (s *Stmt_whileContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_whileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_whileContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_while(s) } } func (s *Stmt_whileContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_while(s) } } func (s *Stmt_whileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_while(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_while() (localctx IStmt_whileContext) { localctx = NewStmt_whileContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1496, PostgreSQLParserRULE_stmt_while) p.EnterOuterAlt(localctx, 1) { p.SetState(10267) p.Opt_loop_label() } { p.SetState(10268) p.Match(PostgreSQLParserWHILE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10269) p.Expr_until_loop() } { p.SetState(10270) p.Loop_body() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_forContext is an interface to support dynamic dispatch. type IStmt_forContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_loop_label() IOpt_loop_labelContext FOR() antlr.TerminalNode For_control() IFor_controlContext Loop_body() ILoop_bodyContext // IsStmt_forContext differentiates from other interfaces. IsStmt_forContext() } type Stmt_forContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_forContext() *Stmt_forContext { var p = new(Stmt_forContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_for return p } func InitEmptyStmt_forContext(p *Stmt_forContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_for } func (*Stmt_forContext) IsStmt_forContext() {} func NewStmt_forContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_forContext { var p = new(Stmt_forContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_for return p } func (s *Stmt_forContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_forContext) Opt_loop_label() IOpt_loop_labelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_loop_labelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_loop_labelContext) } func (s *Stmt_forContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *Stmt_forContext) For_control() IFor_controlContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFor_controlContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFor_controlContext) } func (s *Stmt_forContext) Loop_body() ILoop_bodyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ILoop_bodyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ILoop_bodyContext) } func (s *Stmt_forContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_forContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_forContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_for(s) } } func (s *Stmt_forContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_for(s) } } func (s *Stmt_forContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_for(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_for() (localctx IStmt_forContext) { localctx = NewStmt_forContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1498, PostgreSQLParserRULE_stmt_for) p.EnterOuterAlt(localctx, 1) { p.SetState(10272) p.Opt_loop_label() } { p.SetState(10273) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10274) p.For_control() } { p.SetState(10275) p.Loop_body() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFor_controlContext is an interface to support dynamic dispatch. type IFor_controlContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures For_variable() IFor_variableContext IN_P() antlr.TerminalNode Cursor_name() ICursor_nameContext Opt_cursor_parameters() IOpt_cursor_parametersContext Selectstmt() ISelectstmtContext Explainstmt() IExplainstmtContext EXECUTE() antlr.TerminalNode AllA_expr() []IA_exprContext A_expr(i int) IA_exprContext Opt_for_using_expression() IOpt_for_using_expressionContext Opt_reverse() IOpt_reverseContext DOT_DOT() antlr.TerminalNode Opt_by_expression() IOpt_by_expressionContext // IsFor_controlContext differentiates from other interfaces. IsFor_controlContext() } type For_controlContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFor_controlContext() *For_controlContext { var p = new(For_controlContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_for_control return p } func InitEmptyFor_controlContext(p *For_controlContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_for_control } func (*For_controlContext) IsFor_controlContext() {} func NewFor_controlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_controlContext { var p = new(For_controlContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_for_control return p } func (s *For_controlContext) GetParser() antlr.Parser { return s.parser } func (s *For_controlContext) For_variable() IFor_variableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFor_variableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFor_variableContext) } func (s *For_controlContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *For_controlContext) Cursor_name() ICursor_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICursor_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICursor_nameContext) } func (s *For_controlContext) Opt_cursor_parameters() IOpt_cursor_parametersContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_cursor_parametersContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_cursor_parametersContext) } func (s *For_controlContext) Selectstmt() ISelectstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectstmtContext) } func (s *For_controlContext) Explainstmt() IExplainstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExplainstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExplainstmtContext) } func (s *For_controlContext) EXECUTE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXECUTE, 0) } func (s *For_controlContext) AllA_expr() []IA_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_exprContext); ok { len++ } } tst := make([]IA_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_exprContext); ok { tst[i] = t.(IA_exprContext) i++ } } return tst } func (s *For_controlContext) A_expr(i int) IA_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_exprContext) } func (s *For_controlContext) Opt_for_using_expression() IOpt_for_using_expressionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_for_using_expressionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_for_using_expressionContext) } func (s *For_controlContext) Opt_reverse() IOpt_reverseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_reverseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_reverseContext) } func (s *For_controlContext) DOT_DOT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDOT_DOT, 0) } func (s *For_controlContext) Opt_by_expression() IOpt_by_expressionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_by_expressionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_by_expressionContext) } func (s *For_controlContext) GetRuleContext() antlr.RuleContext { return s } func (s *For_controlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *For_controlContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFor_control(s) } } func (s *For_controlContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFor_control(s) } } func (s *For_controlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFor_control(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) For_control() (localctx IFor_controlContext) { localctx = NewFor_controlContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1500, PostgreSQLParserRULE_for_control) p.EnterOuterAlt(localctx, 1) { p.SetState(10277) p.For_variable() } { p.SetState(10278) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(10294) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 696, p.GetParserRuleContext()) { case 1: { p.SetState(10279) p.Cursor_name() } { p.SetState(10280) p.Opt_cursor_parameters() } case 2: { p.SetState(10282) p.Selectstmt() } case 3: { p.SetState(10283) p.Explainstmt() } case 4: { p.SetState(10284) p.Match(PostgreSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10285) p.A_expr() } { p.SetState(10286) p.Opt_for_using_expression() } case 5: { p.SetState(10288) p.Opt_reverse() } { p.SetState(10289) p.A_expr() } { p.SetState(10290) p.Match(PostgreSQLParserDOT_DOT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10291) p.A_expr() } { p.SetState(10292) p.Opt_by_expression() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_for_using_expressionContext is an interface to support dynamic dispatch. type IOpt_for_using_expressionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USING() antlr.TerminalNode Expr_list() IExpr_listContext // IsOpt_for_using_expressionContext differentiates from other interfaces. IsOpt_for_using_expressionContext() } type Opt_for_using_expressionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_for_using_expressionContext() *Opt_for_using_expressionContext { var p = new(Opt_for_using_expressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_for_using_expression return p } func InitEmptyOpt_for_using_expressionContext(p *Opt_for_using_expressionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_for_using_expression } func (*Opt_for_using_expressionContext) IsOpt_for_using_expressionContext() {} func NewOpt_for_using_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_for_using_expressionContext { var p = new(Opt_for_using_expressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_for_using_expression return p } func (s *Opt_for_using_expressionContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_for_using_expressionContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *Opt_for_using_expressionContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Opt_for_using_expressionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_for_using_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_for_using_expressionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_for_using_expression(s) } } func (s *Opt_for_using_expressionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_for_using_expression(s) } } func (s *Opt_for_using_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_for_using_expression(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_for_using_expression() (localctx IOpt_for_using_expressionContext) { localctx = NewOpt_for_using_expressionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1502, PostgreSQLParserRULE_opt_for_using_expression) p.SetState(10299) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSEMI, PostgreSQLParserLOOP: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 2) { p.SetState(10297) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10298) p.Expr_list() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_cursor_parametersContext is an interface to support dynamic dispatch. type IOpt_cursor_parametersContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN_PAREN() antlr.TerminalNode AllA_expr() []IA_exprContext A_expr(i int) IA_exprContext CLOSE_PAREN() antlr.TerminalNode AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsOpt_cursor_parametersContext differentiates from other interfaces. IsOpt_cursor_parametersContext() } type Opt_cursor_parametersContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_cursor_parametersContext() *Opt_cursor_parametersContext { var p = new(Opt_cursor_parametersContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_cursor_parameters return p } func InitEmptyOpt_cursor_parametersContext(p *Opt_cursor_parametersContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_cursor_parameters } func (*Opt_cursor_parametersContext) IsOpt_cursor_parametersContext() {} func NewOpt_cursor_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_cursor_parametersContext { var p = new(Opt_cursor_parametersContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_cursor_parameters return p } func (s *Opt_cursor_parametersContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_cursor_parametersContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Opt_cursor_parametersContext) AllA_expr() []IA_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_exprContext); ok { len++ } } tst := make([]IA_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_exprContext); ok { tst[i] = t.(IA_exprContext) i++ } } return tst } func (s *Opt_cursor_parametersContext) A_expr(i int) IA_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Opt_cursor_parametersContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Opt_cursor_parametersContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Opt_cursor_parametersContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Opt_cursor_parametersContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_cursor_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_cursor_parametersContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_cursor_parameters(s) } } func (s *Opt_cursor_parametersContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_cursor_parameters(s) } } func (s *Opt_cursor_parametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_cursor_parameters(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_cursor_parameters() (localctx IOpt_cursor_parametersContext) { localctx = NewOpt_cursor_parametersContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1504, PostgreSQLParserRULE_opt_cursor_parameters) var _la int p.SetState(10313) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserLOOP: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserOPEN_PAREN: p.EnterOuterAlt(localctx, 2) { p.SetState(10302) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10303) p.A_expr() } p.SetState(10308) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(10304) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10305) p.A_expr() } p.SetState(10310) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } { p.SetState(10311) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_reverseContext is an interface to support dynamic dispatch. type IOpt_reverseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures REVERSE() antlr.TerminalNode // IsOpt_reverseContext differentiates from other interfaces. IsOpt_reverseContext() } type Opt_reverseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_reverseContext() *Opt_reverseContext { var p = new(Opt_reverseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_reverse return p } func InitEmptyOpt_reverseContext(p *Opt_reverseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_reverse } func (*Opt_reverseContext) IsOpt_reverseContext() {} func NewOpt_reverseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_reverseContext { var p = new(Opt_reverseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_reverse return p } func (s *Opt_reverseContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_reverseContext) REVERSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserREVERSE, 0) } func (s *Opt_reverseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_reverseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_reverseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_reverse(s) } } func (s *Opt_reverseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_reverse(s) } } func (s *Opt_reverseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_reverse(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_reverse() (localctx IOpt_reverseContext) { localctx = NewOpt_reverseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1506, PostgreSQLParserRULE_opt_reverse) p.SetState(10317) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 700, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(10316) p.Match(PostgreSQLParserREVERSE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_by_expressionContext is an interface to support dynamic dispatch. type IOpt_by_expressionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures BY() antlr.TerminalNode A_expr() IA_exprContext // IsOpt_by_expressionContext differentiates from other interfaces. IsOpt_by_expressionContext() } type Opt_by_expressionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_by_expressionContext() *Opt_by_expressionContext { var p = new(Opt_by_expressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_by_expression return p } func InitEmptyOpt_by_expressionContext(p *Opt_by_expressionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_by_expression } func (*Opt_by_expressionContext) IsOpt_by_expressionContext() {} func NewOpt_by_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_by_expressionContext { var p = new(Opt_by_expressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_by_expression return p } func (s *Opt_by_expressionContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_by_expressionContext) BY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBY, 0) } func (s *Opt_by_expressionContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Opt_by_expressionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_by_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_by_expressionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_by_expression(s) } } func (s *Opt_by_expressionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_by_expression(s) } } func (s *Opt_by_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_by_expression(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_by_expression() (localctx IOpt_by_expressionContext) { localctx = NewOpt_by_expressionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1508, PostgreSQLParserRULE_opt_by_expression) p.SetState(10322) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserLOOP: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserBY: p.EnterOuterAlt(localctx, 2) { p.SetState(10320) p.Match(PostgreSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10321) p.A_expr() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFor_variableContext is an interface to support dynamic dispatch. type IFor_variableContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Any_name_list() IAny_name_listContext // IsFor_variableContext differentiates from other interfaces. IsFor_variableContext() } type For_variableContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFor_variableContext() *For_variableContext { var p = new(For_variableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_for_variable return p } func InitEmptyFor_variableContext(p *For_variableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_for_variable } func (*For_variableContext) IsFor_variableContext() {} func NewFor_variableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_variableContext { var p = new(For_variableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_for_variable return p } func (s *For_variableContext) GetParser() antlr.Parser { return s.parser } func (s *For_variableContext) Any_name_list() IAny_name_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_name_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_name_listContext) } func (s *For_variableContext) GetRuleContext() antlr.RuleContext { return s } func (s *For_variableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *For_variableContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterFor_variable(s) } } func (s *For_variableContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitFor_variable(s) } } func (s *For_variableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitFor_variable(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) For_variable() (localctx IFor_variableContext) { localctx = NewFor_variableContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1510, PostgreSQLParserRULE_for_variable) p.EnterOuterAlt(localctx, 1) { p.SetState(10324) p.Any_name_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_foreach_aContext is an interface to support dynamic dispatch. type IStmt_foreach_aContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_loop_label() IOpt_loop_labelContext FOREACH() antlr.TerminalNode For_variable() IFor_variableContext Foreach_slice() IForeach_sliceContext IN_P() antlr.TerminalNode ARRAY() antlr.TerminalNode A_expr() IA_exprContext Loop_body() ILoop_bodyContext // IsStmt_foreach_aContext differentiates from other interfaces. IsStmt_foreach_aContext() } type Stmt_foreach_aContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_foreach_aContext() *Stmt_foreach_aContext { var p = new(Stmt_foreach_aContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_foreach_a return p } func InitEmptyStmt_foreach_aContext(p *Stmt_foreach_aContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_foreach_a } func (*Stmt_foreach_aContext) IsStmt_foreach_aContext() {} func NewStmt_foreach_aContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_foreach_aContext { var p = new(Stmt_foreach_aContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_foreach_a return p } func (s *Stmt_foreach_aContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_foreach_aContext) Opt_loop_label() IOpt_loop_labelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_loop_labelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_loop_labelContext) } func (s *Stmt_foreach_aContext) FOREACH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOREACH, 0) } func (s *Stmt_foreach_aContext) For_variable() IFor_variableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFor_variableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFor_variableContext) } func (s *Stmt_foreach_aContext) Foreach_slice() IForeach_sliceContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IForeach_sliceContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IForeach_sliceContext) } func (s *Stmt_foreach_aContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *Stmt_foreach_aContext) ARRAY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserARRAY, 0) } func (s *Stmt_foreach_aContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Stmt_foreach_aContext) Loop_body() ILoop_bodyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ILoop_bodyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ILoop_bodyContext) } func (s *Stmt_foreach_aContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_foreach_aContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_foreach_aContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_foreach_a(s) } } func (s *Stmt_foreach_aContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_foreach_a(s) } } func (s *Stmt_foreach_aContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_foreach_a(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_foreach_a() (localctx IStmt_foreach_aContext) { localctx = NewStmt_foreach_aContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1512, PostgreSQLParserRULE_stmt_foreach_a) p.EnterOuterAlt(localctx, 1) { p.SetState(10326) p.Opt_loop_label() } { p.SetState(10327) p.Match(PostgreSQLParserFOREACH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10328) p.For_variable() } { p.SetState(10329) p.Foreach_slice() } { p.SetState(10330) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10331) p.Match(PostgreSQLParserARRAY) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10332) p.A_expr() } { p.SetState(10333) p.Loop_body() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IForeach_sliceContext is an interface to support dynamic dispatch. type IForeach_sliceContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SLICE() antlr.TerminalNode Iconst() IIconstContext // IsForeach_sliceContext differentiates from other interfaces. IsForeach_sliceContext() } type Foreach_sliceContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyForeach_sliceContext() *Foreach_sliceContext { var p = new(Foreach_sliceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_foreach_slice return p } func InitEmptyForeach_sliceContext(p *Foreach_sliceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_foreach_slice } func (*Foreach_sliceContext) IsForeach_sliceContext() {} func NewForeach_sliceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreach_sliceContext { var p = new(Foreach_sliceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_foreach_slice return p } func (s *Foreach_sliceContext) GetParser() antlr.Parser { return s.parser } func (s *Foreach_sliceContext) SLICE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSLICE, 0) } func (s *Foreach_sliceContext) Iconst() IIconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIconstContext) } func (s *Foreach_sliceContext) GetRuleContext() antlr.RuleContext { return s } func (s *Foreach_sliceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Foreach_sliceContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterForeach_slice(s) } } func (s *Foreach_sliceContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitForeach_slice(s) } } func (s *Foreach_sliceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitForeach_slice(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Foreach_slice() (localctx IForeach_sliceContext) { localctx = NewForeach_sliceContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1514, PostgreSQLParserRULE_foreach_slice) p.SetState(10338) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserIN_P: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserSLICE: p.EnterOuterAlt(localctx, 2) { p.SetState(10336) p.Match(PostgreSQLParserSLICE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10337) p.Iconst() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_exitContext is an interface to support dynamic dispatch. type IStmt_exitContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Exit_type() IExit_typeContext Opt_label() IOpt_labelContext Opt_exitcond() IOpt_exitcondContext SEMI() antlr.TerminalNode // IsStmt_exitContext differentiates from other interfaces. IsStmt_exitContext() } type Stmt_exitContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_exitContext() *Stmt_exitContext { var p = new(Stmt_exitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_exit return p } func InitEmptyStmt_exitContext(p *Stmt_exitContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_exit } func (*Stmt_exitContext) IsStmt_exitContext() {} func NewStmt_exitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_exitContext { var p = new(Stmt_exitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_exit return p } func (s *Stmt_exitContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_exitContext) Exit_type() IExit_typeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExit_typeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExit_typeContext) } func (s *Stmt_exitContext) Opt_label() IOpt_labelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_labelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_labelContext) } func (s *Stmt_exitContext) Opt_exitcond() IOpt_exitcondContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_exitcondContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_exitcondContext) } func (s *Stmt_exitContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_exitContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_exitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_exitContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_exit(s) } } func (s *Stmt_exitContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_exit(s) } } func (s *Stmt_exitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_exit(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_exit() (localctx IStmt_exitContext) { localctx = NewStmt_exitContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1516, PostgreSQLParserRULE_stmt_exit) p.EnterOuterAlt(localctx, 1) { p.SetState(10340) p.Exit_type() } { p.SetState(10341) p.Opt_label() } { p.SetState(10342) p.Opt_exitcond() } { p.SetState(10343) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExit_typeContext is an interface to support dynamic dispatch. type IExit_typeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures EXIT() antlr.TerminalNode CONTINUE_P() antlr.TerminalNode // IsExit_typeContext differentiates from other interfaces. IsExit_typeContext() } type Exit_typeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExit_typeContext() *Exit_typeContext { var p = new(Exit_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_exit_type return p } func InitEmptyExit_typeContext(p *Exit_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_exit_type } func (*Exit_typeContext) IsExit_typeContext() {} func NewExit_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exit_typeContext { var p = new(Exit_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_exit_type return p } func (s *Exit_typeContext) GetParser() antlr.Parser { return s.parser } func (s *Exit_typeContext) EXIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXIT, 0) } func (s *Exit_typeContext) CONTINUE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONTINUE_P, 0) } func (s *Exit_typeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Exit_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Exit_typeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExit_type(s) } } func (s *Exit_typeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExit_type(s) } } func (s *Exit_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExit_type(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Exit_type() (localctx IExit_typeContext) { localctx = NewExit_typeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1518, PostgreSQLParserRULE_exit_type) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(10345) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserCONTINUE_P || _la == PostgreSQLParserEXIT) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_returnContext is an interface to support dynamic dispatch. type IStmt_returnContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures RETURN() antlr.TerminalNode SEMI() antlr.TerminalNode NEXT() antlr.TerminalNode Sql_expression() ISql_expressionContext QUERY() antlr.TerminalNode Opt_return_result() IOpt_return_resultContext EXECUTE() antlr.TerminalNode A_expr() IA_exprContext Opt_for_using_expression() IOpt_for_using_expressionContext Selectstmt() ISelectstmtContext // IsStmt_returnContext differentiates from other interfaces. IsStmt_returnContext() } type Stmt_returnContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_returnContext() *Stmt_returnContext { var p = new(Stmt_returnContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_return return p } func InitEmptyStmt_returnContext(p *Stmt_returnContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_return } func (*Stmt_returnContext) IsStmt_returnContext() {} func NewStmt_returnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_returnContext { var p = new(Stmt_returnContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_return return p } func (s *Stmt_returnContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_returnContext) RETURN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRETURN, 0) } func (s *Stmt_returnContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_returnContext) NEXT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNEXT, 0) } func (s *Stmt_returnContext) Sql_expression() ISql_expressionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISql_expressionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISql_expressionContext) } func (s *Stmt_returnContext) QUERY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserQUERY, 0) } func (s *Stmt_returnContext) Opt_return_result() IOpt_return_resultContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_return_resultContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_return_resultContext) } func (s *Stmt_returnContext) EXECUTE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXECUTE, 0) } func (s *Stmt_returnContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Stmt_returnContext) Opt_for_using_expression() IOpt_for_using_expressionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_for_using_expressionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_for_using_expressionContext) } func (s *Stmt_returnContext) Selectstmt() ISelectstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectstmtContext) } func (s *Stmt_returnContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_returnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_returnContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_return(s) } } func (s *Stmt_returnContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_return(s) } } func (s *Stmt_returnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_return(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_return() (localctx IStmt_returnContext) { localctx = NewStmt_returnContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1520, PostgreSQLParserRULE_stmt_return) p.EnterOuterAlt(localctx, 1) { p.SetState(10347) p.Match(PostgreSQLParserRETURN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(10359) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 704, p.GetParserRuleContext()) { case 1: { p.SetState(10348) p.Match(PostgreSQLParserNEXT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10349) p.Sql_expression() } case 2: { p.SetState(10350) p.Match(PostgreSQLParserQUERY) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(10356) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserEXECUTE: { p.SetState(10351) p.Match(PostgreSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10352) p.A_expr() } { p.SetState(10353) p.Opt_for_using_expression() } case PostgreSQLParserOPEN_PAREN, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserVALUES: { p.SetState(10355) p.Selectstmt() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case 3: { p.SetState(10358) p.Opt_return_result() } case antlr.ATNInvalidAltNumber: goto errorExit } { p.SetState(10361) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_return_resultContext is an interface to support dynamic dispatch. type IOpt_return_resultContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sql_expression() ISql_expressionContext // IsOpt_return_resultContext differentiates from other interfaces. IsOpt_return_resultContext() } type Opt_return_resultContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_return_resultContext() *Opt_return_resultContext { var p = new(Opt_return_resultContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_return_result return p } func InitEmptyOpt_return_resultContext(p *Opt_return_resultContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_return_result } func (*Opt_return_resultContext) IsOpt_return_resultContext() {} func NewOpt_return_resultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_return_resultContext { var p = new(Opt_return_resultContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_return_result return p } func (s *Opt_return_resultContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_return_resultContext) Sql_expression() ISql_expressionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISql_expressionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISql_expressionContext) } func (s *Opt_return_resultContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_return_resultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_return_resultContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_return_result(s) } } func (s *Opt_return_resultContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_return_result(s) } } func (s *Opt_return_resultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_return_result(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_return_result() (localctx IOpt_return_resultContext) { localctx = NewOpt_return_resultContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1522, PostgreSQLParserRULE_opt_return_result) p.SetState(10365) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 705, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(10364) p.Sql_expression() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_raiseContext is an interface to support dynamic dispatch. type IStmt_raiseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures RAISE() antlr.TerminalNode Opt_stmt_raise_level() IOpt_stmt_raise_levelContext Sconst() ISconstContext Opt_raise_list() IOpt_raise_listContext Opt_raise_using() IOpt_raise_usingContext SEMI() antlr.TerminalNode Identifier() IIdentifierContext SQLSTATE() antlr.TerminalNode // IsStmt_raiseContext differentiates from other interfaces. IsStmt_raiseContext() } type Stmt_raiseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_raiseContext() *Stmt_raiseContext { var p = new(Stmt_raiseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_raise return p } func InitEmptyStmt_raiseContext(p *Stmt_raiseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_raise } func (*Stmt_raiseContext) IsStmt_raiseContext() {} func NewStmt_raiseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_raiseContext { var p = new(Stmt_raiseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_raise return p } func (s *Stmt_raiseContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_raiseContext) RAISE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRAISE, 0) } func (s *Stmt_raiseContext) Opt_stmt_raise_level() IOpt_stmt_raise_levelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_stmt_raise_levelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_stmt_raise_levelContext) } func (s *Stmt_raiseContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Stmt_raiseContext) Opt_raise_list() IOpt_raise_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_raise_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_raise_listContext) } func (s *Stmt_raiseContext) Opt_raise_using() IOpt_raise_usingContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_raise_usingContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_raise_usingContext) } func (s *Stmt_raiseContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_raiseContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *Stmt_raiseContext) SQLSTATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSQLSTATE, 0) } func (s *Stmt_raiseContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_raiseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_raiseContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_raise(s) } } func (s *Stmt_raiseContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_raise(s) } } func (s *Stmt_raiseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_raise(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_raise() (localctx IStmt_raiseContext) { localctx = NewStmt_raiseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1524, PostgreSQLParserRULE_stmt_raise) p.SetState(10393) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 706, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(10367) p.Match(PostgreSQLParserRAISE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10368) p.Opt_stmt_raise_level() } { p.SetState(10369) p.Sconst() } { p.SetState(10370) p.Opt_raise_list() } { p.SetState(10371) p.Opt_raise_using() } { p.SetState(10372) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(10374) p.Match(PostgreSQLParserRAISE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10375) p.Opt_stmt_raise_level() } { p.SetState(10376) p.Identifier() } { p.SetState(10377) p.Opt_raise_using() } { p.SetState(10378) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(10380) p.Match(PostgreSQLParserRAISE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10381) p.Opt_stmt_raise_level() } { p.SetState(10382) p.Match(PostgreSQLParserSQLSTATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10383) p.Sconst() } { p.SetState(10384) p.Opt_raise_using() } { p.SetState(10385) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(10387) p.Match(PostgreSQLParserRAISE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10388) p.Opt_stmt_raise_level() } { p.SetState(10389) p.Opt_raise_using() } { p.SetState(10390) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(10392) p.Match(PostgreSQLParserRAISE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_stmt_raise_levelContext is an interface to support dynamic dispatch. type IOpt_stmt_raise_levelContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures DEBUG() antlr.TerminalNode LOG() antlr.TerminalNode INFO() antlr.TerminalNode NOTICE() antlr.TerminalNode WARNING() antlr.TerminalNode EXCEPTION() antlr.TerminalNode // IsOpt_stmt_raise_levelContext differentiates from other interfaces. IsOpt_stmt_raise_levelContext() } type Opt_stmt_raise_levelContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_stmt_raise_levelContext() *Opt_stmt_raise_levelContext { var p = new(Opt_stmt_raise_levelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_stmt_raise_level return p } func InitEmptyOpt_stmt_raise_levelContext(p *Opt_stmt_raise_levelContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_stmt_raise_level } func (*Opt_stmt_raise_levelContext) IsOpt_stmt_raise_levelContext() {} func NewOpt_stmt_raise_levelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_stmt_raise_levelContext { var p = new(Opt_stmt_raise_levelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_stmt_raise_level return p } func (s *Opt_stmt_raise_levelContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_stmt_raise_levelContext) DEBUG() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEBUG, 0) } func (s *Opt_stmt_raise_levelContext) LOG() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOG, 0) } func (s *Opt_stmt_raise_levelContext) INFO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINFO, 0) } func (s *Opt_stmt_raise_levelContext) NOTICE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOTICE, 0) } func (s *Opt_stmt_raise_levelContext) WARNING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWARNING, 0) } func (s *Opt_stmt_raise_levelContext) EXCEPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXCEPTION, 0) } func (s *Opt_stmt_raise_levelContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_stmt_raise_levelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_stmt_raise_levelContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_stmt_raise_level(s) } } func (s *Opt_stmt_raise_levelContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_stmt_raise_level(s) } } func (s *Opt_stmt_raise_levelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_stmt_raise_level(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_stmt_raise_level() (localctx IOpt_stmt_raise_levelContext) { localctx = NewOpt_stmt_raise_levelContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1526, PostgreSQLParserRULE_opt_stmt_raise_level) p.SetState(10403) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 707, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) case 2: p.EnterOuterAlt(localctx, 2) case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(10397) p.Match(PostgreSQLParserDEBUG) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(10398) p.Match(PostgreSQLParserLOG) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(10399) p.Match(PostgreSQLParserINFO) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(10400) p.Match(PostgreSQLParserNOTICE) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(10401) p.Match(PostgreSQLParserWARNING) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(10402) p.Match(PostgreSQLParserEXCEPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_raise_listContext is an interface to support dynamic dispatch. type IOpt_raise_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode AllA_expr() []IA_exprContext A_expr(i int) IA_exprContext // IsOpt_raise_listContext differentiates from other interfaces. IsOpt_raise_listContext() } type Opt_raise_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_raise_listContext() *Opt_raise_listContext { var p = new(Opt_raise_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_raise_list return p } func InitEmptyOpt_raise_listContext(p *Opt_raise_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_raise_list } func (*Opt_raise_listContext) IsOpt_raise_listContext() {} func NewOpt_raise_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_raise_listContext { var p = new(Opt_raise_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_raise_list return p } func (s *Opt_raise_listContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_raise_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Opt_raise_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Opt_raise_listContext) AllA_expr() []IA_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_exprContext); ok { len++ } } tst := make([]IA_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_exprContext); ok { tst[i] = t.(IA_exprContext) i++ } } return tst } func (s *Opt_raise_listContext) A_expr(i int) IA_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Opt_raise_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_raise_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_raise_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_raise_list(s) } } func (s *Opt_raise_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_raise_list(s) } } func (s *Opt_raise_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_raise_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_raise_list() (localctx IOpt_raise_listContext) { localctx = NewOpt_raise_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1528, PostgreSQLParserRULE_opt_raise_list) var _la int p.SetState(10412) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSEMI, PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserCOMMA: p.EnterOuterAlt(localctx, 2) p.SetState(10408) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ok := true; ok; ok = _la == PostgreSQLParserCOMMA { { p.SetState(10406) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10407) p.A_expr() } p.SetState(10410) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_raise_usingContext is an interface to support dynamic dispatch. type IOpt_raise_usingContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USING() antlr.TerminalNode Opt_raise_using_elem_list() IOpt_raise_using_elem_listContext // IsOpt_raise_usingContext differentiates from other interfaces. IsOpt_raise_usingContext() } type Opt_raise_usingContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_raise_usingContext() *Opt_raise_usingContext { var p = new(Opt_raise_usingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_raise_using return p } func InitEmptyOpt_raise_usingContext(p *Opt_raise_usingContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_raise_using } func (*Opt_raise_usingContext) IsOpt_raise_usingContext() {} func NewOpt_raise_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_raise_usingContext { var p = new(Opt_raise_usingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_raise_using return p } func (s *Opt_raise_usingContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_raise_usingContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *Opt_raise_usingContext) Opt_raise_using_elem_list() IOpt_raise_using_elem_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_raise_using_elem_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_raise_using_elem_listContext) } func (s *Opt_raise_usingContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_raise_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_raise_usingContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_raise_using(s) } } func (s *Opt_raise_usingContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_raise_using(s) } } func (s *Opt_raise_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_raise_using(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_raise_using() (localctx IOpt_raise_usingContext) { localctx = NewOpt_raise_usingContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1530, PostgreSQLParserRULE_opt_raise_using) p.SetState(10417) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSEMI: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 2) { p.SetState(10415) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10416) p.Opt_raise_using_elem_list() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_raise_using_elemContext is an interface to support dynamic dispatch. type IOpt_raise_using_elemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Identifier() IIdentifierContext EQUAL() antlr.TerminalNode A_expr() IA_exprContext // IsOpt_raise_using_elemContext differentiates from other interfaces. IsOpt_raise_using_elemContext() } type Opt_raise_using_elemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_raise_using_elemContext() *Opt_raise_using_elemContext { var p = new(Opt_raise_using_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_raise_using_elem return p } func InitEmptyOpt_raise_using_elemContext(p *Opt_raise_using_elemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_raise_using_elem } func (*Opt_raise_using_elemContext) IsOpt_raise_using_elemContext() {} func NewOpt_raise_using_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_raise_using_elemContext { var p = new(Opt_raise_using_elemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_raise_using_elem return p } func (s *Opt_raise_using_elemContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_raise_using_elemContext) Identifier() IIdentifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentifierContext) } func (s *Opt_raise_using_elemContext) EQUAL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEQUAL, 0) } func (s *Opt_raise_using_elemContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Opt_raise_using_elemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_raise_using_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_raise_using_elemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_raise_using_elem(s) } } func (s *Opt_raise_using_elemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_raise_using_elem(s) } } func (s *Opt_raise_using_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_raise_using_elem(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_raise_using_elem() (localctx IOpt_raise_using_elemContext) { localctx = NewOpt_raise_using_elemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1532, PostgreSQLParserRULE_opt_raise_using_elem) p.EnterOuterAlt(localctx, 1) { p.SetState(10419) p.Identifier() } { p.SetState(10420) p.Match(PostgreSQLParserEQUAL) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10421) p.A_expr() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_raise_using_elem_listContext is an interface to support dynamic dispatch. type IOpt_raise_using_elem_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllOpt_raise_using_elem() []IOpt_raise_using_elemContext Opt_raise_using_elem(i int) IOpt_raise_using_elemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsOpt_raise_using_elem_listContext differentiates from other interfaces. IsOpt_raise_using_elem_listContext() } type Opt_raise_using_elem_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_raise_using_elem_listContext() *Opt_raise_using_elem_listContext { var p = new(Opt_raise_using_elem_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_raise_using_elem_list return p } func InitEmptyOpt_raise_using_elem_listContext(p *Opt_raise_using_elem_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_raise_using_elem_list } func (*Opt_raise_using_elem_listContext) IsOpt_raise_using_elem_listContext() {} func NewOpt_raise_using_elem_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_raise_using_elem_listContext { var p = new(Opt_raise_using_elem_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_raise_using_elem_list return p } func (s *Opt_raise_using_elem_listContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_raise_using_elem_listContext) AllOpt_raise_using_elem() []IOpt_raise_using_elemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IOpt_raise_using_elemContext); ok { len++ } } tst := make([]IOpt_raise_using_elemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IOpt_raise_using_elemContext); ok { tst[i] = t.(IOpt_raise_using_elemContext) i++ } } return tst } func (s *Opt_raise_using_elem_listContext) Opt_raise_using_elem(i int) IOpt_raise_using_elemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_raise_using_elemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IOpt_raise_using_elemContext) } func (s *Opt_raise_using_elem_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Opt_raise_using_elem_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Opt_raise_using_elem_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_raise_using_elem_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_raise_using_elem_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_raise_using_elem_list(s) } } func (s *Opt_raise_using_elem_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_raise_using_elem_list(s) } } func (s *Opt_raise_using_elem_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_raise_using_elem_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_raise_using_elem_list() (localctx IOpt_raise_using_elem_listContext) { localctx = NewOpt_raise_using_elem_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1534, PostgreSQLParserRULE_opt_raise_using_elem_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(10423) p.Opt_raise_using_elem() } p.SetState(10428) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(10424) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10425) p.Opt_raise_using_elem() } p.SetState(10430) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_assertContext is an interface to support dynamic dispatch. type IStmt_assertContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ASSERT() antlr.TerminalNode Sql_expression() ISql_expressionContext Opt_stmt_assert_message() IOpt_stmt_assert_messageContext SEMI() antlr.TerminalNode // IsStmt_assertContext differentiates from other interfaces. IsStmt_assertContext() } type Stmt_assertContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_assertContext() *Stmt_assertContext { var p = new(Stmt_assertContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_assert return p } func InitEmptyStmt_assertContext(p *Stmt_assertContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_assert } func (*Stmt_assertContext) IsStmt_assertContext() {} func NewStmt_assertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_assertContext { var p = new(Stmt_assertContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_assert return p } func (s *Stmt_assertContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_assertContext) ASSERT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserASSERT, 0) } func (s *Stmt_assertContext) Sql_expression() ISql_expressionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISql_expressionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISql_expressionContext) } func (s *Stmt_assertContext) Opt_stmt_assert_message() IOpt_stmt_assert_messageContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_stmt_assert_messageContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_stmt_assert_messageContext) } func (s *Stmt_assertContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_assertContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_assertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_assertContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_assert(s) } } func (s *Stmt_assertContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_assert(s) } } func (s *Stmt_assertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_assert(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_assert() (localctx IStmt_assertContext) { localctx = NewStmt_assertContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1536, PostgreSQLParserRULE_stmt_assert) p.EnterOuterAlt(localctx, 1) { p.SetState(10431) p.Match(PostgreSQLParserASSERT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10432) p.Sql_expression() } { p.SetState(10433) p.Opt_stmt_assert_message() } { p.SetState(10434) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_stmt_assert_messageContext is an interface to support dynamic dispatch. type IOpt_stmt_assert_messageContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures COMMA() antlr.TerminalNode Sql_expression() ISql_expressionContext // IsOpt_stmt_assert_messageContext differentiates from other interfaces. IsOpt_stmt_assert_messageContext() } type Opt_stmt_assert_messageContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_stmt_assert_messageContext() *Opt_stmt_assert_messageContext { var p = new(Opt_stmt_assert_messageContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_stmt_assert_message return p } func InitEmptyOpt_stmt_assert_messageContext(p *Opt_stmt_assert_messageContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_stmt_assert_message } func (*Opt_stmt_assert_messageContext) IsOpt_stmt_assert_messageContext() {} func NewOpt_stmt_assert_messageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_stmt_assert_messageContext { var p = new(Opt_stmt_assert_messageContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_stmt_assert_message return p } func (s *Opt_stmt_assert_messageContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_stmt_assert_messageContext) COMMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, 0) } func (s *Opt_stmt_assert_messageContext) Sql_expression() ISql_expressionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISql_expressionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISql_expressionContext) } func (s *Opt_stmt_assert_messageContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_stmt_assert_messageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_stmt_assert_messageContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_stmt_assert_message(s) } } func (s *Opt_stmt_assert_messageContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_stmt_assert_message(s) } } func (s *Opt_stmt_assert_messageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_stmt_assert_message(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_stmt_assert_message() (localctx IOpt_stmt_assert_messageContext) { localctx = NewOpt_stmt_assert_messageContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1538, PostgreSQLParserRULE_opt_stmt_assert_message) p.SetState(10439) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSEMI: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserCOMMA: p.EnterOuterAlt(localctx, 2) { p.SetState(10437) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10438) p.Sql_expression() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ILoop_bodyContext is an interface to support dynamic dispatch. type ILoop_bodyContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllLOOP() []antlr.TerminalNode LOOP(i int) antlr.TerminalNode Proc_sect() IProc_sectContext END_P() antlr.TerminalNode Opt_label() IOpt_labelContext SEMI() antlr.TerminalNode // IsLoop_bodyContext differentiates from other interfaces. IsLoop_bodyContext() } type Loop_bodyContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyLoop_bodyContext() *Loop_bodyContext { var p = new(Loop_bodyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_loop_body return p } func InitEmptyLoop_bodyContext(p *Loop_bodyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_loop_body } func (*Loop_bodyContext) IsLoop_bodyContext() {} func NewLoop_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Loop_bodyContext { var p = new(Loop_bodyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_loop_body return p } func (s *Loop_bodyContext) GetParser() antlr.Parser { return s.parser } func (s *Loop_bodyContext) AllLOOP() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserLOOP) } func (s *Loop_bodyContext) LOOP(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserLOOP, i) } func (s *Loop_bodyContext) Proc_sect() IProc_sectContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IProc_sectContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IProc_sectContext) } func (s *Loop_bodyContext) END_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEND_P, 0) } func (s *Loop_bodyContext) Opt_label() IOpt_labelContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_labelContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_labelContext) } func (s *Loop_bodyContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Loop_bodyContext) GetRuleContext() antlr.RuleContext { return s } func (s *Loop_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Loop_bodyContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterLoop_body(s) } } func (s *Loop_bodyContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitLoop_body(s) } } func (s *Loop_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitLoop_body(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Loop_body() (localctx ILoop_bodyContext) { localctx = NewLoop_bodyContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1540, PostgreSQLParserRULE_loop_body) p.EnterOuterAlt(localctx, 1) { p.SetState(10441) p.Match(PostgreSQLParserLOOP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10442) p.Proc_sect() } { p.SetState(10443) p.Match(PostgreSQLParserEND_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10444) p.Match(PostgreSQLParserLOOP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10445) p.Opt_label() } { p.SetState(10446) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_execsqlContext is an interface to support dynamic dispatch. type IStmt_execsqlContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Make_execsql_stmt() IMake_execsql_stmtContext SEMI() antlr.TerminalNode // IsStmt_execsqlContext differentiates from other interfaces. IsStmt_execsqlContext() } type Stmt_execsqlContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_execsqlContext() *Stmt_execsqlContext { var p = new(Stmt_execsqlContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_execsql return p } func InitEmptyStmt_execsqlContext(p *Stmt_execsqlContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_execsql } func (*Stmt_execsqlContext) IsStmt_execsqlContext() {} func NewStmt_execsqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_execsqlContext { var p = new(Stmt_execsqlContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_execsql return p } func (s *Stmt_execsqlContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_execsqlContext) Make_execsql_stmt() IMake_execsql_stmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IMake_execsql_stmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IMake_execsql_stmtContext) } func (s *Stmt_execsqlContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_execsqlContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_execsqlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_execsqlContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_execsql(s) } } func (s *Stmt_execsqlContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_execsql(s) } } func (s *Stmt_execsqlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_execsql(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_execsql() (localctx IStmt_execsqlContext) { localctx = NewStmt_execsqlContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1542, PostgreSQLParserRULE_stmt_execsql) p.EnterOuterAlt(localctx, 1) { p.SetState(10448) p.Make_execsql_stmt() } { p.SetState(10449) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_dynexecuteContext is an interface to support dynamic dispatch. type IStmt_dynexecuteContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures EXECUTE() antlr.TerminalNode A_expr() IA_exprContext SEMI() antlr.TerminalNode Opt_execute_into() IOpt_execute_intoContext Opt_execute_using() IOpt_execute_usingContext // IsStmt_dynexecuteContext differentiates from other interfaces. IsStmt_dynexecuteContext() } type Stmt_dynexecuteContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_dynexecuteContext() *Stmt_dynexecuteContext { var p = new(Stmt_dynexecuteContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_dynexecute return p } func InitEmptyStmt_dynexecuteContext(p *Stmt_dynexecuteContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_dynexecute } func (*Stmt_dynexecuteContext) IsStmt_dynexecuteContext() {} func NewStmt_dynexecuteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_dynexecuteContext { var p = new(Stmt_dynexecuteContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_dynexecute return p } func (s *Stmt_dynexecuteContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_dynexecuteContext) EXECUTE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXECUTE, 0) } func (s *Stmt_dynexecuteContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Stmt_dynexecuteContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_dynexecuteContext) Opt_execute_into() IOpt_execute_intoContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_execute_intoContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_execute_intoContext) } func (s *Stmt_dynexecuteContext) Opt_execute_using() IOpt_execute_usingContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_execute_usingContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_execute_usingContext) } func (s *Stmt_dynexecuteContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_dynexecuteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_dynexecuteContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_dynexecute(s) } } func (s *Stmt_dynexecuteContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_dynexecute(s) } } func (s *Stmt_dynexecuteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_dynexecute(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_dynexecute() (localctx IStmt_dynexecuteContext) { localctx = NewStmt_dynexecuteContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1544, PostgreSQLParserRULE_stmt_dynexecute) p.EnterOuterAlt(localctx, 1) { p.SetState(10451) p.Match(PostgreSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10452) p.A_expr() } p.SetState(10460) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 713, p.GetParserRuleContext()) { case 1: { p.SetState(10453) p.Opt_execute_into() } { p.SetState(10454) p.Opt_execute_using() } case 2: { p.SetState(10456) p.Opt_execute_using() } { p.SetState(10457) p.Opt_execute_into() } case 3: case antlr.ATNInvalidAltNumber: goto errorExit } { p.SetState(10462) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_execute_usingContext is an interface to support dynamic dispatch. type IOpt_execute_usingContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USING() antlr.TerminalNode Opt_execute_using_list() IOpt_execute_using_listContext // IsOpt_execute_usingContext differentiates from other interfaces. IsOpt_execute_usingContext() } type Opt_execute_usingContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_execute_usingContext() *Opt_execute_usingContext { var p = new(Opt_execute_usingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_execute_using return p } func InitEmptyOpt_execute_usingContext(p *Opt_execute_usingContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_execute_using } func (*Opt_execute_usingContext) IsOpt_execute_usingContext() {} func NewOpt_execute_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_execute_usingContext { var p = new(Opt_execute_usingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_execute_using return p } func (s *Opt_execute_usingContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_execute_usingContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *Opt_execute_usingContext) Opt_execute_using_list() IOpt_execute_using_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_execute_using_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_execute_using_listContext) } func (s *Opt_execute_usingContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_execute_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_execute_usingContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_execute_using(s) } } func (s *Opt_execute_usingContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_execute_using(s) } } func (s *Opt_execute_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_execute_using(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_execute_using() (localctx IOpt_execute_usingContext) { localctx = NewOpt_execute_usingContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1546, PostgreSQLParserRULE_opt_execute_using) p.SetState(10467) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSEMI, PostgreSQLParserINTO: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 2) { p.SetState(10465) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10466) p.Opt_execute_using_list() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_execute_using_listContext is an interface to support dynamic dispatch. type IOpt_execute_using_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllA_expr() []IA_exprContext A_expr(i int) IA_exprContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsOpt_execute_using_listContext differentiates from other interfaces. IsOpt_execute_using_listContext() } type Opt_execute_using_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_execute_using_listContext() *Opt_execute_using_listContext { var p = new(Opt_execute_using_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_execute_using_list return p } func InitEmptyOpt_execute_using_listContext(p *Opt_execute_using_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_execute_using_list } func (*Opt_execute_using_listContext) IsOpt_execute_using_listContext() {} func NewOpt_execute_using_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_execute_using_listContext { var p = new(Opt_execute_using_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_execute_using_list return p } func (s *Opt_execute_using_listContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_execute_using_listContext) AllA_expr() []IA_exprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IA_exprContext); ok { len++ } } tst := make([]IA_exprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IA_exprContext); ok { tst[i] = t.(IA_exprContext) i++ } } return tst } func (s *Opt_execute_using_listContext) A_expr(i int) IA_exprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Opt_execute_using_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Opt_execute_using_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Opt_execute_using_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_execute_using_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_execute_using_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_execute_using_list(s) } } func (s *Opt_execute_using_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_execute_using_list(s) } } func (s *Opt_execute_using_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_execute_using_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_execute_using_list() (localctx IOpt_execute_using_listContext) { localctx = NewOpt_execute_using_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1548, PostgreSQLParserRULE_opt_execute_using_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(10469) p.A_expr() } p.SetState(10474) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(10470) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10471) p.A_expr() } p.SetState(10476) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_execute_intoContext is an interface to support dynamic dispatch. type IOpt_execute_intoContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures INTO() antlr.TerminalNode Into_target() IInto_targetContext STRICT_P() antlr.TerminalNode // IsOpt_execute_intoContext differentiates from other interfaces. IsOpt_execute_intoContext() } type Opt_execute_intoContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_execute_intoContext() *Opt_execute_intoContext { var p = new(Opt_execute_intoContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_execute_into return p } func InitEmptyOpt_execute_intoContext(p *Opt_execute_intoContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_execute_into } func (*Opt_execute_intoContext) IsOpt_execute_intoContext() {} func NewOpt_execute_intoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_execute_intoContext { var p = new(Opt_execute_intoContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_execute_into return p } func (s *Opt_execute_intoContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_execute_intoContext) INTO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINTO, 0) } func (s *Opt_execute_intoContext) Into_target() IInto_targetContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInto_targetContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IInto_targetContext) } func (s *Opt_execute_intoContext) STRICT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTRICT_P, 0) } func (s *Opt_execute_intoContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_execute_intoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_execute_intoContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_execute_into(s) } } func (s *Opt_execute_intoContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_execute_into(s) } } func (s *Opt_execute_intoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_execute_into(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_execute_into() (localctx IOpt_execute_intoContext) { localctx = NewOpt_execute_intoContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1550, PostgreSQLParserRULE_opt_execute_into) p.SetState(10483) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSEMI, PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserINTO: p.EnterOuterAlt(localctx, 2) { p.SetState(10478) p.Match(PostgreSQLParserINTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(10480) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 716, p.GetParserRuleContext()) == 1 { { p.SetState(10479) p.Match(PostgreSQLParserSTRICT_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } { p.SetState(10482) p.Into_target() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_openContext is an interface to support dynamic dispatch. type IStmt_openContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures OPEN() antlr.TerminalNode SEMI() antlr.TerminalNode Cursor_variable() ICursor_variableContext Opt_scroll_option() IOpt_scroll_optionContext FOR() antlr.TerminalNode Colid() IColidContext Selectstmt() ISelectstmtContext EXECUTE() antlr.TerminalNode Sql_expression() ISql_expressionContext Opt_open_using() IOpt_open_usingContext OPEN_PAREN() antlr.TerminalNode Opt_open_bound_list() IOpt_open_bound_listContext CLOSE_PAREN() antlr.TerminalNode // IsStmt_openContext differentiates from other interfaces. IsStmt_openContext() } type Stmt_openContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_openContext() *Stmt_openContext { var p = new(Stmt_openContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_open return p } func InitEmptyStmt_openContext(p *Stmt_openContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_open } func (*Stmt_openContext) IsStmt_openContext() {} func NewStmt_openContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_openContext { var p = new(Stmt_openContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_open return p } func (s *Stmt_openContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_openContext) OPEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN, 0) } func (s *Stmt_openContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_openContext) Cursor_variable() ICursor_variableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICursor_variableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICursor_variableContext) } func (s *Stmt_openContext) Opt_scroll_option() IOpt_scroll_optionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_scroll_optionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_scroll_optionContext) } func (s *Stmt_openContext) FOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFOR, 0) } func (s *Stmt_openContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Stmt_openContext) Selectstmt() ISelectstmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectstmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectstmtContext) } func (s *Stmt_openContext) EXECUTE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXECUTE, 0) } func (s *Stmt_openContext) Sql_expression() ISql_expressionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISql_expressionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISql_expressionContext) } func (s *Stmt_openContext) Opt_open_using() IOpt_open_usingContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_open_usingContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_open_usingContext) } func (s *Stmt_openContext) OPEN_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN_PAREN, 0) } func (s *Stmt_openContext) Opt_open_bound_list() IOpt_open_bound_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_open_bound_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_open_bound_listContext) } func (s *Stmt_openContext) CLOSE_PAREN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE_PAREN, 0) } func (s *Stmt_openContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_openContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_openContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_open(s) } } func (s *Stmt_openContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_open(s) } } func (s *Stmt_openContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_open(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_open() (localctx IStmt_openContext) { localctx = NewStmt_openContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1552, PostgreSQLParserRULE_stmt_open) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(10485) p.Match(PostgreSQLParserOPEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(10503) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 720, p.GetParserRuleContext()) { case 1: { p.SetState(10486) p.Cursor_variable() } { p.SetState(10487) p.Opt_scroll_option() } { p.SetState(10488) p.Match(PostgreSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(10494) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserOPEN_PAREN, PostgreSQLParserSELECT, PostgreSQLParserTABLE, PostgreSQLParserWITH, PostgreSQLParserVALUES: { p.SetState(10489) p.Selectstmt() } case PostgreSQLParserEXECUTE: { p.SetState(10490) p.Match(PostgreSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10491) p.Sql_expression() } { p.SetState(10492) p.Opt_open_using() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } case 2: { p.SetState(10496) p.Colid() } p.SetState(10501) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserOPEN_PAREN { { p.SetState(10497) p.Match(PostgreSQLParserOPEN_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10498) p.Opt_open_bound_list() } { p.SetState(10499) p.Match(PostgreSQLParserCLOSE_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } } case antlr.ATNInvalidAltNumber: goto errorExit } { p.SetState(10505) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_open_bound_list_itemContext is an interface to support dynamic dispatch. type IOpt_open_bound_list_itemContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext COLON_EQUALS() antlr.TerminalNode A_expr() IA_exprContext // IsOpt_open_bound_list_itemContext differentiates from other interfaces. IsOpt_open_bound_list_itemContext() } type Opt_open_bound_list_itemContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_open_bound_list_itemContext() *Opt_open_bound_list_itemContext { var p = new(Opt_open_bound_list_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_open_bound_list_item return p } func InitEmptyOpt_open_bound_list_itemContext(p *Opt_open_bound_list_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_open_bound_list_item } func (*Opt_open_bound_list_itemContext) IsOpt_open_bound_list_itemContext() {} func NewOpt_open_bound_list_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_open_bound_list_itemContext { var p = new(Opt_open_bound_list_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_open_bound_list_item return p } func (s *Opt_open_bound_list_itemContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_open_bound_list_itemContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Opt_open_bound_list_itemContext) COLON_EQUALS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLON_EQUALS, 0) } func (s *Opt_open_bound_list_itemContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Opt_open_bound_list_itemContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_open_bound_list_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_open_bound_list_itemContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_open_bound_list_item(s) } } func (s *Opt_open_bound_list_itemContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_open_bound_list_item(s) } } func (s *Opt_open_bound_list_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_open_bound_list_item(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_open_bound_list_item() (localctx IOpt_open_bound_list_itemContext) { localctx = NewOpt_open_bound_list_itemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1554, PostgreSQLParserRULE_opt_open_bound_list_item) p.SetState(10512) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 721, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(10507) p.Colid() } { p.SetState(10508) p.Match(PostgreSQLParserCOLON_EQUALS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10509) p.A_expr() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(10511) p.A_expr() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_open_bound_listContext is an interface to support dynamic dispatch. type IOpt_open_bound_listContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllOpt_open_bound_list_item() []IOpt_open_bound_list_itemContext Opt_open_bound_list_item(i int) IOpt_open_bound_list_itemContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsOpt_open_bound_listContext differentiates from other interfaces. IsOpt_open_bound_listContext() } type Opt_open_bound_listContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_open_bound_listContext() *Opt_open_bound_listContext { var p = new(Opt_open_bound_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_open_bound_list return p } func InitEmptyOpt_open_bound_listContext(p *Opt_open_bound_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_open_bound_list } func (*Opt_open_bound_listContext) IsOpt_open_bound_listContext() {} func NewOpt_open_bound_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_open_bound_listContext { var p = new(Opt_open_bound_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_open_bound_list return p } func (s *Opt_open_bound_listContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_open_bound_listContext) AllOpt_open_bound_list_item() []IOpt_open_bound_list_itemContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IOpt_open_bound_list_itemContext); ok { len++ } } tst := make([]IOpt_open_bound_list_itemContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IOpt_open_bound_list_itemContext); ok { tst[i] = t.(IOpt_open_bound_list_itemContext) i++ } } return tst } func (s *Opt_open_bound_listContext) Opt_open_bound_list_item(i int) IOpt_open_bound_list_itemContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_open_bound_list_itemContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IOpt_open_bound_list_itemContext) } func (s *Opt_open_bound_listContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserCOMMA) } func (s *Opt_open_bound_listContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMA, i) } func (s *Opt_open_bound_listContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_open_bound_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_open_bound_listContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_open_bound_list(s) } } func (s *Opt_open_bound_listContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_open_bound_list(s) } } func (s *Opt_open_bound_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_open_bound_list(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_open_bound_list() (localctx IOpt_open_bound_listContext) { localctx = NewOpt_open_bound_listContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1556, PostgreSQLParserRULE_opt_open_bound_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(10514) p.Opt_open_bound_list_item() } p.SetState(10519) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserCOMMA { { p.SetState(10515) p.Match(PostgreSQLParserCOMMA) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10516) p.Opt_open_bound_list_item() } p.SetState(10521) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_open_usingContext is an interface to support dynamic dispatch. type IOpt_open_usingContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures USING() antlr.TerminalNode Expr_list() IExpr_listContext // IsOpt_open_usingContext differentiates from other interfaces. IsOpt_open_usingContext() } type Opt_open_usingContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_open_usingContext() *Opt_open_usingContext { var p = new(Opt_open_usingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_open_using return p } func InitEmptyOpt_open_usingContext(p *Opt_open_usingContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_open_using } func (*Opt_open_usingContext) IsOpt_open_usingContext() {} func NewOpt_open_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_open_usingContext { var p = new(Opt_open_usingContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_open_using return p } func (s *Opt_open_usingContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_open_usingContext) USING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSING, 0) } func (s *Opt_open_usingContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Opt_open_usingContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_open_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_open_usingContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_open_using(s) } } func (s *Opt_open_usingContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_open_using(s) } } func (s *Opt_open_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_open_using(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_open_using() (localctx IOpt_open_usingContext) { localctx = NewOpt_open_usingContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1558, PostgreSQLParserRULE_opt_open_using) p.SetState(10525) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSEMI: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserUSING: p.EnterOuterAlt(localctx, 2) { p.SetState(10523) p.Match(PostgreSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10524) p.Expr_list() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_scroll_optionContext is an interface to support dynamic dispatch. type IOpt_scroll_optionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_scroll_option_no() IOpt_scroll_option_noContext SCROLL() antlr.TerminalNode // IsOpt_scroll_optionContext differentiates from other interfaces. IsOpt_scroll_optionContext() } type Opt_scroll_optionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_scroll_optionContext() *Opt_scroll_optionContext { var p = new(Opt_scroll_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_scroll_option return p } func InitEmptyOpt_scroll_optionContext(p *Opt_scroll_optionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_scroll_option } func (*Opt_scroll_optionContext) IsOpt_scroll_optionContext() {} func NewOpt_scroll_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_scroll_optionContext { var p = new(Opt_scroll_optionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_scroll_option return p } func (s *Opt_scroll_optionContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_scroll_optionContext) Opt_scroll_option_no() IOpt_scroll_option_noContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_scroll_option_noContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_scroll_option_noContext) } func (s *Opt_scroll_optionContext) SCROLL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCROLL, 0) } func (s *Opt_scroll_optionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_scroll_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_scroll_optionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_scroll_option(s) } } func (s *Opt_scroll_optionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_scroll_option(s) } } func (s *Opt_scroll_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_scroll_option(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_scroll_option() (localctx IOpt_scroll_optionContext) { localctx = NewOpt_scroll_optionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1560, PostgreSQLParserRULE_opt_scroll_option) p.SetState(10531) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFOR: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserNO, PostgreSQLParserSCROLL: p.EnterOuterAlt(localctx, 2) { p.SetState(10528) p.Opt_scroll_option_no() } { p.SetState(10529) p.Match(PostgreSQLParserSCROLL) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_scroll_option_noContext is an interface to support dynamic dispatch. type IOpt_scroll_option_noContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NO() antlr.TerminalNode // IsOpt_scroll_option_noContext differentiates from other interfaces. IsOpt_scroll_option_noContext() } type Opt_scroll_option_noContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_scroll_option_noContext() *Opt_scroll_option_noContext { var p = new(Opt_scroll_option_noContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_scroll_option_no return p } func InitEmptyOpt_scroll_option_noContext(p *Opt_scroll_option_noContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_scroll_option_no } func (*Opt_scroll_option_noContext) IsOpt_scroll_option_noContext() {} func NewOpt_scroll_option_noContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_scroll_option_noContext { var p = new(Opt_scroll_option_noContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_scroll_option_no return p } func (s *Opt_scroll_option_noContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_scroll_option_noContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Opt_scroll_option_noContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_scroll_option_noContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_scroll_option_noContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_scroll_option_no(s) } } func (s *Opt_scroll_option_noContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_scroll_option_no(s) } } func (s *Opt_scroll_option_noContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_scroll_option_no(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_scroll_option_no() (localctx IOpt_scroll_option_noContext) { localctx = NewOpt_scroll_option_noContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1562, PostgreSQLParserRULE_opt_scroll_option_no) p.SetState(10535) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSCROLL: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserNO: p.EnterOuterAlt(localctx, 2) { p.SetState(10534) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_fetchContext is an interface to support dynamic dispatch. type IStmt_fetchContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // GetDirection returns the direction rule contexts. GetDirection() IOpt_fetch_directionContext // SetDirection sets the direction rule contexts. SetDirection(IOpt_fetch_directionContext) // Getter signatures FETCH() antlr.TerminalNode Opt_cursor_from() IOpt_cursor_fromContext Cursor_variable() ICursor_variableContext INTO() antlr.TerminalNode Into_target() IInto_targetContext SEMI() antlr.TerminalNode Opt_fetch_direction() IOpt_fetch_directionContext // IsStmt_fetchContext differentiates from other interfaces. IsStmt_fetchContext() } type Stmt_fetchContext struct { antlr.BaseParserRuleContext parser antlr.Parser direction IOpt_fetch_directionContext } func NewEmptyStmt_fetchContext() *Stmt_fetchContext { var p = new(Stmt_fetchContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_fetch return p } func InitEmptyStmt_fetchContext(p *Stmt_fetchContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_fetch } func (*Stmt_fetchContext) IsStmt_fetchContext() {} func NewStmt_fetchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_fetchContext { var p = new(Stmt_fetchContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_fetch return p } func (s *Stmt_fetchContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_fetchContext) GetDirection() IOpt_fetch_directionContext { return s.direction } func (s *Stmt_fetchContext) SetDirection(v IOpt_fetch_directionContext) { s.direction = v } func (s *Stmt_fetchContext) FETCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFETCH, 0) } func (s *Stmt_fetchContext) Opt_cursor_from() IOpt_cursor_fromContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_cursor_fromContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_cursor_fromContext) } func (s *Stmt_fetchContext) Cursor_variable() ICursor_variableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICursor_variableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICursor_variableContext) } func (s *Stmt_fetchContext) INTO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINTO, 0) } func (s *Stmt_fetchContext) Into_target() IInto_targetContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInto_targetContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IInto_targetContext) } func (s *Stmt_fetchContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_fetchContext) Opt_fetch_direction() IOpt_fetch_directionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_fetch_directionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_fetch_directionContext) } func (s *Stmt_fetchContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_fetchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_fetchContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_fetch(s) } } func (s *Stmt_fetchContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_fetch(s) } } func (s *Stmt_fetchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_fetch(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_fetch() (localctx IStmt_fetchContext) { localctx = NewStmt_fetchContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1564, PostgreSQLParserRULE_stmt_fetch) p.EnterOuterAlt(localctx, 1) { p.SetState(10537) p.Match(PostgreSQLParserFETCH) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10538) var _x = p.Opt_fetch_direction() localctx.(*Stmt_fetchContext).direction = _x } { p.SetState(10539) p.Opt_cursor_from() } { p.SetState(10540) p.Cursor_variable() } { p.SetState(10541) p.Match(PostgreSQLParserINTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10542) p.Into_target() } { p.SetState(10543) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IInto_targetContext is an interface to support dynamic dispatch. type IInto_targetContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Expr_list() IExpr_listContext // IsInto_targetContext differentiates from other interfaces. IsInto_targetContext() } type Into_targetContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyInto_targetContext() *Into_targetContext { var p = new(Into_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_into_target return p } func InitEmptyInto_targetContext(p *Into_targetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_into_target } func (*Into_targetContext) IsInto_targetContext() {} func NewInto_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Into_targetContext { var p = new(Into_targetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_into_target return p } func (s *Into_targetContext) GetParser() antlr.Parser { return s.parser } func (s *Into_targetContext) Expr_list() IExpr_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_listContext) } func (s *Into_targetContext) GetRuleContext() antlr.RuleContext { return s } func (s *Into_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Into_targetContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterInto_target(s) } } func (s *Into_targetContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitInto_target(s) } } func (s *Into_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitInto_target(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Into_target() (localctx IInto_targetContext) { localctx = NewInto_targetContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1566, PostgreSQLParserRULE_into_target) p.EnterOuterAlt(localctx, 1) { p.SetState(10545) p.Expr_list() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_cursor_fromContext is an interface to support dynamic dispatch. type IOpt_cursor_fromContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FROM() antlr.TerminalNode IN_P() antlr.TerminalNode // IsOpt_cursor_fromContext differentiates from other interfaces. IsOpt_cursor_fromContext() } type Opt_cursor_fromContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_cursor_fromContext() *Opt_cursor_fromContext { var p = new(Opt_cursor_fromContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_cursor_from return p } func InitEmptyOpt_cursor_fromContext(p *Opt_cursor_fromContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_cursor_from } func (*Opt_cursor_fromContext) IsOpt_cursor_fromContext() {} func NewOpt_cursor_fromContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_cursor_fromContext { var p = new(Opt_cursor_fromContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_cursor_from return p } func (s *Opt_cursor_fromContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_cursor_fromContext) FROM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFROM, 0) } func (s *Opt_cursor_fromContext) IN_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIN_P, 0) } func (s *Opt_cursor_fromContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_cursor_fromContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_cursor_fromContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_cursor_from(s) } } func (s *Opt_cursor_fromContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_cursor_from(s) } } func (s *Opt_cursor_fromContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_cursor_from(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_cursor_from() (localctx IOpt_cursor_fromContext) { localctx = NewOpt_cursor_fromContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1568, PostgreSQLParserRULE_opt_cursor_from) p.SetState(10550) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserPARAM, PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserFROM: p.EnterOuterAlt(localctx, 2) { p.SetState(10548) p.Match(PostgreSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserIN_P: p.EnterOuterAlt(localctx, 3) { p.SetState(10549) p.Match(PostgreSQLParserIN_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_fetch_directionContext is an interface to support dynamic dispatch. type IOpt_fetch_directionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NEXT() antlr.TerminalNode PRIOR() antlr.TerminalNode FIRST_P() antlr.TerminalNode LAST_P() antlr.TerminalNode ABSOLUTE_P() antlr.TerminalNode A_expr() IA_exprContext RELATIVE_P() antlr.TerminalNode ALL() antlr.TerminalNode FORWARD() antlr.TerminalNode BACKWARD() antlr.TerminalNode // IsOpt_fetch_directionContext differentiates from other interfaces. IsOpt_fetch_directionContext() } type Opt_fetch_directionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_fetch_directionContext() *Opt_fetch_directionContext { var p = new(Opt_fetch_directionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_fetch_direction return p } func InitEmptyOpt_fetch_directionContext(p *Opt_fetch_directionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_fetch_direction } func (*Opt_fetch_directionContext) IsOpt_fetch_directionContext() {} func NewOpt_fetch_directionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_fetch_directionContext { var p = new(Opt_fetch_directionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_fetch_direction return p } func (s *Opt_fetch_directionContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_fetch_directionContext) NEXT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNEXT, 0) } func (s *Opt_fetch_directionContext) PRIOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRIOR, 0) } func (s *Opt_fetch_directionContext) FIRST_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFIRST_P, 0) } func (s *Opt_fetch_directionContext) LAST_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLAST_P, 0) } func (s *Opt_fetch_directionContext) ABSOLUTE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserABSOLUTE_P, 0) } func (s *Opt_fetch_directionContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Opt_fetch_directionContext) RELATIVE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRELATIVE_P, 0) } func (s *Opt_fetch_directionContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *Opt_fetch_directionContext) FORWARD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFORWARD, 0) } func (s *Opt_fetch_directionContext) BACKWARD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBACKWARD, 0) } func (s *Opt_fetch_directionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_fetch_directionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_fetch_directionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_fetch_direction(s) } } func (s *Opt_fetch_directionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_fetch_direction(s) } } func (s *Opt_fetch_directionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_fetch_direction(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_fetch_direction() (localctx IOpt_fetch_directionContext) { localctx = NewOpt_fetch_directionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1570, PostgreSQLParserRULE_opt_fetch_direction) var _la int p.SetState(10569) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 728, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) case 2: p.EnterOuterAlt(localctx, 2) case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(10554) p.Match(PostgreSQLParserNEXT) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(10555) p.Match(PostgreSQLParserPRIOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(10556) p.Match(PostgreSQLParserFIRST_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(10557) p.Match(PostgreSQLParserLAST_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(10558) p.Match(PostgreSQLParserABSOLUTE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10559) p.A_expr() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(10560) p.Match(PostgreSQLParserRELATIVE_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10561) p.A_expr() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(10562) p.A_expr() } case 10: p.EnterOuterAlt(localctx, 10) { p.SetState(10563) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } case 11: p.EnterOuterAlt(localctx, 11) { p.SetState(10564) _la = p.GetTokenStream().LA(1) if !(_la == PostgreSQLParserBACKWARD || _la == PostgreSQLParserFORWARD) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } p.SetState(10567) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 727, p.GetParserRuleContext()) == 1 { { p.SetState(10565) p.A_expr() } } else if p.HasError() { // JIM goto errorExit } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 727, p.GetParserRuleContext()) == 2 { { p.SetState(10566) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } } else if p.HasError() { // JIM goto errorExit } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_moveContext is an interface to support dynamic dispatch. type IStmt_moveContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures MOVE() antlr.TerminalNode Opt_fetch_direction() IOpt_fetch_directionContext Cursor_variable() ICursor_variableContext SEMI() antlr.TerminalNode // IsStmt_moveContext differentiates from other interfaces. IsStmt_moveContext() } type Stmt_moveContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_moveContext() *Stmt_moveContext { var p = new(Stmt_moveContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_move return p } func InitEmptyStmt_moveContext(p *Stmt_moveContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_move } func (*Stmt_moveContext) IsStmt_moveContext() {} func NewStmt_moveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_moveContext { var p = new(Stmt_moveContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_move return p } func (s *Stmt_moveContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_moveContext) MOVE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMOVE, 0) } func (s *Stmt_moveContext) Opt_fetch_direction() IOpt_fetch_directionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_fetch_directionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_fetch_directionContext) } func (s *Stmt_moveContext) Cursor_variable() ICursor_variableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICursor_variableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICursor_variableContext) } func (s *Stmt_moveContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_moveContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_moveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_moveContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_move(s) } } func (s *Stmt_moveContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_move(s) } } func (s *Stmt_moveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_move(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_move() (localctx IStmt_moveContext) { localctx = NewStmt_moveContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1572, PostgreSQLParserRULE_stmt_move) p.EnterOuterAlt(localctx, 1) { p.SetState(10571) p.Match(PostgreSQLParserMOVE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10572) p.Opt_fetch_direction() } { p.SetState(10573) p.Cursor_variable() } { p.SetState(10574) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_closeContext is an interface to support dynamic dispatch. type IStmt_closeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CLOSE() antlr.TerminalNode Cursor_variable() ICursor_variableContext SEMI() antlr.TerminalNode // IsStmt_closeContext differentiates from other interfaces. IsStmt_closeContext() } type Stmt_closeContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_closeContext() *Stmt_closeContext { var p = new(Stmt_closeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_close return p } func InitEmptyStmt_closeContext(p *Stmt_closeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_close } func (*Stmt_closeContext) IsStmt_closeContext() {} func NewStmt_closeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_closeContext { var p = new(Stmt_closeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_close return p } func (s *Stmt_closeContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_closeContext) CLOSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE, 0) } func (s *Stmt_closeContext) Cursor_variable() ICursor_variableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICursor_variableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICursor_variableContext) } func (s *Stmt_closeContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_closeContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_closeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_closeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_close(s) } } func (s *Stmt_closeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_close(s) } } func (s *Stmt_closeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_close(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_close() (localctx IStmt_closeContext) { localctx = NewStmt_closeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1574, PostgreSQLParserRULE_stmt_close) p.EnterOuterAlt(localctx, 1) { p.SetState(10576) p.Match(PostgreSQLParserCLOSE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10577) p.Cursor_variable() } { p.SetState(10578) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_nullContext is an interface to support dynamic dispatch. type IStmt_nullContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NULL_P() antlr.TerminalNode SEMI() antlr.TerminalNode // IsStmt_nullContext differentiates from other interfaces. IsStmt_nullContext() } type Stmt_nullContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_nullContext() *Stmt_nullContext { var p = new(Stmt_nullContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_null return p } func InitEmptyStmt_nullContext(p *Stmt_nullContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_null } func (*Stmt_nullContext) IsStmt_nullContext() {} func NewStmt_nullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_nullContext { var p = new(Stmt_nullContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_null return p } func (s *Stmt_nullContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_nullContext) NULL_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNULL_P, 0) } func (s *Stmt_nullContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_nullContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_nullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_nullContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_null(s) } } func (s *Stmt_nullContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_null(s) } } func (s *Stmt_nullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_null(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_null() (localctx IStmt_nullContext) { localctx = NewStmt_nullContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1576, PostgreSQLParserRULE_stmt_null) p.EnterOuterAlt(localctx, 1) { p.SetState(10580) p.Match(PostgreSQLParserNULL_P) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10581) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_commitContext is an interface to support dynamic dispatch. type IStmt_commitContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures COMMIT() antlr.TerminalNode Plsql_opt_transaction_chain() IPlsql_opt_transaction_chainContext SEMI() antlr.TerminalNode // IsStmt_commitContext differentiates from other interfaces. IsStmt_commitContext() } type Stmt_commitContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_commitContext() *Stmt_commitContext { var p = new(Stmt_commitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_commit return p } func InitEmptyStmt_commitContext(p *Stmt_commitContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_commit } func (*Stmt_commitContext) IsStmt_commitContext() {} func NewStmt_commitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_commitContext { var p = new(Stmt_commitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_commit return p } func (s *Stmt_commitContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_commitContext) COMMIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMIT, 0) } func (s *Stmt_commitContext) Plsql_opt_transaction_chain() IPlsql_opt_transaction_chainContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPlsql_opt_transaction_chainContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPlsql_opt_transaction_chainContext) } func (s *Stmt_commitContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_commitContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_commitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_commitContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_commit(s) } } func (s *Stmt_commitContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_commit(s) } } func (s *Stmt_commitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_commit(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_commit() (localctx IStmt_commitContext) { localctx = NewStmt_commitContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1578, PostgreSQLParserRULE_stmt_commit) p.EnterOuterAlt(localctx, 1) { p.SetState(10583) p.Match(PostgreSQLParserCOMMIT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10584) p.Plsql_opt_transaction_chain() } { p.SetState(10585) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_rollbackContext is an interface to support dynamic dispatch. type IStmt_rollbackContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ROLLBACK() antlr.TerminalNode Plsql_opt_transaction_chain() IPlsql_opt_transaction_chainContext SEMI() antlr.TerminalNode // IsStmt_rollbackContext differentiates from other interfaces. IsStmt_rollbackContext() } type Stmt_rollbackContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_rollbackContext() *Stmt_rollbackContext { var p = new(Stmt_rollbackContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_rollback return p } func InitEmptyStmt_rollbackContext(p *Stmt_rollbackContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_rollback } func (*Stmt_rollbackContext) IsStmt_rollbackContext() {} func NewStmt_rollbackContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_rollbackContext { var p = new(Stmt_rollbackContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_rollback return p } func (s *Stmt_rollbackContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_rollbackContext) ROLLBACK() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLLBACK, 0) } func (s *Stmt_rollbackContext) Plsql_opt_transaction_chain() IPlsql_opt_transaction_chainContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPlsql_opt_transaction_chainContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPlsql_opt_transaction_chainContext) } func (s *Stmt_rollbackContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_rollbackContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_rollbackContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_rollbackContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_rollback(s) } } func (s *Stmt_rollbackContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_rollback(s) } } func (s *Stmt_rollbackContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_rollback(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_rollback() (localctx IStmt_rollbackContext) { localctx = NewStmt_rollbackContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1580, PostgreSQLParserRULE_stmt_rollback) p.EnterOuterAlt(localctx, 1) { p.SetState(10587) p.Match(PostgreSQLParserROLLBACK) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10588) p.Plsql_opt_transaction_chain() } { p.SetState(10589) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPlsql_opt_transaction_chainContext is an interface to support dynamic dispatch. type IPlsql_opt_transaction_chainContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AND() antlr.TerminalNode CHAIN() antlr.TerminalNode NO() antlr.TerminalNode // IsPlsql_opt_transaction_chainContext differentiates from other interfaces. IsPlsql_opt_transaction_chainContext() } type Plsql_opt_transaction_chainContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPlsql_opt_transaction_chainContext() *Plsql_opt_transaction_chainContext { var p = new(Plsql_opt_transaction_chainContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_plsql_opt_transaction_chain return p } func InitEmptyPlsql_opt_transaction_chainContext(p *Plsql_opt_transaction_chainContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_plsql_opt_transaction_chain } func (*Plsql_opt_transaction_chainContext) IsPlsql_opt_transaction_chainContext() {} func NewPlsql_opt_transaction_chainContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Plsql_opt_transaction_chainContext { var p = new(Plsql_opt_transaction_chainContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_plsql_opt_transaction_chain return p } func (s *Plsql_opt_transaction_chainContext) GetParser() antlr.Parser { return s.parser } func (s *Plsql_opt_transaction_chainContext) AND() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAND, 0) } func (s *Plsql_opt_transaction_chainContext) CHAIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHAIN, 0) } func (s *Plsql_opt_transaction_chainContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Plsql_opt_transaction_chainContext) GetRuleContext() antlr.RuleContext { return s } func (s *Plsql_opt_transaction_chainContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Plsql_opt_transaction_chainContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPlsql_opt_transaction_chain(s) } } func (s *Plsql_opt_transaction_chainContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPlsql_opt_transaction_chain(s) } } func (s *Plsql_opt_transaction_chainContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPlsql_opt_transaction_chain(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Plsql_opt_transaction_chain() (localctx IPlsql_opt_transaction_chainContext) { localctx = NewPlsql_opt_transaction_chainContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1582, PostgreSQLParserRULE_plsql_opt_transaction_chain) var _la int p.SetState(10597) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND: p.EnterOuterAlt(localctx, 1) { p.SetState(10591) p.Match(PostgreSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(10593) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == PostgreSQLParserNO { { p.SetState(10592) p.Match(PostgreSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit } } } { p.SetState(10595) p.Match(PostgreSQLParserCHAIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserSEMI: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IStmt_setContext is an interface to support dynamic dispatch. type IStmt_setContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures SET() antlr.TerminalNode Any_name() IAny_nameContext TO() antlr.TerminalNode DEFAULT() antlr.TerminalNode SEMI() antlr.TerminalNode RESET() antlr.TerminalNode ALL() antlr.TerminalNode // IsStmt_setContext differentiates from other interfaces. IsStmt_setContext() } type Stmt_setContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmt_setContext() *Stmt_setContext { var p = new(Stmt_setContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_set return p } func InitEmptyStmt_setContext(p *Stmt_setContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_stmt_set } func (*Stmt_setContext) IsStmt_setContext() {} func NewStmt_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_setContext { var p = new(Stmt_setContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_stmt_set return p } func (s *Stmt_setContext) GetParser() antlr.Parser { return s.parser } func (s *Stmt_setContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *Stmt_setContext) Any_name() IAny_nameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_nameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_nameContext) } func (s *Stmt_setContext) TO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTO, 0) } func (s *Stmt_setContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Stmt_setContext) SEMI() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSEMI, 0) } func (s *Stmt_setContext) RESET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESET, 0) } func (s *Stmt_setContext) ALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALL, 0) } func (s *Stmt_setContext) GetRuleContext() antlr.RuleContext { return s } func (s *Stmt_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Stmt_setContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterStmt_set(s) } } func (s *Stmt_setContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitStmt_set(s) } } func (s *Stmt_setContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitStmt_set(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Stmt_set() (localctx IStmt_setContext) { localctx = NewStmt_setContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1584, PostgreSQLParserRULE_stmt_set) p.SetState(10611) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserSET: p.EnterOuterAlt(localctx, 1) { p.SetState(10599) p.Match(PostgreSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10600) p.Any_name() } { p.SetState(10601) p.Match(PostgreSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10602) p.Match(PostgreSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10603) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } case PostgreSQLParserRESET: p.EnterOuterAlt(localctx, 2) { p.SetState(10605) p.Match(PostgreSQLParserRESET) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(10608) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: { p.SetState(10606) p.Any_name() } case PostgreSQLParserALL: { p.SetState(10607) p.Match(PostgreSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } { p.SetState(10610) p.Match(PostgreSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICursor_variableContext is an interface to support dynamic dispatch. type ICursor_variableContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext PARAM() antlr.TerminalNode // IsCursor_variableContext differentiates from other interfaces. IsCursor_variableContext() } type Cursor_variableContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCursor_variableContext() *Cursor_variableContext { var p = new(Cursor_variableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_cursor_variable return p } func InitEmptyCursor_variableContext(p *Cursor_variableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_cursor_variable } func (*Cursor_variableContext) IsCursor_variableContext() {} func NewCursor_variableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_variableContext { var p = new(Cursor_variableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_cursor_variable return p } func (s *Cursor_variableContext) GetParser() antlr.Parser { return s.parser } func (s *Cursor_variableContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Cursor_variableContext) PARAM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPARAM, 0) } func (s *Cursor_variableContext) GetRuleContext() antlr.RuleContext { return s } func (s *Cursor_variableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Cursor_variableContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterCursor_variable(s) } } func (s *Cursor_variableContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitCursor_variable(s) } } func (s *Cursor_variableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitCursor_variable(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Cursor_variable() (localctx ICursor_variableContext) { localctx = NewCursor_variableContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1586, PostgreSQLParserRULE_cursor_variable) p.SetState(10615) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 1) { p.SetState(10613) p.Colid() } case PostgreSQLParserPARAM: p.EnterOuterAlt(localctx, 2) { p.SetState(10614) p.Match(PostgreSQLParserPARAM) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IException_sectContext is an interface to support dynamic dispatch. type IException_sectContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures EXCEPTION() antlr.TerminalNode Proc_exceptions() IProc_exceptionsContext // IsException_sectContext differentiates from other interfaces. IsException_sectContext() } type Exception_sectContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyException_sectContext() *Exception_sectContext { var p = new(Exception_sectContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_exception_sect return p } func InitEmptyException_sectContext(p *Exception_sectContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_exception_sect } func (*Exception_sectContext) IsException_sectContext() {} func NewException_sectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exception_sectContext { var p = new(Exception_sectContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_exception_sect return p } func (s *Exception_sectContext) GetParser() antlr.Parser { return s.parser } func (s *Exception_sectContext) EXCEPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXCEPTION, 0) } func (s *Exception_sectContext) Proc_exceptions() IProc_exceptionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IProc_exceptionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IProc_exceptionsContext) } func (s *Exception_sectContext) GetRuleContext() antlr.RuleContext { return s } func (s *Exception_sectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Exception_sectContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterException_sect(s) } } func (s *Exception_sectContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitException_sect(s) } } func (s *Exception_sectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitException_sect(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Exception_sect() (localctx IException_sectContext) { localctx = NewException_sectContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1588, PostgreSQLParserRULE_exception_sect) p.SetState(10620) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserEND_P: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserEXCEPTION: p.EnterOuterAlt(localctx, 2) { p.SetState(10618) p.Match(PostgreSQLParserEXCEPTION) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10619) p.Proc_exceptions() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IProc_exceptionsContext is an interface to support dynamic dispatch. type IProc_exceptionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllProc_exception() []IProc_exceptionContext Proc_exception(i int) IProc_exceptionContext // IsProc_exceptionsContext differentiates from other interfaces. IsProc_exceptionsContext() } type Proc_exceptionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyProc_exceptionsContext() *Proc_exceptionsContext { var p = new(Proc_exceptionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_proc_exceptions return p } func InitEmptyProc_exceptionsContext(p *Proc_exceptionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_proc_exceptions } func (*Proc_exceptionsContext) IsProc_exceptionsContext() {} func NewProc_exceptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_exceptionsContext { var p = new(Proc_exceptionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_proc_exceptions return p } func (s *Proc_exceptionsContext) GetParser() antlr.Parser { return s.parser } func (s *Proc_exceptionsContext) AllProc_exception() []IProc_exceptionContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IProc_exceptionContext); ok { len++ } } tst := make([]IProc_exceptionContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IProc_exceptionContext); ok { tst[i] = t.(IProc_exceptionContext) i++ } } return tst } func (s *Proc_exceptionsContext) Proc_exception(i int) IProc_exceptionContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IProc_exceptionContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IProc_exceptionContext) } func (s *Proc_exceptionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Proc_exceptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Proc_exceptionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterProc_exceptions(s) } } func (s *Proc_exceptionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitProc_exceptions(s) } } func (s *Proc_exceptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitProc_exceptions(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Proc_exceptions() (localctx IProc_exceptionsContext) { localctx = NewProc_exceptionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1590, PostgreSQLParserRULE_proc_exceptions) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(10623) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ok := true; ok; ok = _la == PostgreSQLParserWHEN { { p.SetState(10622) p.Proc_exception() } p.SetState(10625) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IProc_exceptionContext is an interface to support dynamic dispatch. type IProc_exceptionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WHEN() antlr.TerminalNode Proc_conditions() IProc_conditionsContext THEN() antlr.TerminalNode Proc_sect() IProc_sectContext // IsProc_exceptionContext differentiates from other interfaces. IsProc_exceptionContext() } type Proc_exceptionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyProc_exceptionContext() *Proc_exceptionContext { var p = new(Proc_exceptionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_proc_exception return p } func InitEmptyProc_exceptionContext(p *Proc_exceptionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_proc_exception } func (*Proc_exceptionContext) IsProc_exceptionContext() {} func NewProc_exceptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_exceptionContext { var p = new(Proc_exceptionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_proc_exception return p } func (s *Proc_exceptionContext) GetParser() antlr.Parser { return s.parser } func (s *Proc_exceptionContext) WHEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHEN, 0) } func (s *Proc_exceptionContext) Proc_conditions() IProc_conditionsContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IProc_conditionsContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IProc_conditionsContext) } func (s *Proc_exceptionContext) THEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTHEN, 0) } func (s *Proc_exceptionContext) Proc_sect() IProc_sectContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IProc_sectContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IProc_sectContext) } func (s *Proc_exceptionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Proc_exceptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Proc_exceptionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterProc_exception(s) } } func (s *Proc_exceptionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitProc_exception(s) } } func (s *Proc_exceptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitProc_exception(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Proc_exception() (localctx IProc_exceptionContext) { localctx = NewProc_exceptionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1592, PostgreSQLParserRULE_proc_exception) p.EnterOuterAlt(localctx, 1) { p.SetState(10627) p.Match(PostgreSQLParserWHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10628) p.Proc_conditions() } { p.SetState(10629) p.Match(PostgreSQLParserTHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10630) p.Proc_sect() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IProc_conditionsContext is an interface to support dynamic dispatch. type IProc_conditionsContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllProc_condition() []IProc_conditionContext Proc_condition(i int) IProc_conditionContext AllOR() []antlr.TerminalNode OR(i int) antlr.TerminalNode // IsProc_conditionsContext differentiates from other interfaces. IsProc_conditionsContext() } type Proc_conditionsContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyProc_conditionsContext() *Proc_conditionsContext { var p = new(Proc_conditionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_proc_conditions return p } func InitEmptyProc_conditionsContext(p *Proc_conditionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_proc_conditions } func (*Proc_conditionsContext) IsProc_conditionsContext() {} func NewProc_conditionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_conditionsContext { var p = new(Proc_conditionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_proc_conditions return p } func (s *Proc_conditionsContext) GetParser() antlr.Parser { return s.parser } func (s *Proc_conditionsContext) AllProc_condition() []IProc_conditionContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IProc_conditionContext); ok { len++ } } tst := make([]IProc_conditionContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IProc_conditionContext); ok { tst[i] = t.(IProc_conditionContext) i++ } } return tst } func (s *Proc_conditionsContext) Proc_condition(i int) IProc_conditionContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IProc_conditionContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IProc_conditionContext) } func (s *Proc_conditionsContext) AllOR() []antlr.TerminalNode { return s.GetTokens(PostgreSQLParserOR) } func (s *Proc_conditionsContext) OR(i int) antlr.TerminalNode { return s.GetToken(PostgreSQLParserOR, i) } func (s *Proc_conditionsContext) GetRuleContext() antlr.RuleContext { return s } func (s *Proc_conditionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Proc_conditionsContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterProc_conditions(s) } } func (s *Proc_conditionsContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitProc_conditions(s) } } func (s *Proc_conditionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitProc_conditions(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Proc_conditions() (localctx IProc_conditionsContext) { localctx = NewProc_conditionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1594, PostgreSQLParserRULE_proc_conditions) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(10632) p.Proc_condition() } p.SetState(10637) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == PostgreSQLParserOR { { p.SetState(10633) p.Match(PostgreSQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10634) p.Proc_condition() } p.SetState(10639) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IProc_conditionContext is an interface to support dynamic dispatch. type IProc_conditionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Any_identifier() IAny_identifierContext SQLSTATE() antlr.TerminalNode Sconst() ISconstContext // IsProc_conditionContext differentiates from other interfaces. IsProc_conditionContext() } type Proc_conditionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyProc_conditionContext() *Proc_conditionContext { var p = new(Proc_conditionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_proc_condition return p } func InitEmptyProc_conditionContext(p *Proc_conditionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_proc_condition } func (*Proc_conditionContext) IsProc_conditionContext() {} func NewProc_conditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_conditionContext { var p = new(Proc_conditionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_proc_condition return p } func (s *Proc_conditionContext) GetParser() antlr.Parser { return s.parser } func (s *Proc_conditionContext) Any_identifier() IAny_identifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_identifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_identifierContext) } func (s *Proc_conditionContext) SQLSTATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSQLSTATE, 0) } func (s *Proc_conditionContext) Sconst() ISconstContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISconstContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISconstContext) } func (s *Proc_conditionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Proc_conditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Proc_conditionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterProc_condition(s) } } func (s *Proc_conditionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitProc_condition(s) } } func (s *Proc_conditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitProc_condition(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Proc_condition() (localctx IProc_conditionContext) { localctx = NewProc_conditionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1596, PostgreSQLParserRULE_proc_condition) p.SetState(10643) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 737, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(10640) p.Any_identifier() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(10641) p.Match(PostgreSQLParserSQLSTATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10642) p.Sconst() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_block_labelContext is an interface to support dynamic dispatch. type IOpt_block_labelContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Label_decl() ILabel_declContext // IsOpt_block_labelContext differentiates from other interfaces. IsOpt_block_labelContext() } type Opt_block_labelContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_block_labelContext() *Opt_block_labelContext { var p = new(Opt_block_labelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_block_label return p } func InitEmptyOpt_block_labelContext(p *Opt_block_labelContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_block_label } func (*Opt_block_labelContext) IsOpt_block_labelContext() {} func NewOpt_block_labelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_block_labelContext { var p = new(Opt_block_labelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_block_label return p } func (s *Opt_block_labelContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_block_labelContext) Label_decl() ILabel_declContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ILabel_declContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ILabel_declContext) } func (s *Opt_block_labelContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_block_labelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_block_labelContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_block_label(s) } } func (s *Opt_block_labelContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_block_label(s) } } func (s *Opt_block_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_block_label(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_block_label() (localctx IOpt_block_labelContext) { localctx = NewOpt_block_labelContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1598, PostgreSQLParserRULE_opt_block_label) p.SetState(10647) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserBEGIN_P, PostgreSQLParserDECLARE: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserLESS_LESS: p.EnterOuterAlt(localctx, 2) { p.SetState(10646) p.Label_decl() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_loop_labelContext is an interface to support dynamic dispatch. type IOpt_loop_labelContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Label_decl() ILabel_declContext // IsOpt_loop_labelContext differentiates from other interfaces. IsOpt_loop_labelContext() } type Opt_loop_labelContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_loop_labelContext() *Opt_loop_labelContext { var p = new(Opt_loop_labelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_loop_label return p } func InitEmptyOpt_loop_labelContext(p *Opt_loop_labelContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_loop_label } func (*Opt_loop_labelContext) IsOpt_loop_labelContext() {} func NewOpt_loop_labelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_loop_labelContext { var p = new(Opt_loop_labelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_loop_label return p } func (s *Opt_loop_labelContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_loop_labelContext) Label_decl() ILabel_declContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ILabel_declContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ILabel_declContext) } func (s *Opt_loop_labelContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_loop_labelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_loop_labelContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_loop_label(s) } } func (s *Opt_loop_labelContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_loop_label(s) } } func (s *Opt_loop_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_loop_label(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_loop_label() (localctx IOpt_loop_labelContext) { localctx = NewOpt_loop_labelContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1600, PostgreSQLParserRULE_opt_loop_label) p.SetState(10651) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserFOR, PostgreSQLParserWHILE, PostgreSQLParserFOREACH, PostgreSQLParserLOOP: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserLESS_LESS: p.EnterOuterAlt(localctx, 2) { p.SetState(10650) p.Label_decl() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_labelContext is an interface to support dynamic dispatch. type IOpt_labelContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Any_identifier() IAny_identifierContext // IsOpt_labelContext differentiates from other interfaces. IsOpt_labelContext() } type Opt_labelContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_labelContext() *Opt_labelContext { var p = new(Opt_labelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_label return p } func InitEmptyOpt_labelContext(p *Opt_labelContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_label } func (*Opt_labelContext) IsOpt_labelContext() {} func NewOpt_labelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_labelContext { var p = new(Opt_labelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_label return p } func (s *Opt_labelContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_labelContext) Any_identifier() IAny_identifierContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAny_identifierContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAny_identifierContext) } func (s *Opt_labelContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_labelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_labelContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_label(s) } } func (s *Opt_labelContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_label(s) } } func (s *Opt_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_label(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_label() (localctx IOpt_labelContext) { localctx = NewOpt_labelContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1602, PostgreSQLParserRULE_opt_label) p.SetState(10655) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserEOF, PostgreSQLParserSEMI, PostgreSQLParserWHEN: p.EnterOuterAlt(localctx, 1) case PostgreSQLParserAND, PostgreSQLParserARRAY, PostgreSQLParserCOLLATE, PostgreSQLParserCOLUMN, PostgreSQLParserCONSTRAINT, PostgreSQLParserDEFAULT, PostgreSQLParserDO, PostgreSQLParserFETCH, PostgreSQLParserTABLE, PostgreSQLParserIS, PostgreSQLParserLEFT, PostgreSQLParserOUTER_P, PostgreSQLParserOVER, PostgreSQLParserRIGHT, PostgreSQLParserABORT_P, PostgreSQLParserABSOLUTE_P, PostgreSQLParserACCESS, PostgreSQLParserACTION, PostgreSQLParserADD_P, PostgreSQLParserADMIN, PostgreSQLParserAFTER, PostgreSQLParserAGGREGATE, PostgreSQLParserALSO, PostgreSQLParserALTER, PostgreSQLParserALWAYS, PostgreSQLParserASSERTION, PostgreSQLParserASSIGNMENT, PostgreSQLParserAT, PostgreSQLParserATTRIBUTE, PostgreSQLParserBACKWARD, PostgreSQLParserBEFORE, PostgreSQLParserBEGIN_P, PostgreSQLParserBY, PostgreSQLParserCACHE, PostgreSQLParserCALLED, PostgreSQLParserCASCADE, PostgreSQLParserCASCADED, PostgreSQLParserCATALOG, PostgreSQLParserCHAIN, PostgreSQLParserCHARACTERISTICS, PostgreSQLParserCHECKPOINT, PostgreSQLParserCLASS, PostgreSQLParserCLOSE, PostgreSQLParserCLUSTER, PostgreSQLParserCOMMENT, PostgreSQLParserCOMMENTS, PostgreSQLParserCOMMIT, PostgreSQLParserCOMMITTED, PostgreSQLParserCONFIGURATION, PostgreSQLParserCONNECTION, PostgreSQLParserCONSTRAINTS, PostgreSQLParserCONTENT_P, PostgreSQLParserCONTINUE_P, PostgreSQLParserCONVERSION_P, PostgreSQLParserCOPY, PostgreSQLParserCOST, PostgreSQLParserCSV, PostgreSQLParserCURSOR, PostgreSQLParserCYCLE, PostgreSQLParserDATA_P, PostgreSQLParserDATABASE, PostgreSQLParserDAY_P, PostgreSQLParserDEALLOCATE, PostgreSQLParserDECLARE, PostgreSQLParserDEFAULTS, PostgreSQLParserDEFERRED, PostgreSQLParserDEFINER, PostgreSQLParserDELETE_P, PostgreSQLParserDELIMITER, PostgreSQLParserDELIMITERS, PostgreSQLParserDICTIONARY, PostgreSQLParserDISABLE_P, PostgreSQLParserDISCARD, PostgreSQLParserDOCUMENT_P, PostgreSQLParserDOMAIN_P, PostgreSQLParserDOUBLE_P, PostgreSQLParserDROP, PostgreSQLParserEACH, PostgreSQLParserENABLE_P, PostgreSQLParserENCODING, PostgreSQLParserENCRYPTED, PostgreSQLParserENUM_P, PostgreSQLParserESCAPE, PostgreSQLParserEVENT, PostgreSQLParserEXCLUDE, PostgreSQLParserEXCLUDING, PostgreSQLParserEXCLUSIVE, PostgreSQLParserEXECUTE, PostgreSQLParserEXPLAIN, PostgreSQLParserEXTENSION, PostgreSQLParserEXTERNAL, PostgreSQLParserFAMILY, PostgreSQLParserFIRST_P, PostgreSQLParserFOLLOWING, PostgreSQLParserFORCE, PostgreSQLParserFORWARD, PostgreSQLParserFUNCTION, PostgreSQLParserFUNCTIONS, PostgreSQLParserGLOBAL, PostgreSQLParserGRANTED, PostgreSQLParserHANDLER, PostgreSQLParserHEADER_P, PostgreSQLParserHOLD, PostgreSQLParserHOUR_P, PostgreSQLParserIDENTITY_P, PostgreSQLParserIF_P, PostgreSQLParserIMMEDIATE, PostgreSQLParserIMMUTABLE, PostgreSQLParserIMPLICIT_P, PostgreSQLParserINCLUDING, PostgreSQLParserINCREMENT, PostgreSQLParserINDEX, PostgreSQLParserINDEXES, PostgreSQLParserINHERIT, PostgreSQLParserINHERITS, PostgreSQLParserINLINE_P, PostgreSQLParserINSENSITIVE, PostgreSQLParserINSERT, PostgreSQLParserINSTEAD, PostgreSQLParserINVOKER, PostgreSQLParserISOLATION, PostgreSQLParserKEY, PostgreSQLParserLABEL, PostgreSQLParserLANGUAGE, PostgreSQLParserLARGE_P, PostgreSQLParserLAST_P, PostgreSQLParserLEAKPROOF, PostgreSQLParserLEVEL, PostgreSQLParserLISTEN, PostgreSQLParserLOAD, PostgreSQLParserLOCAL, PostgreSQLParserLOCATION, PostgreSQLParserLOCK_P, PostgreSQLParserMAPPING, PostgreSQLParserMATCH, PostgreSQLParserMATERIALIZED, PostgreSQLParserMAXVALUE, PostgreSQLParserMINUTE_P, PostgreSQLParserMINVALUE, PostgreSQLParserMODE, PostgreSQLParserMONTH_P, PostgreSQLParserMOVE, PostgreSQLParserNAME_P, PostgreSQLParserNAMES, PostgreSQLParserNEXT, PostgreSQLParserNO, PostgreSQLParserNOTHING, PostgreSQLParserNOTIFY, PostgreSQLParserNOWAIT, PostgreSQLParserNULLS_P, PostgreSQLParserOBJECT_P, PostgreSQLParserOF, PostgreSQLParserOFF, PostgreSQLParserOIDS, PostgreSQLParserOPERATOR, PostgreSQLParserOPTION, PostgreSQLParserOPTIONS, PostgreSQLParserOWNED, PostgreSQLParserOWNER, PostgreSQLParserPARSER, PostgreSQLParserPARTIAL, PostgreSQLParserPARTITION, PostgreSQLParserPASSING, PostgreSQLParserPASSWORD, PostgreSQLParserPLANS, PostgreSQLParserPRECEDING, PostgreSQLParserPREPARE, PostgreSQLParserPREPARED, PostgreSQLParserPRESERVE, PostgreSQLParserPRIOR, PostgreSQLParserPRIVILEGES, PostgreSQLParserPROCEDURAL, PostgreSQLParserPROCEDURE, PostgreSQLParserPROGRAM, PostgreSQLParserQUOTE, PostgreSQLParserRANGE, PostgreSQLParserREAD, PostgreSQLParserREASSIGN, PostgreSQLParserRECHECK, PostgreSQLParserRECURSIVE, PostgreSQLParserREF, PostgreSQLParserREFRESH, PostgreSQLParserREINDEX, PostgreSQLParserRELATIVE_P, PostgreSQLParserRELEASE, PostgreSQLParserRENAME, PostgreSQLParserREPEATABLE, PostgreSQLParserREPLACE, PostgreSQLParserREPLICA, PostgreSQLParserRESET, PostgreSQLParserRESTART, PostgreSQLParserRESTRICT, PostgreSQLParserRETURNS, PostgreSQLParserREVOKE, PostgreSQLParserROLE, PostgreSQLParserROLLBACK, PostgreSQLParserROWS, PostgreSQLParserRULE, PostgreSQLParserSAVEPOINT, PostgreSQLParserSCHEMA, PostgreSQLParserSCROLL, PostgreSQLParserSEARCH, PostgreSQLParserSECOND_P, PostgreSQLParserSECURITY, PostgreSQLParserSEQUENCE, PostgreSQLParserSEQUENCES, PostgreSQLParserSERIALIZABLE, PostgreSQLParserSERVER, PostgreSQLParserSESSION, PostgreSQLParserSET, PostgreSQLParserSHARE, PostgreSQLParserSHOW, PostgreSQLParserSIMPLE, PostgreSQLParserSNAPSHOT, PostgreSQLParserSTABLE, PostgreSQLParserSTANDALONE_P, PostgreSQLParserSTART, PostgreSQLParserSTATEMENT, PostgreSQLParserSTATISTICS, PostgreSQLParserSTDIN, PostgreSQLParserSTDOUT, PostgreSQLParserSTORAGE, PostgreSQLParserSTRICT_P, PostgreSQLParserSTRIP_P, PostgreSQLParserSYSID, PostgreSQLParserSYSTEM_P, PostgreSQLParserTABLES, PostgreSQLParserTABLESPACE, PostgreSQLParserTEMP, PostgreSQLParserTEMPLATE, PostgreSQLParserTEMPORARY, PostgreSQLParserTEXT_P, PostgreSQLParserTRANSACTION, PostgreSQLParserTRIGGER, PostgreSQLParserTRUNCATE, PostgreSQLParserTRUSTED, PostgreSQLParserTYPE_P, PostgreSQLParserTYPES_P, PostgreSQLParserUNBOUNDED, PostgreSQLParserUNCOMMITTED, PostgreSQLParserUNENCRYPTED, PostgreSQLParserUNKNOWN, PostgreSQLParserUNLISTEN, PostgreSQLParserUNLOGGED, PostgreSQLParserUNTIL, PostgreSQLParserUPDATE, PostgreSQLParserVACUUM, PostgreSQLParserVALID, PostgreSQLParserVALIDATE, PostgreSQLParserVALIDATOR, PostgreSQLParserVARYING, PostgreSQLParserVERSION_P, PostgreSQLParserVIEW, PostgreSQLParserVOLATILE, PostgreSQLParserWHITESPACE_P, PostgreSQLParserWITHOUT, PostgreSQLParserWORK, PostgreSQLParserWRAPPER, PostgreSQLParserWRITE, PostgreSQLParserXML_P, PostgreSQLParserYEAR_P, PostgreSQLParserYES_P, PostgreSQLParserZONE, PostgreSQLParserBETWEEN, PostgreSQLParserBIGINT, PostgreSQLParserBIT, PostgreSQLParserBOOLEAN_P, PostgreSQLParserCHAR_P, PostgreSQLParserCHARACTER, PostgreSQLParserCOALESCE, PostgreSQLParserDEC, PostgreSQLParserDECIMAL_P, PostgreSQLParserEXISTS, PostgreSQLParserEXTRACT, PostgreSQLParserFLOAT_P, PostgreSQLParserGREATEST, PostgreSQLParserINOUT, PostgreSQLParserINT_P, PostgreSQLParserINTEGER, PostgreSQLParserINTERVAL, PostgreSQLParserLEAST, PostgreSQLParserNATIONAL, PostgreSQLParserNCHAR, PostgreSQLParserNONE, PostgreSQLParserNULLIF, PostgreSQLParserNUMERIC, PostgreSQLParserOVERLAY, PostgreSQLParserPOSITION, PostgreSQLParserPRECISION, PostgreSQLParserREAL, PostgreSQLParserROW, PostgreSQLParserSETOF, PostgreSQLParserSMALLINT, PostgreSQLParserSUBSTRING, PostgreSQLParserTIME, PostgreSQLParserTIMESTAMP, PostgreSQLParserTREAT, PostgreSQLParserTRIM, PostgreSQLParserVALUES, PostgreSQLParserVARCHAR, PostgreSQLParserXMLATTRIBUTES, PostgreSQLParserXMLCOMMENT, PostgreSQLParserXMLAGG, PostgreSQLParserXML_IS_WELL_FORMED, PostgreSQLParserXML_IS_WELL_FORMED_DOCUMENT, PostgreSQLParserXML_IS_WELL_FORMED_CONTENT, PostgreSQLParserXPATH, PostgreSQLParserXPATH_EXISTS, PostgreSQLParserXMLCONCAT, PostgreSQLParserXMLELEMENT, PostgreSQLParserXMLEXISTS, PostgreSQLParserXMLFOREST, PostgreSQLParserXMLPARSE, PostgreSQLParserXMLPI, PostgreSQLParserXMLROOT, PostgreSQLParserXMLSERIALIZE, PostgreSQLParserCALL, PostgreSQLParserCURRENT_P, PostgreSQLParserATTACH, PostgreSQLParserDETACH, PostgreSQLParserEXPRESSION, PostgreSQLParserGENERATED, PostgreSQLParserLOGGED, PostgreSQLParserSTORED, PostgreSQLParserINCLUDE, PostgreSQLParserROUTINE, PostgreSQLParserTRANSFORM, PostgreSQLParserIMPORT_P, PostgreSQLParserPOLICY, PostgreSQLParserMETHOD, PostgreSQLParserREFERENCING, PostgreSQLParserNEW, PostgreSQLParserOLD, PostgreSQLParserVALUE_P, PostgreSQLParserSUBSCRIPTION, PostgreSQLParserPUBLICATION, PostgreSQLParserOUT_P, PostgreSQLParserROUTINES, PostgreSQLParserSCHEMAS, PostgreSQLParserPROCEDURES, PostgreSQLParserINPUT_P, PostgreSQLParserSUPPORT, PostgreSQLParserPARALLEL, PostgreSQLParserSQL_P, PostgreSQLParserDEPENDS, PostgreSQLParserOVERRIDING, PostgreSQLParserCONFLICT, PostgreSQLParserSKIP_P, PostgreSQLParserLOCKED, PostgreSQLParserTIES, PostgreSQLParserROLLUP, PostgreSQLParserCUBE, PostgreSQLParserGROUPING, PostgreSQLParserSETS, PostgreSQLParserORDINALITY, PostgreSQLParserXMLTABLE, PostgreSQLParserCOLUMNS, PostgreSQLParserXMLNAMESPACES, PostgreSQLParserROWTYPE, PostgreSQLParserNORMALIZED, PostgreSQLParserWITHIN, PostgreSQLParserFILTER, PostgreSQLParserGROUPS, PostgreSQLParserOTHERS, PostgreSQLParserNFC, PostgreSQLParserNFD, PostgreSQLParserNFKC, PostgreSQLParserNFKD, PostgreSQLParserUESCAPE, PostgreSQLParserVIEWS, PostgreSQLParserNORMALIZE, PostgreSQLParserDUMP, PostgreSQLParserPRINT_STRICT_PARAMS, PostgreSQLParserVARIABLE_CONFLICT, PostgreSQLParserERROR, PostgreSQLParserUSE_VARIABLE, PostgreSQLParserUSE_COLUMN, PostgreSQLParserALIAS, PostgreSQLParserCONSTANT, PostgreSQLParserPERFORM, PostgreSQLParserGET, PostgreSQLParserDIAGNOSTICS, PostgreSQLParserSTACKED, PostgreSQLParserELSIF, PostgreSQLParserREVERSE, PostgreSQLParserSLICE, PostgreSQLParserEXIT, PostgreSQLParserRETURN, PostgreSQLParserQUERY, PostgreSQLParserRAISE, PostgreSQLParserSQLSTATE, PostgreSQLParserDEBUG, PostgreSQLParserLOG, PostgreSQLParserINFO, PostgreSQLParserNOTICE, PostgreSQLParserWARNING, PostgreSQLParserEXCEPTION, PostgreSQLParserASSERT, PostgreSQLParserOPEN, PostgreSQLParserABS, PostgreSQLParserCBRT, PostgreSQLParserCEIL, PostgreSQLParserCEILING, PostgreSQLParserDEGREES, PostgreSQLParserDIV, PostgreSQLParserEXP, PostgreSQLParserFACTORIAL, PostgreSQLParserFLOOR, PostgreSQLParserGCD, PostgreSQLParserLCM, PostgreSQLParserLN, PostgreSQLParserLOG10, PostgreSQLParserMIN_SCALE, PostgreSQLParserMOD, PostgreSQLParserPI, PostgreSQLParserPOWER, PostgreSQLParserRADIANS, PostgreSQLParserROUND, PostgreSQLParserSCALE, PostgreSQLParserSIGN, PostgreSQLParserSQRT, PostgreSQLParserTRIM_SCALE, PostgreSQLParserTRUNC, PostgreSQLParserWIDTH_BUCKET, PostgreSQLParserRANDOM, PostgreSQLParserSETSEED, PostgreSQLParserACOS, PostgreSQLParserACOSD, PostgreSQLParserASIN, PostgreSQLParserASIND, PostgreSQLParserATAN, PostgreSQLParserATAND, PostgreSQLParserATAN2, PostgreSQLParserATAN2D, PostgreSQLParserCOS, PostgreSQLParserCOSD, PostgreSQLParserCOT, PostgreSQLParserCOTD, PostgreSQLParserSIN, PostgreSQLParserSIND, PostgreSQLParserTAN, PostgreSQLParserTAND, PostgreSQLParserSINH, PostgreSQLParserCOSH, PostgreSQLParserTANH, PostgreSQLParserASINH, PostgreSQLParserACOSH, PostgreSQLParserATANH, PostgreSQLParserBIT_LENGTH, PostgreSQLParserCHAR_LENGTH, PostgreSQLParserCHARACTER_LENGTH, PostgreSQLParserLOWER, PostgreSQLParserOCTET_LENGTH, PostgreSQLParserUPPER, PostgreSQLParserASCII, PostgreSQLParserBTRIM, PostgreSQLParserCHR, PostgreSQLParserCONCAT, PostgreSQLParserCONCAT_WS, PostgreSQLParserFORMAT, PostgreSQLParserINITCAP, PostgreSQLParserLENGTH, PostgreSQLParserLPAD, PostgreSQLParserLTRIM, PostgreSQLParserMD5, PostgreSQLParserPARSE_IDENT, PostgreSQLParserPG_CLIENT_ENCODING, PostgreSQLParserQUOTE_IDENT, PostgreSQLParserQUOTE_LITERAL, PostgreSQLParserQUOTE_NULLABLE, PostgreSQLParserREGEXP_COUNT, PostgreSQLParserREGEXP_INSTR, PostgreSQLParserREGEXP_LIKE, PostgreSQLParserREGEXP_MATCH, PostgreSQLParserREGEXP_MATCHES, PostgreSQLParserREGEXP_REPLACE, PostgreSQLParserREGEXP_SPLIT_TO_ARRAY, PostgreSQLParserREGEXP_SPLIT_TO_TABLE, PostgreSQLParserREGEXP_SUBSTR, PostgreSQLParserREPEAT, PostgreSQLParserRPAD, PostgreSQLParserRTRIM, PostgreSQLParserSPLIT_PART, PostgreSQLParserSTARTS_WITH, PostgreSQLParserSTRING_TO_ARRAY, PostgreSQLParserSTRING_TO_TABLE, PostgreSQLParserSTRPOS, PostgreSQLParserSUBSTR, PostgreSQLParserTO_ASCII, PostgreSQLParserTO_HEX, PostgreSQLParserTRANSLATE, PostgreSQLParserUNISTR, PostgreSQLParserAGE, PostgreSQLParserCLOCK_TIMESTAMP, PostgreSQLParserDATE_BIN, PostgreSQLParserDATE_PART, PostgreSQLParserDATE_TRUNC, PostgreSQLParserISFINITE, PostgreSQLParserJUSTIFY_DAYS, PostgreSQLParserJUSTIFY_HOURS, PostgreSQLParserJUSTIFY_INTERVAL, PostgreSQLParserMAKE_DATE, PostgreSQLParserMAKE_INTERVAL, PostgreSQLParserMAKE_TIME, PostgreSQLParserMAKE_TIMESTAMP, PostgreSQLParserMAKE_TIMESTAMPTZ, PostgreSQLParserNOW, PostgreSQLParserSTATEMENT_TIMESTAMP, PostgreSQLParserTIMEOFDAY, PostgreSQLParserTRANSACTION_TIMESTAMP, PostgreSQLParserTO_TIMESTAMP, PostgreSQLParserTO_CHAR, PostgreSQLParserTO_DATE, PostgreSQLParserTO_NUMBER, PostgreSQLParserIdentifier, PostgreSQLParserQuotedIdentifier, PostgreSQLParserUnicodeQuotedIdentifier, PostgreSQLParserPLSQLVARIABLENAME, PostgreSQLParserPLSQLIDENTIFIER: p.EnterOuterAlt(localctx, 2) { p.SetState(10654) p.Any_identifier() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_exitcondContext is an interface to support dynamic dispatch. type IOpt_exitcondContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures WHEN() antlr.TerminalNode Expr_until_semi() IExpr_until_semiContext // IsOpt_exitcondContext differentiates from other interfaces. IsOpt_exitcondContext() } type Opt_exitcondContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_exitcondContext() *Opt_exitcondContext { var p = new(Opt_exitcondContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_exitcond return p } func InitEmptyOpt_exitcondContext(p *Opt_exitcondContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_exitcond } func (*Opt_exitcondContext) IsOpt_exitcondContext() {} func NewOpt_exitcondContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_exitcondContext { var p = new(Opt_exitcondContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_exitcond return p } func (s *Opt_exitcondContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_exitcondContext) WHEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWHEN, 0) } func (s *Opt_exitcondContext) Expr_until_semi() IExpr_until_semiContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExpr_until_semiContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExpr_until_semiContext) } func (s *Opt_exitcondContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_exitcondContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_exitcondContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_exitcond(s) } } func (s *Opt_exitcondContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_exitcond(s) } } func (s *Opt_exitcondContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_exitcond(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_exitcond() (localctx IOpt_exitcondContext) { localctx = NewOpt_exitcondContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1604, PostgreSQLParserRULE_opt_exitcond) p.SetState(10660) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserWHEN: p.EnterOuterAlt(localctx, 1) { p.SetState(10657) p.Match(PostgreSQLParserWHEN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10658) p.Expr_until_semi() } case PostgreSQLParserSEMI: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IAny_identifierContext is an interface to support dynamic dispatch. type IAny_identifierContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Colid() IColidContext Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext // IsAny_identifierContext differentiates from other interfaces. IsAny_identifierContext() } type Any_identifierContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAny_identifierContext() *Any_identifierContext { var p = new(Any_identifierContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_any_identifier return p } func InitEmptyAny_identifierContext(p *Any_identifierContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_any_identifier } func (*Any_identifierContext) IsAny_identifierContext() {} func NewAny_identifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_identifierContext { var p = new(Any_identifierContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_any_identifier return p } func (s *Any_identifierContext) GetParser() antlr.Parser { return s.parser } func (s *Any_identifierContext) Colid() IColidContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IColidContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IColidContext) } func (s *Any_identifierContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IPlsql_unreserved_keywordContext) } func (s *Any_identifierContext) GetRuleContext() antlr.RuleContext { return s } func (s *Any_identifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Any_identifierContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterAny_identifier(s) } } func (s *Any_identifierContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitAny_identifier(s) } } func (s *Any_identifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitAny_identifier(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Any_identifier() (localctx IAny_identifierContext) { localctx = NewAny_identifierContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1606, PostgreSQLParserRULE_any_identifier) p.SetState(10664) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 742, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(10662) p.Colid() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(10663) p.Plsql_unreserved_keyword() } case antlr.ATNInvalidAltNumber: goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IPlsql_unreserved_keywordContext is an interface to support dynamic dispatch. type IPlsql_unreserved_keywordContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ABSOLUTE_P() antlr.TerminalNode ALIAS() antlr.TerminalNode AND() antlr.TerminalNode ARRAY() antlr.TerminalNode ASSERT() antlr.TerminalNode BACKWARD() antlr.TerminalNode CALL() antlr.TerminalNode CHAIN() antlr.TerminalNode CLOSE() antlr.TerminalNode COLLATE() antlr.TerminalNode COLUMN() antlr.TerminalNode COMMIT() antlr.TerminalNode CONSTANT() antlr.TerminalNode CONSTRAINT() antlr.TerminalNode CONTINUE_P() antlr.TerminalNode CURRENT_P() antlr.TerminalNode CURSOR() antlr.TerminalNode DEBUG() antlr.TerminalNode DEFAULT() antlr.TerminalNode DIAGNOSTICS() antlr.TerminalNode DO() antlr.TerminalNode DUMP() antlr.TerminalNode ELSIF() antlr.TerminalNode ERROR() antlr.TerminalNode EXCEPTION() antlr.TerminalNode EXIT() antlr.TerminalNode FETCH() antlr.TerminalNode FIRST_P() antlr.TerminalNode FORWARD() antlr.TerminalNode GET() antlr.TerminalNode INFO() antlr.TerminalNode INSERT() antlr.TerminalNode IS() antlr.TerminalNode LAST_P() antlr.TerminalNode MOVE() antlr.TerminalNode NEXT() antlr.TerminalNode NO() antlr.TerminalNode NOTICE() antlr.TerminalNode OPEN() antlr.TerminalNode OPTION() antlr.TerminalNode PERFORM() antlr.TerminalNode PRINT_STRICT_PARAMS() antlr.TerminalNode PRIOR() antlr.TerminalNode QUERY() antlr.TerminalNode RAISE() antlr.TerminalNode RELATIVE_P() antlr.TerminalNode RESET() antlr.TerminalNode RETURN() antlr.TerminalNode ROLLBACK() antlr.TerminalNode ROWTYPE() antlr.TerminalNode SCHEMA() antlr.TerminalNode SCROLL() antlr.TerminalNode SET() antlr.TerminalNode SLICE() antlr.TerminalNode SQLSTATE() antlr.TerminalNode STACKED() antlr.TerminalNode TABLE() antlr.TerminalNode TYPE_P() antlr.TerminalNode USE_COLUMN() antlr.TerminalNode USE_VARIABLE() antlr.TerminalNode VARIABLE_CONFLICT() antlr.TerminalNode WARNING() antlr.TerminalNode OUTER_P() antlr.TerminalNode // IsPlsql_unreserved_keywordContext differentiates from other interfaces. IsPlsql_unreserved_keywordContext() } type Plsql_unreserved_keywordContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPlsql_unreserved_keywordContext() *Plsql_unreserved_keywordContext { var p = new(Plsql_unreserved_keywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_plsql_unreserved_keyword return p } func InitEmptyPlsql_unreserved_keywordContext(p *Plsql_unreserved_keywordContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_plsql_unreserved_keyword } func (*Plsql_unreserved_keywordContext) IsPlsql_unreserved_keywordContext() {} func NewPlsql_unreserved_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Plsql_unreserved_keywordContext { var p = new(Plsql_unreserved_keywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_plsql_unreserved_keyword return p } func (s *Plsql_unreserved_keywordContext) GetParser() antlr.Parser { return s.parser } func (s *Plsql_unreserved_keywordContext) ABSOLUTE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserABSOLUTE_P, 0) } func (s *Plsql_unreserved_keywordContext) ALIAS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserALIAS, 0) } func (s *Plsql_unreserved_keywordContext) AND() antlr.TerminalNode { return s.GetToken(PostgreSQLParserAND, 0) } func (s *Plsql_unreserved_keywordContext) ARRAY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserARRAY, 0) } func (s *Plsql_unreserved_keywordContext) ASSERT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserASSERT, 0) } func (s *Plsql_unreserved_keywordContext) BACKWARD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserBACKWARD, 0) } func (s *Plsql_unreserved_keywordContext) CALL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCALL, 0) } func (s *Plsql_unreserved_keywordContext) CHAIN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCHAIN, 0) } func (s *Plsql_unreserved_keywordContext) CLOSE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCLOSE, 0) } func (s *Plsql_unreserved_keywordContext) COLLATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLLATE, 0) } func (s *Plsql_unreserved_keywordContext) COLUMN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOLUMN, 0) } func (s *Plsql_unreserved_keywordContext) COMMIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCOMMIT, 0) } func (s *Plsql_unreserved_keywordContext) CONSTANT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTANT, 0) } func (s *Plsql_unreserved_keywordContext) CONSTRAINT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONSTRAINT, 0) } func (s *Plsql_unreserved_keywordContext) CONTINUE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCONTINUE_P, 0) } func (s *Plsql_unreserved_keywordContext) CURRENT_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURRENT_P, 0) } func (s *Plsql_unreserved_keywordContext) CURSOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserCURSOR, 0) } func (s *Plsql_unreserved_keywordContext) DEBUG() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEBUG, 0) } func (s *Plsql_unreserved_keywordContext) DEFAULT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDEFAULT, 0) } func (s *Plsql_unreserved_keywordContext) DIAGNOSTICS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDIAGNOSTICS, 0) } func (s *Plsql_unreserved_keywordContext) DO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDO, 0) } func (s *Plsql_unreserved_keywordContext) DUMP() antlr.TerminalNode { return s.GetToken(PostgreSQLParserDUMP, 0) } func (s *Plsql_unreserved_keywordContext) ELSIF() antlr.TerminalNode { return s.GetToken(PostgreSQLParserELSIF, 0) } func (s *Plsql_unreserved_keywordContext) ERROR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserERROR, 0) } func (s *Plsql_unreserved_keywordContext) EXCEPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXCEPTION, 0) } func (s *Plsql_unreserved_keywordContext) EXIT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserEXIT, 0) } func (s *Plsql_unreserved_keywordContext) FETCH() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFETCH, 0) } func (s *Plsql_unreserved_keywordContext) FIRST_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFIRST_P, 0) } func (s *Plsql_unreserved_keywordContext) FORWARD() antlr.TerminalNode { return s.GetToken(PostgreSQLParserFORWARD, 0) } func (s *Plsql_unreserved_keywordContext) GET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserGET, 0) } func (s *Plsql_unreserved_keywordContext) INFO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINFO, 0) } func (s *Plsql_unreserved_keywordContext) INSERT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINSERT, 0) } func (s *Plsql_unreserved_keywordContext) IS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserIS, 0) } func (s *Plsql_unreserved_keywordContext) LAST_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserLAST_P, 0) } func (s *Plsql_unreserved_keywordContext) MOVE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserMOVE, 0) } func (s *Plsql_unreserved_keywordContext) NEXT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNEXT, 0) } func (s *Plsql_unreserved_keywordContext) NO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNO, 0) } func (s *Plsql_unreserved_keywordContext) NOTICE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserNOTICE, 0) } func (s *Plsql_unreserved_keywordContext) OPEN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPEN, 0) } func (s *Plsql_unreserved_keywordContext) OPTION() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOPTION, 0) } func (s *Plsql_unreserved_keywordContext) PERFORM() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPERFORM, 0) } func (s *Plsql_unreserved_keywordContext) PRINT_STRICT_PARAMS() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRINT_STRICT_PARAMS, 0) } func (s *Plsql_unreserved_keywordContext) PRIOR() antlr.TerminalNode { return s.GetToken(PostgreSQLParserPRIOR, 0) } func (s *Plsql_unreserved_keywordContext) QUERY() antlr.TerminalNode { return s.GetToken(PostgreSQLParserQUERY, 0) } func (s *Plsql_unreserved_keywordContext) RAISE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRAISE, 0) } func (s *Plsql_unreserved_keywordContext) RELATIVE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRELATIVE_P, 0) } func (s *Plsql_unreserved_keywordContext) RESET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRESET, 0) } func (s *Plsql_unreserved_keywordContext) RETURN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserRETURN, 0) } func (s *Plsql_unreserved_keywordContext) ROLLBACK() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROLLBACK, 0) } func (s *Plsql_unreserved_keywordContext) ROWTYPE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserROWTYPE, 0) } func (s *Plsql_unreserved_keywordContext) SCHEMA() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCHEMA, 0) } func (s *Plsql_unreserved_keywordContext) SCROLL() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSCROLL, 0) } func (s *Plsql_unreserved_keywordContext) SET() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSET, 0) } func (s *Plsql_unreserved_keywordContext) SLICE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSLICE, 0) } func (s *Plsql_unreserved_keywordContext) SQLSTATE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSQLSTATE, 0) } func (s *Plsql_unreserved_keywordContext) STACKED() antlr.TerminalNode { return s.GetToken(PostgreSQLParserSTACKED, 0) } func (s *Plsql_unreserved_keywordContext) TABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTABLE, 0) } func (s *Plsql_unreserved_keywordContext) TYPE_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserTYPE_P, 0) } func (s *Plsql_unreserved_keywordContext) USE_COLUMN() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSE_COLUMN, 0) } func (s *Plsql_unreserved_keywordContext) USE_VARIABLE() antlr.TerminalNode { return s.GetToken(PostgreSQLParserUSE_VARIABLE, 0) } func (s *Plsql_unreserved_keywordContext) VARIABLE_CONFLICT() antlr.TerminalNode { return s.GetToken(PostgreSQLParserVARIABLE_CONFLICT, 0) } func (s *Plsql_unreserved_keywordContext) WARNING() antlr.TerminalNode { return s.GetToken(PostgreSQLParserWARNING, 0) } func (s *Plsql_unreserved_keywordContext) OUTER_P() antlr.TerminalNode { return s.GetToken(PostgreSQLParserOUTER_P, 0) } func (s *Plsql_unreserved_keywordContext) GetRuleContext() antlr.RuleContext { return s } func (s *Plsql_unreserved_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Plsql_unreserved_keywordContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterPlsql_unreserved_keyword(s) } } func (s *Plsql_unreserved_keywordContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitPlsql_unreserved_keyword(s) } } func (s *Plsql_unreserved_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitPlsql_unreserved_keyword(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Plsql_unreserved_keyword() (localctx IPlsql_unreserved_keywordContext) { localctx = NewPlsql_unreserved_keywordContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1608, PostgreSQLParserRULE_plsql_unreserved_keyword) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(10666) _la = p.GetTokenStream().LA(1) if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&2459027012145119232) != 0) || ((int64((_la-92)) & ^0x3f) == 0 && ((int64(1)<<(_la-92))&2310346885883232257) != 0) || ((int64((_la-157)) & ^0x3f) == 0 && ((int64(1)<<(_la-157))&10133099161617425) != 0) || ((int64((_la-232)) & ^0x3f) == 0 && ((int64(1)<<(_la-232))&18015499698831617) != 0) || ((int64((_la-300)) & ^0x3f) == 0 && ((int64(1)<<(_la-300))&9007199322050625) != 0) || ((int64((_la-433)) & ^0x3f) == 0 && ((int64(1)<<(_la-433))&-144097595889811453) != 0) || ((int64((_la-497)) & ^0x3f) == 0 && ((int64(1)<<(_la-497))&12516927) != 0)) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISql_expressionContext is an interface to support dynamic dispatch. type ISql_expressionContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Opt_target_list() IOpt_target_listContext Into_clause() IInto_clauseContext From_clause() IFrom_clauseContext Where_clause() IWhere_clauseContext Group_clause() IGroup_clauseContext Having_clause() IHaving_clauseContext Window_clause() IWindow_clauseContext // IsSql_expressionContext differentiates from other interfaces. IsSql_expressionContext() } type Sql_expressionContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySql_expressionContext() *Sql_expressionContext { var p = new(Sql_expressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_sql_expression return p } func InitEmptySql_expressionContext(p *Sql_expressionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_sql_expression } func (*Sql_expressionContext) IsSql_expressionContext() {} func NewSql_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_expressionContext { var p = new(Sql_expressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_sql_expression return p } func (s *Sql_expressionContext) GetParser() antlr.Parser { return s.parser } func (s *Sql_expressionContext) Opt_target_list() IOpt_target_listContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_target_listContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_target_listContext) } func (s *Sql_expressionContext) Into_clause() IInto_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInto_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IInto_clauseContext) } func (s *Sql_expressionContext) From_clause() IFrom_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFrom_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFrom_clauseContext) } func (s *Sql_expressionContext) Where_clause() IWhere_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWhere_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWhere_clauseContext) } func (s *Sql_expressionContext) Group_clause() IGroup_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGroup_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGroup_clauseContext) } func (s *Sql_expressionContext) Having_clause() IHaving_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IHaving_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IHaving_clauseContext) } func (s *Sql_expressionContext) Window_clause() IWindow_clauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IWindow_clauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IWindow_clauseContext) } func (s *Sql_expressionContext) GetRuleContext() antlr.RuleContext { return s } func (s *Sql_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Sql_expressionContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterSql_expression(s) } } func (s *Sql_expressionContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitSql_expression(s) } } func (s *Sql_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitSql_expression(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Sql_expression() (localctx ISql_expressionContext) { localctx = NewSql_expressionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1610, PostgreSQLParserRULE_sql_expression) p.EnterOuterAlt(localctx, 1) { p.SetState(10668) p.Opt_target_list() } { p.SetState(10669) p.Into_clause() } { p.SetState(10670) p.From_clause() } { p.SetState(10671) p.Where_clause() } { p.SetState(10672) p.Group_clause() } { p.SetState(10673) p.Having_clause() } { p.SetState(10674) p.Window_clause() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExpr_until_thenContext is an interface to support dynamic dispatch. type IExpr_until_thenContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sql_expression() ISql_expressionContext // IsExpr_until_thenContext differentiates from other interfaces. IsExpr_until_thenContext() } type Expr_until_thenContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExpr_until_thenContext() *Expr_until_thenContext { var p = new(Expr_until_thenContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_expr_until_then return p } func InitEmptyExpr_until_thenContext(p *Expr_until_thenContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_expr_until_then } func (*Expr_until_thenContext) IsExpr_until_thenContext() {} func NewExpr_until_thenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_until_thenContext { var p = new(Expr_until_thenContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_expr_until_then return p } func (s *Expr_until_thenContext) GetParser() antlr.Parser { return s.parser } func (s *Expr_until_thenContext) Sql_expression() ISql_expressionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISql_expressionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISql_expressionContext) } func (s *Expr_until_thenContext) GetRuleContext() antlr.RuleContext { return s } func (s *Expr_until_thenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Expr_until_thenContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExpr_until_then(s) } } func (s *Expr_until_thenContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExpr_until_then(s) } } func (s *Expr_until_thenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExpr_until_then(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Expr_until_then() (localctx IExpr_until_thenContext) { localctx = NewExpr_until_thenContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1612, PostgreSQLParserRULE_expr_until_then) p.EnterOuterAlt(localctx, 1) { p.SetState(10676) p.Sql_expression() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExpr_until_semiContext is an interface to support dynamic dispatch. type IExpr_until_semiContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Sql_expression() ISql_expressionContext // IsExpr_until_semiContext differentiates from other interfaces. IsExpr_until_semiContext() } type Expr_until_semiContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExpr_until_semiContext() *Expr_until_semiContext { var p = new(Expr_until_semiContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_expr_until_semi return p } func InitEmptyExpr_until_semiContext(p *Expr_until_semiContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_expr_until_semi } func (*Expr_until_semiContext) IsExpr_until_semiContext() {} func NewExpr_until_semiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_until_semiContext { var p = new(Expr_until_semiContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_expr_until_semi return p } func (s *Expr_until_semiContext) GetParser() antlr.Parser { return s.parser } func (s *Expr_until_semiContext) Sql_expression() ISql_expressionContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISql_expressionContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISql_expressionContext) } func (s *Expr_until_semiContext) GetRuleContext() antlr.RuleContext { return s } func (s *Expr_until_semiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Expr_until_semiContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExpr_until_semi(s) } } func (s *Expr_until_semiContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExpr_until_semi(s) } } func (s *Expr_until_semiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExpr_until_semi(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Expr_until_semi() (localctx IExpr_until_semiContext) { localctx = NewExpr_until_semiContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1614, PostgreSQLParserRULE_expr_until_semi) p.EnterOuterAlt(localctx, 1) { p.SetState(10678) p.Sql_expression() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExpr_until_rightbracketContext is an interface to support dynamic dispatch. type IExpr_until_rightbracketContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr() IA_exprContext // IsExpr_until_rightbracketContext differentiates from other interfaces. IsExpr_until_rightbracketContext() } type Expr_until_rightbracketContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExpr_until_rightbracketContext() *Expr_until_rightbracketContext { var p = new(Expr_until_rightbracketContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_expr_until_rightbracket return p } func InitEmptyExpr_until_rightbracketContext(p *Expr_until_rightbracketContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_expr_until_rightbracket } func (*Expr_until_rightbracketContext) IsExpr_until_rightbracketContext() {} func NewExpr_until_rightbracketContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_until_rightbracketContext { var p = new(Expr_until_rightbracketContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_expr_until_rightbracket return p } func (s *Expr_until_rightbracketContext) GetParser() antlr.Parser { return s.parser } func (s *Expr_until_rightbracketContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Expr_until_rightbracketContext) GetRuleContext() antlr.RuleContext { return s } func (s *Expr_until_rightbracketContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Expr_until_rightbracketContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExpr_until_rightbracket(s) } } func (s *Expr_until_rightbracketContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExpr_until_rightbracket(s) } } func (s *Expr_until_rightbracketContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExpr_until_rightbracket(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Expr_until_rightbracket() (localctx IExpr_until_rightbracketContext) { localctx = NewExpr_until_rightbracketContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1616, PostgreSQLParserRULE_expr_until_rightbracket) p.EnterOuterAlt(localctx, 1) { p.SetState(10680) p.A_expr() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExpr_until_loopContext is an interface to support dynamic dispatch. type IExpr_until_loopContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures A_expr() IA_exprContext // IsExpr_until_loopContext differentiates from other interfaces. IsExpr_until_loopContext() } type Expr_until_loopContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExpr_until_loopContext() *Expr_until_loopContext { var p = new(Expr_until_loopContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_expr_until_loop return p } func InitEmptyExpr_until_loopContext(p *Expr_until_loopContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_expr_until_loop } func (*Expr_until_loopContext) IsExpr_until_loopContext() {} func NewExpr_until_loopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_until_loopContext { var p = new(Expr_until_loopContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_expr_until_loop return p } func (s *Expr_until_loopContext) GetParser() antlr.Parser { return s.parser } func (s *Expr_until_loopContext) A_expr() IA_exprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IA_exprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IA_exprContext) } func (s *Expr_until_loopContext) GetRuleContext() antlr.RuleContext { return s } func (s *Expr_until_loopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Expr_until_loopContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterExpr_until_loop(s) } } func (s *Expr_until_loopContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitExpr_until_loop(s) } } func (s *Expr_until_loopContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitExpr_until_loop(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Expr_until_loop() (localctx IExpr_until_loopContext) { localctx = NewExpr_until_loopContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1618, PostgreSQLParserRULE_expr_until_loop) p.EnterOuterAlt(localctx, 1) { p.SetState(10682) p.A_expr() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IMake_execsql_stmtContext is an interface to support dynamic dispatch. type IMake_execsql_stmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Stmt() IStmtContext Opt_returning_clause_into() IOpt_returning_clause_intoContext // IsMake_execsql_stmtContext differentiates from other interfaces. IsMake_execsql_stmtContext() } type Make_execsql_stmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyMake_execsql_stmtContext() *Make_execsql_stmtContext { var p = new(Make_execsql_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_make_execsql_stmt return p } func InitEmptyMake_execsql_stmtContext(p *Make_execsql_stmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_make_execsql_stmt } func (*Make_execsql_stmtContext) IsMake_execsql_stmtContext() {} func NewMake_execsql_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Make_execsql_stmtContext { var p = new(Make_execsql_stmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_make_execsql_stmt return p } func (s *Make_execsql_stmtContext) GetParser() antlr.Parser { return s.parser } func (s *Make_execsql_stmtContext) Stmt() IStmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IStmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IStmtContext) } func (s *Make_execsql_stmtContext) Opt_returning_clause_into() IOpt_returning_clause_intoContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_returning_clause_intoContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_returning_clause_intoContext) } func (s *Make_execsql_stmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *Make_execsql_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Make_execsql_stmtContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterMake_execsql_stmt(s) } } func (s *Make_execsql_stmtContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitMake_execsql_stmt(s) } } func (s *Make_execsql_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitMake_execsql_stmt(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Make_execsql_stmt() (localctx IMake_execsql_stmtContext) { localctx = NewMake_execsql_stmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1620, PostgreSQLParserRULE_make_execsql_stmt) p.EnterOuterAlt(localctx, 1) { p.SetState(10684) p.Stmt() } { p.SetState(10685) p.Opt_returning_clause_into() } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IOpt_returning_clause_intoContext is an interface to support dynamic dispatch. type IOpt_returning_clause_intoContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures INTO() antlr.TerminalNode Opt_strict() IOpt_strictContext Into_target() IInto_targetContext // IsOpt_returning_clause_intoContext differentiates from other interfaces. IsOpt_returning_clause_intoContext() } type Opt_returning_clause_intoContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOpt_returning_clause_intoContext() *Opt_returning_clause_intoContext { var p = new(Opt_returning_clause_intoContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_returning_clause_into return p } func InitEmptyOpt_returning_clause_intoContext(p *Opt_returning_clause_intoContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = PostgreSQLParserRULE_opt_returning_clause_into } func (*Opt_returning_clause_intoContext) IsOpt_returning_clause_intoContext() {} func NewOpt_returning_clause_intoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_returning_clause_intoContext { var p = new(Opt_returning_clause_intoContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = PostgreSQLParserRULE_opt_returning_clause_into return p } func (s *Opt_returning_clause_intoContext) GetParser() antlr.Parser { return s.parser } func (s *Opt_returning_clause_intoContext) INTO() antlr.TerminalNode { return s.GetToken(PostgreSQLParserINTO, 0) } func (s *Opt_returning_clause_intoContext) Opt_strict() IOpt_strictContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOpt_strictContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOpt_strictContext) } func (s *Opt_returning_clause_intoContext) Into_target() IInto_targetContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IInto_targetContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IInto_targetContext) } func (s *Opt_returning_clause_intoContext) GetRuleContext() antlr.RuleContext { return s } func (s *Opt_returning_clause_intoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *Opt_returning_clause_intoContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.EnterOpt_returning_clause_into(s) } } func (s *Opt_returning_clause_intoContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(PostgreSQLParserListener); ok { listenerT.ExitOpt_returning_clause_into(s) } } func (s *Opt_returning_clause_intoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case PostgreSQLParserVisitor: return t.VisitOpt_returning_clause_into(s) default: return t.VisitChildren(s) } } func (p *PostgreSQLParser) Opt_returning_clause_into() (localctx IOpt_returning_clause_intoContext) { localctx = NewOpt_returning_clause_intoContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 1622, PostgreSQLParserRULE_opt_returning_clause_into) p.SetState(10692) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case PostgreSQLParserINTO: p.EnterOuterAlt(localctx, 1) { p.SetState(10687) p.Match(PostgreSQLParserINTO) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(10688) p.Opt_strict() } { p.SetState(10689) p.Into_target() } case PostgreSQLParserSEMI: p.EnterOuterAlt(localctx, 2) default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } func (p *PostgreSQLParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { switch ruleIndex { case 602: var t *B_exprContext = nil if localctx != nil { t = localctx.(*B_exprContext) } return p.B_expr_Sempred(t, predIndex) default: panic("No predicate with index: " + fmt.Sprint(ruleIndex)) } } func (p *PostgreSQLParser) B_expr_Sempred(localctx antlr.RuleContext, predIndex int) bool { switch predIndex { case 0: return p.Precpred(p.GetParserRuleContext(), 8) case 1: return p.Precpred(p.GetParserRuleContext(), 7) case 2: return p.Precpred(p.GetParserRuleContext(), 6) case 3: return p.Precpred(p.GetParserRuleContext(), 5) case 4: return p.Precpred(p.GetParserRuleContext(), 4) case 5: return p.Precpred(p.GetParserRuleContext(), 10) case 6: return p.Precpred(p.GetParserRuleContext(), 2) case 7: return p.Precpred(p.GetParserRuleContext(), 1) default: panic("No predicate with index: " + fmt.Sprint(predIndex)) } }