// Generated from SQLite.g4 by ANTLR 4.7.1
package androidx.room.parser;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class SQLiteParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
SCOL=1, DOT=2, OPEN_PAR=3, CLOSE_PAR=4, COMMA=5, ASSIGN=6, STAR=7, PLUS=8,
MINUS=9, TILDE=10, PIPE2=11, DIV=12, MOD=13, LT2=14, GT2=15, AMP=16, PIPE=17,
LT=18, LT_EQ=19, GT=20, GT_EQ=21, EQ=22, NOT_EQ1=23, NOT_EQ2=24, TRUE=25,
FALSE=26, K_ABORT=27, K_ACTION=28, K_ADD=29, K_AFTER=30, K_ALL=31, K_ALTER=32,
K_ANALYZE=33, K_AND=34, K_AS=35, K_ASC=36, K_ATTACH=37, K_AUTOINCREMENT=38,
K_BEFORE=39, K_BEGIN=40, K_BETWEEN=41, K_BY=42, K_CASCADE=43, K_CASE=44,
K_CAST=45, K_CHECK=46, K_COLLATE=47, K_COLUMN=48, K_COMMIT=49, K_CONFLICT=50,
K_CONSTRAINT=51, K_CREATE=52, K_CROSS=53, K_CURRENT_DATE=54, K_CURRENT_TIME=55,
K_CURRENT_TIMESTAMP=56, K_DATABASE=57, K_DEFAULT=58, K_DEFERRABLE=59,
K_DEFERRED=60, K_DELETE=61, K_DESC=62, K_DETACH=63, K_DISTINCT=64, K_DROP=65,
K_EACH=66, K_ELSE=67, K_END=68, K_ESCAPE=69, K_EXCEPT=70, K_EXCLUSIVE=71,
K_EXISTS=72, K_EXPLAIN=73, K_FAIL=74, K_FOR=75, K_FOREIGN=76, K_FROM=77,
K_FULL=78, K_GLOB=79, K_GROUP=80, K_HAVING=81, K_IF=82, K_IGNORE=83, K_IMMEDIATE=84,
K_IN=85, K_INDEX=86, K_INDEXED=87, K_INITIALLY=88, K_INNER=89, K_INSERT=90,
K_INSTEAD=91, K_INTERSECT=92, K_INTO=93, K_IS=94, K_ISNULL=95, K_JOIN=96,
K_KEY=97, K_LEFT=98, K_LIKE=99, K_LIMIT=100, K_MATCH=101, K_NATURAL=102,
K_NO=103, K_NOT=104, K_NOTNULL=105, K_NULL=106, K_OF=107, K_OFFSET=108,
K_ON=109, K_OR=110, K_ORDER=111, K_OUTER=112, K_PLAN=113, K_PRAGMA=114,
K_PRIMARY=115, K_QUERY=116, K_RAISE=117, K_RECURSIVE=118, K_REFERENCES=119,
K_REGEXP=120, K_REINDEX=121, K_RELEASE=122, K_RENAME=123, K_REPLACE=124,
K_RESTRICT=125, K_RIGHT=126, K_ROLLBACK=127, K_ROW=128, K_SAVEPOINT=129,
K_SELECT=130, K_SET=131, K_TABLE=132, K_TEMP=133, K_TEMPORARY=134, K_THEN=135,
K_TO=136, K_TRANSACTION=137, K_TRIGGER=138, K_UNION=139, K_UNIQUE=140,
K_UPDATE=141, K_USING=142, K_VACUUM=143, K_VALUES=144, K_VIEW=145, K_VIRTUAL=146,
K_WHEN=147, K_WHERE=148, K_WITH=149, K_WITHOUT=150, WITHOUT_ROWID=151,
DO_NOTHING=152, DO_UPDATE=153, IDENTIFIER=154, NUMERIC_LITERAL=155, BIND_PARAMETER=156,
STRING_LITERAL=157, BLOB_LITERAL=158, SINGLE_LINE_COMMENT=159, MULTILINE_COMMENT=160,
SPACES=161, UNEXPECTED_CHAR=162;
public static final int
RULE_parse = 0, RULE_error = 1, RULE_sql_stmt_list = 2, RULE_sql_stmt = 3,
RULE_alter_table_stmt = 4, RULE_analyze_stmt = 5, RULE_attach_stmt = 6,
RULE_begin_stmt = 7, RULE_commit_stmt = 8, RULE_create_index_stmt = 9,
RULE_create_table_stmt = 10, RULE_create_trigger_stmt = 11, RULE_create_view_stmt = 12,
RULE_create_virtual_table_stmt = 13, RULE_delete_stmt = 14, RULE_delete_stmt_limited = 15,
RULE_detach_stmt = 16, RULE_drop_index_stmt = 17, RULE_drop_table_stmt = 18,
RULE_drop_trigger_stmt = 19, RULE_drop_view_stmt = 20, RULE_insert_stmt = 21,
RULE_upsert_clause = 22, RULE_pragma_stmt = 23, RULE_reindex_stmt = 24,
RULE_release_stmt = 25, RULE_rollback_stmt = 26, RULE_savepoint_stmt = 27,
RULE_select_stmt = 28, RULE_select_or_values = 29, RULE_update_stmt = 30,
RULE_update_stmt_limited = 31, RULE_vacuum_stmt = 32, RULE_column_def = 33,
RULE_type_name = 34, RULE_column_constraint = 35, RULE_conflict_clause = 36,
RULE_expr = 37, RULE_comma_separated_expr = 38, RULE_foreign_key_clause = 39,
RULE_raise_function = 40, RULE_indexed_column = 41, RULE_table_constraint = 42,
RULE_with_clause = 43, RULE_common_table_expression = 44, RULE_qualified_table_name = 45,
RULE_order_clause = 46, RULE_ordering_term = 47, RULE_limit_clause = 48,
RULE_pragma_value = 49, RULE_result_column = 50, RULE_table_or_subquery = 51,
RULE_join_clause = 52, RULE_join_operator = 53, RULE_join_constraint = 54,
RULE_compound_operator = 55, RULE_signed_number = 56, RULE_literal_value = 57,
RULE_boolean_literal = 58, RULE_unary_operator = 59, RULE_binary_operator = 60,
RULE_error_message = 61, RULE_module_argument = 62, RULE_column_alias = 63,
RULE_column_name_list = 64, RULE_keyword = 65, RULE_name = 66, RULE_function_name = 67,
RULE_schema_name = 68, RULE_table_function = 69, RULE_table_name = 70,
RULE_table_or_index_name = 71, RULE_new_table_name = 72, RULE_column_name = 73,
RULE_collation_name = 74, RULE_foreign_table = 75, RULE_index_name = 76,
RULE_trigger_name = 77, RULE_view_name = 78, RULE_module_name = 79, RULE_pragma_name = 80,
RULE_savepoint_name = 81, RULE_table_alias = 82, RULE_transaction_name = 83,
RULE_any_name = 84;
public static final String[] ruleNames = {
"parse", "error", "sql_stmt_list", "sql_stmt", "alter_table_stmt", "analyze_stmt",
"attach_stmt", "begin_stmt", "commit_stmt", "create_index_stmt", "create_table_stmt",
"create_trigger_stmt", "create_view_stmt", "create_virtual_table_stmt",
"delete_stmt", "delete_stmt_limited", "detach_stmt", "drop_index_stmt",
"drop_table_stmt", "drop_trigger_stmt", "drop_view_stmt", "insert_stmt",
"upsert_clause", "pragma_stmt", "reindex_stmt", "release_stmt", "rollback_stmt",
"savepoint_stmt", "select_stmt", "select_or_values", "update_stmt", "update_stmt_limited",
"vacuum_stmt", "column_def", "type_name", "column_constraint", "conflict_clause",
"expr", "comma_separated_expr", "foreign_key_clause", "raise_function",
"indexed_column", "table_constraint", "with_clause", "common_table_expression",
"qualified_table_name", "order_clause", "ordering_term", "limit_clause",
"pragma_value", "result_column", "table_or_subquery", "join_clause", "join_operator",
"join_constraint", "compound_operator", "signed_number", "literal_value",
"boolean_literal", "unary_operator", "binary_operator", "error_message",
"module_argument", "column_alias", "column_name_list", "keyword", "name",
"function_name", "schema_name", "table_function", "table_name", "table_or_index_name",
"new_table_name", "column_name", "collation_name", "foreign_table", "index_name",
"trigger_name", "view_name", "module_name", "pragma_name", "savepoint_name",
"table_alias", "transaction_name", "any_name"
};
private static final String[] _LITERAL_NAMES = {
null, "';'", "'.'", "'('", "')'", "','", "'='", "'*'", "'+'", "'-'", "'~'",
"'||'", "'/'", "'%'", "'<<'", "'>>'", "'&'", "'|'", "'<'", "'<='", "'>'",
"'>='", "'=='", "'!='", "'<>'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, "SCOL", "DOT", "OPEN_PAR", "CLOSE_PAR", "COMMA", "ASSIGN", "STAR",
"PLUS", "MINUS", "TILDE", "PIPE2", "DIV", "MOD", "LT2", "GT2", "AMP",
"PIPE", "LT", "LT_EQ", "GT", "GT_EQ", "EQ", "NOT_EQ1", "NOT_EQ2", "TRUE",
"FALSE", "K_ABORT", "K_ACTION", "K_ADD", "K_AFTER", "K_ALL", "K_ALTER",
"K_ANALYZE", "K_AND", "K_AS", "K_ASC", "K_ATTACH", "K_AUTOINCREMENT",
"K_BEFORE", "K_BEGIN", "K_BETWEEN", "K_BY", "K_CASCADE", "K_CASE", "K_CAST",
"K_CHECK", "K_COLLATE", "K_COLUMN", "K_COMMIT", "K_CONFLICT", "K_CONSTRAINT",
"K_CREATE", "K_CROSS", "K_CURRENT_DATE", "K_CURRENT_TIME", "K_CURRENT_TIMESTAMP",
"K_DATABASE", "K_DEFAULT", "K_DEFERRABLE", "K_DEFERRED", "K_DELETE", "K_DESC",
"K_DETACH", "K_DISTINCT", "K_DROP", "K_EACH", "K_ELSE", "K_END", "K_ESCAPE",
"K_EXCEPT", "K_EXCLUSIVE", "K_EXISTS", "K_EXPLAIN", "K_FAIL", "K_FOR",
"K_FOREIGN", "K_FROM", "K_FULL", "K_GLOB", "K_GROUP", "K_HAVING", "K_IF",
"K_IGNORE", "K_IMMEDIATE", "K_IN", "K_INDEX", "K_INDEXED", "K_INITIALLY",
"K_INNER", "K_INSERT", "K_INSTEAD", "K_INTERSECT", "K_INTO", "K_IS", "K_ISNULL",
"K_JOIN", "K_KEY", "K_LEFT", "K_LIKE", "K_LIMIT", "K_MATCH", "K_NATURAL",
"K_NO", "K_NOT", "K_NOTNULL", "K_NULL", "K_OF", "K_OFFSET", "K_ON", "K_OR",
"K_ORDER", "K_OUTER", "K_PLAN", "K_PRAGMA", "K_PRIMARY", "K_QUERY", "K_RAISE",
"K_RECURSIVE", "K_REFERENCES", "K_REGEXP", "K_REINDEX", "K_RELEASE", "K_RENAME",
"K_REPLACE", "K_RESTRICT", "K_RIGHT", "K_ROLLBACK", "K_ROW", "K_SAVEPOINT",
"K_SELECT", "K_SET", "K_TABLE", "K_TEMP", "K_TEMPORARY", "K_THEN", "K_TO",
"K_TRANSACTION", "K_TRIGGER", "K_UNION", "K_UNIQUE", "K_UPDATE", "K_USING",
"K_VACUUM", "K_VALUES", "K_VIEW", "K_VIRTUAL", "K_WHEN", "K_WHERE", "K_WITH",
"K_WITHOUT", "WITHOUT_ROWID", "DO_NOTHING", "DO_UPDATE", "IDENTIFIER",
"NUMERIC_LITERAL", "BIND_PARAMETER", "STRING_LITERAL", "BLOB_LITERAL",
"SINGLE_LINE_COMMENT", "MULTILINE_COMMENT", "SPACES", "UNEXPECTED_CHAR"
};
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "<INVALID>";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "SQLite.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public SQLiteParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ParseContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(SQLiteParser.EOF, 0); }
public List<Sql_stmt_listContext> sql_stmt_list() {
return getRuleContexts(Sql_stmt_listContext.class);
}
public Sql_stmt_listContext sql_stmt_list(int i) {
return getRuleContext(Sql_stmt_listContext.class,i);
}
public List<ErrorContext> error() {
return getRuleContexts(ErrorContext.class);
}
public ErrorContext error(int i) {
return getRuleContext(ErrorContext.class,i);
}
public ParseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parse; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterParse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitParse(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitParse(this);
else return visitor.visitChildren(this);
}
}
public final ParseContext parse() throws RecognitionException {
ParseContext _localctx = new ParseContext(_ctx, getState());
enterRule(_localctx, 0, RULE_parse);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(174);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SCOL) | (1L << K_ALTER) | (1L << K_ANALYZE) | (1L << K_ATTACH) | (1L << K_BEGIN) | (1L << K_COMMIT) | (1L << K_CREATE) | (1L << K_DELETE) | (1L << K_DETACH))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (K_DROP - 65)) | (1L << (K_END - 65)) | (1L << (K_EXPLAIN - 65)) | (1L << (K_INSERT - 65)) | (1L << (K_PRAGMA - 65)) | (1L << (K_REINDEX - 65)) | (1L << (K_RELEASE - 65)) | (1L << (K_REPLACE - 65)) | (1L << (K_ROLLBACK - 65)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (K_SAVEPOINT - 129)) | (1L << (K_SELECT - 129)) | (1L << (K_UPDATE - 129)) | (1L << (K_VACUUM - 129)) | (1L << (K_VALUES - 129)) | (1L << (K_WITH - 129)) | (1L << (UNEXPECTED_CHAR - 129)))) != 0)) {
{
setState(172);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SCOL:
case K_ALTER:
case K_ANALYZE:
case K_ATTACH:
case K_BEGIN:
case K_COMMIT:
case K_CREATE:
case K_DELETE:
case K_DETACH:
case K_DROP:
case K_END:
case K_EXPLAIN:
case K_INSERT:
case K_PRAGMA:
case K_REINDEX:
case K_RELEASE:
case K_REPLACE:
case K_ROLLBACK:
case K_SAVEPOINT:
case K_SELECT:
case K_UPDATE:
case K_VACUUM:
case K_VALUES:
case K_WITH:
{
setState(170);
sql_stmt_list();
}
break;
case UNEXPECTED_CHAR:
{
setState(171);
error();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(176);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(177);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ErrorContext extends ParserRuleContext {
public Token UNEXPECTED_CHAR;
public TerminalNode UNEXPECTED_CHAR() { return getToken(SQLiteParser.UNEXPECTED_CHAR, 0); }
public ErrorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_error; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterError(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitError(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitError(this);
else return visitor.visitChildren(this);
}
}
public final ErrorContext error() throws RecognitionException {
ErrorContext _localctx = new ErrorContext(_ctx, getState());
enterRule(_localctx, 2, RULE_error);
try {
enterOuterAlt(_localctx, 1);
{
setState(179);
((ErrorContext)_localctx).UNEXPECTED_CHAR = match(UNEXPECTED_CHAR);
throw new RuntimeException("UNEXPECTED_CHAR=" + (((ErrorContext)_localctx).UNEXPECTED_CHAR!=null?((ErrorContext)_localctx).UNEXPECTED_CHAR.getText():null));
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Sql_stmt_listContext extends ParserRuleContext {
public List<Sql_stmtContext> sql_stmt() {
return getRuleContexts(Sql_stmtContext.class);
}
public Sql_stmtContext sql_stmt(int i) {
return getRuleContext(Sql_stmtContext.class,i);
}
public Sql_stmt_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sql_stmt_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterSql_stmt_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitSql_stmt_list(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitSql_stmt_list(this);
else return visitor.visitChildren(this);
}
}
public final Sql_stmt_listContext sql_stmt_list() throws RecognitionException {
Sql_stmt_listContext _localctx = new Sql_stmt_listContext(_ctx, getState());
enterRule(_localctx, 4, RULE_sql_stmt_list);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(185);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SCOL) {
{
{
setState(182);
match(SCOL);
}
}
setState(187);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(188);
sql_stmt();
setState(197);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(190);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(189);
match(SCOL);
}
}
setState(192);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==SCOL );
setState(194);
sql_stmt();
}
}
}
setState(199);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
}
setState(203);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(200);
match(SCOL);
}
}
}
setState(205);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Sql_stmtContext extends ParserRuleContext {
public Alter_table_stmtContext alter_table_stmt() {
return getRuleContext(Alter_table_stmtContext.class,0);
}
public Analyze_stmtContext analyze_stmt() {
return getRuleContext(Analyze_stmtContext.class,0);
}
public Attach_stmtContext attach_stmt() {
return getRuleContext(Attach_stmtContext.class,0);
}
public Begin_stmtContext begin_stmt() {
return getRuleContext(Begin_stmtContext.class,0);
}
public Commit_stmtContext commit_stmt() {
return getRuleContext(Commit_stmtContext.class,0);
}
public Create_index_stmtContext create_index_stmt() {
return getRuleContext(Create_index_stmtContext.class,0);
}
public Create_table_stmtContext create_table_stmt() {
return getRuleContext(Create_table_stmtContext.class,0);
}
public Create_trigger_stmtContext create_trigger_stmt() {
return getRuleContext(Create_trigger_stmtContext.class,0);
}
public Create_view_stmtContext create_view_stmt() {
return getRuleContext(Create_view_stmtContext.class,0);
}
public Create_virtual_table_stmtContext create_virtual_table_stmt() {
return getRuleContext(Create_virtual_table_stmtContext.class,0);
}
public Delete_stmtContext delete_stmt() {
return getRuleContext(Delete_stmtContext.class,0);
}
public Delete_stmt_limitedContext delete_stmt_limited() {
return getRuleContext(Delete_stmt_limitedContext.class,0);
}
public Detach_stmtContext detach_stmt() {
return getRuleContext(Detach_stmtContext.class,0);
}
public Drop_index_stmtContext drop_index_stmt() {
return getRuleContext(Drop_index_stmtContext.class,0);
}
public Drop_table_stmtContext drop_table_stmt() {
return getRuleContext(Drop_table_stmtContext.class,0);
}
public Drop_trigger_stmtContext drop_trigger_stmt() {
return getRuleContext(Drop_trigger_stmtContext.class,0);
}
public Drop_view_stmtContext drop_view_stmt() {
return getRuleContext(Drop_view_stmtContext.class,0);
}
public Insert_stmtContext insert_stmt() {
return getRuleContext(Insert_stmtContext.class,0);
}
public Pragma_stmtContext pragma_stmt() {
return getRuleContext(Pragma_stmtContext.class,0);
}
public Reindex_stmtContext reindex_stmt() {
return getRuleContext(Reindex_stmtContext.class,0);
}
public Release_stmtContext release_stmt() {
return getRuleContext(Release_stmtContext.class,0);
}
public Rollback_stmtContext rollback_stmt() {
return getRuleContext(Rollback_stmtContext.class,0);
}
public Savepoint_stmtContext savepoint_stmt() {
return getRuleContext(Savepoint_stmtContext.class,0);
}
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public Update_stmtContext update_stmt() {
return getRuleContext(Update_stmtContext.class,0);
}
public Update_stmt_limitedContext update_stmt_limited() {
return getRuleContext(Update_stmt_limitedContext.class,0);
}
public Vacuum_stmtContext vacuum_stmt() {
return getRuleContext(Vacuum_stmtContext.class,0);
}
public TerminalNode K_EXPLAIN() { return getToken(SQLiteParser.K_EXPLAIN, 0); }
public TerminalNode K_QUERY() { return getToken(SQLiteParser.K_QUERY, 0); }
public TerminalNode K_PLAN() { return getToken(SQLiteParser.K_PLAN, 0); }
public Sql_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sql_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterSql_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitSql_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitSql_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Sql_stmtContext sql_stmt() throws RecognitionException {
Sql_stmtContext _localctx = new Sql_stmtContext(_ctx, getState());
enterRule(_localctx, 6, RULE_sql_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(211);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_EXPLAIN) {
{
setState(206);
match(K_EXPLAIN);
setState(209);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_QUERY) {
{
setState(207);
match(K_QUERY);
setState(208);
match(K_PLAN);
}
}
}
}
setState(240);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
{
setState(213);
alter_table_stmt();
}
break;
case 2:
{
setState(214);
analyze_stmt();
}
break;
case 3:
{
setState(215);
attach_stmt();
}
break;
case 4:
{
setState(216);
begin_stmt();
}
break;
case 5:
{
setState(217);
commit_stmt();
}
break;
case 6:
{
setState(218);
create_index_stmt();
}
break;
case 7:
{
setState(219);
create_table_stmt();
}
break;
case 8:
{
setState(220);
create_trigger_stmt();
}
break;
case 9:
{
setState(221);
create_view_stmt();
}
break;
case 10:
{
setState(222);
create_virtual_table_stmt();
}
break;
case 11:
{
setState(223);
delete_stmt();
}
break;
case 12:
{
setState(224);
delete_stmt_limited();
}
break;
case 13:
{
setState(225);
detach_stmt();
}
break;
case 14:
{
setState(226);
drop_index_stmt();
}
break;
case 15:
{
setState(227);
drop_table_stmt();
}
break;
case 16:
{
setState(228);
drop_trigger_stmt();
}
break;
case 17:
{
setState(229);
drop_view_stmt();
}
break;
case 18:
{
setState(230);
insert_stmt();
}
break;
case 19:
{
setState(231);
pragma_stmt();
}
break;
case 20:
{
setState(232);
reindex_stmt();
}
break;
case 21:
{
setState(233);
release_stmt();
}
break;
case 22:
{
setState(234);
rollback_stmt();
}
break;
case 23:
{
setState(235);
savepoint_stmt();
}
break;
case 24:
{
setState(236);
select_stmt();
}
break;
case 25:
{
setState(237);
update_stmt();
}
break;
case 26:
{
setState(238);
update_stmt_limited();
}
break;
case 27:
{
setState(239);
vacuum_stmt();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Alter_table_stmtContext extends ParserRuleContext {
public TerminalNode K_ALTER() { return getToken(SQLiteParser.K_ALTER, 0); }
public TerminalNode K_TABLE() { return getToken(SQLiteParser.K_TABLE, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode K_RENAME() { return getToken(SQLiteParser.K_RENAME, 0); }
public TerminalNode K_TO() { return getToken(SQLiteParser.K_TO, 0); }
public New_table_nameContext new_table_name() {
return getRuleContext(New_table_nameContext.class,0);
}
public TerminalNode K_ADD() { return getToken(SQLiteParser.K_ADD, 0); }
public Column_defContext column_def() {
return getRuleContext(Column_defContext.class,0);
}
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode K_COLUMN() { return getToken(SQLiteParser.K_COLUMN, 0); }
public Alter_table_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alter_table_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterAlter_table_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitAlter_table_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitAlter_table_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Alter_table_stmtContext alter_table_stmt() throws RecognitionException {
Alter_table_stmtContext _localctx = new Alter_table_stmtContext(_ctx, getState());
enterRule(_localctx, 8, RULE_alter_table_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(242);
match(K_ALTER);
setState(243);
match(K_TABLE);
setState(247);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
setState(244);
schema_name();
setState(245);
match(DOT);
}
break;
}
setState(249);
table_name();
setState(258);
_errHandler.sync(this);
switch (_input.LA(1)) {
case K_RENAME:
{
setState(250);
match(K_RENAME);
setState(251);
match(K_TO);
setState(252);
new_table_name();
}
break;
case K_ADD:
{
setState(253);
match(K_ADD);
setState(255);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(254);
match(K_COLUMN);
}
break;
}
setState(257);
column_def();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Analyze_stmtContext extends ParserRuleContext {
public TerminalNode K_ANALYZE() { return getToken(SQLiteParser.K_ANALYZE, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public Table_or_index_nameContext table_or_index_name() {
return getRuleContext(Table_or_index_nameContext.class,0);
}
public Analyze_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_analyze_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterAnalyze_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitAnalyze_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitAnalyze_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Analyze_stmtContext analyze_stmt() throws RecognitionException {
Analyze_stmtContext _localctx = new Analyze_stmtContext(_ctx, getState());
enterRule(_localctx, 10, RULE_analyze_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(260);
match(K_ANALYZE);
setState(267);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
{
setState(261);
schema_name();
}
break;
case 2:
{
setState(262);
table_or_index_name();
}
break;
case 3:
{
setState(263);
schema_name();
setState(264);
match(DOT);
setState(265);
table_or_index_name();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Attach_stmtContext extends ParserRuleContext {
public TerminalNode K_ATTACH() { return getToken(SQLiteParser.K_ATTACH, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode K_AS() { return getToken(SQLiteParser.K_AS, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode K_DATABASE() { return getToken(SQLiteParser.K_DATABASE, 0); }
public Attach_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attach_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterAttach_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitAttach_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitAttach_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Attach_stmtContext attach_stmt() throws RecognitionException {
Attach_stmtContext _localctx = new Attach_stmtContext(_ctx, getState());
enterRule(_localctx, 12, RULE_attach_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(269);
match(K_ATTACH);
setState(271);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
setState(270);
match(K_DATABASE);
}
break;
}
setState(273);
expr(0);
setState(274);
match(K_AS);
setState(275);
schema_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Begin_stmtContext extends ParserRuleContext {
public TerminalNode K_BEGIN() { return getToken(SQLiteParser.K_BEGIN, 0); }
public TerminalNode K_TRANSACTION() { return getToken(SQLiteParser.K_TRANSACTION, 0); }
public TerminalNode K_DEFERRED() { return getToken(SQLiteParser.K_DEFERRED, 0); }
public TerminalNode K_IMMEDIATE() { return getToken(SQLiteParser.K_IMMEDIATE, 0); }
public TerminalNode K_EXCLUSIVE() { return getToken(SQLiteParser.K_EXCLUSIVE, 0); }
public Transaction_nameContext transaction_name() {
return getRuleContext(Transaction_nameContext.class,0);
}
public Begin_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_begin_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterBegin_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitBegin_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitBegin_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Begin_stmtContext begin_stmt() throws RecognitionException {
Begin_stmtContext _localctx = new Begin_stmtContext(_ctx, getState());
enterRule(_localctx, 14, RULE_begin_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(277);
match(K_BEGIN);
setState(279);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (K_DEFERRED - 60)) | (1L << (K_EXCLUSIVE - 60)) | (1L << (K_IMMEDIATE - 60)))) != 0)) {
{
setState(278);
_la = _input.LA(1);
if ( !(((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (K_DEFERRED - 60)) | (1L << (K_EXCLUSIVE - 60)) | (1L << (K_IMMEDIATE - 60)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(285);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_TRANSACTION) {
{
setState(281);
match(K_TRANSACTION);
setState(283);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
{
setState(282);
transaction_name();
}
break;
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Commit_stmtContext extends ParserRuleContext {
public TerminalNode K_COMMIT() { return getToken(SQLiteParser.K_COMMIT, 0); }
public TerminalNode K_END() { return getToken(SQLiteParser.K_END, 0); }
public TerminalNode K_TRANSACTION() { return getToken(SQLiteParser.K_TRANSACTION, 0); }
public Transaction_nameContext transaction_name() {
return getRuleContext(Transaction_nameContext.class,0);
}
public Commit_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commit_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterCommit_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitCommit_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitCommit_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Commit_stmtContext commit_stmt() throws RecognitionException {
Commit_stmtContext _localctx = new Commit_stmtContext(_ctx, getState());
enterRule(_localctx, 16, RULE_commit_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(287);
_la = _input.LA(1);
if ( !(_la==K_COMMIT || _la==K_END) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(292);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_TRANSACTION) {
{
setState(288);
match(K_TRANSACTION);
setState(290);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
{
setState(289);
transaction_name();
}
break;
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Create_index_stmtContext extends ParserRuleContext {
public TerminalNode K_CREATE() { return getToken(SQLiteParser.K_CREATE, 0); }
public TerminalNode K_INDEX() { return getToken(SQLiteParser.K_INDEX, 0); }
public Index_nameContext index_name() {
return getRuleContext(Index_nameContext.class,0);
}
public TerminalNode K_ON() { return getToken(SQLiteParser.K_ON, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public List<Indexed_columnContext> indexed_column() {
return getRuleContexts(Indexed_columnContext.class);
}
public Indexed_columnContext indexed_column(int i) {
return getRuleContext(Indexed_columnContext.class,i);
}
public TerminalNode K_UNIQUE() { return getToken(SQLiteParser.K_UNIQUE, 0); }
public TerminalNode K_IF() { return getToken(SQLiteParser.K_IF, 0); }
public TerminalNode K_NOT() { return getToken(SQLiteParser.K_NOT, 0); }
public TerminalNode K_EXISTS() { return getToken(SQLiteParser.K_EXISTS, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode K_WHERE() { return getToken(SQLiteParser.K_WHERE, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Create_index_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_index_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterCreate_index_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitCreate_index_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitCreate_index_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Create_index_stmtContext create_index_stmt() throws RecognitionException {
Create_index_stmtContext _localctx = new Create_index_stmtContext(_ctx, getState());
enterRule(_localctx, 18, RULE_create_index_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(294);
match(K_CREATE);
setState(296);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_UNIQUE) {
{
setState(295);
match(K_UNIQUE);
}
}
setState(298);
match(K_INDEX);
setState(302);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
{
setState(299);
match(K_IF);
setState(300);
match(K_NOT);
setState(301);
match(K_EXISTS);
}
break;
}
setState(307);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
{
setState(304);
schema_name();
setState(305);
match(DOT);
}
break;
}
setState(309);
index_name();
setState(310);
match(K_ON);
setState(311);
table_name();
setState(312);
match(OPEN_PAR);
setState(313);
indexed_column();
setState(318);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(314);
match(COMMA);
setState(315);
indexed_column();
}
}
setState(320);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(321);
match(CLOSE_PAR);
setState(324);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WHERE) {
{
setState(322);
match(K_WHERE);
setState(323);
expr(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Create_table_stmtContext extends ParserRuleContext {
public TerminalNode K_CREATE() { return getToken(SQLiteParser.K_CREATE, 0); }
public TerminalNode K_TABLE() { return getToken(SQLiteParser.K_TABLE, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public List<Column_defContext> column_def() {
return getRuleContexts(Column_defContext.class);
}
public Column_defContext column_def(int i) {
return getRuleContext(Column_defContext.class,i);
}
public TerminalNode K_AS() { return getToken(SQLiteParser.K_AS, 0); }
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public TerminalNode K_IF() { return getToken(SQLiteParser.K_IF, 0); }
public TerminalNode K_NOT() { return getToken(SQLiteParser.K_NOT, 0); }
public TerminalNode K_EXISTS() { return getToken(SQLiteParser.K_EXISTS, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode K_TEMP() { return getToken(SQLiteParser.K_TEMP, 0); }
public TerminalNode K_TEMPORARY() { return getToken(SQLiteParser.K_TEMPORARY, 0); }
public List<Table_constraintContext> table_constraint() {
return getRuleContexts(Table_constraintContext.class);
}
public Table_constraintContext table_constraint(int i) {
return getRuleContext(Table_constraintContext.class,i);
}
public TerminalNode WITHOUT_ROWID() { return getToken(SQLiteParser.WITHOUT_ROWID, 0); }
public Create_table_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_table_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterCreate_table_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitCreate_table_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitCreate_table_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Create_table_stmtContext create_table_stmt() throws RecognitionException {
Create_table_stmtContext _localctx = new Create_table_stmtContext(_ctx, getState());
enterRule(_localctx, 20, RULE_create_table_stmt);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(326);
match(K_CREATE);
setState(328);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_TEMP || _la==K_TEMPORARY) {
{
setState(327);
_la = _input.LA(1);
if ( !(_la==K_TEMP || _la==K_TEMPORARY) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(330);
match(K_TABLE);
setState(334);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(331);
match(K_IF);
setState(332);
match(K_NOT);
setState(333);
match(K_EXISTS);
}
break;
}
setState(339);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
{
setState(336);
schema_name();
setState(337);
match(DOT);
}
break;
}
setState(341);
table_name();
setState(364);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_PAR:
{
setState(342);
match(OPEN_PAR);
setState(343);
column_def();
setState(348);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,27,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(344);
match(COMMA);
setState(345);
column_def();
}
}
}
setState(350);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,27,_ctx);
}
setState(355);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(351);
match(COMMA);
setState(352);
table_constraint();
}
}
setState(357);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(358);
match(CLOSE_PAR);
setState(360);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITHOUT_ROWID) {
{
setState(359);
match(WITHOUT_ROWID);
}
}
}
break;
case K_AS:
{
setState(362);
match(K_AS);
setState(363);
select_stmt();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Create_trigger_stmtContext extends ParserRuleContext {
public TerminalNode K_CREATE() { return getToken(SQLiteParser.K_CREATE, 0); }
public TerminalNode K_TRIGGER() { return getToken(SQLiteParser.K_TRIGGER, 0); }
public Trigger_nameContext trigger_name() {
return getRuleContext(Trigger_nameContext.class,0);
}
public TerminalNode K_ON() { return getToken(SQLiteParser.K_ON, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode K_BEGIN() { return getToken(SQLiteParser.K_BEGIN, 0); }
public TerminalNode K_END() { return getToken(SQLiteParser.K_END, 0); }
public TerminalNode K_DELETE() { return getToken(SQLiteParser.K_DELETE, 0); }
public TerminalNode K_INSERT() { return getToken(SQLiteParser.K_INSERT, 0); }
public TerminalNode K_UPDATE() { return getToken(SQLiteParser.K_UPDATE, 0); }
public TerminalNode K_IF() { return getToken(SQLiteParser.K_IF, 0); }
public TerminalNode K_NOT() { return getToken(SQLiteParser.K_NOT, 0); }
public TerminalNode K_EXISTS() { return getToken(SQLiteParser.K_EXISTS, 0); }
public List<Schema_nameContext> schema_name() {
return getRuleContexts(Schema_nameContext.class);
}
public Schema_nameContext schema_name(int i) {
return getRuleContext(Schema_nameContext.class,i);
}
public TerminalNode K_BEFORE() { return getToken(SQLiteParser.K_BEFORE, 0); }
public TerminalNode K_AFTER() { return getToken(SQLiteParser.K_AFTER, 0); }
public TerminalNode K_INSTEAD() { return getToken(SQLiteParser.K_INSTEAD, 0); }
public List<TerminalNode> K_OF() { return getTokens(SQLiteParser.K_OF); }
public TerminalNode K_OF(int i) {
return getToken(SQLiteParser.K_OF, i);
}
public TerminalNode K_FOR() { return getToken(SQLiteParser.K_FOR, 0); }
public TerminalNode K_EACH() { return getToken(SQLiteParser.K_EACH, 0); }
public TerminalNode K_ROW() { return getToken(SQLiteParser.K_ROW, 0); }
public TerminalNode K_WHEN() { return getToken(SQLiteParser.K_WHEN, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode K_TEMP() { return getToken(SQLiteParser.K_TEMP, 0); }
public TerminalNode K_TEMPORARY() { return getToken(SQLiteParser.K_TEMPORARY, 0); }
public List<Column_nameContext> column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public List<Update_stmtContext> update_stmt() {
return getRuleContexts(Update_stmtContext.class);
}
public Update_stmtContext update_stmt(int i) {
return getRuleContext(Update_stmtContext.class,i);
}
public List<Insert_stmtContext> insert_stmt() {
return getRuleContexts(Insert_stmtContext.class);
}
public Insert_stmtContext insert_stmt(int i) {
return getRuleContext(Insert_stmtContext.class,i);
}
public List<Delete_stmtContext> delete_stmt() {
return getRuleContexts(Delete_stmtContext.class);
}
public Delete_stmtContext delete_stmt(int i) {
return getRuleContext(Delete_stmtContext.class,i);
}
public List<Select_stmtContext> select_stmt() {
return getRuleContexts(Select_stmtContext.class);
}
public Select_stmtContext select_stmt(int i) {
return getRuleContext(Select_stmtContext.class,i);
}
public Create_trigger_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_trigger_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterCreate_trigger_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitCreate_trigger_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitCreate_trigger_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Create_trigger_stmtContext create_trigger_stmt() throws RecognitionException {
Create_trigger_stmtContext _localctx = new Create_trigger_stmtContext(_ctx, getState());
enterRule(_localctx, 22, RULE_create_trigger_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(366);
match(K_CREATE);
setState(368);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_TEMP || _la==K_TEMPORARY) {
{
setState(367);
_la = _input.LA(1);
if ( !(_la==K_TEMP || _la==K_TEMPORARY) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(370);
match(K_TRIGGER);
setState(374);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
case 1:
{
setState(371);
match(K_IF);
setState(372);
match(K_NOT);
setState(373);
match(K_EXISTS);
}
break;
}
setState(379);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
{
setState(376);
schema_name();
setState(377);
match(DOT);
}
break;
}
setState(381);
trigger_name();
setState(386);
_errHandler.sync(this);
switch (_input.LA(1)) {
case K_BEFORE:
{
setState(382);
match(K_BEFORE);
}
break;
case K_AFTER:
{
setState(383);
match(K_AFTER);
}
break;
case K_INSTEAD:
{
setState(384);
match(K_INSTEAD);
setState(385);
match(K_OF);
}
break;
case K_DELETE:
case K_INSERT:
case K_UPDATE:
break;
default:
break;
}
setState(402);
_errHandler.sync(this);
switch (_input.LA(1)) {
case K_DELETE:
{
setState(388);
match(K_DELETE);
}
break;
case K_INSERT:
{
setState(389);
match(K_INSERT);
}
break;
case K_UPDATE:
{
setState(390);
match(K_UPDATE);
setState(400);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_OF) {
{
setState(391);
match(K_OF);
setState(392);
column_name();
setState(397);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(393);
match(COMMA);
setState(394);
column_name();
}
}
setState(399);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(404);
match(K_ON);
setState(408);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
case 1:
{
setState(405);
schema_name();
setState(406);
match(DOT);
}
break;
}
setState(410);
table_name();
setState(414);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_FOR) {
{
setState(411);
match(K_FOR);
setState(412);
match(K_EACH);
setState(413);
match(K_ROW);
}
}
setState(418);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WHEN) {
{
setState(416);
match(K_WHEN);
setState(417);
expr(0);
}
}
setState(420);
match(K_BEGIN);
setState(429);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(425);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
case 1:
{
setState(421);
update_stmt();
}
break;
case 2:
{
setState(422);
insert_stmt();
}
break;
case 3:
{
setState(423);
delete_stmt();
}
break;
case 4:
{
setState(424);
select_stmt();
}
break;
}
setState(427);
match(SCOL);
}
}
setState(431);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==K_DELETE || ((((_la - 90)) & ~0x3f) == 0 && ((1L << (_la - 90)) & ((1L << (K_INSERT - 90)) | (1L << (K_REPLACE - 90)) | (1L << (K_SELECT - 90)) | (1L << (K_UPDATE - 90)) | (1L << (K_VALUES - 90)) | (1L << (K_WITH - 90)))) != 0) );
setState(433);
match(K_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Create_view_stmtContext extends ParserRuleContext {
public TerminalNode K_CREATE() { return getToken(SQLiteParser.K_CREATE, 0); }
public TerminalNode K_VIEW() { return getToken(SQLiteParser.K_VIEW, 0); }
public View_nameContext view_name() {
return getRuleContext(View_nameContext.class,0);
}
public TerminalNode K_AS() { return getToken(SQLiteParser.K_AS, 0); }
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public TerminalNode K_IF() { return getToken(SQLiteParser.K_IF, 0); }
public TerminalNode K_NOT() { return getToken(SQLiteParser.K_NOT, 0); }
public TerminalNode K_EXISTS() { return getToken(SQLiteParser.K_EXISTS, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public List<Column_nameContext> column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public TerminalNode K_TEMP() { return getToken(SQLiteParser.K_TEMP, 0); }
public TerminalNode K_TEMPORARY() { return getToken(SQLiteParser.K_TEMPORARY, 0); }
public Create_view_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_view_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterCreate_view_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitCreate_view_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitCreate_view_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Create_view_stmtContext create_view_stmt() throws RecognitionException {
Create_view_stmtContext _localctx = new Create_view_stmtContext(_ctx, getState());
enterRule(_localctx, 24, RULE_create_view_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(435);
match(K_CREATE);
setState(437);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_TEMP || _la==K_TEMPORARY) {
{
setState(436);
_la = _input.LA(1);
if ( !(_la==K_TEMP || _la==K_TEMPORARY) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(439);
match(K_VIEW);
setState(443);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(440);
match(K_IF);
setState(441);
match(K_NOT);
setState(442);
match(K_EXISTS);
}
break;
}
setState(448);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
{
setState(445);
schema_name();
setState(446);
match(DOT);
}
break;
}
setState(450);
view_name();
setState(459);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
case 1:
{
setState(451);
column_name();
setState(456);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(452);
match(COMMA);
setState(453);
column_name();
}
}
setState(458);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(461);
match(K_AS);
setState(462);
select_stmt();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Create_virtual_table_stmtContext extends ParserRuleContext {
public TerminalNode K_CREATE() { return getToken(SQLiteParser.K_CREATE, 0); }
public TerminalNode K_VIRTUAL() { return getToken(SQLiteParser.K_VIRTUAL, 0); }
public TerminalNode K_TABLE() { return getToken(SQLiteParser.K_TABLE, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode K_USING() { return getToken(SQLiteParser.K_USING, 0); }
public Module_nameContext module_name() {
return getRuleContext(Module_nameContext.class,0);
}
public TerminalNode K_IF() { return getToken(SQLiteParser.K_IF, 0); }
public TerminalNode K_NOT() { return getToken(SQLiteParser.K_NOT, 0); }
public TerminalNode K_EXISTS() { return getToken(SQLiteParser.K_EXISTS, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public List<Module_argumentContext> module_argument() {
return getRuleContexts(Module_argumentContext.class);
}
public Module_argumentContext module_argument(int i) {
return getRuleContext(Module_argumentContext.class,i);
}
public Create_virtual_table_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_virtual_table_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterCreate_virtual_table_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitCreate_virtual_table_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitCreate_virtual_table_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Create_virtual_table_stmtContext create_virtual_table_stmt() throws RecognitionException {
Create_virtual_table_stmtContext _localctx = new Create_virtual_table_stmtContext(_ctx, getState());
enterRule(_localctx, 26, RULE_create_virtual_table_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(464);
match(K_CREATE);
setState(465);
match(K_VIRTUAL);
setState(466);
match(K_TABLE);
setState(470);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
case 1:
{
setState(467);
match(K_IF);
setState(468);
match(K_NOT);
setState(469);
match(K_EXISTS);
}
break;
}
setState(475);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
case 1:
{
setState(472);
schema_name();
setState(473);
match(DOT);
}
break;
}
setState(477);
table_name();
setState(478);
match(K_USING);
setState(479);
module_name();
setState(491);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(480);
match(OPEN_PAR);
setState(481);
module_argument();
setState(486);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(482);
match(COMMA);
setState(483);
module_argument();
}
}
setState(488);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(489);
match(CLOSE_PAR);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Delete_stmtContext extends ParserRuleContext {
public TerminalNode K_DELETE() { return getToken(SQLiteParser.K_DELETE, 0); }
public TerminalNode K_FROM() { return getToken(SQLiteParser.K_FROM, 0); }
public Qualified_table_nameContext qualified_table_name() {
return getRuleContext(Qualified_table_nameContext.class,0);
}
public With_clauseContext with_clause() {
return getRuleContext(With_clauseContext.class,0);
}
public TerminalNode K_WHERE() { return getToken(SQLiteParser.K_WHERE, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Delete_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_delete_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterDelete_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitDelete_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitDelete_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Delete_stmtContext delete_stmt() throws RecognitionException {
Delete_stmtContext _localctx = new Delete_stmtContext(_ctx, getState());
enterRule(_localctx, 28, RULE_delete_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(494);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WITH) {
{
setState(493);
with_clause();
}
}
setState(496);
match(K_DELETE);
setState(497);
match(K_FROM);
setState(498);
qualified_table_name();
setState(501);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WHERE) {
{
setState(499);
match(K_WHERE);
setState(500);
expr(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Delete_stmt_limitedContext extends ParserRuleContext {
public TerminalNode K_DELETE() { return getToken(SQLiteParser.K_DELETE, 0); }
public TerminalNode K_FROM() { return getToken(SQLiteParser.K_FROM, 0); }
public Qualified_table_nameContext qualified_table_name() {
return getRuleContext(Qualified_table_nameContext.class,0);
}
public With_clauseContext with_clause() {
return getRuleContext(With_clauseContext.class,0);
}
public TerminalNode K_WHERE() { return getToken(SQLiteParser.K_WHERE, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Limit_clauseContext limit_clause() {
return getRuleContext(Limit_clauseContext.class,0);
}
public Order_clauseContext order_clause() {
return getRuleContext(Order_clauseContext.class,0);
}
public Delete_stmt_limitedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_delete_stmt_limited; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterDelete_stmt_limited(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitDelete_stmt_limited(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitDelete_stmt_limited(this);
else return visitor.visitChildren(this);
}
}
public final Delete_stmt_limitedContext delete_stmt_limited() throws RecognitionException {
Delete_stmt_limitedContext _localctx = new Delete_stmt_limitedContext(_ctx, getState());
enterRule(_localctx, 30, RULE_delete_stmt_limited);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(504);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WITH) {
{
setState(503);
with_clause();
}
}
setState(506);
match(K_DELETE);
setState(507);
match(K_FROM);
setState(508);
qualified_table_name();
setState(511);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WHERE) {
{
setState(509);
match(K_WHERE);
setState(510);
expr(0);
}
}
setState(517);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_LIMIT || _la==K_ORDER) {
{
setState(514);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_ORDER) {
{
setState(513);
order_clause();
}
}
setState(516);
limit_clause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Detach_stmtContext extends ParserRuleContext {
public TerminalNode K_DETACH() { return getToken(SQLiteParser.K_DETACH, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode K_DATABASE() { return getToken(SQLiteParser.K_DATABASE, 0); }
public Detach_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_detach_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterDetach_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitDetach_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitDetach_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Detach_stmtContext detach_stmt() throws RecognitionException {
Detach_stmtContext _localctx = new Detach_stmtContext(_ctx, getState());
enterRule(_localctx, 32, RULE_detach_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(519);
match(K_DETACH);
setState(521);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
case 1:
{
setState(520);
match(K_DATABASE);
}
break;
}
setState(523);
schema_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Drop_index_stmtContext extends ParserRuleContext {
public TerminalNode K_DROP() { return getToken(SQLiteParser.K_DROP, 0); }
public TerminalNode K_INDEX() { return getToken(SQLiteParser.K_INDEX, 0); }
public Index_nameContext index_name() {
return getRuleContext(Index_nameContext.class,0);
}
public TerminalNode K_IF() { return getToken(SQLiteParser.K_IF, 0); }
public TerminalNode K_EXISTS() { return getToken(SQLiteParser.K_EXISTS, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public Drop_index_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_drop_index_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterDrop_index_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitDrop_index_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitDrop_index_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Drop_index_stmtContext drop_index_stmt() throws RecognitionException {
Drop_index_stmtContext _localctx = new Drop_index_stmtContext(_ctx, getState());
enterRule(_localctx, 34, RULE_drop_index_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(525);
match(K_DROP);
setState(526);
match(K_INDEX);
setState(529);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
case 1:
{
setState(527);
match(K_IF);
setState(528);
match(K_EXISTS);
}
break;
}
setState(534);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
case 1:
{
setState(531);
schema_name();
setState(532);
match(DOT);
}
break;
}
setState(536);
index_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Drop_table_stmtContext extends ParserRuleContext {
public TerminalNode K_DROP() { return getToken(SQLiteParser.K_DROP, 0); }
public TerminalNode K_TABLE() { return getToken(SQLiteParser.K_TABLE, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode K_IF() { return getToken(SQLiteParser.K_IF, 0); }
public TerminalNode K_EXISTS() { return getToken(SQLiteParser.K_EXISTS, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public Drop_table_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_drop_table_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterDrop_table_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitDrop_table_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitDrop_table_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Drop_table_stmtContext drop_table_stmt() throws RecognitionException {
Drop_table_stmtContext _localctx = new Drop_table_stmtContext(_ctx, getState());
enterRule(_localctx, 36, RULE_drop_table_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(538);
match(K_DROP);
setState(539);
match(K_TABLE);
setState(542);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
case 1:
{
setState(540);
match(K_IF);
setState(541);
match(K_EXISTS);
}
break;
}
setState(547);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
case 1:
{
setState(544);
schema_name();
setState(545);
match(DOT);
}
break;
}
setState(549);
table_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Drop_trigger_stmtContext extends ParserRuleContext {
public TerminalNode K_DROP() { return getToken(SQLiteParser.K_DROP, 0); }
public TerminalNode K_TRIGGER() { return getToken(SQLiteParser.K_TRIGGER, 0); }
public Trigger_nameContext trigger_name() {
return getRuleContext(Trigger_nameContext.class,0);
}
public TerminalNode K_IF() { return getToken(SQLiteParser.K_IF, 0); }
public TerminalNode K_EXISTS() { return getToken(SQLiteParser.K_EXISTS, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public Drop_trigger_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_drop_trigger_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterDrop_trigger_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitDrop_trigger_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitDrop_trigger_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Drop_trigger_stmtContext drop_trigger_stmt() throws RecognitionException {
Drop_trigger_stmtContext _localctx = new Drop_trigger_stmtContext(_ctx, getState());
enterRule(_localctx, 38, RULE_drop_trigger_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(551);
match(K_DROP);
setState(552);
match(K_TRIGGER);
setState(555);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) {
case 1:
{
setState(553);
match(K_IF);
setState(554);
match(K_EXISTS);
}
break;
}
setState(560);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
case 1:
{
setState(557);
schema_name();
setState(558);
match(DOT);
}
break;
}
setState(562);
trigger_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Drop_view_stmtContext extends ParserRuleContext {
public TerminalNode K_DROP() { return getToken(SQLiteParser.K_DROP, 0); }
public TerminalNode K_VIEW() { return getToken(SQLiteParser.K_VIEW, 0); }
public View_nameContext view_name() {
return getRuleContext(View_nameContext.class,0);
}
public TerminalNode K_IF() { return getToken(SQLiteParser.K_IF, 0); }
public TerminalNode K_EXISTS() { return getToken(SQLiteParser.K_EXISTS, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public Drop_view_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_drop_view_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterDrop_view_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitDrop_view_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitDrop_view_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Drop_view_stmtContext drop_view_stmt() throws RecognitionException {
Drop_view_stmtContext _localctx = new Drop_view_stmtContext(_ctx, getState());
enterRule(_localctx, 40, RULE_drop_view_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(564);
match(K_DROP);
setState(565);
match(K_VIEW);
setState(568);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
{
setState(566);
match(K_IF);
setState(567);
match(K_EXISTS);
}
break;
}
setState(573);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
case 1:
{
setState(570);
schema_name();
setState(571);
match(DOT);
}
break;
}
setState(575);
view_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Insert_stmtContext extends ParserRuleContext {
public TerminalNode K_INTO() { return getToken(SQLiteParser.K_INTO, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode K_INSERT() { return getToken(SQLiteParser.K_INSERT, 0); }
public TerminalNode K_REPLACE() { return getToken(SQLiteParser.K_REPLACE, 0); }
public TerminalNode K_OR() { return getToken(SQLiteParser.K_OR, 0); }
public TerminalNode K_ROLLBACK() { return getToken(SQLiteParser.K_ROLLBACK, 0); }
public TerminalNode K_ABORT() { return getToken(SQLiteParser.K_ABORT, 0); }
public TerminalNode K_FAIL() { return getToken(SQLiteParser.K_FAIL, 0); }
public TerminalNode K_IGNORE() { return getToken(SQLiteParser.K_IGNORE, 0); }
public TerminalNode K_VALUES() { return getToken(SQLiteParser.K_VALUES, 0); }
public List<Comma_separated_exprContext> comma_separated_expr() {
return getRuleContexts(Comma_separated_exprContext.class);
}
public Comma_separated_exprContext comma_separated_expr(int i) {
return getRuleContext(Comma_separated_exprContext.class,i);
}
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public TerminalNode K_DEFAULT() { return getToken(SQLiteParser.K_DEFAULT, 0); }
public With_clauseContext with_clause() {
return getRuleContext(With_clauseContext.class,0);
}
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode K_AS() { return getToken(SQLiteParser.K_AS, 0); }
public Table_aliasContext table_alias() {
return getRuleContext(Table_aliasContext.class,0);
}
public List<Column_nameContext> column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public Upsert_clauseContext upsert_clause() {
return getRuleContext(Upsert_clauseContext.class,0);
}
public Insert_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insert_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterInsert_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitInsert_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitInsert_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Insert_stmtContext insert_stmt() throws RecognitionException {
Insert_stmtContext _localctx = new Insert_stmtContext(_ctx, getState());
enterRule(_localctx, 42, RULE_insert_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(578);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WITH) {
{
setState(577);
with_clause();
}
}
setState(597);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
case 1:
{
setState(580);
match(K_INSERT);
}
break;
case 2:
{
setState(581);
match(K_REPLACE);
}
break;
case 3:
{
setState(582);
match(K_INSERT);
setState(583);
match(K_OR);
setState(584);
match(K_REPLACE);
}
break;
case 4:
{
setState(585);
match(K_INSERT);
setState(586);
match(K_OR);
setState(587);
match(K_ROLLBACK);
}
break;
case 5:
{
setState(588);
match(K_INSERT);
setState(589);
match(K_OR);
setState(590);
match(K_ABORT);
}
break;
case 6:
{
setState(591);
match(K_INSERT);
setState(592);
match(K_OR);
setState(593);
match(K_FAIL);
}
break;
case 7:
{
setState(594);
match(K_INSERT);
setState(595);
match(K_OR);
setState(596);
match(K_IGNORE);
}
break;
}
setState(599);
match(K_INTO);
setState(603);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
case 1:
{
setState(600);
schema_name();
setState(601);
match(DOT);
}
break;
}
setState(605);
table_name();
setState(608);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_AS) {
{
setState(606);
match(K_AS);
setState(607);
table_alias();
}
}
setState(621);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(610);
match(OPEN_PAR);
setState(611);
column_name();
setState(616);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(612);
match(COMMA);
setState(613);
column_name();
}
}
setState(618);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(619);
match(CLOSE_PAR);
}
}
setState(640);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
case 1:
{
setState(623);
match(K_VALUES);
setState(624);
match(OPEN_PAR);
setState(625);
comma_separated_expr();
setState(626);
match(CLOSE_PAR);
setState(634);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(627);
match(COMMA);
setState(628);
match(OPEN_PAR);
setState(629);
comma_separated_expr();
setState(630);
match(CLOSE_PAR);
}
}
setState(636);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
{
setState(637);
select_stmt();
}
break;
case 3:
{
setState(638);
match(K_DEFAULT);
setState(639);
match(K_VALUES);
}
break;
}
setState(643);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_ON) {
{
setState(642);
upsert_clause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Upsert_clauseContext extends ParserRuleContext {
public TerminalNode K_ON() { return getToken(SQLiteParser.K_ON, 0); }
public TerminalNode K_CONFLICT() { return getToken(SQLiteParser.K_CONFLICT, 0); }
public TerminalNode DO_NOTHING() { return getToken(SQLiteParser.DO_NOTHING, 0); }
public TerminalNode DO_UPDATE() { return getToken(SQLiteParser.DO_UPDATE, 0); }
public TerminalNode K_SET() { return getToken(SQLiteParser.K_SET, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List<Indexed_columnContext> indexed_column() {
return getRuleContexts(Indexed_columnContext.class);
}
public Indexed_columnContext indexed_column(int i) {
return getRuleContext(Indexed_columnContext.class,i);
}
public List<Column_nameContext> column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public List<Column_name_listContext> column_name_list() {
return getRuleContexts(Column_name_listContext.class);
}
public Column_name_listContext column_name_list(int i) {
return getRuleContext(Column_name_listContext.class,i);
}
public List<TerminalNode> K_WHERE() { return getTokens(SQLiteParser.K_WHERE); }
public TerminalNode K_WHERE(int i) {
return getToken(SQLiteParser.K_WHERE, i);
}
public Upsert_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_upsert_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterUpsert_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitUpsert_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitUpsert_clause(this);
else return visitor.visitChildren(this);
}
}
public final Upsert_clauseContext upsert_clause() throws RecognitionException {
Upsert_clauseContext _localctx = new Upsert_clauseContext(_ctx, getState());
enterRule(_localctx, 44, RULE_upsert_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(645);
match(K_ON);
setState(646);
match(K_CONFLICT);
setState(661);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(647);
match(OPEN_PAR);
setState(648);
indexed_column();
setState(653);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(649);
match(COMMA);
setState(650);
indexed_column();
}
}
setState(655);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(656);
match(CLOSE_PAR);
setState(659);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WHERE) {
{
setState(657);
match(K_WHERE);
setState(658);
expr(0);
}
}
}
}
setState(689);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DO_NOTHING:
{
setState(663);
match(DO_NOTHING);
}
break;
case DO_UPDATE:
{
setState(664);
match(DO_UPDATE);
setState(665);
match(K_SET);
setState(668);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
case 1:
{
setState(666);
column_name();
}
break;
case 2:
{
setState(667);
column_name_list();
}
break;
}
setState(670);
match(ASSIGN);
setState(671);
expr(0);
setState(682);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(672);
match(COMMA);
setState(675);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
case 1:
{
setState(673);
column_name();
}
break;
case 2:
{
setState(674);
column_name_list();
}
break;
}
setState(677);
match(ASSIGN);
setState(678);
expr(0);
}
}
setState(684);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(687);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WHERE) {
{
setState(685);
match(K_WHERE);
setState(686);
expr(0);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Pragma_stmtContext extends ParserRuleContext {
public TerminalNode K_PRAGMA() { return getToken(SQLiteParser.K_PRAGMA, 0); }
public Pragma_nameContext pragma_name() {
return getRuleContext(Pragma_nameContext.class,0);
}
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public Pragma_valueContext pragma_value() {
return getRuleContext(Pragma_valueContext.class,0);
}
public Pragma_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pragma_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterPragma_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitPragma_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitPragma_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Pragma_stmtContext pragma_stmt() throws RecognitionException {
Pragma_stmtContext _localctx = new Pragma_stmtContext(_ctx, getState());
enterRule(_localctx, 46, RULE_pragma_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(691);
match(K_PRAGMA);
setState(695);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
case 1:
{
setState(692);
schema_name();
setState(693);
match(DOT);
}
break;
}
setState(697);
pragma_name();
setState(704);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ASSIGN:
{
setState(698);
match(ASSIGN);
setState(699);
pragma_value();
}
break;
case OPEN_PAR:
{
setState(700);
match(OPEN_PAR);
setState(701);
pragma_value();
setState(702);
match(CLOSE_PAR);
}
break;
case EOF:
case SCOL:
case K_ALTER:
case K_ANALYZE:
case K_ATTACH:
case K_BEGIN:
case K_COMMIT:
case K_CREATE:
case K_DELETE:
case K_DETACH:
case K_DROP:
case K_END:
case K_EXPLAIN:
case K_INSERT:
case K_PRAGMA:
case K_REINDEX:
case K_RELEASE:
case K_REPLACE:
case K_ROLLBACK:
case K_SAVEPOINT:
case K_SELECT:
case K_UPDATE:
case K_VACUUM:
case K_VALUES:
case K_WITH:
case UNEXPECTED_CHAR:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Reindex_stmtContext extends ParserRuleContext {
public TerminalNode K_REINDEX() { return getToken(SQLiteParser.K_REINDEX, 0); }
public Collation_nameContext collation_name() {
return getRuleContext(Collation_nameContext.class,0);
}
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public Index_nameContext index_name() {
return getRuleContext(Index_nameContext.class,0);
}
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public Reindex_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reindex_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterReindex_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitReindex_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitReindex_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Reindex_stmtContext reindex_stmt() throws RecognitionException {
Reindex_stmtContext _localctx = new Reindex_stmtContext(_ctx, getState());
enterRule(_localctx, 48, RULE_reindex_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(706);
match(K_REINDEX);
setState(717);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(707);
collation_name();
}
break;
case 2:
{
setState(711);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) {
case 1:
{
setState(708);
schema_name();
setState(709);
match(DOT);
}
break;
}
setState(715);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(713);
table_name();
}
break;
case 2:
{
setState(714);
index_name();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Release_stmtContext extends ParserRuleContext {
public TerminalNode K_RELEASE() { return getToken(SQLiteParser.K_RELEASE, 0); }
public Savepoint_nameContext savepoint_name() {
return getRuleContext(Savepoint_nameContext.class,0);
}
public TerminalNode K_SAVEPOINT() { return getToken(SQLiteParser.K_SAVEPOINT, 0); }
public Release_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_release_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterRelease_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitRelease_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitRelease_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Release_stmtContext release_stmt() throws RecognitionException {
Release_stmtContext _localctx = new Release_stmtContext(_ctx, getState());
enterRule(_localctx, 50, RULE_release_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(719);
match(K_RELEASE);
setState(721);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
case 1:
{
setState(720);
match(K_SAVEPOINT);
}
break;
}
setState(723);
savepoint_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Rollback_stmtContext extends ParserRuleContext {
public TerminalNode K_ROLLBACK() { return getToken(SQLiteParser.K_ROLLBACK, 0); }
public TerminalNode K_TRANSACTION() { return getToken(SQLiteParser.K_TRANSACTION, 0); }
public TerminalNode K_TO() { return getToken(SQLiteParser.K_TO, 0); }
public Savepoint_nameContext savepoint_name() {
return getRuleContext(Savepoint_nameContext.class,0);
}
public Transaction_nameContext transaction_name() {
return getRuleContext(Transaction_nameContext.class,0);
}
public TerminalNode K_SAVEPOINT() { return getToken(SQLiteParser.K_SAVEPOINT, 0); }
public Rollback_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rollback_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterRollback_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitRollback_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitRollback_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Rollback_stmtContext rollback_stmt() throws RecognitionException {
Rollback_stmtContext _localctx = new Rollback_stmtContext(_ctx, getState());
enterRule(_localctx, 52, RULE_rollback_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(725);
match(K_ROLLBACK);
setState(730);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_TRANSACTION) {
{
setState(726);
match(K_TRANSACTION);
setState(728);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
case 1:
{
setState(727);
transaction_name();
}
break;
}
}
}
setState(737);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_TO) {
{
setState(732);
match(K_TO);
setState(734);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
case 1:
{
setState(733);
match(K_SAVEPOINT);
}
break;
}
setState(736);
savepoint_name();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Savepoint_stmtContext extends ParserRuleContext {
public TerminalNode K_SAVEPOINT() { return getToken(SQLiteParser.K_SAVEPOINT, 0); }
public Savepoint_nameContext savepoint_name() {
return getRuleContext(Savepoint_nameContext.class,0);
}
public Savepoint_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_savepoint_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterSavepoint_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitSavepoint_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitSavepoint_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Savepoint_stmtContext savepoint_stmt() throws RecognitionException {
Savepoint_stmtContext _localctx = new Savepoint_stmtContext(_ctx, getState());
enterRule(_localctx, 54, RULE_savepoint_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(739);
match(K_SAVEPOINT);
setState(740);
savepoint_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Select_stmtContext extends ParserRuleContext {
public List<Select_or_valuesContext> select_or_values() {
return getRuleContexts(Select_or_valuesContext.class);
}
public Select_or_valuesContext select_or_values(int i) {
return getRuleContext(Select_or_valuesContext.class,i);
}
public With_clauseContext with_clause() {
return getRuleContext(With_clauseContext.class,0);
}
public List<Compound_operatorContext> compound_operator() {
return getRuleContexts(Compound_operatorContext.class);
}
public Compound_operatorContext compound_operator(int i) {
return getRuleContext(Compound_operatorContext.class,i);
}
public Order_clauseContext order_clause() {
return getRuleContext(Order_clauseContext.class,0);
}
public Limit_clauseContext limit_clause() {
return getRuleContext(Limit_clauseContext.class,0);
}
public Select_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_select_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterSelect_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitSelect_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitSelect_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Select_stmtContext select_stmt() throws RecognitionException {
Select_stmtContext _localctx = new Select_stmtContext(_ctx, getState());
enterRule(_localctx, 56, RULE_select_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(743);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WITH) {
{
setState(742);
with_clause();
}
}
setState(745);
select_or_values();
setState(751);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==K_EXCEPT || _la==K_INTERSECT || _la==K_UNION) {
{
{
setState(746);
compound_operator();
setState(747);
select_or_values();
}
}
setState(753);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(755);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_ORDER) {
{
setState(754);
order_clause();
}
}
setState(758);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_LIMIT) {
{
setState(757);
limit_clause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Select_or_valuesContext extends ParserRuleContext {
public TerminalNode K_SELECT() { return getToken(SQLiteParser.K_SELECT, 0); }
public List<Result_columnContext> result_column() {
return getRuleContexts(Result_columnContext.class);
}
public Result_columnContext result_column(int i) {
return getRuleContext(Result_columnContext.class,i);
}
public TerminalNode K_FROM() { return getToken(SQLiteParser.K_FROM, 0); }
public TerminalNode K_WHERE() { return getToken(SQLiteParser.K_WHERE, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode K_GROUP() { return getToken(SQLiteParser.K_GROUP, 0); }
public TerminalNode K_BY() { return getToken(SQLiteParser.K_BY, 0); }
public List<Comma_separated_exprContext> comma_separated_expr() {
return getRuleContexts(Comma_separated_exprContext.class);
}
public Comma_separated_exprContext comma_separated_expr(int i) {
return getRuleContext(Comma_separated_exprContext.class,i);
}
public TerminalNode K_DISTINCT() { return getToken(SQLiteParser.K_DISTINCT, 0); }
public TerminalNode K_ALL() { return getToken(SQLiteParser.K_ALL, 0); }
public List<Table_or_subqueryContext> table_or_subquery() {
return getRuleContexts(Table_or_subqueryContext.class);
}
public Table_or_subqueryContext table_or_subquery(int i) {
return getRuleContext(Table_or_subqueryContext.class,i);
}
public Join_clauseContext join_clause() {
return getRuleContext(Join_clauseContext.class,0);
}
public TerminalNode K_HAVING() { return getToken(SQLiteParser.K_HAVING, 0); }
public TerminalNode K_VALUES() { return getToken(SQLiteParser.K_VALUES, 0); }
public Select_or_valuesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_select_or_values; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterSelect_or_values(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitSelect_or_values(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitSelect_or_values(this);
else return visitor.visitChildren(this);
}
}
public final Select_or_valuesContext select_or_values() throws RecognitionException {
Select_or_valuesContext _localctx = new Select_or_valuesContext(_ctx, getState());
enterRule(_localctx, 58, RULE_select_or_values);
int _la;
try {
setState(813);
_errHandler.sync(this);
switch (_input.LA(1)) {
case K_SELECT:
enterOuterAlt(_localctx, 1);
{
setState(760);
match(K_SELECT);
setState(762);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
{
setState(761);
_la = _input.LA(1);
if ( !(_la==K_ALL || _la==K_DISTINCT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(764);
result_column();
setState(769);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(765);
match(COMMA);
setState(766);
result_column();
}
}
setState(771);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(784);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_FROM) {
{
setState(772);
match(K_FROM);
setState(782);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
case 1:
{
setState(773);
table_or_subquery();
setState(778);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(774);
match(COMMA);
setState(775);
table_or_subquery();
}
}
setState(780);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
{
setState(781);
join_clause();
}
break;
}
}
}
setState(788);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WHERE) {
{
setState(786);
match(K_WHERE);
setState(787);
expr(0);
}
}
setState(797);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_GROUP) {
{
setState(790);
match(K_GROUP);
setState(791);
match(K_BY);
setState(792);
comma_separated_expr();
setState(795);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_HAVING) {
{
setState(793);
match(K_HAVING);
setState(794);
expr(0);
}
}
}
}
}
break;
case K_VALUES:
enterOuterAlt(_localctx, 2);
{
setState(799);
match(K_VALUES);
setState(800);
match(OPEN_PAR);
setState(801);
comma_separated_expr();
setState(802);
match(CLOSE_PAR);
setState(810);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(803);
match(COMMA);
setState(804);
match(OPEN_PAR);
setState(805);
comma_separated_expr();
setState(806);
match(CLOSE_PAR);
}
}
setState(812);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Update_stmtContext extends ParserRuleContext {
public TerminalNode K_UPDATE() { return getToken(SQLiteParser.K_UPDATE, 0); }
public Qualified_table_nameContext qualified_table_name() {
return getRuleContext(Qualified_table_nameContext.class,0);
}
public TerminalNode K_SET() { return getToken(SQLiteParser.K_SET, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List<Column_nameContext> column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public List<Column_name_listContext> column_name_list() {
return getRuleContexts(Column_name_listContext.class);
}
public Column_name_listContext column_name_list(int i) {
return getRuleContext(Column_name_listContext.class,i);
}
public With_clauseContext with_clause() {
return getRuleContext(With_clauseContext.class,0);
}
public TerminalNode K_OR() { return getToken(SQLiteParser.K_OR, 0); }
public TerminalNode K_ROLLBACK() { return getToken(SQLiteParser.K_ROLLBACK, 0); }
public TerminalNode K_ABORT() { return getToken(SQLiteParser.K_ABORT, 0); }
public TerminalNode K_REPLACE() { return getToken(SQLiteParser.K_REPLACE, 0); }
public TerminalNode K_FAIL() { return getToken(SQLiteParser.K_FAIL, 0); }
public TerminalNode K_IGNORE() { return getToken(SQLiteParser.K_IGNORE, 0); }
public TerminalNode K_WHERE() { return getToken(SQLiteParser.K_WHERE, 0); }
public Update_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_update_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterUpdate_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitUpdate_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitUpdate_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Update_stmtContext update_stmt() throws RecognitionException {
Update_stmtContext _localctx = new Update_stmtContext(_ctx, getState());
enterRule(_localctx, 60, RULE_update_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(816);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WITH) {
{
setState(815);
with_clause();
}
}
setState(818);
match(K_UPDATE);
setState(829);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
case 1:
{
setState(819);
match(K_OR);
setState(820);
match(K_ROLLBACK);
}
break;
case 2:
{
setState(821);
match(K_OR);
setState(822);
match(K_ABORT);
}
break;
case 3:
{
setState(823);
match(K_OR);
setState(824);
match(K_REPLACE);
}
break;
case 4:
{
setState(825);
match(K_OR);
setState(826);
match(K_FAIL);
}
break;
case 5:
{
setState(827);
match(K_OR);
setState(828);
match(K_IGNORE);
}
break;
}
setState(831);
qualified_table_name();
setState(832);
match(K_SET);
setState(835);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
case 1:
{
setState(833);
column_name();
}
break;
case 2:
{
setState(834);
column_name_list();
}
break;
}
setState(837);
match(ASSIGN);
setState(838);
expr(0);
setState(849);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(839);
match(COMMA);
setState(842);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) {
case 1:
{
setState(840);
column_name();
}
break;
case 2:
{
setState(841);
column_name_list();
}
break;
}
setState(844);
match(ASSIGN);
setState(845);
expr(0);
}
}
setState(851);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(854);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WHERE) {
{
setState(852);
match(K_WHERE);
setState(853);
expr(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Update_stmt_limitedContext extends ParserRuleContext {
public TerminalNode K_UPDATE() { return getToken(SQLiteParser.K_UPDATE, 0); }
public Qualified_table_nameContext qualified_table_name() {
return getRuleContext(Qualified_table_nameContext.class,0);
}
public TerminalNode K_SET() { return getToken(SQLiteParser.K_SET, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List<Column_nameContext> column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public List<Column_name_listContext> column_name_list() {
return getRuleContexts(Column_name_listContext.class);
}
public Column_name_listContext column_name_list(int i) {
return getRuleContext(Column_name_listContext.class,i);
}
public With_clauseContext with_clause() {
return getRuleContext(With_clauseContext.class,0);
}
public TerminalNode K_OR() { return getToken(SQLiteParser.K_OR, 0); }
public TerminalNode K_ROLLBACK() { return getToken(SQLiteParser.K_ROLLBACK, 0); }
public TerminalNode K_ABORT() { return getToken(SQLiteParser.K_ABORT, 0); }
public TerminalNode K_REPLACE() { return getToken(SQLiteParser.K_REPLACE, 0); }
public TerminalNode K_FAIL() { return getToken(SQLiteParser.K_FAIL, 0); }
public TerminalNode K_IGNORE() { return getToken(SQLiteParser.K_IGNORE, 0); }
public TerminalNode K_WHERE() { return getToken(SQLiteParser.K_WHERE, 0); }
public Limit_clauseContext limit_clause() {
return getRuleContext(Limit_clauseContext.class,0);
}
public Order_clauseContext order_clause() {
return getRuleContext(Order_clauseContext.class,0);
}
public Update_stmt_limitedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_update_stmt_limited; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterUpdate_stmt_limited(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitUpdate_stmt_limited(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitUpdate_stmt_limited(this);
else return visitor.visitChildren(this);
}
}
public final Update_stmt_limitedContext update_stmt_limited() throws RecognitionException {
Update_stmt_limitedContext _localctx = new Update_stmt_limitedContext(_ctx, getState());
enterRule(_localctx, 62, RULE_update_stmt_limited);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(857);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WITH) {
{
setState(856);
with_clause();
}
}
setState(859);
match(K_UPDATE);
setState(870);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
case 1:
{
setState(860);
match(K_OR);
setState(861);
match(K_ROLLBACK);
}
break;
case 2:
{
setState(862);
match(K_OR);
setState(863);
match(K_ABORT);
}
break;
case 3:
{
setState(864);
match(K_OR);
setState(865);
match(K_REPLACE);
}
break;
case 4:
{
setState(866);
match(K_OR);
setState(867);
match(K_FAIL);
}
break;
case 5:
{
setState(868);
match(K_OR);
setState(869);
match(K_IGNORE);
}
break;
}
setState(872);
qualified_table_name();
setState(873);
match(K_SET);
setState(876);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) {
case 1:
{
setState(874);
column_name();
}
break;
case 2:
{
setState(875);
column_name_list();
}
break;
}
setState(878);
match(ASSIGN);
setState(879);
expr(0);
setState(890);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(880);
match(COMMA);
setState(883);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) {
case 1:
{
setState(881);
column_name();
}
break;
case 2:
{
setState(882);
column_name_list();
}
break;
}
setState(885);
match(ASSIGN);
setState(886);
expr(0);
}
}
setState(892);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(895);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_WHERE) {
{
setState(893);
match(K_WHERE);
setState(894);
expr(0);
}
}
setState(901);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_LIMIT || _la==K_ORDER) {
{
setState(898);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_ORDER) {
{
setState(897);
order_clause();
}
}
setState(900);
limit_clause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Vacuum_stmtContext extends ParserRuleContext {
public TerminalNode K_VACUUM() { return getToken(SQLiteParser.K_VACUUM, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public Vacuum_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vacuum_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterVacuum_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitVacuum_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitVacuum_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Vacuum_stmtContext vacuum_stmt() throws RecognitionException {
Vacuum_stmtContext _localctx = new Vacuum_stmtContext(_ctx, getState());
enterRule(_localctx, 64, RULE_vacuum_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(903);
match(K_VACUUM);
setState(905);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
case 1:
{
setState(904);
schema_name();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Column_defContext extends ParserRuleContext {
public Column_nameContext column_name() {
return getRuleContext(Column_nameContext.class,0);
}
public Type_nameContext type_name() {
return getRuleContext(Type_nameContext.class,0);
}
public List<Column_constraintContext> column_constraint() {
return getRuleContexts(Column_constraintContext.class);
}
public Column_constraintContext column_constraint(int i) {
return getRuleContext(Column_constraintContext.class,i);
}
public Column_defContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_column_def; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterColumn_def(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitColumn_def(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitColumn_def(this);
else return visitor.visitChildren(this);
}
}
public final Column_defContext column_def() throws RecognitionException {
Column_defContext _localctx = new Column_defContext(_ctx, getState());
enterRule(_localctx, 66, RULE_column_def);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(907);
column_name();
setState(909);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
case 1:
{
setState(908);
type_name();
}
break;
}
setState(914);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << K_CHECK) | (1L << K_COLLATE) | (1L << K_CONSTRAINT) | (1L << K_DEFAULT))) != 0) || ((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & ((1L << (K_NOT - 104)) | (1L << (K_NULL - 104)) | (1L << (K_PRIMARY - 104)) | (1L << (K_REFERENCES - 104)) | (1L << (K_UNIQUE - 104)))) != 0)) {
{
{
setState(911);
column_constraint();
}
}
setState(916);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Type_nameContext extends ParserRuleContext {
public List<NameContext> name() {
return getRuleContexts(NameContext.class);
}
public NameContext name(int i) {
return getRuleContext(NameContext.class,i);
}
public List<Signed_numberContext> signed_number() {
return getRuleContexts(Signed_numberContext.class);
}
public Signed_numberContext signed_number(int i) {
return getRuleContext(Signed_numberContext.class,i);
}
public Type_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterType_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitType_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitType_name(this);
else return visitor.visitChildren(this);
}
}
public final Type_nameContext type_name() throws RecognitionException {
Type_nameContext _localctx = new Type_nameContext(_ctx, getState());
enterRule(_localctx, 68, RULE_type_name);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(918);
_errHandler.sync(this);
_alt = 1+1;
do {
switch (_alt) {
case 1+1:
{
{
setState(917);
name();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(920);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,125,_ctx);
} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(932);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
case 1:
{
setState(922);
match(OPEN_PAR);
setState(923);
signed_number();
setState(924);
match(CLOSE_PAR);
}
break;
case 2:
{
setState(926);
match(OPEN_PAR);
setState(927);
signed_number();
setState(928);
match(COMMA);
setState(929);
signed_number();
setState(930);
match(CLOSE_PAR);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Column_constraintContext extends ParserRuleContext {
public TerminalNode K_PRIMARY() { return getToken(SQLiteParser.K_PRIMARY, 0); }
public TerminalNode K_KEY() { return getToken(SQLiteParser.K_KEY, 0); }
public Conflict_clauseContext conflict_clause() {
return getRuleContext(Conflict_clauseContext.class,0);
}
public TerminalNode K_NULL() { return getToken(SQLiteParser.K_NULL, 0); }
public TerminalNode K_UNIQUE() { return getToken(SQLiteParser.K_UNIQUE, 0); }
public TerminalNode K_CHECK() { return getToken(SQLiteParser.K_CHECK, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode K_DEFAULT() { return getToken(SQLiteParser.K_DEFAULT, 0); }
public TerminalNode K_COLLATE() { return getToken(SQLiteParser.K_COLLATE, 0); }
public Collation_nameContext collation_name() {
return getRuleContext(Collation_nameContext.class,0);
}
public Foreign_key_clauseContext foreign_key_clause() {
return getRuleContext(Foreign_key_clauseContext.class,0);
}
public TerminalNode K_CONSTRAINT() { return getToken(SQLiteParser.K_CONSTRAINT, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public Signed_numberContext signed_number() {
return getRuleContext(Signed_numberContext.class,0);
}
public Literal_valueContext literal_value() {
return getRuleContext(Literal_valueContext.class,0);
}
public TerminalNode K_AUTOINCREMENT() { return getToken(SQLiteParser.K_AUTOINCREMENT, 0); }
public TerminalNode K_NOT() { return getToken(SQLiteParser.K_NOT, 0); }
public TerminalNode K_ASC() { return getToken(SQLiteParser.K_ASC, 0); }
public TerminalNode K_DESC() { return getToken(SQLiteParser.K_DESC, 0); }
public Column_constraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_column_constraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterColumn_constraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitColumn_constraint(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitColumn_constraint(this);
else return visitor.visitChildren(this);
}
}
public final Column_constraintContext column_constraint() throws RecognitionException {
Column_constraintContext _localctx = new Column_constraintContext(_ctx, getState());
enterRule(_localctx, 70, RULE_column_constraint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(936);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_CONSTRAINT) {
{
setState(934);
match(K_CONSTRAINT);
setState(935);
name();
}
}
setState(971);
_errHandler.sync(this);
switch (_input.LA(1)) {
case K_PRIMARY:
{
setState(938);
match(K_PRIMARY);
setState(939);
match(K_KEY);
setState(941);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_ASC || _la==K_DESC) {
{
setState(940);
_la = _input.LA(1);
if ( !(_la==K_ASC || _la==K_DESC) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(943);
conflict_clause();
setState(945);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_AUTOINCREMENT) {
{
setState(944);
match(K_AUTOINCREMENT);
}
}
}
break;
case K_NOT:
case K_NULL:
{
setState(948);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_NOT) {
{
setState(947);
match(K_NOT);
}
}
setState(950);
match(K_NULL);
setState(951);
conflict_clause();
}
break;
case K_UNIQUE:
{
setState(952);
match(K_UNIQUE);
setState(953);
conflict_clause();
}
break;
case K_CHECK:
{
setState(954);
match(K_CHECK);
setState(955);
match(OPEN_PAR);
setState(956);
expr(0);
setState(957);
match(CLOSE_PAR);
}
break;
case K_DEFAULT:
{
setState(959);
match(K_DEFAULT);
setState(966);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
case 1:
{
setState(960);
signed_number();
}
break;
case 2:
{
setState(961);
literal_value();
}
break;
case 3:
{
setState(962);
match(OPEN_PAR);
setState(963);
expr(0);
setState(964);
match(CLOSE_PAR);
}
break;
}
}
break;
case K_COLLATE:
{
setState(968);
match(K_COLLATE);
setState(969);
collation_name();
}
break;
case K_REFERENCES:
{
setState(970);
foreign_key_clause();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Conflict_clauseContext extends ParserRuleContext {
public TerminalNode K_ON() { return getToken(SQLiteParser.K_ON, 0); }
public TerminalNode K_CONFLICT() { return getToken(SQLiteParser.K_CONFLICT, 0); }
public TerminalNode K_ROLLBACK() { return getToken(SQLiteParser.K_ROLLBACK, 0); }
public TerminalNode K_ABORT() { return getToken(SQLiteParser.K_ABORT, 0); }
public TerminalNode K_FAIL() { return getToken(SQLiteParser.K_FAIL, 0); }
public TerminalNode K_IGNORE() { return getToken(SQLiteParser.K_IGNORE, 0); }
public TerminalNode K_REPLACE() { return getToken(SQLiteParser.K_REPLACE, 0); }
public Conflict_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conflict_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterConflict_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitConflict_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitConflict_clause(this);
else return visitor.visitChildren(this);
}
}
public final Conflict_clauseContext conflict_clause() throws RecognitionException {
Conflict_clauseContext _localctx = new Conflict_clauseContext(_ctx, getState());
enterRule(_localctx, 72, RULE_conflict_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(976);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_ON) {
{
setState(973);
match(K_ON);
setState(974);
match(K_CONFLICT);
setState(975);
_la = _input.LA(1);
if ( !(_la==K_ABORT || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (K_FAIL - 74)) | (1L << (K_IGNORE - 74)) | (1L << (K_REPLACE - 74)) | (1L << (K_ROLLBACK - 74)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprContext extends ParserRuleContext {
public Literal_valueContext literal_value() {
return getRuleContext(Literal_valueContext.class,0);
}
public TerminalNode BIND_PARAMETER() { return getToken(SQLiteParser.BIND_PARAMETER, 0); }
public Column_nameContext column_name() {
return getRuleContext(Column_nameContext.class,0);
}
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public Unary_operatorContext unary_operator() {
return getRuleContext(Unary_operatorContext.class,0);
}
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public Function_nameContext function_name() {
return getRuleContext(Function_nameContext.class,0);
}
public Comma_separated_exprContext comma_separated_expr() {
return getRuleContext(Comma_separated_exprContext.class,0);
}
public TerminalNode K_DISTINCT() { return getToken(SQLiteParser.K_DISTINCT, 0); }
public TerminalNode K_CAST() { return getToken(SQLiteParser.K_CAST, 0); }
public TerminalNode K_AS() { return getToken(SQLiteParser.K_AS, 0); }
public Type_nameContext type_name() {
return getRuleContext(Type_nameContext.class,0);
}
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public TerminalNode K_EXISTS() { return getToken(SQLiteParser.K_EXISTS, 0); }
public TerminalNode K_NOT() { return getToken(SQLiteParser.K_NOT, 0); }
public TerminalNode K_CASE() { return getToken(SQLiteParser.K_CASE, 0); }
public TerminalNode K_END() { return getToken(SQLiteParser.K_END, 0); }
public List<TerminalNode> K_WHEN() { return getTokens(SQLiteParser.K_WHEN); }
public TerminalNode K_WHEN(int i) {
return getToken(SQLiteParser.K_WHEN, i);
}
public List<TerminalNode> K_THEN() { return getTokens(SQLiteParser.K_THEN); }
public TerminalNode K_THEN(int i) {
return getToken(SQLiteParser.K_THEN, i);
}
public TerminalNode K_ELSE() { return getToken(SQLiteParser.K_ELSE, 0); }
public Raise_functionContext raise_function() {
return getRuleContext(Raise_functionContext.class,0);
}
public Binary_operatorContext binary_operator() {
return getRuleContext(Binary_operatorContext.class,0);
}
public TerminalNode K_IS() { return getToken(SQLiteParser.K_IS, 0); }
public TerminalNode K_BETWEEN() { return getToken(SQLiteParser.K_BETWEEN, 0); }
public TerminalNode K_AND() { return getToken(SQLiteParser.K_AND, 0); }
public TerminalNode K_COLLATE() { return getToken(SQLiteParser.K_COLLATE, 0); }
public Collation_nameContext collation_name() {
return getRuleContext(Collation_nameContext.class,0);
}
public TerminalNode K_LIKE() { return getToken(SQLiteParser.K_LIKE, 0); }
public TerminalNode K_GLOB() { return getToken(SQLiteParser.K_GLOB, 0); }
public TerminalNode K_REGEXP() { return getToken(SQLiteParser.K_REGEXP, 0); }
public TerminalNode K_MATCH() { return getToken(SQLiteParser.K_MATCH, 0); }
public TerminalNode K_ESCAPE() { return getToken(SQLiteParser.K_ESCAPE, 0); }
public TerminalNode K_ISNULL() { return getToken(SQLiteParser.K_ISNULL, 0); }
public TerminalNode K_NOTNULL() { return getToken(SQLiteParser.K_NOTNULL, 0); }
public TerminalNode K_NULL() { return getToken(SQLiteParser.K_NULL, 0); }
public TerminalNode K_IN() { return getToken(SQLiteParser.K_IN, 0); }
public Table_functionContext table_function() {
return getRuleContext(Table_functionContext.class,0);
}
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitExpr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitExpr(this);
else return visitor.visitChildren(this);
}
}
public final ExprContext expr() throws RecognitionException {
return expr(0);
}
private ExprContext expr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExprContext _localctx = new ExprContext(_ctx, _parentState);
ExprContext _prevctx = _localctx;
int _startState = 74;
enterRecursionRule(_localctx, 74, RULE_expr, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1047);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) {
case 1:
{
setState(979);
literal_value();
}
break;
case 2:
{
setState(980);
match(BIND_PARAMETER);
}
break;
case 3:
{
setState(989);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) {
case 1:
{
setState(984);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) {
case 1:
{
setState(981);
schema_name();
setState(982);
match(DOT);
}
break;
}
setState(986);
table_name();
setState(987);
match(DOT);
}
break;
}
setState(991);
column_name();
}
break;
case 4:
{
setState(992);
unary_operator();
setState(993);
expr(14);
}
break;
case 5:
{
setState(995);
function_name();
setState(996);
match(OPEN_PAR);
setState(1002);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_PAR:
case PLUS:
case MINUS:
case TILDE:
case TRUE:
case FALSE:
case K_ABORT:
case K_ACTION:
case K_ADD:
case K_AFTER:
case K_ALL:
case K_ALTER:
case K_ANALYZE:
case K_AND:
case K_AS:
case K_ASC:
case K_ATTACH:
case K_AUTOINCREMENT:
case K_BEFORE:
case K_BEGIN:
case K_BETWEEN:
case K_BY:
case K_CASCADE:
case K_CASE:
case K_CAST:
case K_CHECK:
case K_COLLATE:
case K_COLUMN:
case K_COMMIT:
case K_CONFLICT:
case K_CONSTRAINT:
case K_CREATE:
case K_CROSS:
case K_CURRENT_DATE:
case K_CURRENT_TIME:
case K_CURRENT_TIMESTAMP:
case K_DATABASE:
case K_DEFAULT:
case K_DEFERRABLE:
case K_DEFERRED:
case K_DELETE:
case K_DESC:
case K_DETACH:
case K_DISTINCT:
case K_DROP:
case K_EACH:
case K_ELSE:
case K_END:
case K_ESCAPE:
case K_EXCEPT:
case K_EXCLUSIVE:
case K_EXISTS:
case K_EXPLAIN:
case K_FAIL:
case K_FOR:
case K_FOREIGN:
case K_FROM:
case K_FULL:
case K_GLOB:
case K_GROUP:
case K_HAVING:
case K_IF:
case K_IGNORE:
case K_IMMEDIATE:
case K_IN:
case K_INDEX:
case K_INDEXED:
case K_INITIALLY:
case K_INNER:
case K_INSERT:
case K_INSTEAD:
case K_INTERSECT:
case K_INTO:
case K_IS:
case K_ISNULL:
case K_JOIN:
case K_KEY:
case K_LEFT:
case K_LIKE:
case K_LIMIT:
case K_MATCH:
case K_NATURAL:
case K_NO:
case K_NOT:
case K_NOTNULL:
case K_NULL:
case K_OF:
case K_OFFSET:
case K_ON:
case K_OR:
case K_ORDER:
case K_OUTER:
case K_PLAN:
case K_PRAGMA:
case K_PRIMARY:
case K_QUERY:
case K_RAISE:
case K_RECURSIVE:
case K_REFERENCES:
case K_REGEXP:
case K_REINDEX:
case K_RELEASE:
case K_RENAME:
case K_REPLACE:
case K_RESTRICT:
case K_RIGHT:
case K_ROLLBACK:
case K_ROW:
case K_SAVEPOINT:
case K_SELECT:
case K_SET:
case K_TABLE:
case K_TEMP:
case K_TEMPORARY:
case K_THEN:
case K_TO:
case K_TRANSACTION:
case K_TRIGGER:
case K_UNION:
case K_UNIQUE:
case K_UPDATE:
case K_USING:
case K_VACUUM:
case K_VALUES:
case K_VIEW:
case K_VIRTUAL:
case K_WHEN:
case K_WHERE:
case K_WITH:
case K_WITHOUT:
case IDENTIFIER:
case NUMERIC_LITERAL:
case BIND_PARAMETER:
case STRING_LITERAL:
case BLOB_LITERAL:
{
setState(998);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
case 1:
{
setState(997);
match(K_DISTINCT);
}
break;
}
setState(1000);
comma_separated_expr();
}
break;
case STAR:
{
setState(1001);
match(STAR);
}
break;
case CLOSE_PAR:
break;
default:
break;
}
setState(1004);
match(CLOSE_PAR);
}
break;
case 6:
{
setState(1006);
match(OPEN_PAR);
setState(1007);
comma_separated_expr();
setState(1008);
match(CLOSE_PAR);
}
break;
case 7:
{
setState(1010);
match(K_CAST);
setState(1011);
match(OPEN_PAR);
setState(1012);
expr(0);
setState(1013);
match(K_AS);
setState(1014);
type_name();
setState(1015);
match(CLOSE_PAR);
}
break;
case 8:
{
setState(1021);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_EXISTS || _la==K_NOT) {
{
setState(1018);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_NOT) {
{
setState(1017);
match(K_NOT);
}
}
setState(1020);
match(K_EXISTS);
}
}
setState(1023);
match(OPEN_PAR);
setState(1024);
select_stmt();
setState(1025);
match(CLOSE_PAR);
}
break;
case 9:
{
setState(1027);
match(K_CASE);
setState(1029);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
case 1:
{
setState(1028);
expr(0);
}
break;
}
setState(1036);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1031);
match(K_WHEN);
setState(1032);
expr(0);
setState(1033);
match(K_THEN);
setState(1034);
expr(0);
}
}
setState(1038);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==K_WHEN );
setState(1042);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_ELSE) {
{
setState(1040);
match(K_ELSE);
setState(1041);
expr(0);
}
}
setState(1044);
match(K_END);
}
break;
case 10:
{
setState(1046);
raise_function();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1121);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,156,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1119);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) {
case 1:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1049);
if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
setState(1050);
binary_operator();
setState(1051);
expr(14);
}
break;
case 2:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1053);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(1054);
match(K_IS);
setState(1056);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
case 1:
{
setState(1055);
match(K_NOT);
}
break;
}
setState(1058);
expr(7);
}
break;
case 3:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1059);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(1061);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_NOT) {
{
setState(1060);
match(K_NOT);
}
}
setState(1063);
match(K_BETWEEN);
setState(1064);
expr(0);
setState(1065);
match(K_AND);
setState(1066);
expr(6);
}
break;
case 4:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1068);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(1069);
match(K_COLLATE);
setState(1070);
collation_name();
}
break;
case 5:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1071);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
setState(1073);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_NOT) {
{
setState(1072);
match(K_NOT);
}
}
setState(1075);
_la = _input.LA(1);
if ( !(((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << (K_GLOB - 79)) | (1L << (K_LIKE - 79)) | (1L << (K_MATCH - 79)) | (1L << (K_REGEXP - 79)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1076);
expr(0);
setState(1079);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) {
case 1:
{
setState(1077);
match(K_ESCAPE);
setState(1078);
expr(0);
}
break;
}
}
break;
case 6:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1081);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(1086);
_errHandler.sync(this);
switch (_input.LA(1)) {
case K_ISNULL:
{
setState(1082);
match(K_ISNULL);
}
break;
case K_NOTNULL:
{
setState(1083);
match(K_NOTNULL);
}
break;
case K_NOT:
{
setState(1084);
match(K_NOT);
setState(1085);
match(K_NULL);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 7:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1088);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(1090);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_NOT) {
{
setState(1089);
match(K_NOT);
}
}
setState(1092);
match(K_IN);
setState(1117);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
case 1:
{
setState(1093);
match(OPEN_PAR);
setState(1096);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
case 1:
{
setState(1094);
select_stmt();
}
break;
case 2:
{
setState(1095);
comma_separated_expr();
}
break;
}
setState(1098);
match(CLOSE_PAR);
}
break;
case 2:
{
setState(1102);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) {
case 1:
{
setState(1099);
schema_name();
setState(1100);
match(DOT);
}
break;
}
setState(1104);
table_name();
}
break;
case 3:
{
setState(1108);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) {
case 1:
{
setState(1105);
schema_name();
setState(1106);
match(DOT);
}
break;
}
setState(1110);
table_function();
setState(1111);
match(OPEN_PAR);
setState(1113);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPEN_PAR) | (1L << PLUS) | (1L << MINUS) | (1L << TILDE) | (1L << TRUE) | (1L << FALSE) | (1L << K_ABORT) | (1L << K_ACTION) | (1L << K_ADD) | (1L << K_AFTER) | (1L << K_ALL) | (1L << K_ALTER) | (1L << K_ANALYZE) | (1L << K_AND) | (1L << K_AS) | (1L << K_ASC) | (1L << K_ATTACH) | (1L << K_AUTOINCREMENT) | (1L << K_BEFORE) | (1L << K_BEGIN) | (1L << K_BETWEEN) | (1L << K_BY) | (1L << K_CASCADE) | (1L << K_CASE) | (1L << K_CAST) | (1L << K_CHECK) | (1L << K_COLLATE) | (1L << K_COLUMN) | (1L << K_COMMIT) | (1L << K_CONFLICT) | (1L << K_CONSTRAINT) | (1L << K_CREATE) | (1L << K_CROSS) | (1L << K_CURRENT_DATE) | (1L << K_CURRENT_TIME) | (1L << K_CURRENT_TIMESTAMP) | (1L << K_DATABASE) | (1L << K_DEFAULT) | (1L << K_DEFERRABLE) | (1L << K_DEFERRED) | (1L << K_DELETE) | (1L << K_DESC) | (1L << K_DETACH))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (K_DISTINCT - 64)) | (1L << (K_DROP - 64)) | (1L << (K_EACH - 64)) | (1L << (K_ELSE - 64)) | (1L << (K_END - 64)) | (1L << (K_ESCAPE - 64)) | (1L << (K_EXCEPT - 64)) | (1L << (K_EXCLUSIVE - 64)) | (1L << (K_EXISTS - 64)) | (1L << (K_EXPLAIN - 64)) | (1L << (K_FAIL - 64)) | (1L << (K_FOR - 64)) | (1L << (K_FOREIGN - 64)) | (1L << (K_FROM - 64)) | (1L << (K_FULL - 64)) | (1L << (K_GLOB - 64)) | (1L << (K_GROUP - 64)) | (1L << (K_HAVING - 64)) | (1L << (K_IF - 64)) | (1L << (K_IGNORE - 64)) | (1L << (K_IMMEDIATE - 64)) | (1L << (K_IN - 64)) | (1L << (K_INDEX - 64)) | (1L << (K_INDEXED - 64)) | (1L << (K_INITIALLY - 64)) | (1L << (K_INNER - 64)) | (1L << (K_INSERT - 64)) | (1L << (K_INSTEAD - 64)) | (1L << (K_INTERSECT - 64)) | (1L << (K_INTO - 64)) | (1L << (K_IS - 64)) | (1L << (K_ISNULL - 64)) | (1L << (K_JOIN - 64)) | (1L << (K_KEY - 64)) | (1L << (K_LEFT - 64)) | (1L << (K_LIKE - 64)) | (1L << (K_LIMIT - 64)) | (1L << (K_MATCH - 64)) | (1L << (K_NATURAL - 64)) | (1L << (K_NO - 64)) | (1L << (K_NOT - 64)) | (1L << (K_NOTNULL - 64)) | (1L << (K_NULL - 64)) | (1L << (K_OF - 64)) | (1L << (K_OFFSET - 64)) | (1L << (K_ON - 64)) | (1L << (K_OR - 64)) | (1L << (K_ORDER - 64)) | (1L << (K_OUTER - 64)) | (1L << (K_PLAN - 64)) | (1L << (K_PRAGMA - 64)) | (1L << (K_PRIMARY - 64)) | (1L << (K_QUERY - 64)) | (1L << (K_RAISE - 64)) | (1L << (K_RECURSIVE - 64)) | (1L << (K_REFERENCES - 64)) | (1L << (K_REGEXP - 64)) | (1L << (K_REINDEX - 64)) | (1L << (K_RELEASE - 64)) | (1L << (K_RENAME - 64)) | (1L << (K_REPLACE - 64)) | (1L << (K_RESTRICT - 64)) | (1L << (K_RIGHT - 64)) | (1L << (K_ROLLBACK - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (K_ROW - 128)) | (1L << (K_SAVEPOINT - 128)) | (1L << (K_SELECT - 128)) | (1L << (K_SET - 128)) | (1L << (K_TABLE - 128)) | (1L << (K_TEMP - 128)) | (1L << (K_TEMPORARY - 128)) | (1L << (K_THEN - 128)) | (1L << (K_TO - 128)) | (1L << (K_TRANSACTION - 128)) | (1L << (K_TRIGGER - 128)) | (1L << (K_UNION - 128)) | (1L << (K_UNIQUE - 128)) | (1L << (K_UPDATE - 128)) | (1L << (K_USING - 128)) | (1L << (K_VACUUM - 128)) | (1L << (K_VALUES - 128)) | (1L << (K_VIEW - 128)) | (1L << (K_VIRTUAL - 128)) | (1L << (K_WHEN - 128)) | (1L << (K_WHERE - 128)) | (1L << (K_WITH - 128)) | (1L << (K_WITHOUT - 128)) | (1L << (IDENTIFIER - 128)) | (1L << (NUMERIC_LITERAL - 128)) | (1L << (BIND_PARAMETER - 128)) | (1L << (STRING_LITERAL - 128)) | (1L << (BLOB_LITERAL - 128)))) != 0)) {
{
setState(1112);
comma_separated_expr();
}
}
setState(1115);
match(CLOSE_PAR);
}
break;
}
}
break;
}
}
}
setState(1123);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,156,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class Comma_separated_exprContext extends ParserRuleContext {
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public Comma_separated_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comma_separated_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterComma_separated_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitComma_separated_expr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitComma_separated_expr(this);
else return visitor.visitChildren(this);
}
}
public final Comma_separated_exprContext comma_separated_expr() throws RecognitionException {
Comma_separated_exprContext _localctx = new Comma_separated_exprContext(_ctx, getState());
enterRule(_localctx, 76, RULE_comma_separated_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1124);
expr(0);
setState(1129);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1125);
match(COMMA);
setState(1126);
expr(0);
}
}
setState(1131);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Foreign_key_clauseContext extends ParserRuleContext {
public TerminalNode K_REFERENCES() { return getToken(SQLiteParser.K_REFERENCES, 0); }
public Foreign_tableContext foreign_table() {
return getRuleContext(Foreign_tableContext.class,0);
}
public List<Column_nameContext> column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public TerminalNode K_DEFERRABLE() { return getToken(SQLiteParser.K_DEFERRABLE, 0); }
public List<TerminalNode> K_ON() { return getTokens(SQLiteParser.K_ON); }
public TerminalNode K_ON(int i) {
return getToken(SQLiteParser.K_ON, i);
}
public List<TerminalNode> K_MATCH() { return getTokens(SQLiteParser.K_MATCH); }
public TerminalNode K_MATCH(int i) {
return getToken(SQLiteParser.K_MATCH, i);
}
public List<NameContext> name() {
return getRuleContexts(NameContext.class);
}
public NameContext name(int i) {
return getRuleContext(NameContext.class,i);
}
public List<TerminalNode> K_DELETE() { return getTokens(SQLiteParser.K_DELETE); }
public TerminalNode K_DELETE(int i) {
return getToken(SQLiteParser.K_DELETE, i);
}
public List<TerminalNode> K_UPDATE() { return getTokens(SQLiteParser.K_UPDATE); }
public TerminalNode K_UPDATE(int i) {
return getToken(SQLiteParser.K_UPDATE, i);
}
public TerminalNode K_NOT() { return getToken(SQLiteParser.K_NOT, 0); }
public TerminalNode K_INITIALLY() { return getToken(SQLiteParser.K_INITIALLY, 0); }
public TerminalNode K_DEFERRED() { return getToken(SQLiteParser.K_DEFERRED, 0); }
public TerminalNode K_IMMEDIATE() { return getToken(SQLiteParser.K_IMMEDIATE, 0); }
public List<TerminalNode> K_SET() { return getTokens(SQLiteParser.K_SET); }
public TerminalNode K_SET(int i) {
return getToken(SQLiteParser.K_SET, i);
}
public List<TerminalNode> K_NULL() { return getTokens(SQLiteParser.K_NULL); }
public TerminalNode K_NULL(int i) {
return getToken(SQLiteParser.K_NULL, i);
}
public List<TerminalNode> K_DEFAULT() { return getTokens(SQLiteParser.K_DEFAULT); }
public TerminalNode K_DEFAULT(int i) {
return getToken(SQLiteParser.K_DEFAULT, i);
}
public List<TerminalNode> K_CASCADE() { return getTokens(SQLiteParser.K_CASCADE); }
public TerminalNode K_CASCADE(int i) {
return getToken(SQLiteParser.K_CASCADE, i);
}
public List<TerminalNode> K_RESTRICT() { return getTokens(SQLiteParser.K_RESTRICT); }
public TerminalNode K_RESTRICT(int i) {
return getToken(SQLiteParser.K_RESTRICT, i);
}
public List<TerminalNode> K_NO() { return getTokens(SQLiteParser.K_NO); }
public TerminalNode K_NO(int i) {
return getToken(SQLiteParser.K_NO, i);
}
public List<TerminalNode> K_ACTION() { return getTokens(SQLiteParser.K_ACTION); }
public TerminalNode K_ACTION(int i) {
return getToken(SQLiteParser.K_ACTION, i);
}
public Foreign_key_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_foreign_key_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterForeign_key_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitForeign_key_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitForeign_key_clause(this);
else return visitor.visitChildren(this);
}
}
public final Foreign_key_clauseContext foreign_key_clause() throws RecognitionException {
Foreign_key_clauseContext _localctx = new Foreign_key_clauseContext(_ctx, getState());
enterRule(_localctx, 78, RULE_foreign_key_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1132);
match(K_REFERENCES);
setState(1133);
foreign_table();
setState(1145);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(1134);
match(OPEN_PAR);
setState(1135);
column_name();
setState(1140);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1136);
match(COMMA);
setState(1137);
column_name();
}
}
setState(1142);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1143);
match(CLOSE_PAR);
}
}
setState(1165);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==K_MATCH || _la==K_ON) {
{
{
setState(1161);
_errHandler.sync(this);
switch (_input.LA(1)) {
case K_ON:
{
setState(1147);
match(K_ON);
setState(1148);
_la = _input.LA(1);
if ( !(_la==K_DELETE || _la==K_UPDATE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1157);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) {
case 1:
{
setState(1149);
match(K_SET);
setState(1150);
match(K_NULL);
}
break;
case 2:
{
setState(1151);
match(K_SET);
setState(1152);
match(K_DEFAULT);
}
break;
case 3:
{
setState(1153);
match(K_CASCADE);
}
break;
case 4:
{
setState(1154);
match(K_RESTRICT);
}
break;
case 5:
{
setState(1155);
match(K_NO);
setState(1156);
match(K_ACTION);
}
break;
}
}
break;
case K_MATCH:
{
setState(1159);
match(K_MATCH);
setState(1160);
name();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(1167);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1178);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
case 1:
{
setState(1169);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_NOT) {
{
setState(1168);
match(K_NOT);
}
}
setState(1171);
match(K_DEFERRABLE);
setState(1176);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,164,_ctx) ) {
case 1:
{
setState(1172);
match(K_INITIALLY);
setState(1173);
match(K_DEFERRED);
}
break;
case 2:
{
setState(1174);
match(K_INITIALLY);
setState(1175);
match(K_IMMEDIATE);
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Raise_functionContext extends ParserRuleContext {
public TerminalNode K_RAISE() { return getToken(SQLiteParser.K_RAISE, 0); }
public TerminalNode K_IGNORE() { return getToken(SQLiteParser.K_IGNORE, 0); }
public Error_messageContext error_message() {
return getRuleContext(Error_messageContext.class,0);
}
public TerminalNode K_ROLLBACK() { return getToken(SQLiteParser.K_ROLLBACK, 0); }
public TerminalNode K_ABORT() { return getToken(SQLiteParser.K_ABORT, 0); }
public TerminalNode K_FAIL() { return getToken(SQLiteParser.K_FAIL, 0); }
public Raise_functionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_raise_function; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterRaise_function(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitRaise_function(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitRaise_function(this);
else return visitor.visitChildren(this);
}
}
public final Raise_functionContext raise_function() throws RecognitionException {
Raise_functionContext _localctx = new Raise_functionContext(_ctx, getState());
enterRule(_localctx, 80, RULE_raise_function);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1180);
match(K_RAISE);
setState(1181);
match(OPEN_PAR);
setState(1186);
_errHandler.sync(this);
switch (_input.LA(1)) {
case K_IGNORE:
{
setState(1182);
match(K_IGNORE);
}
break;
case K_ABORT:
case K_FAIL:
case K_ROLLBACK:
{
setState(1183);
_la = _input.LA(1);
if ( !(_la==K_ABORT || _la==K_FAIL || _la==K_ROLLBACK) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1184);
match(COMMA);
setState(1185);
error_message();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1188);
match(CLOSE_PAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Indexed_columnContext extends ParserRuleContext {
public Column_nameContext column_name() {
return getRuleContext(Column_nameContext.class,0);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode K_COLLATE() { return getToken(SQLiteParser.K_COLLATE, 0); }
public Collation_nameContext collation_name() {
return getRuleContext(Collation_nameContext.class,0);
}
public TerminalNode K_ASC() { return getToken(SQLiteParser.K_ASC, 0); }
public TerminalNode K_DESC() { return getToken(SQLiteParser.K_DESC, 0); }
public Indexed_columnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_indexed_column; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterIndexed_column(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitIndexed_column(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitIndexed_column(this);
else return visitor.visitChildren(this);
}
}
public final Indexed_columnContext indexed_column() throws RecognitionException {
Indexed_columnContext _localctx = new Indexed_columnContext(_ctx, getState());
enterRule(_localctx, 82, RULE_indexed_column);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1192);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
case 1:
{
setState(1190);
column_name();
}
break;
case 2:
{
setState(1191);
expr(0);
}
break;
}
setState(1196);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_COLLATE) {
{
setState(1194);
match(K_COLLATE);
setState(1195);
collation_name();
}
}
setState(1199);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_ASC || _la==K_DESC) {
{
setState(1198);
_la = _input.LA(1);
if ( !(_la==K_ASC || _la==K_DESC) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_constraintContext extends ParserRuleContext {
public List<Indexed_columnContext> indexed_column() {
return getRuleContexts(Indexed_columnContext.class);
}
public Indexed_columnContext indexed_column(int i) {
return getRuleContext(Indexed_columnContext.class,i);
}
public Conflict_clauseContext conflict_clause() {
return getRuleContext(Conflict_clauseContext.class,0);
}
public TerminalNode K_CHECK() { return getToken(SQLiteParser.K_CHECK, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode K_FOREIGN() { return getToken(SQLiteParser.K_FOREIGN, 0); }
public TerminalNode K_KEY() { return getToken(SQLiteParser.K_KEY, 0); }
public List<Column_nameContext> column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public Foreign_key_clauseContext foreign_key_clause() {
return getRuleContext(Foreign_key_clauseContext.class,0);
}
public TerminalNode K_CONSTRAINT() { return getToken(SQLiteParser.K_CONSTRAINT, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode K_PRIMARY() { return getToken(SQLiteParser.K_PRIMARY, 0); }
public TerminalNode K_UNIQUE() { return getToken(SQLiteParser.K_UNIQUE, 0); }
public Table_constraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_constraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterTable_constraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitTable_constraint(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitTable_constraint(this);
else return visitor.visitChildren(this);
}
}
public final Table_constraintContext table_constraint() throws RecognitionException {
Table_constraintContext _localctx = new Table_constraintContext(_ctx, getState());
enterRule(_localctx, 84, RULE_table_constraint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1203);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_CONSTRAINT) {
{
setState(1201);
match(K_CONSTRAINT);
setState(1202);
name();
}
}
setState(1241);
_errHandler.sync(this);
switch (_input.LA(1)) {
case K_PRIMARY:
case K_UNIQUE:
{
setState(1208);
_errHandler.sync(this);
switch (_input.LA(1)) {
case K_PRIMARY:
{
setState(1205);
match(K_PRIMARY);
setState(1206);
match(K_KEY);
}
break;
case K_UNIQUE:
{
setState(1207);
match(K_UNIQUE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1210);
match(OPEN_PAR);
setState(1211);
indexed_column();
setState(1216);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1212);
match(COMMA);
setState(1213);
indexed_column();
}
}
setState(1218);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1219);
match(CLOSE_PAR);
setState(1220);
conflict_clause();
}
break;
case K_CHECK:
{
setState(1222);
match(K_CHECK);
setState(1223);
match(OPEN_PAR);
setState(1224);
expr(0);
setState(1225);
match(CLOSE_PAR);
}
break;
case K_FOREIGN:
{
setState(1227);
match(K_FOREIGN);
setState(1228);
match(K_KEY);
setState(1229);
match(OPEN_PAR);
setState(1230);
column_name();
setState(1235);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1231);
match(COMMA);
setState(1232);
column_name();
}
}
setState(1237);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1238);
match(CLOSE_PAR);
setState(1239);
foreign_key_clause();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class With_clauseContext extends ParserRuleContext {
public TerminalNode K_WITH() { return getToken(SQLiteParser.K_WITH, 0); }
public List<Common_table_expressionContext> common_table_expression() {
return getRuleContexts(Common_table_expressionContext.class);
}
public Common_table_expressionContext common_table_expression(int i) {
return getRuleContext(Common_table_expressionContext.class,i);
}
public TerminalNode K_RECURSIVE() { return getToken(SQLiteParser.K_RECURSIVE, 0); }
public With_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_with_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterWith_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitWith_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitWith_clause(this);
else return visitor.visitChildren(this);
}
}
public final With_clauseContext with_clause() throws RecognitionException {
With_clauseContext _localctx = new With_clauseContext(_ctx, getState());
enterRule(_localctx, 86, RULE_with_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1243);
match(K_WITH);
setState(1245);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
case 1:
{
setState(1244);
match(K_RECURSIVE);
}
break;
}
setState(1247);
common_table_expression();
setState(1252);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1248);
match(COMMA);
setState(1249);
common_table_expression();
}
}
setState(1254);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Common_table_expressionContext extends ParserRuleContext {
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode K_AS() { return getToken(SQLiteParser.K_AS, 0); }
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public List<Column_nameContext> column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public Common_table_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_common_table_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterCommon_table_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitCommon_table_expression(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitCommon_table_expression(this);
else return visitor.visitChildren(this);
}
}
public final Common_table_expressionContext common_table_expression() throws RecognitionException {
Common_table_expressionContext _localctx = new Common_table_expressionContext(_ctx, getState());
enterRule(_localctx, 88, RULE_common_table_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1255);
table_name();
setState(1267);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(1256);
match(OPEN_PAR);
setState(1257);
column_name();
setState(1262);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1258);
match(COMMA);
setState(1259);
column_name();
}
}
setState(1264);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1265);
match(CLOSE_PAR);
}
}
setState(1269);
match(K_AS);
setState(1270);
match(OPEN_PAR);
setState(1271);
select_stmt();
setState(1272);
match(CLOSE_PAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Qualified_table_nameContext extends ParserRuleContext {
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode K_AS() { return getToken(SQLiteParser.K_AS, 0); }
public Table_aliasContext table_alias() {
return getRuleContext(Table_aliasContext.class,0);
}
public TerminalNode K_INDEXED() { return getToken(SQLiteParser.K_INDEXED, 0); }
public TerminalNode K_BY() { return getToken(SQLiteParser.K_BY, 0); }
public Index_nameContext index_name() {
return getRuleContext(Index_nameContext.class,0);
}
public TerminalNode K_NOT() { return getToken(SQLiteParser.K_NOT, 0); }
public Qualified_table_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualified_table_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterQualified_table_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitQualified_table_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitQualified_table_name(this);
else return visitor.visitChildren(this);
}
}
public final Qualified_table_nameContext qualified_table_name() throws RecognitionException {
Qualified_table_nameContext _localctx = new Qualified_table_nameContext(_ctx, getState());
enterRule(_localctx, 90, RULE_qualified_table_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1277);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,179,_ctx) ) {
case 1:
{
setState(1274);
schema_name();
setState(1275);
match(DOT);
}
break;
}
setState(1279);
table_name();
setState(1282);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_AS) {
{
setState(1280);
match(K_AS);
setState(1281);
table_alias();
}
}
setState(1289);
_errHandler.sync(this);
switch (_input.LA(1)) {
case K_INDEXED:
{
setState(1284);
match(K_INDEXED);
setState(1285);
match(K_BY);
setState(1286);
index_name();
}
break;
case K_NOT:
{
setState(1287);
match(K_NOT);
setState(1288);
match(K_INDEXED);
}
break;
case EOF:
case SCOL:
case K_ALTER:
case K_ANALYZE:
case K_ATTACH:
case K_BEGIN:
case K_COMMIT:
case K_CREATE:
case K_DELETE:
case K_DETACH:
case K_DROP:
case K_END:
case K_EXPLAIN:
case K_INSERT:
case K_LIMIT:
case K_ORDER:
case K_PRAGMA:
case K_REINDEX:
case K_RELEASE:
case K_REPLACE:
case K_ROLLBACK:
case K_SAVEPOINT:
case K_SELECT:
case K_SET:
case K_UPDATE:
case K_VACUUM:
case K_VALUES:
case K_WHERE:
case K_WITH:
case UNEXPECTED_CHAR:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Order_clauseContext extends ParserRuleContext {
public TerminalNode K_ORDER() { return getToken(SQLiteParser.K_ORDER, 0); }
public TerminalNode K_BY() { return getToken(SQLiteParser.K_BY, 0); }
public List<Ordering_termContext> ordering_term() {
return getRuleContexts(Ordering_termContext.class);
}
public Ordering_termContext ordering_term(int i) {
return getRuleContext(Ordering_termContext.class,i);
}
public Order_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_order_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterOrder_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitOrder_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitOrder_clause(this);
else return visitor.visitChildren(this);
}
}
public final Order_clauseContext order_clause() throws RecognitionException {
Order_clauseContext _localctx = new Order_clauseContext(_ctx, getState());
enterRule(_localctx, 92, RULE_order_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1291);
match(K_ORDER);
setState(1292);
match(K_BY);
setState(1293);
ordering_term();
setState(1298);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1294);
match(COMMA);
setState(1295);
ordering_term();
}
}
setState(1300);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Ordering_termContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode K_COLLATE() { return getToken(SQLiteParser.K_COLLATE, 0); }
public Collation_nameContext collation_name() {
return getRuleContext(Collation_nameContext.class,0);
}
public TerminalNode K_ASC() { return getToken(SQLiteParser.K_ASC, 0); }
public TerminalNode K_DESC() { return getToken(SQLiteParser.K_DESC, 0); }
public Ordering_termContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ordering_term; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterOrdering_term(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitOrdering_term(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitOrdering_term(this);
else return visitor.visitChildren(this);
}
}
public final Ordering_termContext ordering_term() throws RecognitionException {
Ordering_termContext _localctx = new Ordering_termContext(_ctx, getState());
enterRule(_localctx, 94, RULE_ordering_term);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1301);
expr(0);
setState(1304);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_COLLATE) {
{
setState(1302);
match(K_COLLATE);
setState(1303);
collation_name();
}
}
setState(1307);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_ASC || _la==K_DESC) {
{
setState(1306);
_la = _input.LA(1);
if ( !(_la==K_ASC || _la==K_DESC) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Limit_clauseContext extends ParserRuleContext {
public TerminalNode K_LIMIT() { return getToken(SQLiteParser.K_LIMIT, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode K_OFFSET() { return getToken(SQLiteParser.K_OFFSET, 0); }
public Limit_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_limit_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterLimit_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitLimit_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitLimit_clause(this);
else return visitor.visitChildren(this);
}
}
public final Limit_clauseContext limit_clause() throws RecognitionException {
Limit_clauseContext _localctx = new Limit_clauseContext(_ctx, getState());
enterRule(_localctx, 96, RULE_limit_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1309);
match(K_LIMIT);
setState(1310);
expr(0);
setState(1313);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA || _la==K_OFFSET) {
{
setState(1311);
_la = _input.LA(1);
if ( !(_la==COMMA || _la==K_OFFSET) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1312);
expr(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Pragma_valueContext extends ParserRuleContext {
public Signed_numberContext signed_number() {
return getRuleContext(Signed_numberContext.class,0);
}
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode STRING_LITERAL() { return getToken(SQLiteParser.STRING_LITERAL, 0); }
public Boolean_literalContext boolean_literal() {
return getRuleContext(Boolean_literalContext.class,0);
}
public Pragma_valueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pragma_value; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterPragma_value(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitPragma_value(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitPragma_value(this);
else return visitor.visitChildren(this);
}
}
public final Pragma_valueContext pragma_value() throws RecognitionException {
Pragma_valueContext _localctx = new Pragma_valueContext(_ctx, getState());
enterRule(_localctx, 98, RULE_pragma_value);
try {
setState(1319);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1315);
signed_number();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1316);
name();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1317);
match(STRING_LITERAL);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1318);
boolean_literal();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Result_columnContext extends ParserRuleContext {
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Column_aliasContext column_alias() {
return getRuleContext(Column_aliasContext.class,0);
}
public TerminalNode K_AS() { return getToken(SQLiteParser.K_AS, 0); }
public Result_columnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_result_column; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterResult_column(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitResult_column(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitResult_column(this);
else return visitor.visitChildren(this);
}
}
public final Result_columnContext result_column() throws RecognitionException {
Result_columnContext _localctx = new Result_columnContext(_ctx, getState());
enterRule(_localctx, 100, RULE_result_column);
int _la;
try {
setState(1333);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,189,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1321);
match(STAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1322);
table_name();
setState(1323);
match(DOT);
setState(1324);
match(STAR);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1326);
expr(0);
setState(1331);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_AS || _la==IDENTIFIER || _la==STRING_LITERAL) {
{
setState(1328);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_AS) {
{
setState(1327);
match(K_AS);
}
}
setState(1330);
column_alias();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_or_subqueryContext extends ParserRuleContext {
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public Table_aliasContext table_alias() {
return getRuleContext(Table_aliasContext.class,0);
}
public TerminalNode K_INDEXED() { return getToken(SQLiteParser.K_INDEXED, 0); }
public TerminalNode K_BY() { return getToken(SQLiteParser.K_BY, 0); }
public Index_nameContext index_name() {
return getRuleContext(Index_nameContext.class,0);
}
public TerminalNode K_NOT() { return getToken(SQLiteParser.K_NOT, 0); }
public TerminalNode K_AS() { return getToken(SQLiteParser.K_AS, 0); }
public Table_functionContext table_function() {
return getRuleContext(Table_functionContext.class,0);
}
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List<Table_or_subqueryContext> table_or_subquery() {
return getRuleContexts(Table_or_subqueryContext.class);
}
public Table_or_subqueryContext table_or_subquery(int i) {
return getRuleContext(Table_or_subqueryContext.class,i);
}
public Join_clauseContext join_clause() {
return getRuleContext(Join_clauseContext.class,0);
}
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public Table_or_subqueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_or_subquery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterTable_or_subquery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitTable_or_subquery(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitTable_or_subquery(this);
else return visitor.visitChildren(this);
}
}
public final Table_or_subqueryContext table_or_subquery() throws RecognitionException {
Table_or_subqueryContext _localctx = new Table_or_subqueryContext(_ctx, getState());
enterRule(_localctx, 102, RULE_table_or_subquery);
int _la;
try {
setState(1401);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,203,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1338);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
case 1:
{
setState(1335);
schema_name();
setState(1336);
match(DOT);
}
break;
}
setState(1340);
table_name();
setState(1345);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR || _la==K_AS || _la==IDENTIFIER || _la==STRING_LITERAL) {
{
setState(1342);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_AS) {
{
setState(1341);
match(K_AS);
}
}
setState(1344);
table_alias();
}
}
setState(1352);
_errHandler.sync(this);
switch (_input.LA(1)) {
case K_INDEXED:
{
setState(1347);
match(K_INDEXED);
setState(1348);
match(K_BY);
setState(1349);
index_name();
}
break;
case K_NOT:
{
setState(1350);
match(K_NOT);
setState(1351);
match(K_INDEXED);
}
break;
case EOF:
case SCOL:
case CLOSE_PAR:
case COMMA:
case K_ALTER:
case K_ANALYZE:
case K_ATTACH:
case K_BEGIN:
case K_COMMIT:
case K_CREATE:
case K_CROSS:
case K_DELETE:
case K_DETACH:
case K_DROP:
case K_END:
case K_EXCEPT:
case K_EXPLAIN:
case K_GROUP:
case K_INNER:
case K_INSERT:
case K_INTERSECT:
case K_JOIN:
case K_LEFT:
case K_LIMIT:
case K_NATURAL:
case K_ON:
case K_ORDER:
case K_PRAGMA:
case K_REINDEX:
case K_RELEASE:
case K_REPLACE:
case K_ROLLBACK:
case K_SAVEPOINT:
case K_SELECT:
case K_UNION:
case K_UPDATE:
case K_USING:
case K_VACUUM:
case K_VALUES:
case K_WHERE:
case K_WITH:
case UNEXPECTED_CHAR:
break;
default:
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1357);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,194,_ctx) ) {
case 1:
{
setState(1354);
schema_name();
setState(1355);
match(DOT);
}
break;
}
setState(1359);
table_function();
setState(1360);
match(OPEN_PAR);
setState(1369);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPEN_PAR) | (1L << PLUS) | (1L << MINUS) | (1L << TILDE) | (1L << TRUE) | (1L << FALSE) | (1L << K_ABORT) | (1L << K_ACTION) | (1L << K_ADD) | (1L << K_AFTER) | (1L << K_ALL) | (1L << K_ALTER) | (1L << K_ANALYZE) | (1L << K_AND) | (1L << K_AS) | (1L << K_ASC) | (1L << K_ATTACH) | (1L << K_AUTOINCREMENT) | (1L << K_BEFORE) | (1L << K_BEGIN) | (1L << K_BETWEEN) | (1L << K_BY) | (1L << K_CASCADE) | (1L << K_CASE) | (1L << K_CAST) | (1L << K_CHECK) | (1L << K_COLLATE) | (1L << K_COLUMN) | (1L << K_COMMIT) | (1L << K_CONFLICT) | (1L << K_CONSTRAINT) | (1L << K_CREATE) | (1L << K_CROSS) | (1L << K_CURRENT_DATE) | (1L << K_CURRENT_TIME) | (1L << K_CURRENT_TIMESTAMP) | (1L << K_DATABASE) | (1L << K_DEFAULT) | (1L << K_DEFERRABLE) | (1L << K_DEFERRED) | (1L << K_DELETE) | (1L << K_DESC) | (1L << K_DETACH))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (K_DISTINCT - 64)) | (1L << (K_DROP - 64)) | (1L << (K_EACH - 64)) | (1L << (K_ELSE - 64)) | (1L << (K_END - 64)) | (1L << (K_ESCAPE - 64)) | (1L << (K_EXCEPT - 64)) | (1L << (K_EXCLUSIVE - 64)) | (1L << (K_EXISTS - 64)) | (1L << (K_EXPLAIN - 64)) | (1L << (K_FAIL - 64)) | (1L << (K_FOR - 64)) | (1L << (K_FOREIGN - 64)) | (1L << (K_FROM - 64)) | (1L << (K_FULL - 64)) | (1L << (K_GLOB - 64)) | (1L << (K_GROUP - 64)) | (1L << (K_HAVING - 64)) | (1L << (K_IF - 64)) | (1L << (K_IGNORE - 64)) | (1L << (K_IMMEDIATE - 64)) | (1L << (K_IN - 64)) | (1L << (K_INDEX - 64)) | (1L << (K_INDEXED - 64)) | (1L << (K_INITIALLY - 64)) | (1L << (K_INNER - 64)) | (1L << (K_INSERT - 64)) | (1L << (K_INSTEAD - 64)) | (1L << (K_INTERSECT - 64)) | (1L << (K_INTO - 64)) | (1L << (K_IS - 64)) | (1L << (K_ISNULL - 64)) | (1L << (K_JOIN - 64)) | (1L << (K_KEY - 64)) | (1L << (K_LEFT - 64)) | (1L << (K_LIKE - 64)) | (1L << (K_LIMIT - 64)) | (1L << (K_MATCH - 64)) | (1L << (K_NATURAL - 64)) | (1L << (K_NO - 64)) | (1L << (K_NOT - 64)) | (1L << (K_NOTNULL - 64)) | (1L << (K_NULL - 64)) | (1L << (K_OF - 64)) | (1L << (K_OFFSET - 64)) | (1L << (K_ON - 64)) | (1L << (K_OR - 64)) | (1L << (K_ORDER - 64)) | (1L << (K_OUTER - 64)) | (1L << (K_PLAN - 64)) | (1L << (K_PRAGMA - 64)) | (1L << (K_PRIMARY - 64)) | (1L << (K_QUERY - 64)) | (1L << (K_RAISE - 64)) | (1L << (K_RECURSIVE - 64)) | (1L << (K_REFERENCES - 64)) | (1L << (K_REGEXP - 64)) | (1L << (K_REINDEX - 64)) | (1L << (K_RELEASE - 64)) | (1L << (K_RENAME - 64)) | (1L << (K_REPLACE - 64)) | (1L << (K_RESTRICT - 64)) | (1L << (K_RIGHT - 64)) | (1L << (K_ROLLBACK - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (K_ROW - 128)) | (1L << (K_SAVEPOINT - 128)) | (1L << (K_SELECT - 128)) | (1L << (K_SET - 128)) | (1L << (K_TABLE - 128)) | (1L << (K_TEMP - 128)) | (1L << (K_TEMPORARY - 128)) | (1L << (K_THEN - 128)) | (1L << (K_TO - 128)) | (1L << (K_TRANSACTION - 128)) | (1L << (K_TRIGGER - 128)) | (1L << (K_UNION - 128)) | (1L << (K_UNIQUE - 128)) | (1L << (K_UPDATE - 128)) | (1L << (K_USING - 128)) | (1L << (K_VACUUM - 128)) | (1L << (K_VALUES - 128)) | (1L << (K_VIEW - 128)) | (1L << (K_VIRTUAL - 128)) | (1L << (K_WHEN - 128)) | (1L << (K_WHERE - 128)) | (1L << (K_WITH - 128)) | (1L << (K_WITHOUT - 128)) | (1L << (IDENTIFIER - 128)) | (1L << (NUMERIC_LITERAL - 128)) | (1L << (BIND_PARAMETER - 128)) | (1L << (STRING_LITERAL - 128)) | (1L << (BLOB_LITERAL - 128)))) != 0)) {
{
setState(1361);
expr(0);
setState(1366);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1362);
match(COMMA);
setState(1363);
expr(0);
}
}
setState(1368);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1371);
match(CLOSE_PAR);
setState(1376);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR || _la==K_AS || _la==IDENTIFIER || _la==STRING_LITERAL) {
{
setState(1373);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_AS) {
{
setState(1372);
match(K_AS);
}
}
setState(1375);
table_alias();
}
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1378);
match(OPEN_PAR);
setState(1388);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) {
case 1:
{
setState(1379);
table_or_subquery();
setState(1384);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1380);
match(COMMA);
setState(1381);
table_or_subquery();
}
}
setState(1386);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
{
setState(1387);
join_clause();
}
break;
}
setState(1390);
match(CLOSE_PAR);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1392);
match(OPEN_PAR);
setState(1393);
select_stmt();
setState(1394);
match(CLOSE_PAR);
setState(1399);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR || _la==K_AS || _la==IDENTIFIER || _la==STRING_LITERAL) {
{
setState(1396);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_AS) {
{
setState(1395);
match(K_AS);
}
}
setState(1398);
table_alias();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Join_clauseContext extends ParserRuleContext {
public List<Table_or_subqueryContext> table_or_subquery() {
return getRuleContexts(Table_or_subqueryContext.class);
}
public Table_or_subqueryContext table_or_subquery(int i) {
return getRuleContext(Table_or_subqueryContext.class,i);
}
public List<Join_operatorContext> join_operator() {
return getRuleContexts(Join_operatorContext.class);
}
public Join_operatorContext join_operator(int i) {
return getRuleContext(Join_operatorContext.class,i);
}
public List<Join_constraintContext> join_constraint() {
return getRuleContexts(Join_constraintContext.class);
}
public Join_constraintContext join_constraint(int i) {
return getRuleContext(Join_constraintContext.class,i);
}
public Join_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_join_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterJoin_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitJoin_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitJoin_clause(this);
else return visitor.visitChildren(this);
}
}
public final Join_clauseContext join_clause() throws RecognitionException {
Join_clauseContext _localctx = new Join_clauseContext(_ctx, getState());
enterRule(_localctx, 104, RULE_join_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1403);
table_or_subquery();
setState(1410);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA || _la==K_CROSS || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & ((1L << (K_INNER - 89)) | (1L << (K_JOIN - 89)) | (1L << (K_LEFT - 89)) | (1L << (K_NATURAL - 89)))) != 0)) {
{
{
setState(1404);
join_operator();
setState(1405);
table_or_subquery();
setState(1406);
join_constraint();
}
}
setState(1412);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Join_operatorContext extends ParserRuleContext {
public TerminalNode K_JOIN() { return getToken(SQLiteParser.K_JOIN, 0); }
public TerminalNode K_NATURAL() { return getToken(SQLiteParser.K_NATURAL, 0); }
public TerminalNode K_LEFT() { return getToken(SQLiteParser.K_LEFT, 0); }
public TerminalNode K_INNER() { return getToken(SQLiteParser.K_INNER, 0); }
public TerminalNode K_CROSS() { return getToken(SQLiteParser.K_CROSS, 0); }
public TerminalNode K_OUTER() { return getToken(SQLiteParser.K_OUTER, 0); }
public Join_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_join_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterJoin_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitJoin_operator(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitJoin_operator(this);
else return visitor.visitChildren(this);
}
}
public final Join_operatorContext join_operator() throws RecognitionException {
Join_operatorContext _localctx = new Join_operatorContext(_ctx, getState());
enterRule(_localctx, 106, RULE_join_operator);
int _la;
try {
setState(1426);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COMMA:
enterOuterAlt(_localctx, 1);
{
setState(1413);
match(COMMA);
}
break;
case K_CROSS:
case K_INNER:
case K_JOIN:
case K_LEFT:
case K_NATURAL:
enterOuterAlt(_localctx, 2);
{
setState(1415);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_NATURAL) {
{
setState(1414);
match(K_NATURAL);
}
}
setState(1423);
_errHandler.sync(this);
switch (_input.LA(1)) {
case K_LEFT:
{
setState(1417);
match(K_LEFT);
setState(1419);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==K_OUTER) {
{
setState(1418);
match(K_OUTER);
}
}
}
break;
case K_INNER:
{
setState(1421);
match(K_INNER);
}
break;
case K_CROSS:
{
setState(1422);
match(K_CROSS);
}
break;
case K_JOIN:
break;
default:
break;
}
setState(1425);
match(K_JOIN);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Join_constraintContext extends ParserRuleContext {
public TerminalNode K_ON() { return getToken(SQLiteParser.K_ON, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode K_USING() { return getToken(SQLiteParser.K_USING, 0); }
public List<Column_nameContext> column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public Join_constraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_join_constraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterJoin_constraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitJoin_constraint(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitJoin_constraint(this);
else return visitor.visitChildren(this);
}
}
public final Join_constraintContext join_constraint() throws RecognitionException {
Join_constraintContext _localctx = new Join_constraintContext(_ctx, getState());
enterRule(_localctx, 108, RULE_join_constraint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1442);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,210,_ctx) ) {
case 1:
{
setState(1428);
match(K_ON);
setState(1429);
expr(0);
}
break;
case 2:
{
setState(1430);
match(K_USING);
setState(1431);
match(OPEN_PAR);
setState(1432);
column_name();
setState(1437);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1433);
match(COMMA);
setState(1434);
column_name();
}
}
setState(1439);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1440);
match(CLOSE_PAR);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Compound_operatorContext extends ParserRuleContext {
public TerminalNode K_UNION() { return getToken(SQLiteParser.K_UNION, 0); }
public TerminalNode K_ALL() { return getToken(SQLiteParser.K_ALL, 0); }
public TerminalNode K_INTERSECT() { return getToken(SQLiteParser.K_INTERSECT, 0); }
public TerminalNode K_EXCEPT() { return getToken(SQLiteParser.K_EXCEPT, 0); }
public Compound_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compound_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterCompound_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitCompound_operator(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitCompound_operator(this);
else return visitor.visitChildren(this);
}
}
public final Compound_operatorContext compound_operator() throws RecognitionException {
Compound_operatorContext _localctx = new Compound_operatorContext(_ctx, getState());
enterRule(_localctx, 110, RULE_compound_operator);
try {
setState(1449);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,211,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1444);
match(K_UNION);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1445);
match(K_UNION);
setState(1446);
match(K_ALL);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1447);
match(K_INTERSECT);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1448);
match(K_EXCEPT);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Signed_numberContext extends ParserRuleContext {
public TerminalNode NUMERIC_LITERAL() { return getToken(SQLiteParser.NUMERIC_LITERAL, 0); }
public Signed_numberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_signed_number; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterSigned_number(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitSigned_number(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitSigned_number(this);
else return visitor.visitChildren(this);
}
}
public final Signed_numberContext signed_number() throws RecognitionException {
Signed_numberContext _localctx = new Signed_numberContext(_ctx, getState());
enterRule(_localctx, 112, RULE_signed_number);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1452);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==MINUS) {
{
setState(1451);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1454);
match(NUMERIC_LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Literal_valueContext extends ParserRuleContext {
public TerminalNode NUMERIC_LITERAL() { return getToken(SQLiteParser.NUMERIC_LITERAL, 0); }
public TerminalNode STRING_LITERAL() { return getToken(SQLiteParser.STRING_LITERAL, 0); }
public TerminalNode BLOB_LITERAL() { return getToken(SQLiteParser.BLOB_LITERAL, 0); }
public TerminalNode K_NULL() { return getToken(SQLiteParser.K_NULL, 0); }
public TerminalNode K_CURRENT_TIME() { return getToken(SQLiteParser.K_CURRENT_TIME, 0); }
public TerminalNode K_CURRENT_DATE() { return getToken(SQLiteParser.K_CURRENT_DATE, 0); }
public TerminalNode K_CURRENT_TIMESTAMP() { return getToken(SQLiteParser.K_CURRENT_TIMESTAMP, 0); }
public Boolean_literalContext boolean_literal() {
return getRuleContext(Boolean_literalContext.class,0);
}
public Literal_valueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal_value; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterLiteral_value(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitLiteral_value(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitLiteral_value(this);
else return visitor.visitChildren(this);
}
}
public final Literal_valueContext literal_value() throws RecognitionException {
Literal_valueContext _localctx = new Literal_valueContext(_ctx, getState());
enterRule(_localctx, 114, RULE_literal_value);
try {
setState(1464);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NUMERIC_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(1456);
match(NUMERIC_LITERAL);
}
break;
case STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(1457);
match(STRING_LITERAL);
}
break;
case BLOB_LITERAL:
enterOuterAlt(_localctx, 3);
{
setState(1458);
match(BLOB_LITERAL);
}
break;
case K_NULL:
enterOuterAlt(_localctx, 4);
{
setState(1459);
match(K_NULL);
}
break;
case K_CURRENT_TIME:
enterOuterAlt(_localctx, 5);
{
setState(1460);
match(K_CURRENT_TIME);
}
break;
case K_CURRENT_DATE:
enterOuterAlt(_localctx, 6);
{
setState(1461);
match(K_CURRENT_DATE);
}
break;
case K_CURRENT_TIMESTAMP:
enterOuterAlt(_localctx, 7);
{
setState(1462);
match(K_CURRENT_TIMESTAMP);
}
break;
case TRUE:
case FALSE:
enterOuterAlt(_localctx, 8);
{
setState(1463);
boolean_literal();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Boolean_literalContext extends ParserRuleContext {
public TerminalNode TRUE() { return getToken(SQLiteParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(SQLiteParser.FALSE, 0); }
public Boolean_literalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_boolean_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterBoolean_literal(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitBoolean_literal(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitBoolean_literal(this);
else return visitor.visitChildren(this);
}
}
public final Boolean_literalContext boolean_literal() throws RecognitionException {
Boolean_literalContext _localctx = new Boolean_literalContext(_ctx, getState());
enterRule(_localctx, 116, RULE_boolean_literal);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1466);
_la = _input.LA(1);
if ( !(_la==TRUE || _la==FALSE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Unary_operatorContext extends ParserRuleContext {
public TerminalNode K_NOT() { return getToken(SQLiteParser.K_NOT, 0); }
public Unary_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unary_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterUnary_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitUnary_operator(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitUnary_operator(this);
else return visitor.visitChildren(this);
}
}
public final Unary_operatorContext unary_operator() throws RecognitionException {
Unary_operatorContext _localctx = new Unary_operatorContext(_ctx, getState());
enterRule(_localctx, 118, RULE_unary_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1468);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PLUS) | (1L << MINUS) | (1L << TILDE))) != 0) || _la==K_NOT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Binary_operatorContext extends ParserRuleContext {
public TerminalNode K_AND() { return getToken(SQLiteParser.K_AND, 0); }
public TerminalNode K_OR() { return getToken(SQLiteParser.K_OR, 0); }
public Binary_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_binary_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterBinary_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitBinary_operator(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitBinary_operator(this);
else return visitor.visitChildren(this);
}
}
public final Binary_operatorContext binary_operator() throws RecognitionException {
Binary_operatorContext _localctx = new Binary_operatorContext(_ctx, getState());
enterRule(_localctx, 120, RULE_binary_operator);
int _la;
try {
setState(1478);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PIPE2:
enterOuterAlt(_localctx, 1);
{
setState(1470);
match(PIPE2);
}
break;
case STAR:
case DIV:
case MOD:
enterOuterAlt(_localctx, 2);
{
setState(1471);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STAR) | (1L << DIV) | (1L << MOD))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case PLUS:
case MINUS:
enterOuterAlt(_localctx, 3);
{
setState(1472);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case LT2:
case GT2:
case AMP:
case PIPE:
enterOuterAlt(_localctx, 4);
{
setState(1473);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LT2) | (1L << GT2) | (1L << AMP) | (1L << PIPE))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case LT:
case LT_EQ:
case GT:
case GT_EQ:
enterOuterAlt(_localctx, 5);
{
setState(1474);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LT) | (1L << LT_EQ) | (1L << GT) | (1L << GT_EQ))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case ASSIGN:
case EQ:
case NOT_EQ1:
case NOT_EQ2:
enterOuterAlt(_localctx, 6);
{
setState(1475);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ASSIGN) | (1L << EQ) | (1L << NOT_EQ1) | (1L << NOT_EQ2))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case K_AND:
enterOuterAlt(_localctx, 7);
{
setState(1476);
match(K_AND);
}
break;
case K_OR:
enterOuterAlt(_localctx, 8);
{
setState(1477);
match(K_OR);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Error_messageContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL() { return getToken(SQLiteParser.STRING_LITERAL, 0); }
public Error_messageContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_error_message; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterError_message(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitError_message(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitError_message(this);
else return visitor.visitChildren(this);
}
}
public final Error_messageContext error_message() throws RecognitionException {
Error_messageContext _localctx = new Error_messageContext(_ctx, getState());
enterRule(_localctx, 122, RULE_error_message);
try {
enterOuterAlt(_localctx, 1);
{
setState(1480);
match(STRING_LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Module_argumentContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Column_defContext column_def() {
return getRuleContext(Column_defContext.class,0);
}
public Module_argumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_module_argument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterModule_argument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitModule_argument(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitModule_argument(this);
else return visitor.visitChildren(this);
}
}
public final Module_argumentContext module_argument() throws RecognitionException {
Module_argumentContext _localctx = new Module_argumentContext(_ctx, getState());
enterRule(_localctx, 124, RULE_module_argument);
try {
setState(1484);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,215,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1482);
expr(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1483);
column_def();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Column_aliasContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(SQLiteParser.IDENTIFIER, 0); }
public TerminalNode STRING_LITERAL() { return getToken(SQLiteParser.STRING_LITERAL, 0); }
public Column_aliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_column_alias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterColumn_alias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitColumn_alias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitColumn_alias(this);
else return visitor.visitChildren(this);
}
}
public final Column_aliasContext column_alias() throws RecognitionException {
Column_aliasContext _localctx = new Column_aliasContext(_ctx, getState());
enterRule(_localctx, 126, RULE_column_alias);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1486);
_la = _input.LA(1);
if ( !(_la==IDENTIFIER || _la==STRING_LITERAL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Column_name_listContext extends ParserRuleContext {
public List<Column_nameContext> column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public Column_name_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_column_name_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterColumn_name_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitColumn_name_list(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitColumn_name_list(this);
else return visitor.visitChildren(this);
}
}
public final Column_name_listContext column_name_list() throws RecognitionException {
Column_name_listContext _localctx = new Column_name_listContext(_ctx, getState());
enterRule(_localctx, 128, RULE_column_name_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1488);
match(OPEN_PAR);
setState(1489);
column_name();
setState(1494);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1490);
match(COMMA);
setState(1491);
column_name();
}
}
setState(1496);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1497);
match(CLOSE_PAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class KeywordContext extends ParserRuleContext {
public TerminalNode K_ABORT() { return getToken(SQLiteParser.K_ABORT, 0); }
public TerminalNode K_ACTION() { return getToken(SQLiteParser.K_ACTION, 0); }
public TerminalNode K_ADD() { return getToken(SQLiteParser.K_ADD, 0); }
public TerminalNode K_AFTER() { return getToken(SQLiteParser.K_AFTER, 0); }
public TerminalNode K_ALL() { return getToken(SQLiteParser.K_ALL, 0); }
public TerminalNode K_ALTER() { return getToken(SQLiteParser.K_ALTER, 0); }
public TerminalNode K_ANALYZE() { return getToken(SQLiteParser.K_ANALYZE, 0); }
public TerminalNode K_AND() { return getToken(SQLiteParser.K_AND, 0); }
public TerminalNode K_AS() { return getToken(SQLiteParser.K_AS, 0); }
public TerminalNode K_ASC() { return getToken(SQLiteParser.K_ASC, 0); }
public TerminalNode K_ATTACH() { return getToken(SQLiteParser.K_ATTACH, 0); }
public TerminalNode K_AUTOINCREMENT() { return getToken(SQLiteParser.K_AUTOINCREMENT, 0); }
public TerminalNode K_BEFORE() { return getToken(SQLiteParser.K_BEFORE, 0); }
public TerminalNode K_BEGIN() { return getToken(SQLiteParser.K_BEGIN, 0); }
public TerminalNode K_BETWEEN() { return getToken(SQLiteParser.K_BETWEEN, 0); }
public TerminalNode K_BY() { return getToken(SQLiteParser.K_BY, 0); }
public TerminalNode K_CASCADE() { return getToken(SQLiteParser.K_CASCADE, 0); }
public TerminalNode K_CASE() { return getToken(SQLiteParser.K_CASE, 0); }
public TerminalNode K_CAST() { return getToken(SQLiteParser.K_CAST, 0); }
public TerminalNode K_CHECK() { return getToken(SQLiteParser.K_CHECK, 0); }
public TerminalNode K_COLLATE() { return getToken(SQLiteParser.K_COLLATE, 0); }
public TerminalNode K_COLUMN() { return getToken(SQLiteParser.K_COLUMN, 0); }
public TerminalNode K_COMMIT() { return getToken(SQLiteParser.K_COMMIT, 0); }
public TerminalNode K_CONFLICT() { return getToken(SQLiteParser.K_CONFLICT, 0); }
public TerminalNode K_CONSTRAINT() { return getToken(SQLiteParser.K_CONSTRAINT, 0); }
public TerminalNode K_CREATE() { return getToken(SQLiteParser.K_CREATE, 0); }
public TerminalNode K_CROSS() { return getToken(SQLiteParser.K_CROSS, 0); }
public TerminalNode K_CURRENT_DATE() { return getToken(SQLiteParser.K_CURRENT_DATE, 0); }
public TerminalNode K_CURRENT_TIME() { return getToken(SQLiteParser.K_CURRENT_TIME, 0); }
public TerminalNode K_CURRENT_TIMESTAMP() { return getToken(SQLiteParser.K_CURRENT_TIMESTAMP, 0); }
public TerminalNode K_DATABASE() { return getToken(SQLiteParser.K_DATABASE, 0); }
public TerminalNode K_DEFAULT() { return getToken(SQLiteParser.K_DEFAULT, 0); }
public TerminalNode K_DEFERRABLE() { return getToken(SQLiteParser.K_DEFERRABLE, 0); }
public TerminalNode K_DEFERRED() { return getToken(SQLiteParser.K_DEFERRED, 0); }
public TerminalNode K_DELETE() { return getToken(SQLiteParser.K_DELETE, 0); }
public TerminalNode K_DESC() { return getToken(SQLiteParser.K_DESC, 0); }
public TerminalNode K_DETACH() { return getToken(SQLiteParser.K_DETACH, 0); }
public TerminalNode K_DISTINCT() { return getToken(SQLiteParser.K_DISTINCT, 0); }
public TerminalNode K_DROP() { return getToken(SQLiteParser.K_DROP, 0); }
public TerminalNode K_EACH() { return getToken(SQLiteParser.K_EACH, 0); }
public TerminalNode K_ELSE() { return getToken(SQLiteParser.K_ELSE, 0); }
public TerminalNode K_END() { return getToken(SQLiteParser.K_END, 0); }
public TerminalNode K_ESCAPE() { return getToken(SQLiteParser.K_ESCAPE, 0); }
public TerminalNode K_EXCEPT() { return getToken(SQLiteParser.K_EXCEPT, 0); }
public TerminalNode K_EXCLUSIVE() { return getToken(SQLiteParser.K_EXCLUSIVE, 0); }
public TerminalNode K_EXISTS() { return getToken(SQLiteParser.K_EXISTS, 0); }
public TerminalNode K_EXPLAIN() { return getToken(SQLiteParser.K_EXPLAIN, 0); }
public TerminalNode K_FAIL() { return getToken(SQLiteParser.K_FAIL, 0); }
public TerminalNode K_FOR() { return getToken(SQLiteParser.K_FOR, 0); }
public TerminalNode K_FOREIGN() { return getToken(SQLiteParser.K_FOREIGN, 0); }
public TerminalNode K_FROM() { return getToken(SQLiteParser.K_FROM, 0); }
public TerminalNode K_FULL() { return getToken(SQLiteParser.K_FULL, 0); }
public TerminalNode K_GLOB() { return getToken(SQLiteParser.K_GLOB, 0); }
public TerminalNode K_GROUP() { return getToken(SQLiteParser.K_GROUP, 0); }
public TerminalNode K_HAVING() { return getToken(SQLiteParser.K_HAVING, 0); }
public TerminalNode K_IF() { return getToken(SQLiteParser.K_IF, 0); }
public TerminalNode K_IGNORE() { return getToken(SQLiteParser.K_IGNORE, 0); }
public TerminalNode K_IMMEDIATE() { return getToken(SQLiteParser.K_IMMEDIATE, 0); }
public TerminalNode K_IN() { return getToken(SQLiteParser.K_IN, 0); }
public TerminalNode K_INDEX() { return getToken(SQLiteParser.K_INDEX, 0); }
public TerminalNode K_INDEXED() { return getToken(SQLiteParser.K_INDEXED, 0); }
public TerminalNode K_INITIALLY() { return getToken(SQLiteParser.K_INITIALLY, 0); }
public TerminalNode K_INNER() { return getToken(SQLiteParser.K_INNER, 0); }
public TerminalNode K_INSERT() { return getToken(SQLiteParser.K_INSERT, 0); }
public TerminalNode K_INSTEAD() { return getToken(SQLiteParser.K_INSTEAD, 0); }
public TerminalNode K_INTERSECT() { return getToken(SQLiteParser.K_INTERSECT, 0); }
public TerminalNode K_INTO() { return getToken(SQLiteParser.K_INTO, 0); }
public TerminalNode K_IS() { return getToken(SQLiteParser.K_IS, 0); }
public TerminalNode K_ISNULL() { return getToken(SQLiteParser.K_ISNULL, 0); }
public TerminalNode K_JOIN() { return getToken(SQLiteParser.K_JOIN, 0); }
public TerminalNode K_KEY() { return getToken(SQLiteParser.K_KEY, 0); }
public TerminalNode K_LEFT() { return getToken(SQLiteParser.K_LEFT, 0); }
public TerminalNode K_LIKE() { return getToken(SQLiteParser.K_LIKE, 0); }
public TerminalNode K_LIMIT() { return getToken(SQLiteParser.K_LIMIT, 0); }
public TerminalNode K_MATCH() { return getToken(SQLiteParser.K_MATCH, 0); }
public TerminalNode K_NATURAL() { return getToken(SQLiteParser.K_NATURAL, 0); }
public TerminalNode K_NO() { return getToken(SQLiteParser.K_NO, 0); }
public TerminalNode K_NOT() { return getToken(SQLiteParser.K_NOT, 0); }
public TerminalNode K_NOTNULL() { return getToken(SQLiteParser.K_NOTNULL, 0); }
public TerminalNode K_NULL() { return getToken(SQLiteParser.K_NULL, 0); }
public TerminalNode K_OF() { return getToken(SQLiteParser.K_OF, 0); }
public TerminalNode K_OFFSET() { return getToken(SQLiteParser.K_OFFSET, 0); }
public TerminalNode K_ON() { return getToken(SQLiteParser.K_ON, 0); }
public TerminalNode K_OR() { return getToken(SQLiteParser.K_OR, 0); }
public TerminalNode K_ORDER() { return getToken(SQLiteParser.K_ORDER, 0); }
public TerminalNode K_OUTER() { return getToken(SQLiteParser.K_OUTER, 0); }
public TerminalNode K_PLAN() { return getToken(SQLiteParser.K_PLAN, 0); }
public TerminalNode K_PRAGMA() { return getToken(SQLiteParser.K_PRAGMA, 0); }
public TerminalNode K_PRIMARY() { return getToken(SQLiteParser.K_PRIMARY, 0); }
public TerminalNode K_QUERY() { return getToken(SQLiteParser.K_QUERY, 0); }
public TerminalNode K_RAISE() { return getToken(SQLiteParser.K_RAISE, 0); }
public TerminalNode K_RECURSIVE() { return getToken(SQLiteParser.K_RECURSIVE, 0); }
public TerminalNode K_REFERENCES() { return getToken(SQLiteParser.K_REFERENCES, 0); }
public TerminalNode K_REGEXP() { return getToken(SQLiteParser.K_REGEXP, 0); }
public TerminalNode K_REINDEX() { return getToken(SQLiteParser.K_REINDEX, 0); }
public TerminalNode K_RELEASE() { return getToken(SQLiteParser.K_RELEASE, 0); }
public TerminalNode K_RENAME() { return getToken(SQLiteParser.K_RENAME, 0); }
public TerminalNode K_REPLACE() { return getToken(SQLiteParser.K_REPLACE, 0); }
public TerminalNode K_RESTRICT() { return getToken(SQLiteParser.K_RESTRICT, 0); }
public TerminalNode K_RIGHT() { return getToken(SQLiteParser.K_RIGHT, 0); }
public TerminalNode K_ROLLBACK() { return getToken(SQLiteParser.K_ROLLBACK, 0); }
public TerminalNode K_ROW() { return getToken(SQLiteParser.K_ROW, 0); }
public TerminalNode K_SAVEPOINT() { return getToken(SQLiteParser.K_SAVEPOINT, 0); }
public TerminalNode K_SELECT() { return getToken(SQLiteParser.K_SELECT, 0); }
public TerminalNode K_SET() { return getToken(SQLiteParser.K_SET, 0); }
public TerminalNode K_TABLE() { return getToken(SQLiteParser.K_TABLE, 0); }
public TerminalNode K_TEMP() { return getToken(SQLiteParser.K_TEMP, 0); }
public TerminalNode K_TEMPORARY() { return getToken(SQLiteParser.K_TEMPORARY, 0); }
public TerminalNode K_THEN() { return getToken(SQLiteParser.K_THEN, 0); }
public TerminalNode K_TO() { return getToken(SQLiteParser.K_TO, 0); }
public TerminalNode K_TRANSACTION() { return getToken(SQLiteParser.K_TRANSACTION, 0); }
public TerminalNode K_TRIGGER() { return getToken(SQLiteParser.K_TRIGGER, 0); }
public TerminalNode K_UNION() { return getToken(SQLiteParser.K_UNION, 0); }
public TerminalNode K_UNIQUE() { return getToken(SQLiteParser.K_UNIQUE, 0); }
public TerminalNode K_UPDATE() { return getToken(SQLiteParser.K_UPDATE, 0); }
public TerminalNode K_USING() { return getToken(SQLiteParser.K_USING, 0); }
public TerminalNode K_VACUUM() { return getToken(SQLiteParser.K_VACUUM, 0); }
public TerminalNode K_VALUES() { return getToken(SQLiteParser.K_VALUES, 0); }
public TerminalNode K_VIEW() { return getToken(SQLiteParser.K_VIEW, 0); }
public TerminalNode K_VIRTUAL() { return getToken(SQLiteParser.K_VIRTUAL, 0); }
public TerminalNode K_WHEN() { return getToken(SQLiteParser.K_WHEN, 0); }
public TerminalNode K_WHERE() { return getToken(SQLiteParser.K_WHERE, 0); }
public TerminalNode K_WITH() { return getToken(SQLiteParser.K_WITH, 0); }
public TerminalNode K_WITHOUT() { return getToken(SQLiteParser.K_WITHOUT, 0); }
public KeywordContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_keyword; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterKeyword(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitKeyword(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitKeyword(this);
else return visitor.visitChildren(this);
}
}
public final KeywordContext keyword() throws RecognitionException {
KeywordContext _localctx = new KeywordContext(_ctx, getState());
enterRule(_localctx, 130, RULE_keyword);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1499);
_la = _input.LA(1);
if ( !(((((_la - 27)) & ~0x3f) == 0 && ((1L << (_la - 27)) & ((1L << (K_ABORT - 27)) | (1L << (K_ACTION - 27)) | (1L << (K_ADD - 27)) | (1L << (K_AFTER - 27)) | (1L << (K_ALL - 27)) | (1L << (K_ALTER - 27)) | (1L << (K_ANALYZE - 27)) | (1L << (K_AND - 27)) | (1L << (K_AS - 27)) | (1L << (K_ASC - 27)) | (1L << (K_ATTACH - 27)) | (1L << (K_AUTOINCREMENT - 27)) | (1L << (K_BEFORE - 27)) | (1L << (K_BEGIN - 27)) | (1L << (K_BETWEEN - 27)) | (1L << (K_BY - 27)) | (1L << (K_CASCADE - 27)) | (1L << (K_CASE - 27)) | (1L << (K_CAST - 27)) | (1L << (K_CHECK - 27)) | (1L << (K_COLLATE - 27)) | (1L << (K_COLUMN - 27)) | (1L << (K_COMMIT - 27)) | (1L << (K_CONFLICT - 27)) | (1L << (K_CONSTRAINT - 27)) | (1L << (K_CREATE - 27)) | (1L << (K_CROSS - 27)) | (1L << (K_CURRENT_DATE - 27)) | (1L << (K_CURRENT_TIME - 27)) | (1L << (K_CURRENT_TIMESTAMP - 27)) | (1L << (K_DATABASE - 27)) | (1L << (K_DEFAULT - 27)) | (1L << (K_DEFERRABLE - 27)) | (1L << (K_DEFERRED - 27)) | (1L << (K_DELETE - 27)) | (1L << (K_DESC - 27)) | (1L << (K_DETACH - 27)) | (1L << (K_DISTINCT - 27)) | (1L << (K_DROP - 27)) | (1L << (K_EACH - 27)) | (1L << (K_ELSE - 27)) | (1L << (K_END - 27)) | (1L << (K_ESCAPE - 27)) | (1L << (K_EXCEPT - 27)) | (1L << (K_EXCLUSIVE - 27)) | (1L << (K_EXISTS - 27)) | (1L << (K_EXPLAIN - 27)) | (1L << (K_FAIL - 27)) | (1L << (K_FOR - 27)) | (1L << (K_FOREIGN - 27)) | (1L << (K_FROM - 27)) | (1L << (K_FULL - 27)) | (1L << (K_GLOB - 27)) | (1L << (K_GROUP - 27)) | (1L << (K_HAVING - 27)) | (1L << (K_IF - 27)) | (1L << (K_IGNORE - 27)) | (1L << (K_IMMEDIATE - 27)) | (1L << (K_IN - 27)) | (1L << (K_INDEX - 27)) | (1L << (K_INDEXED - 27)) | (1L << (K_INITIALLY - 27)) | (1L << (K_INNER - 27)) | (1L << (K_INSERT - 27)))) != 0) || ((((_la - 91)) & ~0x3f) == 0 && ((1L << (_la - 91)) & ((1L << (K_INSTEAD - 91)) | (1L << (K_INTERSECT - 91)) | (1L << (K_INTO - 91)) | (1L << (K_IS - 91)) | (1L << (K_ISNULL - 91)) | (1L << (K_JOIN - 91)) | (1L << (K_KEY - 91)) | (1L << (K_LEFT - 91)) | (1L << (K_LIKE - 91)) | (1L << (K_LIMIT - 91)) | (1L << (K_MATCH - 91)) | (1L << (K_NATURAL - 91)) | (1L << (K_NO - 91)) | (1L << (K_NOT - 91)) | (1L << (K_NOTNULL - 91)) | (1L << (K_NULL - 91)) | (1L << (K_OF - 91)) | (1L << (K_OFFSET - 91)) | (1L << (K_ON - 91)) | (1L << (K_OR - 91)) | (1L << (K_ORDER - 91)) | (1L << (K_OUTER - 91)) | (1L << (K_PLAN - 91)) | (1L << (K_PRAGMA - 91)) | (1L << (K_PRIMARY - 91)) | (1L << (K_QUERY - 91)) | (1L << (K_RAISE - 91)) | (1L << (K_RECURSIVE - 91)) | (1L << (K_REFERENCES - 91)) | (1L << (K_REGEXP - 91)) | (1L << (K_REINDEX - 91)) | (1L << (K_RELEASE - 91)) | (1L << (K_RENAME - 91)) | (1L << (K_REPLACE - 91)) | (1L << (K_RESTRICT - 91)) | (1L << (K_RIGHT - 91)) | (1L << (K_ROLLBACK - 91)) | (1L << (K_ROW - 91)) | (1L << (K_SAVEPOINT - 91)) | (1L << (K_SELECT - 91)) | (1L << (K_SET - 91)) | (1L << (K_TABLE - 91)) | (1L << (K_TEMP - 91)) | (1L << (K_TEMPORARY - 91)) | (1L << (K_THEN - 91)) | (1L << (K_TO - 91)) | (1L << (K_TRANSACTION - 91)) | (1L << (K_TRIGGER - 91)) | (1L << (K_UNION - 91)) | (1L << (K_UNIQUE - 91)) | (1L << (K_UPDATE - 91)) | (1L << (K_USING - 91)) | (1L << (K_VACUUM - 91)) | (1L << (K_VALUES - 91)) | (1L << (K_VIEW - 91)) | (1L << (K_VIRTUAL - 91)) | (1L << (K_WHEN - 91)) | (1L << (K_WHERE - 91)) | (1L << (K_WITH - 91)) | (1L << (K_WITHOUT - 91)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public NameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitName(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitName(this);
else return visitor.visitChildren(this);
}
}
public final NameContext name() throws RecognitionException {
NameContext _localctx = new NameContext(_ctx, getState());
enterRule(_localctx, 132, RULE_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1501);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Function_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Function_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterFunction_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitFunction_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitFunction_name(this);
else return visitor.visitChildren(this);
}
}
public final Function_nameContext function_name() throws RecognitionException {
Function_nameContext _localctx = new Function_nameContext(_ctx, getState());
enterRule(_localctx, 134, RULE_function_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1503);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Schema_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Schema_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_schema_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterSchema_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitSchema_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitSchema_name(this);
else return visitor.visitChildren(this);
}
}
public final Schema_nameContext schema_name() throws RecognitionException {
Schema_nameContext _localctx = new Schema_nameContext(_ctx, getState());
enterRule(_localctx, 136, RULE_schema_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1505);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_functionContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Table_functionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_function; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterTable_function(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitTable_function(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitTable_function(this);
else return visitor.visitChildren(this);
}
}
public final Table_functionContext table_function() throws RecognitionException {
Table_functionContext _localctx = new Table_functionContext(_ctx, getState());
enterRule(_localctx, 138, RULE_table_function);
try {
enterOuterAlt(_localctx, 1);
{
setState(1507);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Table_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterTable_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitTable_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitTable_name(this);
else return visitor.visitChildren(this);
}
}
public final Table_nameContext table_name() throws RecognitionException {
Table_nameContext _localctx = new Table_nameContext(_ctx, getState());
enterRule(_localctx, 140, RULE_table_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1509);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_or_index_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Table_or_index_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_or_index_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterTable_or_index_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitTable_or_index_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitTable_or_index_name(this);
else return visitor.visitChildren(this);
}
}
public final Table_or_index_nameContext table_or_index_name() throws RecognitionException {
Table_or_index_nameContext _localctx = new Table_or_index_nameContext(_ctx, getState());
enterRule(_localctx, 142, RULE_table_or_index_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1511);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class New_table_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public New_table_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_new_table_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterNew_table_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitNew_table_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitNew_table_name(this);
else return visitor.visitChildren(this);
}
}
public final New_table_nameContext new_table_name() throws RecognitionException {
New_table_nameContext _localctx = new New_table_nameContext(_ctx, getState());
enterRule(_localctx, 144, RULE_new_table_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1513);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Column_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Column_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_column_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterColumn_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitColumn_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitColumn_name(this);
else return visitor.visitChildren(this);
}
}
public final Column_nameContext column_name() throws RecognitionException {
Column_nameContext _localctx = new Column_nameContext(_ctx, getState());
enterRule(_localctx, 146, RULE_column_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1515);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Collation_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Collation_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_collation_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterCollation_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitCollation_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitCollation_name(this);
else return visitor.visitChildren(this);
}
}
public final Collation_nameContext collation_name() throws RecognitionException {
Collation_nameContext _localctx = new Collation_nameContext(_ctx, getState());
enterRule(_localctx, 148, RULE_collation_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1517);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Foreign_tableContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Foreign_tableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_foreign_table; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterForeign_table(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitForeign_table(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitForeign_table(this);
else return visitor.visitChildren(this);
}
}
public final Foreign_tableContext foreign_table() throws RecognitionException {
Foreign_tableContext _localctx = new Foreign_tableContext(_ctx, getState());
enterRule(_localctx, 150, RULE_foreign_table);
try {
enterOuterAlt(_localctx, 1);
{
setState(1519);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Index_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Index_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_index_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterIndex_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitIndex_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitIndex_name(this);
else return visitor.visitChildren(this);
}
}
public final Index_nameContext index_name() throws RecognitionException {
Index_nameContext _localctx = new Index_nameContext(_ctx, getState());
enterRule(_localctx, 152, RULE_index_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1521);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Trigger_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Trigger_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trigger_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterTrigger_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitTrigger_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitTrigger_name(this);
else return visitor.visitChildren(this);
}
}
public final Trigger_nameContext trigger_name() throws RecognitionException {
Trigger_nameContext _localctx = new Trigger_nameContext(_ctx, getState());
enterRule(_localctx, 154, RULE_trigger_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1523);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class View_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public View_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_view_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterView_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitView_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitView_name(this);
else return visitor.visitChildren(this);
}
}
public final View_nameContext view_name() throws RecognitionException {
View_nameContext _localctx = new View_nameContext(_ctx, getState());
enterRule(_localctx, 156, RULE_view_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1525);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Module_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Module_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_module_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterModule_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitModule_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitModule_name(this);
else return visitor.visitChildren(this);
}
}
public final Module_nameContext module_name() throws RecognitionException {
Module_nameContext _localctx = new Module_nameContext(_ctx, getState());
enterRule(_localctx, 158, RULE_module_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1527);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Pragma_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Pragma_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pragma_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterPragma_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitPragma_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitPragma_name(this);
else return visitor.visitChildren(this);
}
}
public final Pragma_nameContext pragma_name() throws RecognitionException {
Pragma_nameContext _localctx = new Pragma_nameContext(_ctx, getState());
enterRule(_localctx, 160, RULE_pragma_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1529);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Savepoint_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Savepoint_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_savepoint_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterSavepoint_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitSavepoint_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitSavepoint_name(this);
else return visitor.visitChildren(this);
}
}
public final Savepoint_nameContext savepoint_name() throws RecognitionException {
Savepoint_nameContext _localctx = new Savepoint_nameContext(_ctx, getState());
enterRule(_localctx, 162, RULE_savepoint_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1531);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_aliasContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(SQLiteParser.IDENTIFIER, 0); }
public TerminalNode STRING_LITERAL() { return getToken(SQLiteParser.STRING_LITERAL, 0); }
public Table_aliasContext table_alias() {
return getRuleContext(Table_aliasContext.class,0);
}
public Table_aliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_alias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterTable_alias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitTable_alias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitTable_alias(this);
else return visitor.visitChildren(this);
}
}
public final Table_aliasContext table_alias() throws RecognitionException {
Table_aliasContext _localctx = new Table_aliasContext(_ctx, getState());
enterRule(_localctx, 164, RULE_table_alias);
try {
setState(1539);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(1533);
match(IDENTIFIER);
}
break;
case STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(1534);
match(STRING_LITERAL);
}
break;
case OPEN_PAR:
enterOuterAlt(_localctx, 3);
{
setState(1535);
match(OPEN_PAR);
setState(1536);
table_alias();
setState(1537);
match(CLOSE_PAR);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Transaction_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Transaction_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_transaction_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterTransaction_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitTransaction_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitTransaction_name(this);
else return visitor.visitChildren(this);
}
}
public final Transaction_nameContext transaction_name() throws RecognitionException {
Transaction_nameContext _localctx = new Transaction_nameContext(_ctx, getState());
enterRule(_localctx, 166, RULE_transaction_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1541);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Any_nameContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(SQLiteParser.IDENTIFIER, 0); }
public KeywordContext keyword() {
return getRuleContext(KeywordContext.class,0);
}
public TerminalNode STRING_LITERAL() { return getToken(SQLiteParser.STRING_LITERAL, 0); }
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Any_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_any_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).enterAny_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteListener ) ((SQLiteListener)listener).exitAny_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteVisitor ) return ((SQLiteVisitor<? extends T>)visitor).visitAny_name(this);
else return visitor.visitChildren(this);
}
}
public final Any_nameContext any_name() throws RecognitionException {
Any_nameContext _localctx = new Any_nameContext(_ctx, getState());
enterRule(_localctx, 168, RULE_any_name);
try {
setState(1550);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(1543);
match(IDENTIFIER);
}
break;
case K_ABORT:
case K_ACTION:
case K_ADD:
case K_AFTER:
case K_ALL:
case K_ALTER:
case K_ANALYZE:
case K_AND:
case K_AS:
case K_ASC:
case K_ATTACH:
case K_AUTOINCREMENT:
case K_BEFORE:
case K_BEGIN:
case K_BETWEEN:
case K_BY:
case K_CASCADE:
case K_CASE:
case K_CAST:
case K_CHECK:
case K_COLLATE:
case K_COLUMN:
case K_COMMIT:
case K_CONFLICT:
case K_CONSTRAINT:
case K_CREATE:
case K_CROSS:
case K_CURRENT_DATE:
case K_CURRENT_TIME:
case K_CURRENT_TIMESTAMP:
case K_DATABASE:
case K_DEFAULT:
case K_DEFERRABLE:
case K_DEFERRED:
case K_DELETE:
case K_DESC:
case K_DETACH:
case K_DISTINCT:
case K_DROP:
case K_EACH:
case K_ELSE:
case K_END:
case K_ESCAPE:
case K_EXCEPT:
case K_EXCLUSIVE:
case K_EXISTS:
case K_EXPLAIN:
case K_FAIL:
case K_FOR:
case K_FOREIGN:
case K_FROM:
case K_FULL:
case K_GLOB:
case K_GROUP:
case K_HAVING:
case K_IF:
case K_IGNORE:
case K_IMMEDIATE:
case K_IN:
case K_INDEX:
case K_INDEXED:
case K_INITIALLY:
case K_INNER:
case K_INSERT:
case K_INSTEAD:
case K_INTERSECT:
case K_INTO:
case K_IS:
case K_ISNULL:
case K_JOIN:
case K_KEY:
case K_LEFT:
case K_LIKE:
case K_LIMIT:
case K_MATCH:
case K_NATURAL:
case K_NO:
case K_NOT:
case K_NOTNULL:
case K_NULL:
case K_OF:
case K_OFFSET:
case K_ON:
case K_OR:
case K_ORDER:
case K_OUTER:
case K_PLAN:
case K_PRAGMA:
case K_PRIMARY:
case K_QUERY:
case K_RAISE:
case K_RECURSIVE:
case K_REFERENCES:
case K_REGEXP:
case K_REINDEX:
case K_RELEASE:
case K_RENAME:
case K_REPLACE:
case K_RESTRICT:
case K_RIGHT:
case K_ROLLBACK:
case K_ROW:
case K_SAVEPOINT:
case K_SELECT:
case K_SET:
case K_TABLE:
case K_TEMP:
case K_TEMPORARY:
case K_THEN:
case K_TO:
case K_TRANSACTION:
case K_TRIGGER:
case K_UNION:
case K_UNIQUE:
case K_UPDATE:
case K_USING:
case K_VACUUM:
case K_VALUES:
case K_VIEW:
case K_VIRTUAL:
case K_WHEN:
case K_WHERE:
case K_WITH:
case K_WITHOUT:
enterOuterAlt(_localctx, 2);
{
setState(1544);
keyword();
}
break;
case STRING_LITERAL:
enterOuterAlt(_localctx, 3);
{
setState(1545);
match(STRING_LITERAL);
}
break;
case OPEN_PAR:
enterOuterAlt(_localctx, 4);
{
setState(1546);
match(OPEN_PAR);
setState(1547);
any_name();
setState(1548);
match(CLOSE_PAR);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 37:
return expr_sempred((ExprContext)_localctx, predIndex);
}
return true;
}
private boolean expr_sempred(ExprContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 13);
case 1:
return precpred(_ctx, 6);
case 2:
return precpred(_ctx, 5);
case 3:
return precpred(_ctx, 9);
case 4:
return precpred(_ctx, 8);
case 5:
return precpred(_ctx, 7);
case 6:
return precpred(_ctx, 4);
}
return true;
}
public static final String _serializedATN =
"\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\u00a4\u0613\t"+
"\t\t\t\t\t\b\t\b\t\t\t\n\t\n3"+
"\t3\f\t\f\r\t\r6\t67\t70\t01\t12\t2"+
"3\t34\t45\t56\t67\t70\t01\t1"+
"2\t23\t34\t45\t56\t67\t7 \t !"+
"\t!\"\t\"#\t#$\t$%\t%&\t&