// Generated from MySQLParser.g4 by ANTLR 4.7
#include "MySQLParserListener.h"
#include "MySQLParserVisitor.h"
#include "MySQLParser.h"
using namespace antlrcpp;
using namespace parser;
using namespace antlr4;
MySQLParser::MySQLParser(TokenStream *input) : Parser(input) {
_interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
}
MySQLParser::~MySQLParser() {
delete _interpreter;
}
std::string MySQLParser::getGrammarFileName() const {
return "MySQLParser.g4";
}
const std::vector<:string>& MySQLParser::getRuleNames() const {
return _ruleNames;
}
dfa::Vocabulary& MySQLParser::getVocabulary() const {
return _vocabulary;
}
//----------------- RootContext ------------------------------------------------------------------
MySQLParser::RootContext::RootContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* MySQLParser::RootContext::EOF() {
return getToken(MySQLParser::EOF, 0);
}
MySQLParser::Sql_statementsContext* MySQLParser::RootContext::sql_statements() {
return getRuleContext<:sql_statementscontext>(0);
}
std::vector<:terminalnode> MySQLParser::RootContext::MINUS() {
return getTokens(MySQLParser::MINUS);
}
tree::TerminalNode* MySQLParser::RootContext::MINUS(size_t i) {
return getToken(MySQLParser::MINUS, i);
}
size_t MySQLParser::RootContext::getRuleIndex() const {
return MySQLParser::RuleRoot;
}
void MySQLParser::RootContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterRoot(this);
}
void MySQLParser::RootContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitRoot(this);
}
antlrcpp::Any MySQLParser::RootContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitRoot(this);
else
return visitor->visitChildren(this);
}
MySQLParser::RootContext* MySQLParser::root() {
RootContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 0, MySQLParser::RuleRoot);
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(575);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << MySQLParser::ALTER)
| (1ULL << MySQLParser::ANALYZE)
| (1ULL << MySQLParser::CALL)
| (1ULL << MySQLParser::CHANGE)
| (1ULL << MySQLParser::CHECK)
| (1ULL << MySQLParser::CREATE)
| (1ULL << MySQLParser::DELETE)
| (1ULL << MySQLParser::DESC)
| (1ULL << MySQLParser::DESCRIBE)
| (1ULL << MySQLParser::DROP)
| (1ULL << MySQLParser::EXPLAIN)
| (1ULL << MySQLParser::GRANT))) != 0) || ((((_la - 71) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 71)) & ((1ULL << (MySQLParser::INSERT - 71))
| (1ULL << (MySQLParser::KILL - 71))
| (1ULL << (MySQLParser::LOAD - 71))
| (1ULL << (MySQLParser::LOCK - 71))
| (1ULL << (MySQLParser::OPTIMIZE - 71))
| (1ULL << (MySQLParser::PURGE - 71))
| (1ULL << (MySQLParser::RELEASE - 71))
| (1ULL << (MySQLParser::RENAME - 71))
| (1ULL << (MySQLParser::REPLACE - 71))
| (1ULL << (MySQLParser::REVOKE - 71))
| (1ULL << (MySQLParser::SELECT - 71))
| (1ULL << (MySQLParser::SET - 71))
| (1ULL << (MySQLParser::SHOW - 71)))) != 0) || ((((_la - 156) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 156)) & ((1ULL << (MySQLParser::UNLOCK - 156))
| (1ULL << (MySQLParser::UPDATE - 156))
| (1ULL << (MySQLParser::USE - 156)))) != 0) || ((((_la - 257) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 257)) & ((1ULL << (MySQLParser::BEGIN - 257))
| (1ULL << (MySQLParser::BINLOG - 257))
| (1ULL << (MySQLParser::CACHE - 257))
| (1ULL << (MySQLParser::CHECKSUM - 257))
| (1ULL << (MySQLParser::COMMIT - 257))
| (1ULL << (MySQLParser::DEALLOCATE - 257))
| (1ULL << (MySQLParser::DO - 257)))) != 0) || ((((_la - 330) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 330)) & ((1ULL << (MySQLParser::FLUSH - 330))
| (1ULL << (MySQLParser::HANDLER - 330))
| (1ULL << (MySQLParser::HELP - 330))
| (1ULL << (MySQLParser::INSTALL - 330)))) != 0) || ((((_la - 438) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 438)) & ((1ULL << (MySQLParser::PREPARE - 438))
| (1ULL << (MySQLParser::REPAIR - 438))
| (1ULL << (MySQLParser::RESET - 438))
| (1ULL << (MySQLParser::ROLLBACK - 438))
| (1ULL << (MySQLParser::SAVEPOINT - 438))
| (1ULL << (MySQLParser::START - 438)))) != 0) || ((((_la - 505) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 505)) & ((1ULL << (MySQLParser::STOP - 505))
| (1ULL << (MySQLParser::TRUNCATE - 505))
| (1ULL << (MySQLParser::UNINSTALL - 505))
| (1ULL << (MySQLParser::XA - 505))
| (1ULL << (MySQLParser::EXECUTE - 505))
| (1ULL << (MySQLParser::SHUTDOWN - 505)))) != 0) || _la == MySQLParser::LR_BRACKET
|| _la == MySQLParser::SEMI) {
setState(574);
sql_statements();
}
setState(579);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::MINUS) {
setState(577);
match(MySQLParser::MINUS);
setState(578);
match(MySQLParser::MINUS);
}
setState(581);
match(MySQLParser::EOF);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Sql_statementsContext ------------------------------------------------------------------
MySQLParser::Sql_statementsContext::Sql_statementsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<:sql_statementcontext> MySQLParser::Sql_statementsContext::sql_statement() {
return getRuleContexts<:sql_statementcontext>();
}
MySQLParser::Sql_statementContext* MySQLParser::Sql_statementsContext::sql_statement(size_t i) {
return getRuleContext<:sql_statementcontext>(i);
}
std::vector<:empty_statementcontext> MySQLParser::Sql_statementsContext::empty_statement() {
return getRuleContexts<:empty_statementcontext>();
}
MySQLParser::Empty_statementContext* MySQLParser::Sql_statementsContext::empty_statement(size_t i) {
return getRuleContext<:empty_statementcontext>(i);
}
std::vector<:terminalnode> MySQLParser::Sql_statementsContext::SEMI() {
return getTokens(MySQLParser::SEMI);
}
tree::TerminalNode* MySQLParser::Sql_statementsContext::SEMI(size_t i) {
return getToken(MySQLParser::SEMI, i);
}
std::vector<:terminalnode> MySQLParser::Sql_statementsContext::MINUS() {
return getTokens(MySQLParser::MINUS);
}
tree::TerminalNode* MySQLParser::Sql_statementsContext::MINUS(size_t i) {
return getToken(MySQLParser::MINUS, i);
}
size_t MySQLParser::Sql_statementsContext::getRuleIndex() const {
return MySQLParser::RuleSql_statements;
}
void MySQLParser::Sql_statementsContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterSql_statements(this);
}
void MySQLParser::Sql_statementsContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitSql_statements(this);
}
antlrcpp::Any MySQLParser::Sql_statementsContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitSql_statements(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Sql_statementsContext* MySQLParser::sql_statements() {
Sql_statementsContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 2, MySQLParser::RuleSql_statements);
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(593);
_errHandler->sync(this);
alt = getInterpreter<:parseratnsimulator>()->adaptivePredict(_input, 4, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(591);
_errHandler->sync(this);
switch (_input->LA(1)) {
case MySQLParser::ALTER:
case MySQLParser::ANALYZE:
case MySQLParser::CALL:
case MySQLParser::CHANGE:
case MySQLParser::CHECK:
case MySQLParser::CREATE:
case MySQLParser::DELETE:
case MySQLParser::DESC:
case MySQLParser::DESCRIBE:
case MySQLParser::DROP:
case MySQLParser::EXPLAIN:
case MySQLParser::GRANT:
case MySQLParser::INSERT:
case MySQLParser::KILL:
case MySQLParser::LOAD:
case MySQLParser::LOCK:
case MySQLParser::OPTIMIZE:
case MySQLParser::PURGE:
case MySQLParser::RELEASE:
case MySQLParser::RENAME:
case MySQLParser::REPLACE:
case MySQLParser::REVOKE:
case MySQLParser::SELECT:
case MySQLParser::SET:
case MySQLParser::SHOW:
case MySQLParser::UNLOCK:
case MySQLParser::UPDATE:
case MySQLParser::USE:
case MySQLParser::BEGIN:
case MySQLParser::BINLOG:
case MySQLParser::CACHE:
case MySQLParser::CHECKSUM:
case MySQLParser::COMMIT:
case MySQLParser::DEALLOCATE:
case MySQLParser::DO:
case MySQLParser::FLUSH:
case MySQLParser::HANDLER:
case MySQLParser::HELP:
case MySQLParser::INSTALL:
case MySQLParser::PREPARE:
case MySQLParser::REPAIR:
case MySQLParser::RESET:
case MySQLParser::ROLLBACK:
case MySQLParser::SAVEPOINT:
case MySQLParser::START:
case MySQLParser::STOP:
case MySQLParser::TRUNCATE:
case MySQLParser::UNINSTALL:
case MySQLParser::XA:
case MySQLParser::EXECUTE:
case MySQLParser::SHUTDOWN:
case MySQLParser::LR_BRACKET: {
setState(583);
sql_statement();
setState(586);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::MINUS) {
setState(584);
match(MySQLParser::MINUS);
setState(585);
match(MySQLParser::MINUS);
}
setState(588);
match(MySQLParser::SEMI);
break;
}
case MySQLParser::SEMI: {
setState(590);
empty_statement();
break;
}
default:
throw NoViableAltException(this);
}
}
setState(595);
_errHandler->sync(this);
alt = getInterpreter<:parseratnsimulator>()->adaptivePredict(_input, 4, _ctx);
}
setState(605);
_errHandler->sync(this);
switch (_input->LA(1)) {
case MySQLParser::ALTER:
case MySQLParser::ANALYZE:
case MySQLParser::CALL:
case MySQLParser::CHANGE:
case MySQLParser::CHECK:
case MySQLParser::CREATE:
case MySQLParser::DELETE:
case MySQLParser::DESC:
case MySQLParser::DESCRIBE:
case MySQLParser::DROP:
case MySQLParser::EXPLAIN:
case MySQLParser::GRANT:
case MySQLParser::INSERT:
case MySQLParser::KILL:
case MySQLParser::LOAD:
case MySQLParser::LOCK:
case MySQLParser::OPTIMIZE:
case MySQLParser::PURGE:
case MySQLParser::RELEASE:
case MySQLParser::RENAME:
case MySQLParser::REPLACE:
case MySQLParser::REVOKE:
case MySQLParser::SELECT:
case MySQLParser::SET:
case MySQLParser::SHOW:
case MySQLParser::UNLOCK:
case MySQLParser::UPDATE:
case MySQLParser::USE:
case MySQLParser::BEGIN:
case MySQLParser::BINLOG:
case MySQLParser::CACHE:
case MySQLParser::CHECKSUM:
case MySQLParser::COMMIT:
case MySQLParser::DEALLOCATE:
case MySQLParser::DO:
case MySQLParser::FLUSH:
case MySQLParser::HANDLER:
case MySQLParser::HELP:
case MySQLParser::INSTALL:
case MySQLParser::PREPARE:
case MySQLParser::REPAIR:
case MySQLParser::RESET:
case MySQLParser::ROLLBACK:
case MySQLParser::SAVEPOINT:
case MySQLParser::START:
case MySQLParser::STOP:
case MySQLParser::TRUNCATE:
case MySQLParser::UNINSTALL:
case MySQLParser::XA:
case MySQLParser::EXECUTE:
case MySQLParser::SHUTDOWN:
case MySQLParser::LR_BRACKET: {
setState(596);
sql_statement();
setState(602);
_errHandler->sync(this);
switch (getInterpreter<:parseratnsimulator>()->adaptivePredict(_input, 6, _ctx)) {
case 1: {
setState(599);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::MINUS) {
setState(597);
match(MySQLParser::MINUS);
setState(598);
match(MySQLParser::MINUS);
}
setState(601);
match(MySQLParser::SEMI);
break;
}
}
break;
}
case MySQLParser::SEMI: {
setState(604);
empty_statement();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Sql_statementContext ------------------------------------------------------------------
MySQLParser::Sql_statementContext::Sql_statementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
MySQLParser::Ddl_statementContext* MySQLParser::Sql_statementContext::ddl_statement() {
return getRuleContext<:ddl_statementcontext>(0);
}
MySQLParser::Dml_statementContext* MySQLParser::Sql_statementContext::dml_statement() {
return getRuleContext<:dml_statementcontext>(0);
}
MySQLParser::Transaction_statementContext* MySQLParser::Sql_statementContext::transaction_statement() {
return getRuleContext<:transaction_statementcontext>(0);
}
MySQLParser::Replication_statementContext* MySQLParser::Sql_statementContext::replication_statement() {
return getRuleContext<:replication_statementcontext>(0);
}
MySQLParser::Prepared_statementContext* MySQLParser::Sql_statementContext::prepared_statement() {
return getRuleContext<:prepared_statementcontext>(0);
}
MySQLParser::Administration_statementContext* MySQLParser::Sql_statementContext::administration_statement() {
return getRuleContext<:administration_statementcontext>(0);
}
MySQLParser::Utility_statementContext* MySQLParser::Sql_statementContext::utility_statement() {
return getRuleContext<:utility_statementcontext>(0);
}
size_t MySQLParser::Sql_statementContext::getRuleIndex() const {
return MySQLParser::RuleSql_statement;
}
void MySQLParser::Sql_statementContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterSql_statement(this);
}
void MySQLParser::Sql_statementContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitSql_statement(this);
}
antlrcpp::Any MySQLParser::Sql_statementContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitSql_statement(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Sql_statementContext* MySQLParser::sql_statement() {
Sql_statementContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 4, MySQLParser::RuleSql_statement);
auto onExit = finally([=] {
exitRule();
});
try {
setState(614);
_errHandler->sync(this);
switch (getInterpreter<:parseratnsimulator>()->adaptivePredict(_input, 8, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(607);
ddl_statement();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(608);
dml_statement();
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(609);
transaction_statement();
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(610);
replication_statement();
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(611);
prepared_statement();
break;
}
case 6: {
enterOuterAlt(_localctx, 6);
setState(612);
administration_statement();
break;
}
case 7: {
enterOuterAlt(_localctx, 7);
setState(613);
utility_statement();
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Empty_statementContext ------------------------------------------------------------------
MySQLParser::Empty_statementContext::Empty_statementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* MySQLParser::Empty_statementContext::SEMI() {
return getToken(MySQLParser::SEMI, 0);
}
size_t MySQLParser::Empty_statementContext::getRuleIndex() const {
return MySQLParser::RuleEmpty_statement;
}
void MySQLParser::Empty_statementContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterEmpty_statement(this);
}
void MySQLParser::Empty_statementContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitEmpty_statement(this);
}
antlrcpp::Any MySQLParser::Empty_statementContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitEmpty_statement(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Empty_statementContext* MySQLParser::empty_statement() {
Empty_statementContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 6, MySQLParser::RuleEmpty_statement);
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(616);
match(MySQLParser::SEMI);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Ddl_statementContext ------------------------------------------------------------------
MySQLParser::Ddl_statementContext::Ddl_statementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
MySQLParser::Create_databaseContext* MySQLParser::Ddl_statementContext::create_database() {
return getRuleContext<:create_databasecontext>(0);
}
MySQLParser::Create_eventContext* MySQLParser::Ddl_statementContext::create_event() {
return getRuleContext<:create_eventcontext>(0);
}
MySQLParser::Create_indexContext* MySQLParser::Ddl_statementContext::create_index() {
return getRuleContext<:create_indexcontext>(0);
}
MySQLParser::Create_logfile_groupContext* MySQLParser::Ddl_statementContext::create_logfile_group() {
return getRuleContext<:create_logfile_groupcontext>(0);
}
MySQLParser::Create_procedureContext* MySQLParser::Ddl_statementContext::create_procedure() {
return getRuleContext<:create_procedurecontext>(0);
}
MySQLParser::Create_functionContext* MySQLParser::Ddl_statementContext::create_function() {
return getRuleContext<:create_functioncontext>(0);
}
MySQLParser::Create_serverContext* MySQLParser::Ddl_statementContext::create_server() {
return getRuleContext<:create_servercontext>(0);
}
MySQLParser::Create_tableContext* MySQLParser::Ddl_statementContext::create_table() {
return getRuleContext<:create_tablecontext>(0);
}
MySQLParser::Create_tablespace_innodbContext* MySQLParser::Ddl_statementContext::create_tablespace_innodb() {
return getRuleContext<:create_tablespace_innodbcontext>(0);
}
MySQLParser::Create_tablespace_ndbContext* MySQLParser::Ddl_statementContext::create_tablespace_ndb() {
return getRuleContext<:create_tablespace_ndbcontext>(0);
}
MySQLParser::Create_triggerContext* MySQLParser::Ddl_statementContext::create_trigger() {
return getRuleContext<:create_triggercontext>(0);
}
MySQLParser::Create_viewContext* MySQLParser::Ddl_statementContext::create_view() {
return getRuleContext<:create_viewcontext>(0);
}
MySQLParser::Alter_databaseContext* MySQLParser::Ddl_statementContext::alter_database() {
return getRuleContext<:alter_databasecontext>(0);
}
MySQLParser::Alter_eventContext* MySQLParser::Ddl_statementContext::alter_event() {
return getRuleContext<:alter_eventcontext>(0);
}
MySQLParser::Alter_functionContext* MySQLParser::Ddl_statementContext::alter_function() {
return getRuleContext<:alter_functioncontext>(0);
}
MySQLParser::Alter_instanceContext* MySQLParser::Ddl_statementContext::alter_instance() {
return getRuleContext<:alter_instancecontext>(0);
}
MySQLParser::Alter_logfile_groupContext* MySQLParser::Ddl_statementContext::alter_logfile_group() {
return getRuleContext<:alter_logfile_groupcontext>(0);
}
MySQLParser::Alter_procedureContext* MySQLParser::Ddl_statementContext::alter_procedure() {
return getRuleContext<:alter_procedurecontext>(0);
}
MySQLParser::Alter_serverContext* MySQLParser::Ddl_statementContext::alter_server() {
return getRuleContext<:alter_servercontext>(0);
}
MySQLParser::Alter_tableContext* MySQLParser::Ddl_statementContext::alter_table() {
return getRuleContext<:alter_tablecontext>(0);
}
MySQLParser::Alter_tablespaceContext* MySQLParser::Ddl_statementContext::alter_tablespace() {
return getRuleContext<:alter_tablespacecontext>(0);
}
MySQLParser::Alter_viewContext* MySQLParser::Ddl_statementContext::alter_view() {
return getRuleContext<:alter_viewcontext>(0);
}
MySQLParser::Drop_databaseContext* MySQLParser::Ddl_statementContext::drop_database() {
return getRuleContext<:drop_databasecontext>(0);
}
MySQLParser::Drop_eventContext* MySQLParser::Ddl_statementContext::drop_event() {
return getRuleContext<:drop_eventcontext>(0);
}
MySQLParser::Drop_indexContext* MySQLParser::Ddl_statementContext::drop_index() {
return getRuleContext<:drop_indexcontext>(0);
}
MySQLParser::Drop_logfile_groupContext* MySQLParser::Ddl_statementContext::drop_logfile_group() {
return getRuleContext<:drop_logfile_groupcontext>(0);
}
MySQLParser::Drop_procedureContext* MySQLParser::Ddl_statementContext::drop_procedure() {
return getRuleContext<:drop_procedurecontext>(0);
}
MySQLParser::Drop_functionContext* MySQLParser::Ddl_statementContext::drop_function() {
return getRuleContext<:drop_functioncontext>(0);
}
MySQLParser::Drop_serverContext* MySQLParser::Ddl_statementContext::drop_server() {
return getRuleContext<:drop_servercontext>(0);
}
MySQLParser::Drop_tableContext* MySQLParser::Ddl_statementContext::drop_table() {
return getRuleContext<:drop_tablecontext>(0);
}
MySQLParser::Drop_tablespaceContext* MySQLParser::Ddl_statementContext::drop_tablespace() {
return getRuleContext<:drop_tablespacecontext>(0);
}
MySQLParser::Drop_triggerContext* MySQLParser::Ddl_statementContext::drop_trigger() {
return getRuleContext<:drop_triggercontext>(0);
}
MySQLParser::Drop_viewContext* MySQLParser::Ddl_statementContext::drop_view() {
return getRuleContext<:drop_viewcontext>(0);
}
MySQLParser::Rename_tableContext* MySQLParser::Ddl_statementContext::rename_table() {
return getRuleContext<:rename_tablecontext>(0);
}
MySQLParser::Truncate_tableContext* MySQLParser::Ddl_statementContext::truncate_table() {
return getRuleContext<:truncate_tablecontext>(0);
}
size_t MySQLParser::Ddl_statementContext::getRuleIndex() const {
return MySQLParser::RuleDdl_statement;
}
void MySQLParser::Ddl_statementContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterDdl_statement(this);
}
void MySQLParser::Ddl_statementContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitDdl_statement(this);
}
antlrcpp::Any MySQLParser::Ddl_statementContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitDdl_statement(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Ddl_statementContext* MySQLParser::ddl_statement() {
Ddl_statementContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 8, MySQLParser::RuleDdl_statement);
auto onExit = finally([=] {
exitRule();
});
try {
setState(653);
_errHandler->sync(this);
switch (getInterpreter<:parseratnsimulator>()->adaptivePredict(_input, 9, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(618);
create_database();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(619);
create_event();
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(620);
create_index();
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(621);
create_logfile_group();
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(622);
create_procedure();
break;
}
case 6: {
enterOuterAlt(_localctx, 6);
setState(623);
create_function();
break;
}
case 7: {
enterOuterAlt(_localctx, 7);
setState(624);
create_server();
break;
}
case 8: {
enterOuterAlt(_localctx, 8);
setState(625);
create_table();
break;
}
case 9: {
enterOuterAlt(_localctx, 9);
setState(626);
create_tablespace_innodb();
break;
}
case 10: {
enterOuterAlt(_localctx, 10);
setState(627);
create_tablespace_ndb();
break;
}
case 11: {
enterOuterAlt(_localctx, 11);
setState(628);
create_trigger();
break;
}
case 12: {
enterOuterAlt(_localctx, 12);
setState(629);
create_view();
break;
}
case 13: {
enterOuterAlt(_localctx, 13);
setState(630);
alter_database();
break;
}
case 14: {
enterOuterAlt(_localctx, 14);
setState(631);
alter_event();
break;
}
case 15: {
enterOuterAlt(_localctx, 15);
setState(632);
alter_function();
break;
}
case 16: {
enterOuterAlt(_localctx, 16);
setState(633);
alter_instance();
break;
}
case 17: {
enterOuterAlt(_localctx, 17);
setState(634);
alter_logfile_group();
break;
}
case 18: {
enterOuterAlt(_localctx, 18);
setState(635);
alter_procedure();
break;
}
case 19: {
enterOuterAlt(_localctx, 19);
setState(636);
alter_server();
break;
}
case 20: {
enterOuterAlt(_localctx, 20);
setState(637);
alter_table();
break;
}
case 21: {
enterOuterAlt(_localctx, 21);
setState(638);
alter_tablespace();
break;
}
case 22: {
enterOuterAlt(_localctx, 22);
setState(639);
alter_view();
break;
}
case 23: {
enterOuterAlt(_localctx, 23);
setState(640);
drop_database();
break;
}
case 24: {
enterOuterAlt(_localctx, 24);
setState(641);
drop_event();
break;
}
case 25: {
enterOuterAlt(_localctx, 25);
setState(642);
drop_index();
break;
}
case 26: {
enterOuterAlt(_localctx, 26);
setState(643);
drop_logfile_group();
break;
}
case 27: {
enterOuterAlt(_localctx, 27);
setState(644);
drop_procedure();
break;
}
case 28: {
enterOuterAlt(_localctx, 28);
setState(645);
drop_function();
break;
}
case 29: {
enterOuterAlt(_localctx, 29);
setState(646);
drop_server();
break;
}
case 30: {
enterOuterAlt(_localctx, 30);
setState(647);
drop_table();
break;
}
case 31: {
enterOuterAlt(_localctx, 31);
setState(648);
drop_tablespace();
break;
}
case 32: {
enterOuterAlt(_localctx, 32);
setState(649);
drop_trigger();
break;
}
case 33: {
enterOuterAlt(_localctx, 33);
setState(650);
drop_view();
break;
}
case 34: {
enterOuterAlt(_localctx, 34);
setState(651);
rename_table();
break;
}
case 35: {
enterOuterAlt(_localctx, 35);
setState(652);
truncate_table();
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Dml_statementContext ------------------------------------------------------------------
MySQLParser::Dml_statementContext::Dml_statementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
MySQLParser::Select_statementContext* MySQLParser::Dml_statementContext::select_statement() {
return getRuleContext<:select_statementcontext>(0);
}
MySQLParser::Insert_statementContext* MySQLParser::Dml_statementContext::insert_statement() {
return getRuleContext<:insert_statementcontext>(0);
}
MySQLParser::Update_statementContext* MySQLParser::Dml_statementContext::update_statement() {
return getRuleContext<:update_statementcontext>(0);
}
MySQLParser::Delete_statementContext* MySQLParser::Dml_statementContext::delete_statement() {
return getRuleContext<:delete_statementcontext>(0);
}
MySQLParser::Replace_statementContext* MySQLParser::Dml_statementContext::replace_statement() {
return getRuleContext<:replace_statementcontext>(0);
}
MySQLParser::Call_statementContext* MySQLParser::Dml_statementContext::call_statement() {
return getRuleContext<:call_statementcontext>(0);
}
MySQLParser::Load_data_statementContext* MySQLParser::Dml_statementContext::load_data_statement() {
return getRuleContext<:load_data_statementcontext>(0);
}
MySQLParser::Load_xml_statementContext* MySQLParser::Dml_statementContext::load_xml_statement() {
return getRuleContext<:load_xml_statementcontext>(0);
}
MySQLParser::Do_statementContext* MySQLParser::Dml_statementContext::do_statement() {
return getRuleContext<:do_statementcontext>(0);
}
MySQLParser::Handler_statementContext* MySQLParser::Dml_statementContext::handler_statement() {
return getRuleContext<:handler_statementcontext>(0);
}
size_t MySQLParser::Dml_statementContext::getRuleIndex() const {
return MySQLParser::RuleDml_statement;
}
void MySQLParser::Dml_statementContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterDml_statement(this);
}
void MySQLParser::Dml_statementContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitDml_statement(this);
}
antlrcpp::Any MySQLParser::Dml_statementContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitDml_statement(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Dml_statementContext* MySQLParser::dml_statement() {
Dml_statementContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 10, MySQLParser::RuleDml_statement);
auto onExit = finally([=] {
exitRule();
});
try {
setState(665);
_errHandler->sync(this);
switch (getInterpreter<:parseratnsimulator>()->adaptivePredict(_input, 10, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(655);
select_statement();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(656);
insert_statement();
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(657);
update_statement();
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(658);
delete_statement();
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(659);
replace_statement();
break;
}
case 6: {
enterOuterAlt(_localctx, 6);
setState(660);
call_statement();
break;
}
case 7: {
enterOuterAlt(_localctx, 7);
setState(661);
load_data_statement();
break;
}
case 8: {
enterOuterAlt(_localctx, 8);
setState(662);
load_xml_statement();
break;
}
case 9: {
enterOuterAlt(_localctx, 9);
setState(663);
do_statement();
break;
}
case 10: {
enterOuterAlt(_localctx, 10);
setState(664);
handler_statement();
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Transaction_statementContext ------------------------------------------------------------------
MySQLParser::Transaction_statementContext::Transaction_statementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
MySQLParser::Start_transactionContext* MySQLParser::Transaction_statementContext::start_transaction() {
return getRuleContext<:start_transactioncontext>(0);
}
MySQLParser::Begin_workContext* MySQLParser::Transaction_statementContext::begin_work() {
return getRuleContext<:begin_workcontext>(0);
}
MySQLParser::Commit_workContext* MySQLParser::Transaction_statementContext::commit_work() {
return getRuleContext<:commit_workcontext>(0);
}
MySQLParser::Rollback_workContext* MySQLParser::Transaction_statementContext::rollback_work() {
return getRuleContext<:rollback_workcontext>(0);
}
MySQLParser::Savepoint_statementContext* MySQLParser::Transaction_statementContext::savepoint_statement() {
return getRuleContext<:savepoint_statementcontext>(0);
}
MySQLParser::Rollback_statementContext* MySQLParser::Transaction_statementContext::rollback_statement() {
return getRuleContext<:rollback_statementcontext>(0);
}
MySQLParser::Release_statementContext* MySQLParser::Transaction_statementContext::release_statement() {
return getRuleContext<:release_statementcontext>(0);
}
MySQLParser::Lock_tablesContext* MySQLParser::Transaction_statementContext::lock_tables() {
return getRuleContext<:lock_tablescontext>(0);
}
MySQLParser::Unlock_tablesContext* MySQLParser::Transaction_statementContext::unlock_tables() {
return getRuleContext<:unlock_tablescontext>(0);
}
size_t MySQLParser::Transaction_statementContext::getRuleIndex() const {
return MySQLParser::RuleTransaction_statement;
}
void MySQLParser::Transaction_statementContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterTransaction_statement(this);
}
void MySQLParser::Transaction_statementContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitTransaction_statement(this);
}
antlrcpp::Any MySQLParser::Transaction_statementContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitTransaction_statement(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Transaction_statementContext* MySQLParser::transaction_statement() {
Transaction_statementContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 12, MySQLParser::RuleTransaction_statement);
auto onExit = finally([=] {
exitRule();
});
try {
setState(676);
_errHandler->sync(this);
switch (getInterpreter<:parseratnsimulator>()->adaptivePredict(_input, 11, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(667);
start_transaction();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(668);
begin_work();
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(669);
commit_work();
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(670);
rollback_work();
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(671);
savepoint_statement();
break;
}
case 6: {
enterOuterAlt(_localctx, 6);
setState(672);
rollback_statement();
break;
}
case 7: {
enterOuterAlt(_localctx, 7);
setState(673);
release_statement();
break;
}
case 8: {
enterOuterAlt(_localctx, 8);
setState(674);
lock_tables();
break;
}
case 9: {
enterOuterAlt(_localctx, 9);
setState(675);
unlock_tables();
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Replication_statementContext ------------------------------------------------------------------
MySQLParser::Replication_statementContext::Replication_statementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
MySQLParser::Change_masterContext* MySQLParser::Replication_statementContext::change_master() {
return getRuleContext<:change_mastercontext>(0);
}
MySQLParser::Change_repl_filterContext* MySQLParser::Replication_statementContext::change_repl_filter() {
return getRuleContext<:change_repl_filtercontext>(0);
}
MySQLParser::Purge_binary_logsContext* MySQLParser::Replication_statementContext::purge_binary_logs() {
return getRuleContext<:purge_binary_logscontext>(0);
}
MySQLParser::Reset_masterContext* MySQLParser::Replication_statementContext::reset_master() {
return getRuleContext<:reset_mastercontext>(0);
}
MySQLParser::Reset_slaveContext* MySQLParser::Replication_statementContext::reset_slave() {
return getRuleContext<:reset_slavecontext>(0);
}
MySQLParser::Start_slaveContext* MySQLParser::Replication_statementContext::start_slave() {
return getRuleContext<:start_slavecontext>(0);
}
MySQLParser::Stop_slaveContext* MySQLParser::Replication_statementContext::stop_slave() {
return getRuleContext<:stop_slavecontext>(0);
}
MySQLParser::Start_group_replContext* MySQLParser::Replication_statementContext::start_group_repl() {
return getRuleContext<:start_group_replcontext>(0);
}
MySQLParser::Stop_group_replContext* MySQLParser::Replication_statementContext::stop_group_repl() {
return getRuleContext<:stop_group_replcontext>(0);
}
MySQLParser::Xa_start_transactionContext* MySQLParser::Replication_statementContext::xa_start_transaction() {
return getRuleContext<:xa_start_transactioncontext>(0);
}
MySQLParser::Xa_end_transactionContext* MySQLParser::Replication_statementContext::xa_end_transaction() {
return getRuleContext<:xa_end_transactioncontext>(0);
}
MySQLParser::Xa_prepareContext* MySQLParser::Replication_statementContext::xa_prepare() {
return getRuleContext<:xa_preparecontext>(0);
}
MySQLParser::Xa_commit_workContext* MySQLParser::Replication_statementContext::xa_commit_work() {
return getRuleContext<:xa_commit_workcontext>(0);
}
MySQLParser::Xa_rollback_workContext* MySQLParser::Replication_statementContext::xa_rollback_work() {
return getRuleContext<:xa_rollback_workcontext>(0);
}
MySQLParser::Xa_recover_workContext* MySQLParser::Replication_statementContext::xa_recover_work() {
return getRuleContext<:xa_recover_workcontext>(0);
}
size_t MySQLParser::Replication_statementContext::getRuleIndex() const {
return MySQLParser::RuleReplication_statement;
}
void MySQLParser::Replication_statementContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterReplication_statement(this);
}
void MySQLParser::Replication_statementContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitReplication_statement(this);
}
antlrcpp::Any MySQLParser::Replication_statementContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitReplication_statement(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Replication_statementContext* MySQLParser::replication_statement() {
Replication_statementContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 14, MySQLParser::RuleReplication_statement);
auto onExit = finally([=] {
exitRule();
});
try {
setState(693);
_errHandler->sync(this);
switch (getInterpreter<:parseratnsimulator>()->adaptivePredict(_input, 12, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(678);
change_master();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(679);
change_repl_filter();
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(680);
purge_binary_logs();
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(681);
reset_master();
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(682);
reset_slave();
break;
}
case 6: {
enterOuterAlt(_localctx, 6);
setState(683);
start_slave();
break;
}
case 7: {
enterOuterAlt(_localctx, 7);
setState(684);
stop_slave();
break;
}
case 8: {
enterOuterAlt(_localctx, 8);
setState(685);
start_group_repl();
break;
}
case 9: {
enterOuterAlt(_localctx, 9);
setState(686);
stop_group_repl();
break;
}
case 10: {
enterOuterAlt(_localctx, 10);
setState(687);
xa_start_transaction();
break;
}
case 11: {
enterOuterAlt(_localctx, 11);
setState(688);
xa_end_transaction();
break;
}
case 12: {
enterOuterAlt(_localctx, 12);
setState(689);
xa_prepare();
break;
}
case 13: {
enterOuterAlt(_localctx, 13);
setState(690);
xa_commit_work();
break;
}
case 14: {
enterOuterAlt(_localctx, 14);
setState(691);
xa_rollback_work();
break;
}
case 15: {
enterOuterAlt(_localctx, 15);
setState(692);
xa_recover_work();
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Prepared_statementContext ------------------------------------------------------------------
MySQLParser::Prepared_statementContext::Prepared_statementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
MySQLParser::Prepare_statementContext* MySQLParser::Prepared_statementContext::prepare_statement() {
return getRuleContext<:prepare_statementcontext>(0);
}
MySQLParser::Execute_statementContext* MySQLParser::Prepared_statementContext::execute_statement() {
return getRuleContext<:execute_statementcontext>(0);
}
MySQLParser::Deallocate_prepareContext* MySQLParser::Prepared_statementContext::deallocate_prepare() {
return getRuleContext<:deallocate_preparecontext>(0);
}
size_t MySQLParser::Prepared_statementContext::getRuleIndex() const {
return MySQLParser::RulePrepared_statement;
}
void MySQLParser::Prepared_statementContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterPrepared_statement(this);
}
void MySQLParser::Prepared_statementContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitPrepared_statement(this);
}
antlrcpp::Any MySQLParser::Prepared_statementContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitPrepared_statement(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Prepared_statementContext* MySQLParser::prepared_statement() {
Prepared_statementContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 16, MySQLParser::RulePrepared_statement);
auto onExit = finally([=] {
exitRule();
});
try {
setState(698);
_errHandler->sync(this);
switch (_input->LA(1)) {
case MySQLParser::PREPARE: {
enterOuterAlt(_localctx, 1);
setState(695);
prepare_statement();
break;
}
case MySQLParser::EXECUTE: {
enterOuterAlt(_localctx, 2);
setState(696);
execute_statement();
break;
}
case MySQLParser::DROP:
case MySQLParser::DEALLOCATE: {
enterOuterAlt(_localctx, 3);
setState(697);
deallocate_prepare();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Compound_statementContext ------------------------------------------------------------------
MySQLParser::Compound_statementContext::Compound_statementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
MySQLParser::Block_statementContext* MySQLParser::Compound_statementContext::block_statement() {
return getRuleContext<:block_statementcontext>(0);
}
MySQLParser::Case_statementContext* MySQLParser::Compound_statementContext::case_statement() {
return getRuleContext<:case_statementcontext>(0);
}
MySQLParser::If_statementContext* MySQLParser::Compound_statementContext::if_statement() {
return getRuleContext<:if_statementcontext>(0);
}
MySQLParser::Leave_statementContext* MySQLParser::Compound_statementContext::leave_statement() {
return getRuleContext<:leave_statementcontext>(0);
}
MySQLParser::Loop_statementContext* MySQLParser::Compound_statementContext::loop_statement() {
return getRuleContext<:loop_statementcontext>(0);
}
MySQLParser::Repeat_statementContext* MySQLParser::Compound_statementContext::repeat_statement() {
return getRuleContext<:repeat_statementcontext>(0);
}
MySQLParser::While_statementContext* MySQLParser::Compound_statementContext::while_statement() {
return getRuleContext<:while_statementcontext>(0);
}
MySQLParser::Iterate_statementContext* MySQLParser::Compound_statementContext::iterate_statement() {
return getRuleContext<:iterate_statementcontext>(0);
}
MySQLParser::Return_statementContext* MySQLParser::Compound_statementContext::return_statement() {
return getRuleContext<:return_statementcontext>(0);
}
MySQLParser::Cursor_statementContext* MySQLParser::Compound_statementContext::cursor_statement() {
return getRuleContext<:cursor_statementcontext>(0);
}
size_t MySQLParser::Compound_statementContext::getRuleIndex() const {
return MySQLParser::RuleCompound_statement;
}
void MySQLParser::Compound_statementContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterCompound_statement(this);
}
void MySQLParser::Compound_statementContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitCompound_statement(this);
}
antlrcpp::Any MySQLParser::Compound_statementContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitCompound_statement(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Compound_statementContext* MySQLParser::compound_statement() {
Compound_statementContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 18, MySQLParser::RuleCompound_statement);
auto onExit = finally([=] {
exitRule();
});
try {
setState(710);
_errHandler->sync(this);
switch (getInterpreter<:parseratnsimulator>()->adaptivePredict(_input, 14, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(700);
block_statement();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(701);
case_statement();
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(702);
if_statement();
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(703);
leave_statement();
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(704);
loop_statement();
break;
}
case 6: {
enterOuterAlt(_localctx, 6);
setState(705);
repeat_statement();
break;
}
case 7: {
enterOuterAlt(_localctx, 7);
setState(706);
while_statement();
break;
}
case 8: {
enterOuterAlt(_localctx, 8);
setState(707);
iterate_statement();
break;
}
case 9: {
enterOuterAlt(_localctx, 9);
setState(708);
return_statement();
break;
}
case 10: {
enterOuterAlt(_localctx, 10);
setState(709);
cursor_statement();
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Administration_statementContext ------------------------------------------------------------------
MySQLParser::Administration_statementContext::Administration_statementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
MySQLParser::Alter_userContext* MySQLParser::Administration_statementContext::alter_user() {
return getRuleContext<:alter_usercontext>(0);
}
MySQLParser::Create_userContext* MySQLParser::Administration_statementContext::create_user() {
return getRuleContext<:create_usercontext>(0);
}
MySQLParser::Drop_userContext* MySQLParser::Administration_statementContext::drop_user() {
return getRuleContext<:drop_usercontext>(0);
}
MySQLParser::Grant_statementContext* MySQLParser::Administration_statementContext::grant_statement() {
return getRuleContext<:grant_statementcontext>(0);
}
MySQLParser::Grant_proxyContext* MySQLParser::Administration_statementContext::grant_proxy() {
return getRuleContext<:grant_proxycontext>(0);
}
MySQLParser::Rename_userContext* MySQLParser::Administration_statementContext::rename_user() {
return getRuleContext<:rename_usercontext>(0);
}
MySQLParser::Revoke_statementContext* MySQLParser::Administration_statementContext::revoke_statement() {
return getRuleContext<:revoke_statementcontext>(0);
}
MySQLParser::Revoke_proxyContext* MySQLParser::Administration_statementContext::revoke_proxy() {
return getRuleContext<:revoke_proxycontext>(0);
}
MySQLParser::Analyze_tableContext* MySQLParser::Administration_statementContext::analyze_table() {
return getRuleContext<:analyze_tablecontext>(0);
}
MySQLParser::Check_tableContext* MySQLParser::Administration_statementContext::check_table() {
return getRuleContext<:check_tablecontext>(0);
}
MySQLParser::Checksum_tableContext* MySQLParser::Administration_statementContext::checksum_table() {
return getRuleContext<:checksum_tablecontext>(0);
}
MySQLParser::Optimize_tableContext* MySQLParser::Administration_statementContext::optimize_table() {
return getRuleContext<:optimize_tablecontext>(0);
}
MySQLParser::Repair_tableContext* MySQLParser::Administration_statementContext::repair_table() {
return getRuleContext<:repair_tablecontext>(0);
}
MySQLParser::Create_udfunctionContext* MySQLParser::Administration_statementContext::create_udfunction() {
return getRuleContext<:create_udfunctioncontext>(0);
}
MySQLParser::Install_pluginContext* MySQLParser::Administration_statementContext::install_plugin() {
return getRuleContext<:install_plugincontext>(0);
}
MySQLParser::Uninstall_pluginContext* MySQLParser::Administration_statementContext::uninstall_plugin() {
return getRuleContext<:uninstall_plugincontext>(0);
}
MySQLParser::Set_statementContext* MySQLParser::Administration_statementContext::set_statement() {
return getRuleContext<:set_statementcontext>(0);
}
MySQLParser::Show_statementContext* MySQLParser::Administration_statementContext::show_statement() {
return getRuleContext<:show_statementcontext>(0);
}
MySQLParser::Binlog_statementContext* MySQLParser::Administration_statementContext::binlog_statement() {
return getRuleContext<:binlog_statementcontext>(0);
}
MySQLParser::Cache_index_statementContext* MySQLParser::Administration_statementContext::cache_index_statement() {
return getRuleContext<:cache_index_statementcontext>(0);
}
MySQLParser::Flush_statementContext* MySQLParser::Administration_statementContext::flush_statement() {
return getRuleContext<:flush_statementcontext>(0);
}
MySQLParser::Kill_statementContext* MySQLParser::Administration_statementContext::kill_statement() {
return getRuleContext<:kill_statementcontext>(0);
}
MySQLParser::Load_index_into_cacheContext* MySQLParser::Administration_statementContext::load_index_into_cache() {
return getRuleContext<:load_index_into_cachecontext>(0);
}
MySQLParser::Reset_statementContext* MySQLParser::Administration_statementContext::reset_statement() {
return getRuleContext<:reset_statementcontext>(0);
}
MySQLParser::Shutdown_statementContext* MySQLParser::Administration_statementContext::shutdown_statement() {
return getRuleContext<:shutdown_statementcontext>(0);
}
size_t MySQLParser::Administration_statementContext::getRuleIndex() const {
return MySQLParser::RuleAdministration_statement;
}
void MySQLParser::Administration_statementContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterAdministration_statement(this);
}
void MySQLParser::Administration_statementContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitAdministration_statement(this);
}
antlrcpp::Any MySQLParser::Administration_statementContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitAdministration_statement(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Administration_statementContext* MySQLParser::administration_statement() {
Administration_statementContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 20, MySQLParser::RuleAdministration_statement);
auto onExit = finally([=] {
exitRule();
});
try {
setState(737);
_errHandler->sync(this);
switch (getInterpreter<:parseratnsimulator>()->adaptivePredict(_input, 15, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(712);
alter_user();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(713);
create_user();
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(714);
drop_user();
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(715);
grant_statement();
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(716);
grant_proxy();
break;
}
case 6: {
enterOuterAlt(_localctx, 6);
setState(717);
rename_user();
break;
}
case 7: {
enterOuterAlt(_localctx, 7);
setState(718);
revoke_statement();
break;
}
case 8: {
enterOuterAlt(_localctx, 8);
setState(719);
revoke_proxy();
break;
}
case 9: {
enterOuterAlt(_localctx, 9);
setState(720);
analyze_table();
break;
}
case 10: {
enterOuterAlt(_localctx, 10);
setState(721);
check_table();
break;
}
case 11: {
enterOuterAlt(_localctx, 11);
setState(722);
checksum_table();
break;
}
case 12: {
enterOuterAlt(_localctx, 12);
setState(723);
optimize_table();
break;
}
case 13: {
enterOuterAlt(_localctx, 13);
setState(724);
repair_table();
break;
}
case 14: {
enterOuterAlt(_localctx, 14);
setState(725);
create_udfunction();
break;
}
case 15: {
enterOuterAlt(_localctx, 15);
setState(726);
install_plugin();
break;
}
case 16: {
enterOuterAlt(_localctx, 16);
setState(727);
uninstall_plugin();
break;
}
case 17: {
enterOuterAlt(_localctx, 17);
setState(728);
set_statement();
break;
}
case 18: {
enterOuterAlt(_localctx, 18);
setState(729);
show_statement();
break;
}
case 19: {
enterOuterAlt(_localctx, 19);
setState(730);
binlog_statement();
break;
}
case 20: {
enterOuterAlt(_localctx, 20);
setState(731);
cache_index_statement();
break;
}
case 21: {
enterOuterAlt(_localctx, 21);
setState(732);
flush_statement();
break;
}
case 22: {
enterOuterAlt(_localctx, 22);
setState(733);
kill_statement();
break;
}
case 23: {
enterOuterAlt(_localctx, 23);
setState(734);
load_index_into_cache();
break;
}
case 24: {
enterOuterAlt(_localctx, 24);
setState(735);
reset_statement();
break;
}
case 25: {
enterOuterAlt(_localctx, 25);
setState(736);
shutdown_statement();
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Utility_statementContext ------------------------------------------------------------------
MySQLParser::Utility_statementContext::Utility_statementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
MySQLParser::Simple_describe_statementContext* MySQLParser::Utility_statementContext::simple_describe_statement() {
return getRuleContext<:simple_describe_statementcontext>(0);
}
MySQLParser::Full_describe_statementContext* MySQLParser::Utility_statementContext::full_describe_statement() {
return getRuleContext<:full_describe_statementcontext>(0);
}
MySQLParser::Help_statementContext* MySQLParser::Utility_statementContext::help_statement() {
return getRuleContext<:help_statementcontext>(0);
}
MySQLParser::Use_statementContext* MySQLParser::Utility_statementContext::use_statement() {
return getRuleContext<:use_statementcontext>(0);
}
size_t MySQLParser::Utility_statementContext::getRuleIndex() const {
return MySQLParser::RuleUtility_statement;
}
void MySQLParser::Utility_statementContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterUtility_statement(this);
}
void MySQLParser::Utility_statementContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitUtility_statement(this);
}
antlrcpp::Any MySQLParser::Utility_statementContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitUtility_statement(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Utility_statementContext* MySQLParser::utility_statement() {
Utility_statementContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 22, MySQLParser::RuleUtility_statement);
auto onExit = finally([=] {
exitRule();
});
try {
setState(743);
_errHandler->sync(this);
switch (getInterpreter<:parseratnsimulator>()->adaptivePredict(_input, 16, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(739);
simple_describe_statement();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(740);
full_describe_statement();
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(741);
help_statement();
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(742);
use_statement();
break;
}
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Create_databaseContext ------------------------------------------------------------------
MySQLParser::Create_databaseContext::Create_databaseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* MySQLParser::Create_databaseContext::CREATE() {
return getToken(MySQLParser::CREATE, 0);
}
MySQLParser::Id_Context* MySQLParser::Create_databaseContext::id_() {
return getRuleContext<:id_context>(0);
}
tree::TerminalNode* MySQLParser::Create_databaseContext::DATABASE() {
return getToken(MySQLParser::DATABASE, 0);
}
tree::TerminalNode* MySQLParser::Create_databaseContext::SCHEMA() {
return getToken(MySQLParser::SCHEMA, 0);
}
MySQLParser::If_not_existsContext* MySQLParser::Create_databaseContext::if_not_exists() {
return getRuleContext<:if_not_existscontext>(0);
}
std::vector<:create_database_optioncontext> MySQLParser::Create_databaseContext::create_database_option() {
return getRuleContexts<:create_database_optioncontext>();
}
MySQLParser::Create_database_optionContext* MySQLParser::Create_databaseContext::create_database_option(size_t i) {
return getRuleContext<:create_database_optioncontext>(i);
}
size_t MySQLParser::Create_databaseContext::getRuleIndex() const {
return MySQLParser::RuleCreate_database;
}
void MySQLParser::Create_databaseContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterCreate_database(this);
}
void MySQLParser::Create_databaseContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitCreate_database(this);
}
antlrcpp::Any MySQLParser::Create_databaseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitCreate_database(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Create_databaseContext* MySQLParser::create_database() {
Create_databaseContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 24, MySQLParser::RuleCreate_database);
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(745);
match(MySQLParser::CREATE);
setState(746);
_la = _input->LA(1);
if (!(_la == MySQLParser::DATABASE || _la == MySQLParser::SCHEMA)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(748);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::IF) {
setState(747);
if_not_exists();
}
setState(750);
id_();
setState(754);
_errHandler->sync(this);
_la = _input->LA(1);
while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << MySQLParser::CHARACTER)
| (1ULL << MySQLParser::COLLATE)
| (1ULL << MySQLParser::DEFAULT))) != 0)) {
setState(751);
create_database_option();
setState(756);
_errHandler->sync(this);
_la = _input->LA(1);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Create_eventContext ------------------------------------------------------------------
MySQLParser::Create_eventContext::Create_eventContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* MySQLParser::Create_eventContext::CREATE() {
return getToken(MySQLParser::CREATE, 0);
}
tree::TerminalNode* MySQLParser::Create_eventContext::EVENT() {
return getToken(MySQLParser::EVENT, 0);
}
MySQLParser::Full_idContext* MySQLParser::Create_eventContext::full_id() {
return getRuleContext<:full_idcontext>(0);
}
std::vector<:terminalnode> MySQLParser::Create_eventContext::ON() {
return getTokens(MySQLParser::ON);
}
tree::TerminalNode* MySQLParser::Create_eventContext::ON(size_t i) {
return getToken(MySQLParser::ON, i);
}
tree::TerminalNode* MySQLParser::Create_eventContext::SCHEDULE() {
return getToken(MySQLParser::SCHEDULE, 0);
}
MySQLParser::Schedule_expressionContext* MySQLParser::Create_eventContext::schedule_expression() {
return getRuleContext<:schedule_expressioncontext>(0);
}
tree::TerminalNode* MySQLParser::Create_eventContext::DO() {
return getToken(MySQLParser::DO, 0);
}
MySQLParser::Routine_bodyContext* MySQLParser::Create_eventContext::routine_body() {
return getRuleContext<:routine_bodycontext>(0);
}
MySQLParser::Owner_statementContext* MySQLParser::Create_eventContext::owner_statement() {
return getRuleContext<:owner_statementcontext>(0);
}
MySQLParser::If_not_existsContext* MySQLParser::Create_eventContext::if_not_exists() {
return getRuleContext<:if_not_existscontext>(0);
}
tree::TerminalNode* MySQLParser::Create_eventContext::COMPLETION() {
return getToken(MySQLParser::COMPLETION, 0);
}
tree::TerminalNode* MySQLParser::Create_eventContext::PRESERVE() {
return getToken(MySQLParser::PRESERVE, 0);
}
tree::TerminalNode* MySQLParser::Create_eventContext::ENABLE() {
return getToken(MySQLParser::ENABLE, 0);
}
tree::TerminalNode* MySQLParser::Create_eventContext::DISABLE() {
return getToken(MySQLParser::DISABLE, 0);
}
tree::TerminalNode* MySQLParser::Create_eventContext::SLAVE() {
return getToken(MySQLParser::SLAVE, 0);
}
tree::TerminalNode* MySQLParser::Create_eventContext::COMMENT() {
return getToken(MySQLParser::COMMENT, 0);
}
tree::TerminalNode* MySQLParser::Create_eventContext::STRING_LITERAL() {
return getToken(MySQLParser::STRING_LITERAL, 0);
}
tree::TerminalNode* MySQLParser::Create_eventContext::NOT() {
return getToken(MySQLParser::NOT, 0);
}
size_t MySQLParser::Create_eventContext::getRuleIndex() const {
return MySQLParser::RuleCreate_event;
}
void MySQLParser::Create_eventContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterCreate_event(this);
}
void MySQLParser::Create_eventContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitCreate_event(this);
}
antlrcpp::Any MySQLParser::Create_eventContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitCreate_event(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Create_eventContext* MySQLParser::create_event() {
Create_eventContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 26, MySQLParser::RuleCreate_event);
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(757);
match(MySQLParser::CREATE);
setState(759);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::DEFINER) {
setState(758);
owner_statement();
}
setState(761);
match(MySQLParser::EVENT);
setState(763);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::IF) {
setState(762);
if_not_exists();
}
setState(765);
full_id();
setState(766);
match(MySQLParser::ON);
setState(767);
match(MySQLParser::SCHEDULE);
setState(768);
schedule_expression();
setState(775);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::ON) {
setState(769);
match(MySQLParser::ON);
setState(770);
match(MySQLParser::COMPLETION);
setState(772);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::NOT) {
setState(771);
match(MySQLParser::NOT);
}
setState(774);
match(MySQLParser::PRESERVE);
}
setState(782);
_errHandler->sync(this);
switch (getInterpreter<:parseratnsimulator>()->adaptivePredict(_input, 23, _ctx)) {
case 1: {
setState(777);
match(MySQLParser::ENABLE);
break;
}
case 2: {
setState(778);
match(MySQLParser::DISABLE);
break;
}
case 3: {
setState(779);
match(MySQLParser::DISABLE);
setState(780);
match(MySQLParser::ON);
setState(781);
match(MySQLParser::SLAVE);
break;
}
}
setState(786);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::COMMENT) {
setState(784);
match(MySQLParser::COMMENT);
setState(785);
match(MySQLParser::STRING_LITERAL);
}
setState(788);
match(MySQLParser::DO);
setState(789);
routine_body();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Create_indexContext ------------------------------------------------------------------
MySQLParser::Create_indexContext::Create_indexContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* MySQLParser::Create_indexContext::CREATE() {
return getToken(MySQLParser::CREATE, 0);
}
tree::TerminalNode* MySQLParser::Create_indexContext::INDEX() {
return getToken(MySQLParser::INDEX, 0);
}
MySQLParser::Id_Context* MySQLParser::Create_indexContext::id_() {
return getRuleContext<:id_context>(0);
}
tree::TerminalNode* MySQLParser::Create_indexContext::ON() {
return getToken(MySQLParser::ON, 0);
}
MySQLParser::Table_nameContext* MySQLParser::Create_indexContext::table_name() {
return getRuleContext<:table_namecontext>(0);
}
MySQLParser::Index_colname_listContext* MySQLParser::Create_indexContext::index_colname_list() {
return getRuleContext<:index_colname_listcontext>(0);
}
MySQLParser::Index_typeContext* MySQLParser::Create_indexContext::index_type() {
return getRuleContext<:index_typecontext>(0);
}
std::vector<:index_optioncontext> MySQLParser::Create_indexContext::index_option() {
return getRuleContexts<:index_optioncontext>();
}
MySQLParser::Index_optionContext* MySQLParser::Create_indexContext::index_option(size_t i) {
return getRuleContext<:index_optioncontext>(i);
}
tree::TerminalNode* MySQLParser::Create_indexContext::ALGORITHM() {
return getToken(MySQLParser::ALGORITHM, 0);
}
tree::TerminalNode* MySQLParser::Create_indexContext::LOCK() {
return getToken(MySQLParser::LOCK, 0);
}
tree::TerminalNode* MySQLParser::Create_indexContext::ONLINE() {
return getToken(MySQLParser::ONLINE, 0);
}
tree::TerminalNode* MySQLParser::Create_indexContext::OFFLINE() {
return getToken(MySQLParser::OFFLINE, 0);
}
tree::TerminalNode* MySQLParser::Create_indexContext::UNIQUE() {
return getToken(MySQLParser::UNIQUE, 0);
}
tree::TerminalNode* MySQLParser::Create_indexContext::FULLTEXT() {
return getToken(MySQLParser::FULLTEXT, 0);
}
tree::TerminalNode* MySQLParser::Create_indexContext::SPATIAL() {
return getToken(MySQLParser::SPATIAL, 0);
}
tree::TerminalNode* MySQLParser::Create_indexContext::DEFAULT() {
return getToken(MySQLParser::DEFAULT, 0);
}
tree::TerminalNode* MySQLParser::Create_indexContext::INPLACE() {
return getToken(MySQLParser::INPLACE, 0);
}
tree::TerminalNode* MySQLParser::Create_indexContext::COPY() {
return getToken(MySQLParser::COPY, 0);
}
tree::TerminalNode* MySQLParser::Create_indexContext::NONE() {
return getToken(MySQLParser::NONE, 0);
}
tree::TerminalNode* MySQLParser::Create_indexContext::SHARED() {
return getToken(MySQLParser::SHARED, 0);
}
tree::TerminalNode* MySQLParser::Create_indexContext::EXCLUSIVE() {
return getToken(MySQLParser::EXCLUSIVE, 0);
}
size_t MySQLParser::Create_indexContext::getRuleIndex() const {
return MySQLParser::RuleCreate_index;
}
void MySQLParser::Create_indexContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterCreate_index(this);
}
void MySQLParser::Create_indexContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitCreate_index(this);
}
antlrcpp::Any MySQLParser::Create_indexContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitCreate_index(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Create_indexContext* MySQLParser::create_index() {
Create_indexContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 28, MySQLParser::RuleCreate_index);
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(791);
match(MySQLParser::CREATE);
setState(793);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::OFFLINE
|| _la == MySQLParser::ONLINE) {
setState(792);
_la = _input->LA(1);
if (!(_la == MySQLParser::OFFLINE
|| _la == MySQLParser::ONLINE)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
setState(796);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::FULLTEXT || _la == MySQLParser::SPATIAL
|| _la == MySQLParser::UNIQUE) {
setState(795);
dynamic_cast(_localctx)->index_category = _input->LT(1);
_la = _input->LA(1);
if (!(_la == MySQLParser::FULLTEXT || _la == MySQLParser::SPATIAL
|| _la == MySQLParser::UNIQUE)) {
dynamic_cast(_localctx)->index_category = _errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
setState(798);
match(MySQLParser::INDEX);
setState(799);
id_();
setState(801);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::USING) {
setState(800);
index_type();
}
setState(803);
match(MySQLParser::ON);
setState(804);
table_name();
setState(805);
index_colname_list();
setState(809);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == MySQLParser::USING
|| _la == MySQLParser::WITH || _la == MySQLParser::COMMENT || _la == MySQLParser::KEY_BLOCK_SIZE) {
setState(806);
index_option();
setState(811);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(822);
_errHandler->sync(this);
switch (_input->LA(1)) {
case MySQLParser::ALGORITHM: {
setState(812);
match(MySQLParser::ALGORITHM);
setState(814);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::EQUAL_SYMBOL) {
setState(813);
match(MySQLParser::EQUAL_SYMBOL);
}
setState(816);
dynamic_cast(_localctx)->alg_type = _input->LT(1);
_la = _input->LA(1);
if (!(_la == MySQLParser::DEFAULT || _la == MySQLParser::COPY
|| _la == MySQLParser::INPLACE)) {
dynamic_cast(_localctx)->alg_type = _errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
break;
}
case MySQLParser::LOCK: {
setState(817);
match(MySQLParser::LOCK);
setState(819);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::EQUAL_SYMBOL) {
setState(818);
match(MySQLParser::EQUAL_SYMBOL);
}
setState(821);
dynamic_cast(_localctx)->lock_type = _input->LT(1);
_la = _input->LA(1);
if (!(_la == MySQLParser::DEFAULT || _la == MySQLParser::EXCLUSIVE || _la == MySQLParser::NONE || _la == MySQLParser::SHARED)) {
dynamic_cast(_localctx)->lock_type = _errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
break;
}
case MySQLParser::EOF:
case MySQLParser::MINUS:
case MySQLParser::SEMI: {
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Create_logfile_groupContext ------------------------------------------------------------------
MySQLParser::Create_logfile_groupContext::Create_logfile_groupContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* MySQLParser::Create_logfile_groupContext::CREATE() {
return getToken(MySQLParser::CREATE, 0);
}
tree::TerminalNode* MySQLParser::Create_logfile_groupContext::LOGFILE() {
return getToken(MySQLParser::LOGFILE, 0);
}
tree::TerminalNode* MySQLParser::Create_logfile_groupContext::GROUP() {
return getToken(MySQLParser::GROUP, 0);
}
std::vector<:id_context> MySQLParser::Create_logfile_groupContext::id_() {
return getRuleContexts<:id_context>();
}
MySQLParser::Id_Context* MySQLParser::Create_logfile_groupContext::id_(size_t i) {
return getRuleContext<:id_context>(i);
}
tree::TerminalNode* MySQLParser::Create_logfile_groupContext::ADD() {
return getToken(MySQLParser::ADD, 0);
}
tree::TerminalNode* MySQLParser::Create_logfile_groupContext::UNDOFILE() {
return getToken(MySQLParser::UNDOFILE, 0);
}
tree::TerminalNode* MySQLParser::Create_logfile_groupContext::ENGINE() {
return getToken(MySQLParser::ENGINE, 0);
}
MySQLParser::Engine_nameContext* MySQLParser::Create_logfile_groupContext::engine_name() {
return getRuleContext<:engine_namecontext>(0);
}
std::vector<:terminalnode> MySQLParser::Create_logfile_groupContext::STRING_LITERAL() {
return getTokens(MySQLParser::STRING_LITERAL);
}
tree::TerminalNode* MySQLParser::Create_logfile_groupContext::STRING_LITERAL(size_t i) {
return getToken(MySQLParser::STRING_LITERAL, i);
}
tree::TerminalNode* MySQLParser::Create_logfile_groupContext::INITIAL_SIZE() {
return getToken(MySQLParser::INITIAL_SIZE, 0);
}
tree::TerminalNode* MySQLParser::Create_logfile_groupContext::UNDO_BUFFER_SIZE() {
return getToken(MySQLParser::UNDO_BUFFER_SIZE, 0);
}
tree::TerminalNode* MySQLParser::Create_logfile_groupContext::REDO_BUFFER_SIZE() {
return getToken(MySQLParser::REDO_BUFFER_SIZE, 0);
}
tree::TerminalNode* MySQLParser::Create_logfile_groupContext::NODEGROUP() {
return getToken(MySQLParser::NODEGROUP, 0);
}
tree::TerminalNode* MySQLParser::Create_logfile_groupContext::WAIT() {
return getToken(MySQLParser::WAIT, 0);
}
tree::TerminalNode* MySQLParser::Create_logfile_groupContext::COMMENT() {
return getToken(MySQLParser::COMMENT, 0);
}
std::vector<:filesize_literalcontext> MySQLParser::Create_logfile_groupContext::filesize_literal() {
return getRuleContexts<:filesize_literalcontext>();
}
MySQLParser::Filesize_literalContext* MySQLParser::Create_logfile_groupContext::filesize_literal(size_t i) {
return getRuleContext<:filesize_literalcontext>(i);
}
size_t MySQLParser::Create_logfile_groupContext::getRuleIndex() const {
return MySQLParser::RuleCreate_logfile_group;
}
void MySQLParser::Create_logfile_groupContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterCreate_logfile_group(this);
}
void MySQLParser::Create_logfile_groupContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitCreate_logfile_group(this);
}
antlrcpp::Any MySQLParser::Create_logfile_groupContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitCreate_logfile_group(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Create_logfile_groupContext* MySQLParser::create_logfile_group() {
Create_logfile_groupContext *_localctx = _tracker.createInstance(_ctx, getState());
enterRule(_localctx, 30, MySQLParser::RuleCreate_logfile_group);
size_t _la = 0;
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(824);
match(MySQLParser::CREATE);
setState(825);
match(MySQLParser::LOGFILE);
setState(826);
match(MySQLParser::GROUP);
setState(827);
id_();
setState(828);
match(MySQLParser::ADD);
setState(829);
match(MySQLParser::UNDOFILE);
setState(830);
dynamic_cast(_localctx)->undo_file = match(MySQLParser::STRING_LITERAL);
setState(836);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::INITIAL_SIZE) {
setState(831);
match(MySQLParser::INITIAL_SIZE);
setState(833);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::EQUAL_SYMBOL) {
setState(832);
match(MySQLParser::EQUAL_SYMBOL);
}
setState(835);
dynamic_cast(_localctx)->init_size = filesize_literal();
}
setState(843);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::UNDO_BUFFER_SIZE) {
setState(838);
match(MySQLParser::UNDO_BUFFER_SIZE);
setState(840);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::EQUAL_SYMBOL) {
setState(839);
match(MySQLParser::EQUAL_SYMBOL);
}
setState(842);
dynamic_cast(_localctx)->undo_size = filesize_literal();
}
setState(850);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::REDO_BUFFER_SIZE) {
setState(845);
match(MySQLParser::REDO_BUFFER_SIZE);
setState(847);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::EQUAL_SYMBOL) {
setState(846);
match(MySQLParser::EQUAL_SYMBOL);
}
setState(849);
dynamic_cast(_localctx)->redo_size = filesize_literal();
}
setState(857);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::NODEGROUP) {
setState(852);
match(MySQLParser::NODEGROUP);
setState(854);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::EQUAL_SYMBOL) {
setState(853);
match(MySQLParser::EQUAL_SYMBOL);
}
setState(856);
id_();
}
setState(860);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::WAIT) {
setState(859);
match(MySQLParser::WAIT);
}
setState(867);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::COMMENT) {
setState(862);
match(MySQLParser::COMMENT);
setState(864);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::EQUAL_SYMBOL) {
setState(863);
match(MySQLParser::EQUAL_SYMBOL);
}
setState(866);
dynamic_cast(_localctx)->comment = match(MySQLParser::STRING_LITERAL);
}
setState(869);
match(MySQLParser::ENGINE);
setState(871);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == MySQLParser::EQUAL_SYMBOL) {
setState(870);
match(MySQLParser::EQUAL_SYMBOL);
}
setState(873);
engine_name();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- Create_procedureContext ------------------------------------------------------------------
MySQLParser::Create_procedureContext::Create_procedureContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* MySQLParser::Create_procedureContext::CREATE() {
return getToken(MySQLParser::CREATE, 0);
}
tree::TerminalNode* MySQLParser::Create_procedureContext::PROCEDURE() {
return getToken(MySQLParser::PROCEDURE, 0);
}
MySQLParser::Full_idContext* MySQLParser::Create_procedureContext::full_id() {
return getRuleContext<:full_idcontext>(0);
}
MySQLParser::Routine_bodyContext* MySQLParser::Create_procedureContext::routine_body() {
return getRuleContext<:routine_bodycontext>(0);
}
MySQLParser::Owner_statementContext* MySQLParser::Create_procedureContext::owner_statement() {
return getRuleContext<:owner_statementcontext>(0);
}
std::vector<:proc_paramcontext> MySQLParser::Create_procedureContext::proc_param() {
return getRuleContexts<:proc_paramcontext>();
}
MySQLParser::Proc_paramContext* MySQLParser::Create_procedureContext::proc_param(size_t i) {
return getRuleContext<:proc_paramcontext>(i);
}
std::vector<:routine_characteristiccontext> MySQLParser::Create_procedureContext::routine_characteristic() {
return getRuleContexts<:routine_characteristiccontext>();
}
MySQLParser::Routine_characteristicContext* MySQLParser::Create_procedureContext::routine_characteristic(size_t i) {
return getRuleContext<:routine_characteristiccontext>(i);
}
size_t MySQLParser::Create_procedureContext::getRuleIndex() const {
return MySQLParser::RuleCreate_procedure;
}
void MySQLParser::Create_procedureContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->enterCreate_procedure(this);
}
void MySQLParser::Create_procedureContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast(listener);
if (parserListener != nullptr)
parserListener->exitCreate_procedure(this);
}
antlrcpp::Any MySQLParser::Create_procedureContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast(visitor))
return parserVisitor->visitCreate_procedure(this);
else
return visitor->visitChildren(this);
}
MySQLParser::Create_procedureContext* MySQLParser::create_procedure() {
Create_procedureContext *_localctx = _tracker.createInstance