mirror of
https://gitee.com/dromara/mayfly-go
synced 2026-01-22 13:45:47 +08:00
185014 lines
5.4 MiB
185014 lines
5.4 MiB
// 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))
|
|
}
|
|
}
|