// Generated from /mnt/disks/build-disk/src/android/androidx-main/frameworks/support/room/room-compiler/SQLiteParser.g4 by ANTLR 4.13.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", "CheckReturnValue"})
public class SQLiteParser extends Parser {
static { RuntimeMetaData.checkVersion("4.13.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, ABORT_=25,
ACTION_=26, ADD_=27, AFTER_=28, ALL_=29, ALTER_=30, ANALYZE_=31, AND_=32,
AS_=33, ASC_=34, ATTACH_=35, AUTOINCREMENT_=36, BEFORE_=37, BEGIN_=38,
BETWEEN_=39, BY_=40, CASCADE_=41, CASE_=42, CAST_=43, CHECK_=44, COLLATE_=45,
COLUMN_=46, COMMIT_=47, CONFLICT_=48, CONSTRAINT_=49, CREATE_=50, CROSS_=51,
CURRENT_DATE_=52, CURRENT_TIME_=53, CURRENT_TIMESTAMP_=54, DATABASE_=55,
DEFAULT_=56, DEFERRABLE_=57, DEFERRED_=58, DELETE_=59, DESC_=60, DETACH_=61,
DISTINCT_=62, DROP_=63, EACH_=64, ELSE_=65, END_=66, ESCAPE_=67, EXCEPT_=68,
EXCLUSIVE_=69, EXISTS_=70, EXPLAIN_=71, FAIL_=72, FOR_=73, FOREIGN_=74,
FROM_=75, FULL_=76, GLOB_=77, GROUP_=78, HAVING_=79, IF_=80, IGNORE_=81,
IMMEDIATE_=82, IN_=83, INDEX_=84, INDEXED_=85, INITIALLY_=86, INNER_=87,
INSERT_=88, INSTEAD_=89, INTERSECT_=90, INTO_=91, IS_=92, ISNULL_=93,
JOIN_=94, KEY_=95, LEFT_=96, LIKE_=97, LIMIT_=98, MATCH_=99, NATURAL_=100,
NO_=101, NOT_=102, NOTNULL_=103, NULL_=104, OF_=105, OFFSET_=106, ON_=107,
OR_=108, ORDER_=109, OUTER_=110, PLAN_=111, PRAGMA_=112, PRIMARY_=113,
QUERY_=114, RAISE_=115, RECURSIVE_=116, REFERENCES_=117, REGEXP_=118,
REINDEX_=119, RELEASE_=120, RENAME_=121, REPLACE_=122, RESTRICT_=123,
RETURNING_=124, RIGHT_=125, ROLLBACK_=126, ROW_=127, ROWS_=128, SAVEPOINT_=129,
SELECT_=130, SET_=131, TABLE_=132, TEMP_=133, TEMPORARY_=134, THEN_=135,
TO_=136, TRANSACTION_=137, TRIGGER_=138, UNION_=139, UNIQUE_=140, UPDATE_=141,
USING_=142, VACUUM_=143, VALUES_=144, VIEW_=145, VIRTUAL_=146, WHEN_=147,
WHERE_=148, WITH_=149, WITHOUT_=150, FIRST_VALUE_=151, OVER_=152, PARTITION_=153,
RANGE_=154, PRECEDING_=155, UNBOUNDED_=156, CURRENT_=157, FOLLOWING_=158,
CUME_DIST_=159, DENSE_RANK_=160, LAG_=161, LAST_VALUE_=162, LEAD_=163,
NTH_VALUE_=164, NTILE_=165, PERCENT_RANK_=166, RANK_=167, ROW_NUMBER_=168,
GENERATED_=169, ALWAYS_=170, STORED_=171, TRUE_=172, FALSE_=173, WINDOW_=174,
NULLS_=175, FIRST_=176, LAST_=177, FILTER_=178, GROUPS_=179, EXCLUDE_=180,
TIES_=181, OTHERS_=182, DO_=183, NOTHING_=184, IDENTIFIER=185, NUMERIC_LITERAL=186,
BIND_PARAMETER=187, STRING_LITERAL=188, BLOB_LITERAL=189, SINGLE_LINE_COMMENT=190,
MULTILINE_COMMENT=191, SPACES=192, UNEXPECTED_CHAR=193;
public static final int
RULE_parse = 0, RULE_sql_stmt_list = 1, RULE_sql_stmt = 2, RULE_alter_table_stmt = 3,
RULE_analyze_stmt = 4, RULE_attach_stmt = 5, RULE_begin_stmt = 6, RULE_commit_stmt = 7,
RULE_rollback_stmt = 8, RULE_savepoint_stmt = 9, RULE_release_stmt = 10,
RULE_create_index_stmt = 11, RULE_indexed_column = 12, RULE_create_table_stmt = 13,
RULE_column_def = 14, RULE_type_name = 15, RULE_column_constraint = 16,
RULE_signed_number = 17, RULE_table_constraint = 18, RULE_foreign_key_clause = 19,
RULE_conflict_clause = 20, RULE_create_trigger_stmt = 21, RULE_create_view_stmt = 22,
RULE_create_virtual_table_stmt = 23, RULE_with_clause = 24, RULE_cte_table_name = 25,
RULE_recursive_cte = 26, RULE_common_table_expression = 27, RULE_delete_stmt = 28,
RULE_delete_stmt_limited = 29, RULE_detach_stmt = 30, RULE_drop_stmt = 31,
RULE_expr = 32, RULE_comma_separated_expr = 33, RULE_raise_function = 34,
RULE_literal_value = 35, RULE_value_row = 36, RULE_values_clause = 37,
RULE_insert_stmt = 38, RULE_returning_clause = 39, RULE_upsert_clause = 40,
RULE_pragma_stmt = 41, RULE_pragma_value = 42, RULE_reindex_stmt = 43,
RULE_select_stmt = 44, RULE_join_clause = 45, RULE_select_core = 46, RULE_factored_select_stmt = 47,
RULE_simple_select_stmt = 48, RULE_compound_select_stmt = 49, RULE_table_or_subquery = 50,
RULE_result_column = 51, RULE_join_operator = 52, RULE_join_constraint = 53,
RULE_compound_operator = 54, RULE_update_stmt = 55, RULE_column_name_list = 56,
RULE_update_stmt_limited = 57, RULE_qualified_table_name = 58, RULE_vacuum_stmt = 59,
RULE_filter_clause = 60, RULE_window_defn = 61, RULE_over_clause = 62,
RULE_frame_spec = 63, RULE_frame_clause = 64, RULE_simple_function_invocation = 65,
RULE_aggregate_function_invocation = 66, RULE_window_function_invocation = 67,
RULE_common_table_stmt = 68, RULE_order_by_stmt = 69, RULE_limit_stmt = 70,
RULE_ordering_term = 71, RULE_asc_desc = 72, RULE_frame_left = 73, RULE_frame_right = 74,
RULE_frame_single = 75, RULE_window_function = 76, RULE_offset = 77, RULE_default_value = 78,
RULE_partition_by = 79, RULE_order_by_expr = 80, RULE_order_by_expr_asc_desc = 81,
RULE_expr_asc_desc = 82, RULE_initial_select = 83, RULE_recursive_select = 84,
RULE_unary_operator = 85, RULE_error_message = 86, RULE_module_argument = 87,
RULE_column_alias = 88, RULE_keyword = 89, RULE_name = 90, RULE_function_name = 91,
RULE_schema_name = 92, RULE_table_name = 93, RULE_table_or_index_name = 94,
RULE_column_name = 95, RULE_collation_name = 96, RULE_foreign_table = 97,
RULE_index_name = 98, RULE_trigger_name = 99, RULE_view_name = 100, RULE_module_name = 101,
RULE_pragma_name = 102, RULE_savepoint_name = 103, RULE_table_alias = 104,
RULE_transaction_name = 105, RULE_window_name = 106, RULE_alias = 107,
RULE_filename = 108, RULE_base_window_name = 109, RULE_simple_func = 110,
RULE_aggregate_func = 111, RULE_table_function_name = 112, RULE_any_name = 113;
private static String[] makeRuleNames() {
return new String[] {
"parse", "sql_stmt_list", "sql_stmt", "alter_table_stmt", "analyze_stmt",
"attach_stmt", "begin_stmt", "commit_stmt", "rollback_stmt", "savepoint_stmt",
"release_stmt", "create_index_stmt", "indexed_column", "create_table_stmt",
"column_def", "type_name", "column_constraint", "signed_number", "table_constraint",
"foreign_key_clause", "conflict_clause", "create_trigger_stmt", "create_view_stmt",
"create_virtual_table_stmt", "with_clause", "cte_table_name", "recursive_cte",
"common_table_expression", "delete_stmt", "delete_stmt_limited", "detach_stmt",
"drop_stmt", "expr", "comma_separated_expr", "raise_function", "literal_value",
"value_row", "values_clause", "insert_stmt", "returning_clause", "upsert_clause",
"pragma_stmt", "pragma_value", "reindex_stmt", "select_stmt", "join_clause",
"select_core", "factored_select_stmt", "simple_select_stmt", "compound_select_stmt",
"table_or_subquery", "result_column", "join_operator", "join_constraint",
"compound_operator", "update_stmt", "column_name_list", "update_stmt_limited",
"qualified_table_name", "vacuum_stmt", "filter_clause", "window_defn",
"over_clause", "frame_spec", "frame_clause", "simple_function_invocation",
"aggregate_function_invocation", "window_function_invocation", "common_table_stmt",
"order_by_stmt", "limit_stmt", "ordering_term", "asc_desc", "frame_left",
"frame_right", "frame_single", "window_function", "offset", "default_value",
"partition_by", "order_by_expr", "order_by_expr_asc_desc", "expr_asc_desc",
"initial_select", "recursive_select", "unary_operator", "error_message",
"module_argument", "column_alias", "keyword", "name", "function_name",
"schema_name", "table_name", "table_or_index_name", "column_name", "collation_name",
"foreign_table", "index_name", "trigger_name", "view_name", "module_name",
"pragma_name", "savepoint_name", "table_alias", "transaction_name", "window_name",
"alias", "filename", "base_window_name", "simple_func", "aggregate_func",
"table_function_name", "any_name"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "';'", "'.'", "'('", "')'", "','", "'='", "'*'", "'+'", "'-'",
"'~'", "'||'", "'/'", "'%'", "'<<'", "'>>'", "'&'", "'|'", "'<'", "'<='",
"'>'", "'>='", "'=='", "'!='", "'<>'", "'ABORT'", "'ACTION'", "'ADD'",
"'AFTER'", "'ALL'", "'ALTER'", "'ANALYZE'", "'AND'", "'AS'", "'ASC'",
"'ATTACH'", "'AUTOINCREMENT'", "'BEFORE'", "'BEGIN'", "'BETWEEN'", "'BY'",
"'CASCADE'", "'CASE'", "'CAST'", "'CHECK'", "'COLLATE'", "'COLUMN'",
"'COMMIT'", "'CONFLICT'", "'CONSTRAINT'", "'CREATE'", "'CROSS'", "'CURRENT_DATE'",
"'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", "'DATABASE'", "'DEFAULT'", "'DEFERRABLE'",
"'DEFERRED'", "'DELETE'", "'DESC'", "'DETACH'", "'DISTINCT'", "'DROP'",
"'EACH'", "'ELSE'", "'END'", "'ESCAPE'", "'EXCEPT'", "'EXCLUSIVE'", "'EXISTS'",
"'EXPLAIN'", "'FAIL'", "'FOR'", "'FOREIGN'", "'FROM'", "'FULL'", "'GLOB'",
"'GROUP'", "'HAVING'", "'IF'", "'IGNORE'", "'IMMEDIATE'", "'IN'", "'INDEX'",
"'INDEXED'", "'INITIALLY'", "'INNER'", "'INSERT'", "'INSTEAD'", "'INTERSECT'",
"'INTO'", "'IS'", "'ISNULL'", "'JOIN'", "'KEY'", "'LEFT'", "'LIKE'",
"'LIMIT'", "'MATCH'", "'NATURAL'", "'NO'", "'NOT'", "'NOTNULL'", "'NULL'",
"'OF'", "'OFFSET'", "'ON'", "'OR'", "'ORDER'", "'OUTER'", "'PLAN'", "'PRAGMA'",
"'PRIMARY'", "'QUERY'", "'RAISE'", "'RECURSIVE'", "'REFERENCES'", "'REGEXP'",
"'REINDEX'", "'RELEASE'", "'RENAME'", "'REPLACE'", "'RESTRICT'", "'RETURNING'",
"'RIGHT'", "'ROLLBACK'", "'ROW'", "'ROWS'", "'SAVEPOINT'", "'SELECT'",
"'SET'", "'TABLE'", "'TEMP'", "'TEMPORARY'", "'THEN'", "'TO'", "'TRANSACTION'",
"'TRIGGER'", "'UNION'", "'UNIQUE'", "'UPDATE'", "'USING'", "'VACUUM'",
"'VALUES'", "'VIEW'", "'VIRTUAL'", "'WHEN'", "'WHERE'", "'WITH'", "'WITHOUT'",
"'FIRST_VALUE'", "'OVER'", "'PARTITION'", "'RANGE'", "'PRECEDING'", "'UNBOUNDED'",
"'CURRENT'", "'FOLLOWING'", "'CUME_DIST'", "'DENSE_RANK'", "'LAG'", "'LAST_VALUE'",
"'LEAD'", "'NTH_VALUE'", "'NTILE'", "'PERCENT_RANK'", "'RANK'", "'ROW_NUMBER'",
"'GENERATED'", "'ALWAYS'", "'STORED'", "'TRUE'", "'FALSE'", "'WINDOW'",
"'NULLS'", "'FIRST'", "'LAST'", "'FILTER'", "'GROUPS'", "'EXCLUDE'",
"'TIES'", "'OTHERS'", "'DO'", "'NOTHING'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
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", "ABORT_",
"ACTION_", "ADD_", "AFTER_", "ALL_", "ALTER_", "ANALYZE_", "AND_", "AS_",
"ASC_", "ATTACH_", "AUTOINCREMENT_", "BEFORE_", "BEGIN_", "BETWEEN_",
"BY_", "CASCADE_", "CASE_", "CAST_", "CHECK_", "COLLATE_", "COLUMN_",
"COMMIT_", "CONFLICT_", "CONSTRAINT_", "CREATE_", "CROSS_", "CURRENT_DATE_",
"CURRENT_TIME_", "CURRENT_TIMESTAMP_", "DATABASE_", "DEFAULT_", "DEFERRABLE_",
"DEFERRED_", "DELETE_", "DESC_", "DETACH_", "DISTINCT_", "DROP_", "EACH_",
"ELSE_", "END_", "ESCAPE_", "EXCEPT_", "EXCLUSIVE_", "EXISTS_", "EXPLAIN_",
"FAIL_", "FOR_", "FOREIGN_", "FROM_", "FULL_", "GLOB_", "GROUP_", "HAVING_",
"IF_", "IGNORE_", "IMMEDIATE_", "IN_", "INDEX_", "INDEXED_", "INITIALLY_",
"INNER_", "INSERT_", "INSTEAD_", "INTERSECT_", "INTO_", "IS_", "ISNULL_",
"JOIN_", "KEY_", "LEFT_", "LIKE_", "LIMIT_", "MATCH_", "NATURAL_", "NO_",
"NOT_", "NOTNULL_", "NULL_", "OF_", "OFFSET_", "ON_", "OR_", "ORDER_",
"OUTER_", "PLAN_", "PRAGMA_", "PRIMARY_", "QUERY_", "RAISE_", "RECURSIVE_",
"REFERENCES_", "REGEXP_", "REINDEX_", "RELEASE_", "RENAME_", "REPLACE_",
"RESTRICT_", "RETURNING_", "RIGHT_", "ROLLBACK_", "ROW_", "ROWS_", "SAVEPOINT_",
"SELECT_", "SET_", "TABLE_", "TEMP_", "TEMPORARY_", "THEN_", "TO_", "TRANSACTION_",
"TRIGGER_", "UNION_", "UNIQUE_", "UPDATE_", "USING_", "VACUUM_", "VALUES_",
"VIEW_", "VIRTUAL_", "WHEN_", "WHERE_", "WITH_", "WITHOUT_", "FIRST_VALUE_",
"OVER_", "PARTITION_", "RANGE_", "PRECEDING_", "UNBOUNDED_", "CURRENT_",
"FOLLOWING_", "CUME_DIST_", "DENSE_RANK_", "LAG_", "LAST_VALUE_", "LEAD_",
"NTH_VALUE_", "NTILE_", "PERCENT_RANK_", "RANK_", "ROW_NUMBER_", "GENERATED_",
"ALWAYS_", "STORED_", "TRUE_", "FALSE_", "WINDOW_", "NULLS_", "FIRST_",
"LAST_", "FILTER_", "GROUPS_", "EXCLUDE_", "TIES_", "OTHERS_", "DO_",
"NOTHING_", "IDENTIFIER", "NUMERIC_LITERAL", "BIND_PARAMETER", "STRING_LITERAL",
"BLOB_LITERAL", "SINGLE_LINE_COMMENT", "MULTILINE_COMMENT", "SPACES",
"UNEXPECTED_CHAR"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "<INVALID>";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "SQLiteParser.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);
}
@SuppressWarnings("CheckReturnValue")
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 ParseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parse; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterParse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitParse(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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(231);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -6339801325483589630L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & -7971300971697405919L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & 550913L) != 0)) {
{
{
setState(228);
sql_stmt_list();
}
}
setState(233);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(234);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 List<TerminalNode> SCOL() { return getTokens(SQLiteParser.SCOL); }
public TerminalNode SCOL(int i) {
return getToken(SQLiteParser.SCOL, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterSql_stmt_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitSql_stmt_list(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 2, RULE_sql_stmt_list);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(239);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SCOL) {
{
{
setState(236);
match(SCOL);
}
}
setState(241);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(242);
sql_stmt();
setState(251);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(244);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(243);
match(SCOL);
}
}
setState(246);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==SCOL );
setState(248);
sql_stmt();
}
}
}
setState(253);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
}
setState(257);
_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(254);
match(SCOL);
}
}
}
setState(259);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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_stmtContext drop_stmt() {
return getRuleContext(Drop_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 EXPLAIN_() { return getToken(SQLiteParser.EXPLAIN_, 0); }
public TerminalNode QUERY_() { return getToken(SQLiteParser.QUERY_, 0); }
public TerminalNode PLAN_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterSql_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitSql_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 4, RULE_sql_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(265);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXPLAIN_) {
{
setState(260);
match(EXPLAIN_);
setState(263);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QUERY_) {
{
setState(261);
match(QUERY_);
setState(262);
match(PLAN_);
}
}
}
}
setState(291);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
{
setState(267);
alter_table_stmt();
}
break;
case 2:
{
setState(268);
analyze_stmt();
}
break;
case 3:
{
setState(269);
attach_stmt();
}
break;
case 4:
{
setState(270);
begin_stmt();
}
break;
case 5:
{
setState(271);
commit_stmt();
}
break;
case 6:
{
setState(272);
create_index_stmt();
}
break;
case 7:
{
setState(273);
create_table_stmt();
}
break;
case 8:
{
setState(274);
create_trigger_stmt();
}
break;
case 9:
{
setState(275);
create_view_stmt();
}
break;
case 10:
{
setState(276);
create_virtual_table_stmt();
}
break;
case 11:
{
setState(277);
delete_stmt();
}
break;
case 12:
{
setState(278);
delete_stmt_limited();
}
break;
case 13:
{
setState(279);
detach_stmt();
}
break;
case 14:
{
setState(280);
drop_stmt();
}
break;
case 15:
{
setState(281);
insert_stmt();
}
break;
case 16:
{
setState(282);
pragma_stmt();
}
break;
case 17:
{
setState(283);
reindex_stmt();
}
break;
case 18:
{
setState(284);
release_stmt();
}
break;
case 19:
{
setState(285);
rollback_stmt();
}
break;
case 20:
{
setState(286);
savepoint_stmt();
}
break;
case 21:
{
setState(287);
select_stmt();
}
break;
case 22:
{
setState(288);
update_stmt();
}
break;
case 23:
{
setState(289);
update_stmt_limited();
}
break;
case 24:
{
setState(290);
vacuum_stmt();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Alter_table_stmtContext extends ParserRuleContext {
public Table_nameContext new_table_name;
public Column_nameContext old_column_name;
public Column_nameContext new_column_name;
public TerminalNode ALTER_() { return getToken(SQLiteParser.ALTER_, 0); }
public TerminalNode TABLE_() { return getToken(SQLiteParser.TABLE_, 0); }
public List<Table_nameContext> table_name() {
return getRuleContexts(Table_nameContext.class);
}
public Table_nameContext table_name(int i) {
return getRuleContext(Table_nameContext.class,i);
}
public TerminalNode RENAME_() { return getToken(SQLiteParser.RENAME_, 0); }
public TerminalNode ADD_() { return getToken(SQLiteParser.ADD_, 0); }
public Column_defContext column_def() {
return getRuleContext(Column_defContext.class,0);
}
public TerminalNode DROP_() { return getToken(SQLiteParser.DROP_, 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 Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode DOT() { return getToken(SQLiteParser.DOT, 0); }
public TerminalNode TO_() { return getToken(SQLiteParser.TO_, 0); }
public TerminalNode COLUMN_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterAlter_table_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitAlter_table_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 6, RULE_alter_table_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(293);
match(ALTER_);
setState(294);
match(TABLE_);
setState(298);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
{
setState(295);
schema_name();
setState(296);
match(DOT);
}
break;
}
setState(300);
table_name();
setState(323);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RENAME_:
{
setState(301);
match(RENAME_);
setState(311);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(302);
match(TO_);
setState(303);
((Alter_table_stmtContext)_localctx).new_table_name = table_name();
}
break;
case 2:
{
setState(305);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
setState(304);
match(COLUMN_);
}
break;
}
setState(307);
((Alter_table_stmtContext)_localctx).old_column_name = column_name();
setState(308);
match(TO_);
setState(309);
((Alter_table_stmtContext)_localctx).new_column_name = column_name();
}
break;
}
}
break;
case ADD_:
{
setState(313);
match(ADD_);
setState(315);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
setState(314);
match(COLUMN_);
}
break;
}
setState(317);
column_def();
}
break;
case DROP_:
{
setState(318);
match(DROP_);
setState(320);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
{
setState(319);
match(COLUMN_);
}
break;
}
setState(322);
column_name();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Analyze_stmtContext extends ParserRuleContext {
public TerminalNode ANALYZE_() { return getToken(SQLiteParser.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 TerminalNode DOT() { return getToken(SQLiteParser.DOT, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterAnalyze_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitAnalyze_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 8, RULE_analyze_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(325);
match(ANALYZE_);
setState(333);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
{
setState(326);
schema_name();
}
break;
case 2:
{
setState(330);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
{
setState(327);
schema_name();
setState(328);
match(DOT);
}
break;
}
setState(332);
table_or_index_name();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Attach_stmtContext extends ParserRuleContext {
public TerminalNode ATTACH_() { return getToken(SQLiteParser.ATTACH_, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode AS_() { return getToken(SQLiteParser.AS_, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode DATABASE_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterAttach_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitAttach_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 10, RULE_attach_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(335);
match(ATTACH_);
setState(337);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
case 1:
{
setState(336);
match(DATABASE_);
}
break;
}
setState(339);
expr(0);
setState(340);
match(AS_);
setState(341);
schema_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Begin_stmtContext extends ParserRuleContext {
public TerminalNode BEGIN_() { return getToken(SQLiteParser.BEGIN_, 0); }
public TerminalNode TRANSACTION_() { return getToken(SQLiteParser.TRANSACTION_, 0); }
public TerminalNode DEFERRED_() { return getToken(SQLiteParser.DEFERRED_, 0); }
public TerminalNode IMMEDIATE_() { return getToken(SQLiteParser.IMMEDIATE_, 0); }
public TerminalNode EXCLUSIVE_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterBegin_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitBegin_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 12, RULE_begin_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(343);
match(BEGIN_);
setState(345);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 58)) & ~0x3f) == 0 && ((1L << (_la - 58)) & 16779265L) != 0)) {
{
setState(344);
_la = _input.LA(1);
if ( !(((((_la - 58)) & ~0x3f) == 0 && ((1L << (_la - 58)) & 16779265L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(351);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION_) {
{
setState(347);
match(TRANSACTION_);
setState(349);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(348);
transaction_name();
}
break;
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Commit_stmtContext extends ParserRuleContext {
public TerminalNode COMMIT_() { return getToken(SQLiteParser.COMMIT_, 0); }
public TerminalNode END_() { return getToken(SQLiteParser.END_, 0); }
public TerminalNode TRANSACTION_() { return getToken(SQLiteParser.TRANSACTION_, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterCommit_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitCommit_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 14, RULE_commit_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(353);
_la = _input.LA(1);
if ( !(_la==COMMIT_ || _la==END_) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(355);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION_) {
{
setState(354);
match(TRANSACTION_);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Rollback_stmtContext extends ParserRuleContext {
public TerminalNode ROLLBACK_() { return getToken(SQLiteParser.ROLLBACK_, 0); }
public TerminalNode TRANSACTION_() { return getToken(SQLiteParser.TRANSACTION_, 0); }
public TerminalNode TO_() { return getToken(SQLiteParser.TO_, 0); }
public Savepoint_nameContext savepoint_name() {
return getRuleContext(Savepoint_nameContext.class,0);
}
public TerminalNode SAVEPOINT_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterRollback_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitRollback_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 16, RULE_rollback_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(357);
match(ROLLBACK_);
setState(359);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION_) {
{
setState(358);
match(TRANSACTION_);
}
}
setState(366);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TO_) {
{
setState(361);
match(TO_);
setState(363);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
{
setState(362);
match(SAVEPOINT_);
}
break;
}
setState(365);
savepoint_name();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Savepoint_stmtContext extends ParserRuleContext {
public TerminalNode SAVEPOINT_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterSavepoint_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitSavepoint_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 18, RULE_savepoint_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(368);
match(SAVEPOINT_);
setState(369);
savepoint_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Release_stmtContext extends ParserRuleContext {
public TerminalNode RELEASE_() { return getToken(SQLiteParser.RELEASE_, 0); }
public Savepoint_nameContext savepoint_name() {
return getRuleContext(Savepoint_nameContext.class,0);
}
public TerminalNode SAVEPOINT_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterRelease_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitRelease_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 20, RULE_release_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(371);
match(RELEASE_);
setState(373);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
{
setState(372);
match(SAVEPOINT_);
}
break;
}
setState(375);
savepoint_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Create_index_stmtContext extends ParserRuleContext {
public TerminalNode CREATE_() { return getToken(SQLiteParser.CREATE_, 0); }
public TerminalNode INDEX_() { return getToken(SQLiteParser.INDEX_, 0); }
public Index_nameContext index_name() {
return getRuleContext(Index_nameContext.class,0);
}
public TerminalNode ON_() { return getToken(SQLiteParser.ON_, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 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 CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public TerminalNode UNIQUE_() { return getToken(SQLiteParser.UNIQUE_, 0); }
public TerminalNode IF_() { return getToken(SQLiteParser.IF_, 0); }
public TerminalNode NOT_() { return getToken(SQLiteParser.NOT_, 0); }
public TerminalNode EXISTS_() { return getToken(SQLiteParser.EXISTS_, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode DOT() { return getToken(SQLiteParser.DOT, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public TerminalNode WHERE_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterCreate_index_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitCreate_index_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 22, RULE_create_index_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(377);
match(CREATE_);
setState(379);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==UNIQUE_) {
{
setState(378);
match(UNIQUE_);
}
}
setState(381);
match(INDEX_);
setState(385);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
{
setState(382);
match(IF_);
setState(383);
match(NOT_);
setState(384);
match(EXISTS_);
}
break;
}
setState(390);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
{
setState(387);
schema_name();
setState(388);
match(DOT);
}
break;
}
setState(392);
index_name();
setState(393);
match(ON_);
setState(394);
table_name();
setState(395);
match(OPEN_PAR);
setState(396);
indexed_column();
setState(401);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(397);
match(COMMA);
setState(398);
indexed_column();
}
}
setState(403);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(404);
match(CLOSE_PAR);
setState(407);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE_) {
{
setState(405);
match(WHERE_);
setState(406);
expr(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 COLLATE_() { return getToken(SQLiteParser.COLLATE_, 0); }
public Collation_nameContext collation_name() {
return getRuleContext(Collation_nameContext.class,0);
}
public Asc_descContext asc_desc() {
return getRuleContext(Asc_descContext.class,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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterIndexed_column(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitIndexed_column(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 24, RULE_indexed_column);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(411);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
case 1:
{
setState(409);
column_name();
}
break;
case 2:
{
setState(410);
expr(0);
}
break;
}
setState(415);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLLATE_) {
{
setState(413);
match(COLLATE_);
setState(414);
collation_name();
}
}
setState(418);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC_ || _la==DESC_) {
{
setState(417);
asc_desc();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Create_table_stmtContext extends ParserRuleContext {
public Token row_ROW_ID;
public TerminalNode CREATE_() { return getToken(SQLiteParser.CREATE_, 0); }
public TerminalNode TABLE_() { return getToken(SQLiteParser.TABLE_, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 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 CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public TerminalNode AS_() { return getToken(SQLiteParser.AS_, 0); }
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public TerminalNode IF_() { return getToken(SQLiteParser.IF_, 0); }
public TerminalNode NOT_() { return getToken(SQLiteParser.NOT_, 0); }
public TerminalNode EXISTS_() { return getToken(SQLiteParser.EXISTS_, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode DOT() { return getToken(SQLiteParser.DOT, 0); }
public TerminalNode TEMP_() { return getToken(SQLiteParser.TEMP_, 0); }
public TerminalNode TEMPORARY_() { return getToken(SQLiteParser.TEMPORARY_, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
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_() { return getToken(SQLiteParser.WITHOUT_, 0); }
public TerminalNode IDENTIFIER() { return getToken(SQLiteParser.IDENTIFIER, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterCreate_table_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitCreate_table_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 26, RULE_create_table_stmt);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(420);
match(CREATE_);
setState(422);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMP_ || _la==TEMPORARY_) {
{
setState(421);
_la = _input.LA(1);
if ( !(_la==TEMP_ || _la==TEMPORARY_) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(424);
match(TABLE_);
setState(428);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
case 1:
{
setState(425);
match(IF_);
setState(426);
match(NOT_);
setState(427);
match(EXISTS_);
}
break;
}
setState(433);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
case 1:
{
setState(430);
schema_name();
setState(431);
match(DOT);
}
break;
}
setState(435);
table_name();
setState(459);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_PAR:
{
setState(436);
match(OPEN_PAR);
setState(437);
column_def();
setState(442);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(438);
match(COMMA);
setState(439);
column_def();
}
}
}
setState(444);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
}
setState(449);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(445);
match(COMMA);
setState(446);
table_constraint();
}
}
setState(451);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(452);
match(CLOSE_PAR);
setState(455);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITHOUT_) {
{
setState(453);
match(WITHOUT_);
setState(454);
((Create_table_stmtContext)_localctx).row_ROW_ID = match(IDENTIFIER);
}
}
}
break;
case AS_:
{
setState(457);
match(AS_);
setState(458);
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;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterColumn_def(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitColumn_def(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 28, RULE_column_def);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(461);
column_name();
setState(463);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
case 1:
{
setState(462);
type_name();
}
break;
}
setState(468);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 72673329139417088L) != 0) || ((((_la - 102)) & ~0x3f) == 0 && ((1L << (_la - 102)) & 274877941765L) != 0) || _la==GENERATED_) {
{
{
setState(465);
column_constraint();
}
}
setState(470);
_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;
}
@SuppressWarnings("CheckReturnValue")
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 TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
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 TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public TerminalNode COMMA() { return getToken(SQLiteParser.COMMA, 0); }
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterType_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitType_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 30, RULE_type_name);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(472);
_errHandler.sync(this);
_alt = 1+1;
do {
switch (_alt) {
case 1+1:
{
{
setState(471);
name();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(474);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,42,_ctx);
} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(486);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
case 1:
{
setState(476);
match(OPEN_PAR);
setState(477);
signed_number();
setState(478);
match(CLOSE_PAR);
}
break;
case 2:
{
setState(480);
match(OPEN_PAR);
setState(481);
signed_number();
setState(482);
match(COMMA);
setState(483);
signed_number();
setState(484);
match(CLOSE_PAR);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Column_constraintContext extends ParserRuleContext {
public TerminalNode CHECK_() { return getToken(SQLiteParser.CHECK_, 0); }
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public TerminalNode DEFAULT_() { return getToken(SQLiteParser.DEFAULT_, 0); }
public TerminalNode COLLATE_() { return getToken(SQLiteParser.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 AS_() { return getToken(SQLiteParser.AS_, 0); }
public TerminalNode CONSTRAINT_() { return getToken(SQLiteParser.CONSTRAINT_, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode PRIMARY_() { return getToken(SQLiteParser.PRIMARY_, 0); }
public TerminalNode KEY_() { return getToken(SQLiteParser.KEY_, 0); }
public TerminalNode NULL_() { return getToken(SQLiteParser.NULL_, 0); }
public TerminalNode UNIQUE_() { return getToken(SQLiteParser.UNIQUE_, 0); }
public Signed_numberContext signed_number() {
return getRuleContext(Signed_numberContext.class,0);
}
public Literal_valueContext literal_value() {
return getRuleContext(Literal_valueContext.class,0);
}
public Conflict_clauseContext conflict_clause() {
return getRuleContext(Conflict_clauseContext.class,0);
}
public TerminalNode GENERATED_() { return getToken(SQLiteParser.GENERATED_, 0); }
public TerminalNode ALWAYS_() { return getToken(SQLiteParser.ALWAYS_, 0); }
public TerminalNode STORED_() { return getToken(SQLiteParser.STORED_, 0); }
public TerminalNode VIRTUAL_() { return getToken(SQLiteParser.VIRTUAL_, 0); }
public Asc_descContext asc_desc() {
return getRuleContext(Asc_descContext.class,0);
}
public TerminalNode AUTOINCREMENT_() { return getToken(SQLiteParser.AUTOINCREMENT_, 0); }
public TerminalNode NOT_() { return getToken(SQLiteParser.NOT_, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterColumn_constraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitColumn_constraint(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 32, RULE_column_constraint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(490);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CONSTRAINT_) {
{
setState(488);
match(CONSTRAINT_);
setState(489);
name();
}
}
setState(541);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PRIMARY_:
{
{
setState(492);
match(PRIMARY_);
setState(493);
match(KEY_);
setState(495);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC_ || _la==DESC_) {
{
setState(494);
asc_desc();
}
}
setState(498);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON_) {
{
setState(497);
conflict_clause();
}
}
setState(501);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AUTOINCREMENT_) {
{
setState(500);
match(AUTOINCREMENT_);
}
}
}
}
break;
case NOT_:
case NULL_:
case UNIQUE_:
{
setState(508);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NOT_:
case NULL_:
{
setState(504);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT_) {
{
setState(503);
match(NOT_);
}
}
setState(506);
match(NULL_);
}
break;
case UNIQUE_:
{
setState(507);
match(UNIQUE_);
}
break;
default:
throw new NoViableAltException(this);
}
setState(511);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON_) {
{
setState(510);
conflict_clause();
}
}
}
break;
case CHECK_:
{
setState(513);
match(CHECK_);
setState(514);
match(OPEN_PAR);
setState(515);
expr(0);
setState(516);
match(CLOSE_PAR);
}
break;
case DEFAULT_:
{
setState(518);
match(DEFAULT_);
setState(525);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
case 1:
{
setState(519);
signed_number();
}
break;
case 2:
{
setState(520);
literal_value();
}
break;
case 3:
{
setState(521);
match(OPEN_PAR);
setState(522);
expr(0);
setState(523);
match(CLOSE_PAR);
}
break;
}
}
break;
case COLLATE_:
{
setState(527);
match(COLLATE_);
setState(528);
collation_name();
}
break;
case REFERENCES_:
{
setState(529);
foreign_key_clause();
}
break;
case AS_:
case GENERATED_:
{
setState(532);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GENERATED_) {
{
setState(530);
match(GENERATED_);
setState(531);
match(ALWAYS_);
}
}
setState(534);
match(AS_);
setState(535);
match(OPEN_PAR);
setState(536);
expr(0);
setState(537);
match(CLOSE_PAR);
setState(539);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==VIRTUAL_ || _la==STORED_) {
{
setState(538);
_la = _input.LA(1);
if ( !(_la==VIRTUAL_ || _la==STORED_) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Signed_numberContext extends ParserRuleContext {
public TerminalNode NUMERIC_LITERAL() { return getToken(SQLiteParser.NUMERIC_LITERAL, 0); }
public TerminalNode PLUS() { return getToken(SQLiteParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(SQLiteParser.MINUS, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterSigned_number(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitSigned_number(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 34, RULE_signed_number);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(544);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==MINUS) {
{
setState(543);
_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(546);
match(NUMERIC_LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Table_constraintContext extends ParserRuleContext {
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 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 CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public TerminalNode CHECK_() { return getToken(SQLiteParser.CHECK_, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode FOREIGN_() { return getToken(SQLiteParser.FOREIGN_, 0); }
public TerminalNode KEY_() { return getToken(SQLiteParser.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 CONSTRAINT_() { return getToken(SQLiteParser.CONSTRAINT_, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode PRIMARY_() { return getToken(SQLiteParser.PRIMARY_, 0); }
public TerminalNode UNIQUE_() { return getToken(SQLiteParser.UNIQUE_, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public Conflict_clauseContext conflict_clause() {
return getRuleContext(Conflict_clauseContext.class,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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterTable_constraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitTable_constraint(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 36, RULE_table_constraint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(550);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CONSTRAINT_) {
{
setState(548);
match(CONSTRAINT_);
setState(549);
name();
}
}
setState(589);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PRIMARY_:
case UNIQUE_:
{
setState(555);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PRIMARY_:
{
setState(552);
match(PRIMARY_);
setState(553);
match(KEY_);
}
break;
case UNIQUE_:
{
setState(554);
match(UNIQUE_);
}
break;
default:
throw new NoViableAltException(this);
}
setState(557);
match(OPEN_PAR);
setState(558);
indexed_column();
setState(563);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(559);
match(COMMA);
setState(560);
indexed_column();
}
}
setState(565);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(566);
match(CLOSE_PAR);
setState(568);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON_) {
{
setState(567);
conflict_clause();
}
}
}
break;
case CHECK_:
{
setState(570);
match(CHECK_);
setState(571);
match(OPEN_PAR);
setState(572);
expr(0);
setState(573);
match(CLOSE_PAR);
}
break;
case FOREIGN_:
{
setState(575);
match(FOREIGN_);
setState(576);
match(KEY_);
setState(577);
match(OPEN_PAR);
setState(578);
column_name();
setState(583);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(579);
match(COMMA);
setState(580);
column_name();
}
}
setState(585);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(586);
match(CLOSE_PAR);
setState(587);
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;
}
@SuppressWarnings("CheckReturnValue")
public static class Foreign_key_clauseContext extends ParserRuleContext {
public TerminalNode REFERENCES_() { return getToken(SQLiteParser.REFERENCES_, 0); }
public Foreign_tableContext foreign_table() {
return getRuleContext(Foreign_tableContext.class,0);
}
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 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 CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public List<TerminalNode> ON_() { return getTokens(SQLiteParser.ON_); }
public TerminalNode ON_(int i) {
return getToken(SQLiteParser.ON_, i);
}
public List<TerminalNode> MATCH_() { return getTokens(SQLiteParser.MATCH_); }
public TerminalNode MATCH_(int i) {
return getToken(SQLiteParser.MATCH_, i);
}
public List<NameContext> name() {
return getRuleContexts(NameContext.class);
}
public NameContext name(int i) {
return getRuleContext(NameContext.class,i);
}
public TerminalNode DEFERRABLE_() { return getToken(SQLiteParser.DEFERRABLE_, 0); }
public List<TerminalNode> DELETE_() { return getTokens(SQLiteParser.DELETE_); }
public TerminalNode DELETE_(int i) {
return getToken(SQLiteParser.DELETE_, i);
}
public List<TerminalNode> UPDATE_() { return getTokens(SQLiteParser.UPDATE_); }
public TerminalNode UPDATE_(int i) {
return getToken(SQLiteParser.UPDATE_, i);
}
public List<TerminalNode> SET_() { return getTokens(SQLiteParser.SET_); }
public TerminalNode SET_(int i) {
return getToken(SQLiteParser.SET_, i);
}
public List<TerminalNode> CASCADE_() { return getTokens(SQLiteParser.CASCADE_); }
public TerminalNode CASCADE_(int i) {
return getToken(SQLiteParser.CASCADE_, i);
}
public List<TerminalNode> RESTRICT_() { return getTokens(SQLiteParser.RESTRICT_); }
public TerminalNode RESTRICT_(int i) {
return getToken(SQLiteParser.RESTRICT_, i);
}
public List<TerminalNode> NO_() { return getTokens(SQLiteParser.NO_); }
public TerminalNode NO_(int i) {
return getToken(SQLiteParser.NO_, i);
}
public List<TerminalNode> ACTION_() { return getTokens(SQLiteParser.ACTION_); }
public TerminalNode ACTION_(int i) {
return getToken(SQLiteParser.ACTION_, i);
}
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public List<TerminalNode> NULL_() { return getTokens(SQLiteParser.NULL_); }
public TerminalNode NULL_(int i) {
return getToken(SQLiteParser.NULL_, i);
}
public List<TerminalNode> DEFAULT_() { return getTokens(SQLiteParser.DEFAULT_); }
public TerminalNode DEFAULT_(int i) {
return getToken(SQLiteParser.DEFAULT_, i);
}
public TerminalNode NOT_() { return getToken(SQLiteParser.NOT_, 0); }
public TerminalNode INITIALLY_() { return getToken(SQLiteParser.INITIALLY_, 0); }
public TerminalNode DEFERRED_() { return getToken(SQLiteParser.DEFERRED_, 0); }
public TerminalNode IMMEDIATE_() { return getToken(SQLiteParser.IMMEDIATE_, 0); }
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterForeign_key_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitForeign_key_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 38, RULE_foreign_key_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(591);
match(REFERENCES_);
setState(592);
foreign_table();
setState(604);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(593);
match(OPEN_PAR);
setState(594);
column_name();
setState(599);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(595);
match(COMMA);
setState(596);
column_name();
}
}
setState(601);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(602);
match(CLOSE_PAR);
}
}
setState(620);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==MATCH_ || _la==ON_) {
{
setState(618);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ON_:
{
setState(606);
match(ON_);
setState(607);
_la = _input.LA(1);
if ( !(_la==DELETE_ || _la==UPDATE_) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(614);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SET_:
{
setState(608);
match(SET_);
setState(609);
_la = _input.LA(1);
if ( !(_la==DEFAULT_ || _la==NULL_) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case CASCADE_:
{
setState(610);
match(CASCADE_);
}
break;
case RESTRICT_:
{
setState(611);
match(RESTRICT_);
}
break;
case NO_:
{
setState(612);
match(NO_);
setState(613);
match(ACTION_);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case MATCH_:
{
setState(616);
match(MATCH_);
setState(617);
name();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(622);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(631);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
case 1:
{
setState(624);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT_) {
{
setState(623);
match(NOT_);
}
}
setState(626);
match(DEFERRABLE_);
setState(629);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INITIALLY_) {
{
setState(627);
match(INITIALLY_);
setState(628);
_la = _input.LA(1);
if ( !(_la==DEFERRED_ || _la==IMMEDIATE_) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Conflict_clauseContext extends ParserRuleContext {
public TerminalNode ON_() { return getToken(SQLiteParser.ON_, 0); }
public TerminalNode CONFLICT_() { return getToken(SQLiteParser.CONFLICT_, 0); }
public TerminalNode ROLLBACK_() { return getToken(SQLiteParser.ROLLBACK_, 0); }
public TerminalNode ABORT_() { return getToken(SQLiteParser.ABORT_, 0); }
public TerminalNode FAIL_() { return getToken(SQLiteParser.FAIL_, 0); }
public TerminalNode IGNORE_() { return getToken(SQLiteParser.IGNORE_, 0); }
public TerminalNode REPLACE_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterConflict_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitConflict_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 40, RULE_conflict_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(633);
match(ON_);
setState(634);
match(CONFLICT_);
setState(635);
_la = _input.LA(1);
if ( !(_la==ABORT_ || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & 19140298416325121L) != 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;
}
@SuppressWarnings("CheckReturnValue")
public static class Create_trigger_stmtContext extends ParserRuleContext {
public TerminalNode CREATE_() { return getToken(SQLiteParser.CREATE_, 0); }
public TerminalNode TRIGGER_() { return getToken(SQLiteParser.TRIGGER_, 0); }
public Trigger_nameContext trigger_name() {
return getRuleContext(Trigger_nameContext.class,0);
}
public TerminalNode ON_() { return getToken(SQLiteParser.ON_, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode BEGIN_() { return getToken(SQLiteParser.BEGIN_, 0); }
public TerminalNode END_() { return getToken(SQLiteParser.END_, 0); }
public TerminalNode DELETE_() { return getToken(SQLiteParser.DELETE_, 0); }
public TerminalNode INSERT_() { return getToken(SQLiteParser.INSERT_, 0); }
public TerminalNode UPDATE_() { return getToken(SQLiteParser.UPDATE_, 0); }
public TerminalNode IF_() { return getToken(SQLiteParser.IF_, 0); }
public TerminalNode NOT_() { return getToken(SQLiteParser.NOT_, 0); }
public TerminalNode EXISTS_() { return getToken(SQLiteParser.EXISTS_, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode DOT() { return getToken(SQLiteParser.DOT, 0); }
public TerminalNode BEFORE_() { return getToken(SQLiteParser.BEFORE_, 0); }
public TerminalNode AFTER_() { return getToken(SQLiteParser.AFTER_, 0); }
public TerminalNode INSTEAD_() { return getToken(SQLiteParser.INSTEAD_, 0); }
public List<TerminalNode> OF_() { return getTokens(SQLiteParser.OF_); }
public TerminalNode OF_(int i) {
return getToken(SQLiteParser.OF_, i);
}
public TerminalNode FOR_() { return getToken(SQLiteParser.FOR_, 0); }
public TerminalNode EACH_() { return getToken(SQLiteParser.EACH_, 0); }
public TerminalNode ROW_() { return getToken(SQLiteParser.ROW_, 0); }
public TerminalNode WHEN_() { return getToken(SQLiteParser.WHEN_, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public List<TerminalNode> SCOL() { return getTokens(SQLiteParser.SCOL); }
public TerminalNode SCOL(int i) {
return getToken(SQLiteParser.SCOL, i);
}
public TerminalNode TEMP_() { return getToken(SQLiteParser.TEMP_, 0); }
public TerminalNode TEMPORARY_() { return getToken(SQLiteParser.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 List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterCreate_trigger_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitCreate_trigger_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 42, RULE_create_trigger_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(637);
match(CREATE_);
setState(639);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMP_ || _la==TEMPORARY_) {
{
setState(638);
_la = _input.LA(1);
if ( !(_la==TEMP_ || _la==TEMPORARY_) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(641);
match(TRIGGER_);
setState(645);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
case 1:
{
setState(642);
match(IF_);
setState(643);
match(NOT_);
setState(644);
match(EXISTS_);
}
break;
}
setState(650);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
case 1:
{
setState(647);
schema_name();
setState(648);
match(DOT);
}
break;
}
setState(652);
trigger_name();
setState(657);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BEFORE_:
{
setState(653);
match(BEFORE_);
}
break;
case AFTER_:
{
setState(654);
match(AFTER_);
}
break;
case INSTEAD_:
{
setState(655);
match(INSTEAD_);
setState(656);
match(OF_);
}
break;
case DELETE_:
case INSERT_:
case UPDATE_:
break;
default:
break;
}
setState(673);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DELETE_:
{
setState(659);
match(DELETE_);
}
break;
case INSERT_:
{
setState(660);
match(INSERT_);
}
break;
case UPDATE_:
{
setState(661);
match(UPDATE_);
setState(671);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OF_) {
{
setState(662);
match(OF_);
setState(663);
column_name();
setState(668);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(664);
match(COMMA);
setState(665);
column_name();
}
}
setState(670);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(675);
match(ON_);
setState(676);
table_name();
setState(680);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOR_) {
{
setState(677);
match(FOR_);
setState(678);
match(EACH_);
setState(679);
match(ROW_);
}
}
setState(684);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHEN_) {
{
setState(682);
match(WHEN_);
setState(683);
expr(0);
}
}
setState(686);
match(BEGIN_);
setState(695);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(691);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
case 1:
{
setState(687);
update_stmt();
}
break;
case 2:
{
setState(688);
insert_stmt();
}
break;
case 3:
{
setState(689);
delete_stmt();
}
break;
case 4:
{
setState(690);
select_stmt();
}
break;
}
setState(693);
match(SCOL);
}
}
setState(697);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==DELETE_ || ((((_la - 88)) & ~0x3f) == 0 && ((1L << (_la - 88)) & 2386912217732743169L) != 0) );
setState(699);
match(END_);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Create_view_stmtContext extends ParserRuleContext {
public TerminalNode CREATE_() { return getToken(SQLiteParser.CREATE_, 0); }
public TerminalNode VIEW_() { return getToken(SQLiteParser.VIEW_, 0); }
public View_nameContext view_name() {
return getRuleContext(View_nameContext.class,0);
}
public TerminalNode AS_() { return getToken(SQLiteParser.AS_, 0); }
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public TerminalNode IF_() { return getToken(SQLiteParser.IF_, 0); }
public TerminalNode NOT_() { return getToken(SQLiteParser.NOT_, 0); }
public TerminalNode EXISTS_() { return getToken(SQLiteParser.EXISTS_, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode DOT() { return getToken(SQLiteParser.DOT, 0); }
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 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 CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public TerminalNode TEMP_() { return getToken(SQLiteParser.TEMP_, 0); }
public TerminalNode TEMPORARY_() { return getToken(SQLiteParser.TEMPORARY_, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterCreate_view_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitCreate_view_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 44, RULE_create_view_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(701);
match(CREATE_);
setState(703);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMP_ || _la==TEMPORARY_) {
{
setState(702);
_la = _input.LA(1);
if ( !(_la==TEMP_ || _la==TEMPORARY_) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(705);
match(VIEW_);
setState(709);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) {
case 1:
{
setState(706);
match(IF_);
setState(707);
match(NOT_);
setState(708);
match(EXISTS_);
}
break;
}
setState(714);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) {
case 1:
{
setState(711);
schema_name();
setState(712);
match(DOT);
}
break;
}
setState(716);
view_name();
setState(728);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(717);
match(OPEN_PAR);
setState(718);
column_name();
setState(723);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(719);
match(COMMA);
setState(720);
column_name();
}
}
setState(725);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(726);
match(CLOSE_PAR);
}
}
setState(730);
match(AS_);
setState(731);
select_stmt();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Create_virtual_table_stmtContext extends ParserRuleContext {
public TerminalNode CREATE_() { return getToken(SQLiteParser.CREATE_, 0); }
public TerminalNode VIRTUAL_() { return getToken(SQLiteParser.VIRTUAL_, 0); }
public TerminalNode TABLE_() { return getToken(SQLiteParser.TABLE_, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode USING_() { return getToken(SQLiteParser.USING_, 0); }
public Module_nameContext module_name() {
return getRuleContext(Module_nameContext.class,0);
}
public TerminalNode IF_() { return getToken(SQLiteParser.IF_, 0); }
public TerminalNode NOT_() { return getToken(SQLiteParser.NOT_, 0); }
public TerminalNode EXISTS_() { return getToken(SQLiteParser.EXISTS_, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode DOT() { return getToken(SQLiteParser.DOT, 0); }
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 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 TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterCreate_virtual_table_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitCreate_virtual_table_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 46, RULE_create_virtual_table_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(733);
match(CREATE_);
setState(734);
match(VIRTUAL_);
setState(735);
match(TABLE_);
setState(739);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) {
case 1:
{
setState(736);
match(IF_);
setState(737);
match(NOT_);
setState(738);
match(EXISTS_);
}
break;
}
setState(744);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(741);
schema_name();
setState(742);
match(DOT);
}
break;
}
setState(746);
table_name();
setState(747);
match(USING_);
setState(748);
module_name();
setState(760);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(749);
match(OPEN_PAR);
setState(750);
module_argument();
setState(755);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(751);
match(COMMA);
setState(752);
module_argument();
}
}
setState(757);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(758);
match(CLOSE_PAR);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class With_clauseContext extends ParserRuleContext {
public TerminalNode WITH_() { return getToken(SQLiteParser.WITH_, 0); }
public List<Cte_table_nameContext> cte_table_name() {
return getRuleContexts(Cte_table_nameContext.class);
}
public Cte_table_nameContext cte_table_name(int i) {
return getRuleContext(Cte_table_nameContext.class,i);
}
public List<TerminalNode> AS_() { return getTokens(SQLiteParser.AS_); }
public TerminalNode AS_(int i) {
return getToken(SQLiteParser.AS_, i);
}
public List<TerminalNode> OPEN_PAR() { return getTokens(SQLiteParser.OPEN_PAR); }
public TerminalNode OPEN_PAR(int i) {
return getToken(SQLiteParser.OPEN_PAR, 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 List<TerminalNode> CLOSE_PAR() { return getTokens(SQLiteParser.CLOSE_PAR); }
public TerminalNode CLOSE_PAR(int i) {
return getToken(SQLiteParser.CLOSE_PAR, i);
}
public TerminalNode RECURSIVE_() { return getToken(SQLiteParser.RECURSIVE_, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterWith_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitWith_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 48, RULE_with_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(762);
match(WITH_);
setState(764);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
case 1:
{
setState(763);
match(RECURSIVE_);
}
break;
}
setState(766);
cte_table_name();
setState(767);
match(AS_);
setState(768);
match(OPEN_PAR);
setState(769);
select_stmt();
setState(770);
match(CLOSE_PAR);
setState(780);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(771);
match(COMMA);
setState(772);
cte_table_name();
setState(773);
match(AS_);
setState(774);
match(OPEN_PAR);
setState(775);
select_stmt();
setState(776);
match(CLOSE_PAR);
}
}
setState(782);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class Cte_table_nameContext extends ParserRuleContext {
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 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 CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public Cte_table_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cte_table_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterCte_table_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitCte_table_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitCte_table_name(this);
else return visitor.visitChildren(this);
}
}
public final Cte_table_nameContext cte_table_name() throws RecognitionException {
Cte_table_nameContext _localctx = new Cte_table_nameContext(_ctx, getState());
enterRule(_localctx, 50, RULE_cte_table_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(783);
table_name();
setState(795);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(784);
match(OPEN_PAR);
setState(785);
column_name();
setState(790);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(786);
match(COMMA);
setState(787);
column_name();
}
}
setState(792);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(793);
match(CLOSE_PAR);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Recursive_cteContext extends ParserRuleContext {
public Cte_table_nameContext cte_table_name() {
return getRuleContext(Cte_table_nameContext.class,0);
}
public TerminalNode AS_() { return getToken(SQLiteParser.AS_, 0); }
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public Initial_selectContext initial_select() {
return getRuleContext(Initial_selectContext.class,0);
}
public TerminalNode UNION_() { return getToken(SQLiteParser.UNION_, 0); }
public Recursive_selectContext recursive_select() {
return getRuleContext(Recursive_selectContext.class,0);
}
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public TerminalNode ALL_() { return getToken(SQLiteParser.ALL_, 0); }
public Recursive_cteContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_recursive_cte; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterRecursive_cte(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitRecursive_cte(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitRecursive_cte(this);
else return visitor.visitChildren(this);
}
}
public final Recursive_cteContext recursive_cte() throws RecognitionException {
Recursive_cteContext _localctx = new Recursive_cteContext(_ctx, getState());
enterRule(_localctx, 52, RULE_recursive_cte);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(797);
cte_table_name();
setState(798);
match(AS_);
setState(799);
match(OPEN_PAR);
setState(800);
initial_select();
setState(801);
match(UNION_);
setState(803);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL_) {
{
setState(802);
match(ALL_);
}
}
setState(805);
recursive_select();
setState(806);
match(CLOSE_PAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Common_table_expressionContext extends ParserRuleContext {
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode AS_() { return getToken(SQLiteParser.AS_, 0); }
public List<TerminalNode> OPEN_PAR() { return getTokens(SQLiteParser.OPEN_PAR); }
public TerminalNode OPEN_PAR(int i) {
return getToken(SQLiteParser.OPEN_PAR, i);
}
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public List<TerminalNode> CLOSE_PAR() { return getTokens(SQLiteParser.CLOSE_PAR); }
public TerminalNode CLOSE_PAR(int i) {
return getToken(SQLiteParser.CLOSE_PAR, 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<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterCommon_table_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitCommon_table_expression(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 54, RULE_common_table_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(808);
table_name();
setState(820);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(809);
match(OPEN_PAR);
setState(810);
column_name();
setState(815);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(811);
match(COMMA);
setState(812);
column_name();
}
}
setState(817);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(818);
match(CLOSE_PAR);
}
}
setState(822);
match(AS_);
setState(823);
match(OPEN_PAR);
setState(824);
select_stmt();
setState(825);
match(CLOSE_PAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Delete_stmtContext extends ParserRuleContext {
public TerminalNode DELETE_() { return getToken(SQLiteParser.DELETE_, 0); }
public TerminalNode FROM_() { return getToken(SQLiteParser.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 WHERE_() { return getToken(SQLiteParser.WHERE_, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Returning_clauseContext returning_clause() {
return getRuleContext(Returning_clauseContext.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterDelete_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitDelete_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 56, RULE_delete_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(828);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH_) {
{
setState(827);
with_clause();
}
}
setState(830);
match(DELETE_);
setState(831);
match(FROM_);
setState(832);
qualified_table_name();
setState(835);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE_) {
{
setState(833);
match(WHERE_);
setState(834);
expr(0);
}
}
setState(838);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING_) {
{
setState(837);
returning_clause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Delete_stmt_limitedContext extends ParserRuleContext {
public TerminalNode DELETE_() { return getToken(SQLiteParser.DELETE_, 0); }
public TerminalNode FROM_() { return getToken(SQLiteParser.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 WHERE_() { return getToken(SQLiteParser.WHERE_, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Returning_clauseContext returning_clause() {
return getRuleContext(Returning_clauseContext.class,0);
}
public Limit_stmtContext limit_stmt() {
return getRuleContext(Limit_stmtContext.class,0);
}
public Order_by_stmtContext order_by_stmt() {
return getRuleContext(Order_by_stmtContext.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterDelete_stmt_limited(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitDelete_stmt_limited(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 58, RULE_delete_stmt_limited);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(841);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH_) {
{
setState(840);
with_clause();
}
}
setState(843);
match(DELETE_);
setState(844);
match(FROM_);
setState(845);
qualified_table_name();
setState(848);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE_) {
{
setState(846);
match(WHERE_);
setState(847);
expr(0);
}
}
setState(851);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING_) {
{
setState(850);
returning_clause();
}
}
setState(857);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIMIT_ || _la==ORDER_) {
{
setState(854);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER_) {
{
setState(853);
order_by_stmt();
}
}
setState(856);
limit_stmt();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Detach_stmtContext extends ParserRuleContext {
public TerminalNode DETACH_() { return getToken(SQLiteParser.DETACH_, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode DATABASE_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterDetach_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitDetach_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 60, RULE_detach_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(859);
match(DETACH_);
setState(861);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) {
case 1:
{
setState(860);
match(DATABASE_);
}
break;
}
setState(863);
schema_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Drop_stmtContext extends ParserRuleContext {
public Token object;
public TerminalNode DROP_() { return getToken(SQLiteParser.DROP_, 0); }
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public TerminalNode INDEX_() { return getToken(SQLiteParser.INDEX_, 0); }
public TerminalNode TABLE_() { return getToken(SQLiteParser.TABLE_, 0); }
public TerminalNode TRIGGER_() { return getToken(SQLiteParser.TRIGGER_, 0); }
public TerminalNode VIEW_() { return getToken(SQLiteParser.VIEW_, 0); }
public TerminalNode IF_() { return getToken(SQLiteParser.IF_, 0); }
public TerminalNode EXISTS_() { return getToken(SQLiteParser.EXISTS_, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode DOT() { return getToken(SQLiteParser.DOT, 0); }
public Drop_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_drop_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterDrop_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitDrop_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitDrop_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Drop_stmtContext drop_stmt() throws RecognitionException {
Drop_stmtContext _localctx = new Drop_stmtContext(_ctx, getState());
enterRule(_localctx, 62, RULE_drop_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(865);
match(DROP_);
setState(866);
((Drop_stmtContext)_localctx).object = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & 2324138882699886593L) != 0)) ) {
((Drop_stmtContext)_localctx).object = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(869);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) {
case 1:
{
setState(867);
match(IF_);
setState(868);
match(EXISTS_);
}
break;
}
setState(874);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) {
case 1:
{
setState(871);
schema_name();
setState(872);
match(DOT);
}
break;
}
setState(876);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 List<TerminalNode> DOT() { return getTokens(SQLiteParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(SQLiteParser.DOT, i);
}
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 TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public TerminalNode STAR() { return getToken(SQLiteParser.STAR, 0); }
public Filter_clauseContext filter_clause() {
return getRuleContext(Filter_clauseContext.class,0);
}
public Over_clauseContext over_clause() {
return getRuleContext(Over_clauseContext.class,0);
}
public Comma_separated_exprContext comma_separated_expr() {
return getRuleContext(Comma_separated_exprContext.class,0);
}
public TerminalNode DISTINCT_() { return getToken(SQLiteParser.DISTINCT_, 0); }
public TerminalNode CAST_() { return getToken(SQLiteParser.CAST_, 0); }
public TerminalNode AS_() { return getToken(SQLiteParser.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 EXISTS_() { return getToken(SQLiteParser.EXISTS_, 0); }
public TerminalNode NOT_() { return getToken(SQLiteParser.NOT_, 0); }
public TerminalNode CASE_() { return getToken(SQLiteParser.CASE_, 0); }
public TerminalNode END_() { return getToken(SQLiteParser.END_, 0); }
public List<TerminalNode> WHEN_() { return getTokens(SQLiteParser.WHEN_); }
public TerminalNode WHEN_(int i) {
return getToken(SQLiteParser.WHEN_, i);
}
public List<TerminalNode> THEN_() { return getTokens(SQLiteParser.THEN_); }
public TerminalNode THEN_(int i) {
return getToken(SQLiteParser.THEN_, i);
}
public TerminalNode ELSE_() { return getToken(SQLiteParser.ELSE_, 0); }
public Raise_functionContext raise_function() {
return getRuleContext(Raise_functionContext.class,0);
}
public TerminalNode PIPE2() { return getToken(SQLiteParser.PIPE2, 0); }
public TerminalNode DIV() { return getToken(SQLiteParser.DIV, 0); }
public TerminalNode MOD() { return getToken(SQLiteParser.MOD, 0); }
public TerminalNode PLUS() { return getToken(SQLiteParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(SQLiteParser.MINUS, 0); }
public TerminalNode LT2() { return getToken(SQLiteParser.LT2, 0); }
public TerminalNode GT2() { return getToken(SQLiteParser.GT2, 0); }
public TerminalNode AMP() { return getToken(SQLiteParser.AMP, 0); }
public TerminalNode PIPE() { return getToken(SQLiteParser.PIPE, 0); }
public TerminalNode LT() { return getToken(SQLiteParser.LT, 0); }
public TerminalNode LT_EQ() { return getToken(SQLiteParser.LT_EQ, 0); }
public TerminalNode GT() { return getToken(SQLiteParser.GT, 0); }
public TerminalNode GT_EQ() { return getToken(SQLiteParser.GT_EQ, 0); }
public TerminalNode ASSIGN() { return getToken(SQLiteParser.ASSIGN, 0); }
public TerminalNode EQ() { return getToken(SQLiteParser.EQ, 0); }
public TerminalNode NOT_EQ1() { return getToken(SQLiteParser.NOT_EQ1, 0); }
public TerminalNode NOT_EQ2() { return getToken(SQLiteParser.NOT_EQ2, 0); }
public TerminalNode IS_() { return getToken(SQLiteParser.IS_, 0); }
public TerminalNode FROM_() { return getToken(SQLiteParser.FROM_, 0); }
public TerminalNode IN_() { return getToken(SQLiteParser.IN_, 0); }
public TerminalNode LIKE_() { return getToken(SQLiteParser.LIKE_, 0); }
public TerminalNode GLOB_() { return getToken(SQLiteParser.GLOB_, 0); }
public TerminalNode MATCH_() { return getToken(SQLiteParser.MATCH_, 0); }
public TerminalNode REGEXP_() { return getToken(SQLiteParser.REGEXP_, 0); }
public TerminalNode AND_() { return getToken(SQLiteParser.AND_, 0); }
public TerminalNode OR_() { return getToken(SQLiteParser.OR_, 0); }
public TerminalNode BETWEEN_() { return getToken(SQLiteParser.BETWEEN_, 0); }
public TerminalNode COLLATE_() { return getToken(SQLiteParser.COLLATE_, 0); }
public Collation_nameContext collation_name() {
return getRuleContext(Collation_nameContext.class,0);
}
public TerminalNode ESCAPE_() { return getToken(SQLiteParser.ESCAPE_, 0); }
public TerminalNode ISNULL_() { return getToken(SQLiteParser.ISNULL_, 0); }
public TerminalNode NOTNULL_() { return getToken(SQLiteParser.NOTNULL_, 0); }
public TerminalNode NULL_() { return getToken(SQLiteParser.NULL_, 0); }
public Table_function_nameContext table_function_name() {
return getRuleContext(Table_function_nameContext.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitExpr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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 = 64;
enterRecursionRule(_localctx, 64, RULE_expr, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(952);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) {
case 1:
{
setState(879);
literal_value();
}
break;
case 2:
{
setState(880);
match(BIND_PARAMETER);
}
break;
case 3:
{
setState(889);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
case 1:
{
setState(884);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,108,_ctx) ) {
case 1:
{
setState(881);
schema_name();
setState(882);
match(DOT);
}
break;
}
setState(886);
table_name();
setState(887);
match(DOT);
}
break;
}
setState(891);
column_name();
}
break;
case 4:
{
setState(892);
unary_operator();
setState(893);
expr(21);
}
break;
case 5:
{
setState(895);
function_name();
setState(896);
match(OPEN_PAR);
setState(902);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_PAR:
case PLUS:
case MINUS:
case TILDE:
case ABORT_:
case ACTION_:
case ADD_:
case AFTER_:
case ALL_:
case ALTER_:
case ANALYZE_:
case AND_:
case AS_:
case ASC_:
case ATTACH_:
case AUTOINCREMENT_:
case BEFORE_:
case BEGIN_:
case BETWEEN_:
case BY_:
case CASCADE_:
case CASE_:
case CAST_:
case CHECK_:
case COLLATE_:
case COLUMN_:
case COMMIT_:
case CONFLICT_:
case CONSTRAINT_:
case CREATE_:
case CROSS_:
case CURRENT_DATE_:
case CURRENT_TIME_:
case CURRENT_TIMESTAMP_:
case DATABASE_:
case DEFAULT_:
case DEFERRABLE_:
case DEFERRED_:
case DELETE_:
case DESC_:
case DETACH_:
case DISTINCT_:
case DROP_:
case EACH_:
case ELSE_:
case END_:
case ESCAPE_:
case EXCEPT_:
case EXCLUSIVE_:
case EXISTS_:
case EXPLAIN_:
case FAIL_:
case FOR_:
case FOREIGN_:
case FROM_:
case FULL_:
case GLOB_:
case GROUP_:
case HAVING_:
case IF_:
case IGNORE_:
case IMMEDIATE_:
case IN_:
case INDEX_:
case INDEXED_:
case INITIALLY_:
case INNER_:
case INSERT_:
case INSTEAD_:
case INTERSECT_:
case INTO_:
case IS_:
case ISNULL_:
case JOIN_:
case KEY_:
case LEFT_:
case LIKE_:
case LIMIT_:
case MATCH_:
case NATURAL_:
case NO_:
case NOT_:
case NOTNULL_:
case NULL_:
case OF_:
case OFFSET_:
case ON_:
case OR_:
case ORDER_:
case OUTER_:
case PLAN_:
case PRAGMA_:
case PRIMARY_:
case QUERY_:
case RAISE_:
case RECURSIVE_:
case REFERENCES_:
case REGEXP_:
case REINDEX_:
case RELEASE_:
case RENAME_:
case REPLACE_:
case RESTRICT_:
case RIGHT_:
case ROLLBACK_:
case ROW_:
case ROWS_:
case SAVEPOINT_:
case SELECT_:
case SET_:
case TABLE_:
case TEMP_:
case TEMPORARY_:
case THEN_:
case TO_:
case TRANSACTION_:
case TRIGGER_:
case UNION_:
case UNIQUE_:
case UPDATE_:
case USING_:
case VACUUM_:
case VALUES_:
case VIEW_:
case VIRTUAL_:
case WHEN_:
case WHERE_:
case WITH_:
case WITHOUT_:
case FIRST_VALUE_:
case OVER_:
case PARTITION_:
case RANGE_:
case PRECEDING_:
case UNBOUNDED_:
case CURRENT_:
case FOLLOWING_:
case CUME_DIST_:
case DENSE_RANK_:
case LAG_:
case LAST_VALUE_:
case LEAD_:
case NTH_VALUE_:
case NTILE_:
case PERCENT_RANK_:
case RANK_:
case ROW_NUMBER_:
case GENERATED_:
case ALWAYS_:
case STORED_:
case TRUE_:
case FALSE_:
case WINDOW_:
case NULLS_:
case FIRST_:
case LAST_:
case FILTER_:
case GROUPS_:
case EXCLUDE_:
case IDENTIFIER:
case NUMERIC_LITERAL:
case BIND_PARAMETER:
case STRING_LITERAL:
case BLOB_LITERAL:
{
{
setState(898);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
case 1:
{
setState(897);
match(DISTINCT_);
}
break;
}
setState(900);
comma_separated_expr();
}
}
break;
case STAR:
{
setState(901);
match(STAR);
}
break;
case CLOSE_PAR:
break;
default:
break;
}
setState(904);
match(CLOSE_PAR);
setState(906);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) {
case 1:
{
setState(905);
filter_clause();
}
break;
}
setState(909);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) {
case 1:
{
setState(908);
over_clause();
}
break;
}
}
break;
case 6:
{
setState(911);
match(OPEN_PAR);
setState(912);
comma_separated_expr();
setState(913);
match(CLOSE_PAR);
}
break;
case 7:
{
setState(915);
match(CAST_);
setState(916);
match(OPEN_PAR);
setState(917);
expr(0);
setState(918);
match(AS_);
setState(919);
type_name();
setState(920);
match(CLOSE_PAR);
}
break;
case 8:
{
setState(926);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXISTS_ || _la==NOT_) {
{
setState(923);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT_) {
{
setState(922);
match(NOT_);
}
}
setState(925);
match(EXISTS_);
}
}
setState(928);
match(OPEN_PAR);
setState(929);
select_stmt();
setState(930);
match(CLOSE_PAR);
}
break;
case 9:
{
setState(932);
match(CASE_);
setState(934);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) {
case 1:
{
setState(933);
expr(0);
}
break;
}
setState(941);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(936);
match(WHEN_);
setState(937);
expr(0);
setState(938);
match(THEN_);
setState(939);
expr(0);
}
}
setState(943);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN_ );
setState(947);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE_) {
{
setState(945);
match(ELSE_);
setState(946);
expr(0);
}
}
setState(949);
match(END_);
}
break;
case 10:
{
setState(951);
raise_function();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1066);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,133,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1064);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
case 1:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(954);
if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
setState(955);
match(PIPE2);
setState(956);
expr(21);
}
break;
case 2:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(957);
if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)");
setState(958);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 12416L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(959);
expr(20);
}
break;
case 3:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(960);
if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
setState(961);
_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(962);
expr(19);
}
break;
case 4:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(963);
if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
setState(964);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 245760L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(965);
expr(18);
}
break;
case 5:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(966);
if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
setState(967);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 3932160L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(968);
expr(17);
}
break;
case 6:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(969);
if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
setState(989);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) {
case 1:
{
setState(970);
match(ASSIGN);
}
break;
case 2:
{
setState(971);
match(EQ);
}
break;
case 3:
{
setState(972);
match(NOT_EQ1);
}
break;
case 4:
{
setState(973);
match(NOT_EQ2);
}
break;
case 5:
{
setState(974);
match(IS_);
}
break;
case 6:
{
setState(975);
match(IS_);
setState(976);
match(NOT_);
}
break;
case 7:
{
setState(977);
match(IS_);
setState(978);
match(DISTINCT_);
setState(979);
match(FROM_);
}
break;
case 8:
{
setState(980);
match(IS_);
setState(981);
match(NOT_);
setState(982);
match(DISTINCT_);
setState(983);
match(FROM_);
}
break;
case 9:
{
setState(984);
match(IN_);
}
break;
case 10:
{
setState(985);
match(LIKE_);
}
break;
case 11:
{
setState(986);
match(GLOB_);
}
break;
case 12:
{
setState(987);
match(MATCH_);
}
break;
case 13:
{
setState(988);
match(REGEXP_);
}
break;
}
setState(991);
expr(16);
}
break;
case 7:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(992);
if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
setState(993);
match(AND_);
setState(994);
expr(15);
}
break;
case 8:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(995);
if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
setState(996);
match(OR_);
setState(997);
expr(14);
}
break;
case 9:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(998);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(999);
match(IS_);
setState(1001);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
case 1:
{
setState(1000);
match(NOT_);
}
break;
}
setState(1003);
expr(7);
}
break;
case 10:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1004);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(1006);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT_) {
{
setState(1005);
match(NOT_);
}
}
setState(1008);
match(BETWEEN_);
setState(1009);
expr(0);
setState(1010);
match(AND_);
setState(1011);
expr(6);
}
break;
case 11:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1013);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(1014);
match(COLLATE_);
setState(1015);
collation_name();
}
break;
case 12:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1016);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
setState(1018);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT_) {
{
setState(1017);
match(NOT_);
}
}
setState(1020);
_la = _input.LA(1);
if ( !(((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 2199028498433L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1021);
expr(0);
setState(1024);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
case 1:
{
setState(1022);
match(ESCAPE_);
setState(1023);
expr(0);
}
break;
}
}
break;
case 13:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1026);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(1031);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ISNULL_:
{
setState(1027);
match(ISNULL_);
}
break;
case NOTNULL_:
{
setState(1028);
match(NOTNULL_);
}
break;
case NOT_:
{
setState(1029);
match(NOT_);
setState(1030);
match(NULL_);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 14:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(1033);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(1035);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT_) {
{
setState(1034);
match(NOT_);
}
}
setState(1037);
match(IN_);
setState(1062);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
case 1:
{
setState(1038);
match(OPEN_PAR);
setState(1041);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
case 1:
{
setState(1039);
select_stmt();
}
break;
case 2:
{
setState(1040);
comma_separated_expr();
}
break;
}
setState(1043);
match(CLOSE_PAR);
}
break;
case 2:
{
setState(1047);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
case 1:
{
setState(1044);
schema_name();
setState(1045);
match(DOT);
}
break;
}
setState(1049);
table_name();
}
break;
case 3:
{
setState(1053);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
case 1:
{
setState(1050);
schema_name();
setState(1051);
match(DOT);
}
break;
}
setState(1055);
table_function_name();
setState(1056);
match(OPEN_PAR);
setState(1058);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -33552632L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1152921504606846977L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 4476578029606273023L) != 0)) {
{
setState(1057);
comma_separated_expr();
}
}
setState(1060);
match(CLOSE_PAR);
}
break;
}
}
break;
}
}
}
setState(1068);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,133,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterComma_separated_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitComma_separated_expr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 66, RULE_comma_separated_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1069);
expr(0);
setState(1074);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1070);
match(COMMA);
setState(1071);
expr(0);
}
}
setState(1076);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class Raise_functionContext extends ParserRuleContext {
public TerminalNode RAISE_() { return getToken(SQLiteParser.RAISE_, 0); }
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public TerminalNode IGNORE_() { return getToken(SQLiteParser.IGNORE_, 0); }
public TerminalNode COMMA() { return getToken(SQLiteParser.COMMA, 0); }
public Error_messageContext error_message() {
return getRuleContext(Error_messageContext.class,0);
}
public TerminalNode ROLLBACK_() { return getToken(SQLiteParser.ROLLBACK_, 0); }
public TerminalNode ABORT_() { return getToken(SQLiteParser.ABORT_, 0); }
public TerminalNode FAIL_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterRaise_function(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitRaise_function(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 68, RULE_raise_function);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1077);
match(RAISE_);
setState(1078);
match(OPEN_PAR);
setState(1083);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IGNORE_:
{
setState(1079);
match(IGNORE_);
}
break;
case ABORT_:
case FAIL_:
case ROLLBACK_:
{
setState(1080);
_la = _input.LA(1);
if ( !(_la==ABORT_ || _la==FAIL_ || _la==ROLLBACK_) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1081);
match(COMMA);
setState(1082);
error_message();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1085);
match(CLOSE_PAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 NULL_() { return getToken(SQLiteParser.NULL_, 0); }
public TerminalNode TRUE_() { return getToken(SQLiteParser.TRUE_, 0); }
public TerminalNode FALSE_() { return getToken(SQLiteParser.FALSE_, 0); }
public TerminalNode CURRENT_TIME_() { return getToken(SQLiteParser.CURRENT_TIME_, 0); }
public TerminalNode CURRENT_DATE_() { return getToken(SQLiteParser.CURRENT_DATE_, 0); }
public TerminalNode CURRENT_TIMESTAMP_() { return getToken(SQLiteParser.CURRENT_TIMESTAMP_, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterLiteral_value(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitLiteral_value(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 70, RULE_literal_value);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1087);
_la = _input.LA(1);
if ( !(((((_la - 52)) & ~0x3f) == 0 && ((1L << (_la - 52)) & 4503599627370503L) != 0) || ((((_la - 172)) & ~0x3f) == 0 && ((1L << (_la - 172)) & 212995L) != 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;
}
@SuppressWarnings("CheckReturnValue")
public static class Value_rowContext extends ParserRuleContext {
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public Comma_separated_exprContext comma_separated_expr() {
return getRuleContext(Comma_separated_exprContext.class,0);
}
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public Value_rowContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_value_row; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterValue_row(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitValue_row(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitValue_row(this);
else return visitor.visitChildren(this);
}
}
public final Value_rowContext value_row() throws RecognitionException {
Value_rowContext _localctx = new Value_rowContext(_ctx, getState());
enterRule(_localctx, 72, RULE_value_row);
try {
enterOuterAlt(_localctx, 1);
{
setState(1089);
match(OPEN_PAR);
setState(1090);
comma_separated_expr();
setState(1091);
match(CLOSE_PAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Values_clauseContext extends ParserRuleContext {
public TerminalNode VALUES_() { return getToken(SQLiteParser.VALUES_, 0); }
public List<Value_rowContext> value_row() {
return getRuleContexts(Value_rowContext.class);
}
public Value_rowContext value_row(int i) {
return getRuleContext(Value_rowContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public Values_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_values_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterValues_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitValues_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitValues_clause(this);
else return visitor.visitChildren(this);
}
}
public final Values_clauseContext values_clause() throws RecognitionException {
Values_clauseContext _localctx = new Values_clauseContext(_ctx, getState());
enterRule(_localctx, 74, RULE_values_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1093);
match(VALUES_);
setState(1094);
value_row();
setState(1099);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1095);
match(COMMA);
setState(1096);
value_row();
}
}
setState(1101);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class Insert_stmtContext extends ParserRuleContext {
public TerminalNode INTO_() { return getToken(SQLiteParser.INTO_, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode INSERT_() { return getToken(SQLiteParser.INSERT_, 0); }
public TerminalNode REPLACE_() { return getToken(SQLiteParser.REPLACE_, 0); }
public TerminalNode OR_() { return getToken(SQLiteParser.OR_, 0); }
public TerminalNode DEFAULT_() { return getToken(SQLiteParser.DEFAULT_, 0); }
public TerminalNode VALUES_() { return getToken(SQLiteParser.VALUES_, 0); }
public With_clauseContext with_clause() {
return getRuleContext(With_clauseContext.class,0);
}
public TerminalNode ROLLBACK_() { return getToken(SQLiteParser.ROLLBACK_, 0); }
public TerminalNode ABORT_() { return getToken(SQLiteParser.ABORT_, 0); }
public TerminalNode FAIL_() { return getToken(SQLiteParser.FAIL_, 0); }
public TerminalNode IGNORE_() { return getToken(SQLiteParser.IGNORE_, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode DOT() { return getToken(SQLiteParser.DOT, 0); }
public TerminalNode AS_() { return getToken(SQLiteParser.AS_, 0); }
public Table_aliasContext table_alias() {
return getRuleContext(Table_aliasContext.class,0);
}
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 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 CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public Returning_clauseContext returning_clause() {
return getRuleContext(Returning_clauseContext.class,0);
}
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public Values_clauseContext values_clause() {
return getRuleContext(Values_clauseContext.class,0);
}
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterInsert_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitInsert_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 76, RULE_insert_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1103);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH_) {
{
setState(1102);
with_clause();
}
}
setState(1110);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
case 1:
{
setState(1105);
match(INSERT_);
}
break;
case 2:
{
setState(1106);
match(REPLACE_);
}
break;
case 3:
{
setState(1107);
match(INSERT_);
setState(1108);
match(OR_);
setState(1109);
_la = _input.LA(1);
if ( !(_la==ABORT_ || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & 19140298416325121L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1112);
match(INTO_);
setState(1116);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) {
case 1:
{
setState(1113);
schema_name();
setState(1114);
match(DOT);
}
break;
}
setState(1118);
table_name();
setState(1121);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS_) {
{
setState(1119);
match(AS_);
setState(1120);
table_alias();
}
}
setState(1134);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(1123);
match(OPEN_PAR);
setState(1124);
column_name();
setState(1129);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1125);
match(COMMA);
setState(1126);
column_name();
}
}
setState(1131);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1132);
match(CLOSE_PAR);
}
}
setState(1145);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT_:
case VALUES_:
case WITH_:
{
{
setState(1138);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) {
case 1:
{
setState(1136);
values_clause();
}
break;
case 2:
{
setState(1137);
select_stmt();
}
break;
}
setState(1141);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON_) {
{
setState(1140);
upsert_clause();
}
}
}
}
break;
case DEFAULT_:
{
setState(1143);
match(DEFAULT_);
setState(1144);
match(VALUES_);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1148);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING_) {
{
setState(1147);
returning_clause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Returning_clauseContext extends ParserRuleContext {
public TerminalNode RETURNING_() { return getToken(SQLiteParser.RETURNING_, 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 List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public Returning_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_returning_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterReturning_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitReturning_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitReturning_clause(this);
else return visitor.visitChildren(this);
}
}
public final Returning_clauseContext returning_clause() throws RecognitionException {
Returning_clauseContext _localctx = new Returning_clauseContext(_ctx, getState());
enterRule(_localctx, 78, RULE_returning_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1150);
match(RETURNING_);
setState(1151);
result_column();
setState(1156);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1152);
match(COMMA);
setState(1153);
result_column();
}
}
setState(1158);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class Upsert_clauseContext extends ParserRuleContext {
public TerminalNode ON_() { return getToken(SQLiteParser.ON_, 0); }
public TerminalNode CONFLICT_() { return getToken(SQLiteParser.CONFLICT_, 0); }
public TerminalNode DO_() { return getToken(SQLiteParser.DO_, 0); }
public TerminalNode NOTHING_() { return getToken(SQLiteParser.NOTHING_, 0); }
public TerminalNode UPDATE_() { return getToken(SQLiteParser.UPDATE_, 0); }
public TerminalNode SET_() { return getToken(SQLiteParser.SET_, 0); }
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 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 CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public List<TerminalNode> ASSIGN() { return getTokens(SQLiteParser.ASSIGN); }
public TerminalNode ASSIGN(int i) {
return getToken(SQLiteParser.ASSIGN, i);
}
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public List<TerminalNode> WHERE_() { return getTokens(SQLiteParser.WHERE_); }
public TerminalNode WHERE_(int i) {
return getToken(SQLiteParser.WHERE_, 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 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterUpsert_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitUpsert_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 80, RULE_upsert_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1159);
match(ON_);
setState(1160);
match(CONFLICT_);
setState(1175);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(1161);
match(OPEN_PAR);
setState(1162);
indexed_column();
setState(1167);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1163);
match(COMMA);
setState(1164);
indexed_column();
}
}
setState(1169);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1170);
match(CLOSE_PAR);
setState(1173);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE_) {
{
setState(1171);
match(WHERE_);
setState(1172);
expr(0);
}
}
}
}
setState(1177);
match(DO_);
setState(1204);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NOTHING_:
{
setState(1178);
match(NOTHING_);
}
break;
case UPDATE_:
{
setState(1179);
match(UPDATE_);
setState(1180);
match(SET_);
{
setState(1183);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) {
case 1:
{
setState(1181);
column_name();
}
break;
case 2:
{
setState(1182);
column_name_list();
}
break;
}
setState(1185);
match(ASSIGN);
setState(1186);
expr(0);
setState(1197);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1187);
match(COMMA);
setState(1190);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) {
case 1:
{
setState(1188);
column_name();
}
break;
case 2:
{
setState(1189);
column_name_list();
}
break;
}
setState(1192);
match(ASSIGN);
setState(1193);
expr(0);
}
}
setState(1199);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1202);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE_) {
{
setState(1200);
match(WHERE_);
setState(1201);
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;
}
@SuppressWarnings("CheckReturnValue")
public static class Pragma_stmtContext extends ParserRuleContext {
public TerminalNode PRAGMA_() { return getToken(SQLiteParser.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 TerminalNode DOT() { return getToken(SQLiteParser.DOT, 0); }
public TerminalNode ASSIGN() { return getToken(SQLiteParser.ASSIGN, 0); }
public Pragma_valueContext pragma_value() {
return getRuleContext(Pragma_valueContext.class,0);
}
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterPragma_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitPragma_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 82, RULE_pragma_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1206);
match(PRAGMA_);
setState(1210);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
case 1:
{
setState(1207);
schema_name();
setState(1208);
match(DOT);
}
break;
}
setState(1212);
pragma_name();
setState(1219);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ASSIGN:
{
setState(1213);
match(ASSIGN);
setState(1214);
pragma_value();
}
break;
case OPEN_PAR:
{
setState(1215);
match(OPEN_PAR);
setState(1216);
pragma_value();
setState(1217);
match(CLOSE_PAR);
}
break;
case EOF:
case SCOL:
case ALTER_:
case ANALYZE_:
case ATTACH_:
case BEGIN_:
case COMMIT_:
case CREATE_:
case DELETE_:
case DETACH_:
case DROP_:
case END_:
case EXPLAIN_:
case INSERT_:
case PRAGMA_:
case REINDEX_:
case RELEASE_:
case REPLACE_:
case ROLLBACK_:
case SAVEPOINT_:
case SELECT_:
case UPDATE_:
case VACUUM_:
case VALUES_:
case WITH_:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterPragma_value(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitPragma_value(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 84, RULE_pragma_value);
try {
setState(1224);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1221);
signed_number();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1222);
name();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1223);
match(STRING_LITERAL);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Reindex_stmtContext extends ParserRuleContext {
public TerminalNode REINDEX_() { return getToken(SQLiteParser.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 TerminalNode DOT() { return getToken(SQLiteParser.DOT, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterReindex_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitReindex_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 86, RULE_reindex_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1226);
match(REINDEX_);
setState(1237);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
case 1:
{
setState(1227);
collation_name();
}
break;
case 2:
{
setState(1231);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
case 1:
{
setState(1228);
schema_name();
setState(1229);
match(DOT);
}
break;
}
setState(1235);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) {
case 1:
{
setState(1233);
table_name();
}
break;
case 2:
{
setState(1234);
index_name();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Select_stmtContext extends ParserRuleContext {
public List<Select_coreContext> select_core() {
return getRuleContexts(Select_coreContext.class);
}
public Select_coreContext select_core(int i) {
return getRuleContext(Select_coreContext.class,i);
}
public Common_table_stmtContext common_table_stmt() {
return getRuleContext(Common_table_stmtContext.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_by_stmtContext order_by_stmt() {
return getRuleContext(Order_by_stmtContext.class,0);
}
public Limit_stmtContext limit_stmt() {
return getRuleContext(Limit_stmtContext.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterSelect_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitSelect_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 88, RULE_select_stmt);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1240);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH_) {
{
setState(1239);
common_table_stmt();
}
}
setState(1242);
select_core();
setState(1248);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,163,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1243);
compound_operator();
setState(1244);
select_core();
}
}
}
setState(1250);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,163,_ctx);
}
setState(1252);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER_) {
{
setState(1251);
order_by_stmt();
}
}
setState(1255);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIMIT_) {
{
setState(1254);
limit_stmt();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterJoin_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitJoin_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 90, RULE_join_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1257);
table_or_subquery();
setState(1265);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA || _la==CROSS_ || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & 562949971511297L) != 0)) {
{
{
setState(1258);
join_operator();
setState(1259);
table_or_subquery();
setState(1261);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) {
case 1:
{
setState(1260);
join_constraint();
}
break;
}
}
}
setState(1267);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class Select_coreContext extends ParserRuleContext {
public ExprContext whereExpr;
public ExprContext expr;
public List<ExprContext> groupByExpr = new ArrayList<ExprContext>();
public ExprContext havingExpr;
public TerminalNode SELECT_() { return getToken(SQLiteParser.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 List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public TerminalNode FROM_() { return getToken(SQLiteParser.FROM_, 0); }
public TerminalNode WHERE_() { return getToken(SQLiteParser.WHERE_, 0); }
public TerminalNode GROUP_() { return getToken(SQLiteParser.GROUP_, 0); }
public TerminalNode BY_() { return getToken(SQLiteParser.BY_, 0); }
public TerminalNode WINDOW_() { return getToken(SQLiteParser.WINDOW_, 0); }
public List<Window_nameContext> window_name() {
return getRuleContexts(Window_nameContext.class);
}
public Window_nameContext window_name(int i) {
return getRuleContext(Window_nameContext.class,i);
}
public List<TerminalNode> AS_() { return getTokens(SQLiteParser.AS_); }
public TerminalNode AS_(int i) {
return getToken(SQLiteParser.AS_, i);
}
public List<Window_defnContext> window_defn() {
return getRuleContexts(Window_defnContext.class);
}
public Window_defnContext window_defn(int i) {
return getRuleContext(Window_defnContext.class,i);
}
public TerminalNode DISTINCT_() { return getToken(SQLiteParser.DISTINCT_, 0); }
public TerminalNode ALL_() { return getToken(SQLiteParser.ALL_, 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 TerminalNode HAVING_() { return getToken(SQLiteParser.HAVING_, 0); }
public Values_clauseContext values_clause() {
return getRuleContext(Values_clauseContext.class,0);
}
public Select_coreContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_select_core; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterSelect_core(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitSelect_core(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitSelect_core(this);
else return visitor.visitChildren(this);
}
}
public final Select_coreContext select_core() throws RecognitionException {
Select_coreContext _localctx = new Select_coreContext(_ctx, getState());
enterRule(_localctx, 92, RULE_select_core);
int _la;
try {
setState(1331);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT_:
enterOuterAlt(_localctx, 1);
{
{
setState(1268);
match(SELECT_);
setState(1270);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) {
case 1:
{
setState(1269);
_la = _input.LA(1);
if ( !(_la==ALL_ || _la==DISTINCT_) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1272);
result_column();
setState(1277);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1273);
match(COMMA);
setState(1274);
result_column();
}
}
setState(1279);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1292);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM_) {
{
setState(1280);
match(FROM_);
setState(1290);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
case 1:
{
setState(1281);
table_or_subquery();
setState(1286);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1282);
match(COMMA);
setState(1283);
table_or_subquery();
}
}
setState(1288);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
{
setState(1289);
join_clause();
}
break;
}
}
}
setState(1296);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE_) {
{
setState(1294);
match(WHERE_);
setState(1295);
((Select_coreContext)_localctx).whereExpr = expr(0);
}
}
setState(1312);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP_) {
{
setState(1298);
match(GROUP_);
setState(1299);
match(BY_);
setState(1300);
((Select_coreContext)_localctx).expr = expr(0);
((Select_coreContext)_localctx).groupByExpr.add(((Select_coreContext)_localctx).expr);
setState(1305);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1301);
match(COMMA);
setState(1302);
((Select_coreContext)_localctx).expr = expr(0);
((Select_coreContext)_localctx).groupByExpr.add(((Select_coreContext)_localctx).expr);
}
}
setState(1307);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1310);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING_) {
{
setState(1308);
match(HAVING_);
setState(1309);
((Select_coreContext)_localctx).havingExpr = expr(0);
}
}
}
}
setState(1328);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WINDOW_) {
{
setState(1314);
match(WINDOW_);
setState(1315);
window_name();
setState(1316);
match(AS_);
setState(1317);
window_defn();
setState(1325);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1318);
match(COMMA);
setState(1319);
window_name();
setState(1320);
match(AS_);
setState(1321);
window_defn();
}
}
setState(1327);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
}
}
break;
case VALUES_:
enterOuterAlt(_localctx, 2);
{
setState(1330);
values_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;
}
@SuppressWarnings("CheckReturnValue")
public static class Factored_select_stmtContext extends ParserRuleContext {
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public Factored_select_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_factored_select_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterFactored_select_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitFactored_select_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitFactored_select_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Factored_select_stmtContext factored_select_stmt() throws RecognitionException {
Factored_select_stmtContext _localctx = new Factored_select_stmtContext(_ctx, getState());
enterRule(_localctx, 94, RULE_factored_select_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(1333);
select_stmt();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Simple_select_stmtContext extends ParserRuleContext {
public Select_coreContext select_core() {
return getRuleContext(Select_coreContext.class,0);
}
public Common_table_stmtContext common_table_stmt() {
return getRuleContext(Common_table_stmtContext.class,0);
}
public Order_by_stmtContext order_by_stmt() {
return getRuleContext(Order_by_stmtContext.class,0);
}
public Limit_stmtContext limit_stmt() {
return getRuleContext(Limit_stmtContext.class,0);
}
public Simple_select_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simple_select_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterSimple_select_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitSimple_select_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitSimple_select_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Simple_select_stmtContext simple_select_stmt() throws RecognitionException {
Simple_select_stmtContext _localctx = new Simple_select_stmtContext(_ctx, getState());
enterRule(_localctx, 96, RULE_simple_select_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1336);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH_) {
{
setState(1335);
common_table_stmt();
}
}
setState(1338);
select_core();
setState(1340);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER_) {
{
setState(1339);
order_by_stmt();
}
}
setState(1343);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIMIT_) {
{
setState(1342);
limit_stmt();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Compound_select_stmtContext extends ParserRuleContext {
public List<Select_coreContext> select_core() {
return getRuleContexts(Select_coreContext.class);
}
public Select_coreContext select_core(int i) {
return getRuleContext(Select_coreContext.class,i);
}
public Common_table_stmtContext common_table_stmt() {
return getRuleContext(Common_table_stmtContext.class,0);
}
public Order_by_stmtContext order_by_stmt() {
return getRuleContext(Order_by_stmtContext.class,0);
}
public Limit_stmtContext limit_stmt() {
return getRuleContext(Limit_stmtContext.class,0);
}
public List<TerminalNode> UNION_() { return getTokens(SQLiteParser.UNION_); }
public TerminalNode UNION_(int i) {
return getToken(SQLiteParser.UNION_, i);
}
public List<TerminalNode> INTERSECT_() { return getTokens(SQLiteParser.INTERSECT_); }
public TerminalNode INTERSECT_(int i) {
return getToken(SQLiteParser.INTERSECT_, i);
}
public List<TerminalNode> EXCEPT_() { return getTokens(SQLiteParser.EXCEPT_); }
public TerminalNode EXCEPT_(int i) {
return getToken(SQLiteParser.EXCEPT_, i);
}
public List<TerminalNode> ALL_() { return getTokens(SQLiteParser.ALL_); }
public TerminalNode ALL_(int i) {
return getToken(SQLiteParser.ALL_, i);
}
public Compound_select_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compound_select_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterCompound_select_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitCompound_select_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitCompound_select_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Compound_select_stmtContext compound_select_stmt() throws RecognitionException {
Compound_select_stmtContext _localctx = new Compound_select_stmtContext(_ctx, getState());
enterRule(_localctx, 98, RULE_compound_select_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1346);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH_) {
{
setState(1345);
common_table_stmt();
}
}
setState(1348);
select_core();
setState(1358);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1355);
_errHandler.sync(this);
switch (_input.LA(1)) {
case UNION_:
{
setState(1349);
match(UNION_);
setState(1351);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL_) {
{
setState(1350);
match(ALL_);
}
}
}
break;
case INTERSECT_:
{
setState(1353);
match(INTERSECT_);
}
break;
case EXCEPT_:
{
setState(1354);
match(EXCEPT_);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1357);
select_core();
}
}
setState(1360);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==EXCEPT_ || _la==INTERSECT_ || _la==UNION_ );
setState(1363);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER_) {
{
setState(1362);
order_by_stmt();
}
}
setState(1366);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIMIT_) {
{
setState(1365);
limit_stmt();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 TerminalNode DOT() { return getToken(SQLiteParser.DOT, 0); }
public Table_aliasContext table_alias() {
return getRuleContext(Table_aliasContext.class,0);
}
public TerminalNode INDEXED_() { return getToken(SQLiteParser.INDEXED_, 0); }
public TerminalNode BY_() { return getToken(SQLiteParser.BY_, 0); }
public Index_nameContext index_name() {
return getRuleContext(Index_nameContext.class,0);
}
public TerminalNode NOT_() { return getToken(SQLiteParser.NOT_, 0); }
public TerminalNode AS_() { return getToken(SQLiteParser.AS_, 0); }
public Table_function_nameContext table_function_name() {
return getRuleContext(Table_function_nameContext.class,0);
}
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterTable_or_subquery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitTable_or_subquery(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 100, RULE_table_or_subquery);
int _la;
try {
setState(1432);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
{
setState(1371);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,189,_ctx) ) {
case 1:
{
setState(1368);
schema_name();
setState(1369);
match(DOT);
}
break;
}
setState(1373);
table_name();
setState(1378);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR || _la==AS_ || _la==IDENTIFIER || _la==STRING_LITERAL) {
{
setState(1375);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS_) {
{
setState(1374);
match(AS_);
}
}
setState(1377);
table_alias();
}
}
setState(1385);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INDEXED_:
{
setState(1380);
match(INDEXED_);
setState(1381);
match(BY_);
setState(1382);
index_name();
}
break;
case NOT_:
{
setState(1383);
match(NOT_);
setState(1384);
match(INDEXED_);
}
break;
case EOF:
case SCOL:
case CLOSE_PAR:
case COMMA:
case ALTER_:
case ANALYZE_:
case ATTACH_:
case BEGIN_:
case COMMIT_:
case CREATE_:
case CROSS_:
case DELETE_:
case DETACH_:
case DROP_:
case END_:
case EXCEPT_:
case EXPLAIN_:
case FULL_:
case GROUP_:
case INNER_:
case INSERT_:
case INTERSECT_:
case JOIN_:
case LEFT_:
case LIMIT_:
case NATURAL_:
case ON_:
case ORDER_:
case PRAGMA_:
case REINDEX_:
case RELEASE_:
case REPLACE_:
case RETURNING_:
case RIGHT_:
case ROLLBACK_:
case SAVEPOINT_:
case SELECT_:
case UNION_:
case UPDATE_:
case USING_:
case VACUUM_:
case VALUES_:
case WHERE_:
case WITH_:
case WINDOW_:
break;
default:
break;
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1390);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,193,_ctx) ) {
case 1:
{
setState(1387);
schema_name();
setState(1388);
match(DOT);
}
break;
}
setState(1392);
table_function_name();
setState(1393);
match(OPEN_PAR);
setState(1394);
expr(0);
setState(1399);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1395);
match(COMMA);
setState(1396);
expr(0);
}
}
setState(1401);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1402);
match(CLOSE_PAR);
setState(1407);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR || _la==AS_ || _la==IDENTIFIER || _la==STRING_LITERAL) {
{
setState(1404);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS_) {
{
setState(1403);
match(AS_);
}
}
setState(1406);
table_alias();
}
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1409);
match(OPEN_PAR);
setState(1419);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) {
case 1:
{
setState(1410);
table_or_subquery();
setState(1415);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1411);
match(COMMA);
setState(1412);
table_or_subquery();
}
}
setState(1417);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
{
setState(1418);
join_clause();
}
break;
}
setState(1421);
match(CLOSE_PAR);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1423);
match(OPEN_PAR);
setState(1424);
select_stmt();
setState(1425);
match(CLOSE_PAR);
setState(1430);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAR || _la==AS_ || _la==IDENTIFIER || _la==STRING_LITERAL) {
{
setState(1427);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS_) {
{
setState(1426);
match(AS_);
}
}
setState(1429);
table_alias();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Result_columnContext extends ParserRuleContext {
public TerminalNode STAR() { return getToken(SQLiteParser.STAR, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode DOT() { return getToken(SQLiteParser.DOT, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Column_aliasContext column_alias() {
return getRuleContext(Column_aliasContext.class,0);
}
public TerminalNode AS_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterResult_column(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitResult_column(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 102, RULE_result_column);
int _la;
try {
setState(1446);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,204,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1434);
match(STAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1435);
table_name();
setState(1436);
match(DOT);
setState(1437);
match(STAR);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1439);
expr(0);
setState(1444);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS_ || _la==IDENTIFIER || _la==STRING_LITERAL) {
{
setState(1441);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS_) {
{
setState(1440);
match(AS_);
}
}
setState(1443);
column_alias();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Join_operatorContext extends ParserRuleContext {
public TerminalNode COMMA() { return getToken(SQLiteParser.COMMA, 0); }
public TerminalNode JOIN_() { return getToken(SQLiteParser.JOIN_, 0); }
public TerminalNode NATURAL_() { return getToken(SQLiteParser.NATURAL_, 0); }
public TerminalNode INNER_() { return getToken(SQLiteParser.INNER_, 0); }
public TerminalNode CROSS_() { return getToken(SQLiteParser.CROSS_, 0); }
public TerminalNode LEFT_() { return getToken(SQLiteParser.LEFT_, 0); }
public TerminalNode RIGHT_() { return getToken(SQLiteParser.RIGHT_, 0); }
public TerminalNode FULL_() { return getToken(SQLiteParser.FULL_, 0); }
public TerminalNode OUTER_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterJoin_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitJoin_operator(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 104, RULE_join_operator);
int _la;
try {
setState(1461);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COMMA:
enterOuterAlt(_localctx, 1);
{
setState(1448);
match(COMMA);
}
break;
case CROSS_:
case FULL_:
case INNER_:
case JOIN_:
case LEFT_:
case NATURAL_:
case RIGHT_:
enterOuterAlt(_localctx, 2);
{
setState(1450);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NATURAL_) {
{
setState(1449);
match(NATURAL_);
}
}
setState(1458);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FULL_:
case LEFT_:
case RIGHT_:
{
setState(1452);
_la = _input.LA(1);
if ( !(((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & 562949954469889L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1454);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER_) {
{
setState(1453);
match(OUTER_);
}
}
}
break;
case INNER_:
{
setState(1456);
match(INNER_);
}
break;
case CROSS_:
{
setState(1457);
match(CROSS_);
}
break;
case JOIN_:
break;
default:
break;
}
setState(1460);
match(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;
}
@SuppressWarnings("CheckReturnValue")
public static class Join_constraintContext extends ParserRuleContext {
public TerminalNode ON_() { return getToken(SQLiteParser.ON_, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode USING_() { return getToken(SQLiteParser.USING_, 0); }
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 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 CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterJoin_constraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitJoin_constraint(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 106, RULE_join_constraint);
int _la;
try {
setState(1477);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ON_:
enterOuterAlt(_localctx, 1);
{
setState(1463);
match(ON_);
setState(1464);
expr(0);
}
break;
case USING_:
enterOuterAlt(_localctx, 2);
{
setState(1465);
match(USING_);
setState(1466);
match(OPEN_PAR);
setState(1467);
column_name();
setState(1472);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1468);
match(COMMA);
setState(1469);
column_name();
}
}
setState(1474);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1475);
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;
}
@SuppressWarnings("CheckReturnValue")
public static class Compound_operatorContext extends ParserRuleContext {
public TerminalNode UNION_() { return getToken(SQLiteParser.UNION_, 0); }
public TerminalNode ALL_() { return getToken(SQLiteParser.ALL_, 0); }
public TerminalNode INTERSECT_() { return getToken(SQLiteParser.INTERSECT_, 0); }
public TerminalNode EXCEPT_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterCompound_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitCompound_operator(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 108, RULE_compound_operator);
int _la;
try {
setState(1485);
_errHandler.sync(this);
switch (_input.LA(1)) {
case UNION_:
enterOuterAlt(_localctx, 1);
{
setState(1479);
match(UNION_);
setState(1481);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL_) {
{
setState(1480);
match(ALL_);
}
}
}
break;
case INTERSECT_:
enterOuterAlt(_localctx, 2);
{
setState(1483);
match(INTERSECT_);
}
break;
case EXCEPT_:
enterOuterAlt(_localctx, 3);
{
setState(1484);
match(EXCEPT_);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Update_stmtContext extends ParserRuleContext {
public TerminalNode UPDATE_() { return getToken(SQLiteParser.UPDATE_, 0); }
public Qualified_table_nameContext qualified_table_name() {
return getRuleContext(Qualified_table_nameContext.class,0);
}
public TerminalNode SET_() { return getToken(SQLiteParser.SET_, 0); }
public List<TerminalNode> ASSIGN() { return getTokens(SQLiteParser.ASSIGN); }
public TerminalNode ASSIGN(int i) {
return getToken(SQLiteParser.ASSIGN, i);
}
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 OR_() { return getToken(SQLiteParser.OR_, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public TerminalNode FROM_() { return getToken(SQLiteParser.FROM_, 0); }
public TerminalNode WHERE_() { return getToken(SQLiteParser.WHERE_, 0); }
public Returning_clauseContext returning_clause() {
return getRuleContext(Returning_clauseContext.class,0);
}
public TerminalNode ROLLBACK_() { return getToken(SQLiteParser.ROLLBACK_, 0); }
public TerminalNode ABORT_() { return getToken(SQLiteParser.ABORT_, 0); }
public TerminalNode REPLACE_() { return getToken(SQLiteParser.REPLACE_, 0); }
public TerminalNode FAIL_() { return getToken(SQLiteParser.FAIL_, 0); }
public TerminalNode IGNORE_() { return getToken(SQLiteParser.IGNORE_, 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 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterUpdate_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitUpdate_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 110, RULE_update_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1488);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH_) {
{
setState(1487);
with_clause();
}
}
setState(1490);
match(UPDATE_);
setState(1493);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,214,_ctx) ) {
case 1:
{
setState(1491);
match(OR_);
setState(1492);
_la = _input.LA(1);
if ( !(_la==ABORT_ || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & 19140298416325121L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1495);
qualified_table_name();
setState(1496);
match(SET_);
setState(1499);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,215,_ctx) ) {
case 1:
{
setState(1497);
column_name();
}
break;
case 2:
{
setState(1498);
column_name_list();
}
break;
}
setState(1501);
match(ASSIGN);
setState(1502);
expr(0);
setState(1513);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1503);
match(COMMA);
setState(1506);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,216,_ctx) ) {
case 1:
{
setState(1504);
column_name();
}
break;
case 2:
{
setState(1505);
column_name_list();
}
break;
}
setState(1508);
match(ASSIGN);
setState(1509);
expr(0);
}
}
setState(1515);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1528);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM_) {
{
setState(1516);
match(FROM_);
setState(1526);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,219,_ctx) ) {
case 1:
{
setState(1517);
table_or_subquery();
setState(1522);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1518);
match(COMMA);
setState(1519);
table_or_subquery();
}
}
setState(1524);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
{
setState(1525);
join_clause();
}
break;
}
}
}
setState(1532);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE_) {
{
setState(1530);
match(WHERE_);
setState(1531);
expr(0);
}
}
setState(1535);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING_) {
{
setState(1534);
returning_clause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Column_name_listContext extends ParserRuleContext {
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 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 CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterColumn_name_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitColumn_name_list(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 112, RULE_column_name_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1537);
match(OPEN_PAR);
setState(1538);
column_name();
setState(1543);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1539);
match(COMMA);
setState(1540);
column_name();
}
}
setState(1545);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1546);
match(CLOSE_PAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Update_stmt_limitedContext extends ParserRuleContext {
public TerminalNode UPDATE_() { return getToken(SQLiteParser.UPDATE_, 0); }
public Qualified_table_nameContext qualified_table_name() {
return getRuleContext(Qualified_table_nameContext.class,0);
}
public TerminalNode SET_() { return getToken(SQLiteParser.SET_, 0); }
public List<TerminalNode> ASSIGN() { return getTokens(SQLiteParser.ASSIGN); }
public TerminalNode ASSIGN(int i) {
return getToken(SQLiteParser.ASSIGN, i);
}
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 OR_() { return getToken(SQLiteParser.OR_, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public TerminalNode WHERE_() { return getToken(SQLiteParser.WHERE_, 0); }
public Returning_clauseContext returning_clause() {
return getRuleContext(Returning_clauseContext.class,0);
}
public Limit_stmtContext limit_stmt() {
return getRuleContext(Limit_stmtContext.class,0);
}
public TerminalNode ROLLBACK_() { return getToken(SQLiteParser.ROLLBACK_, 0); }
public TerminalNode ABORT_() { return getToken(SQLiteParser.ABORT_, 0); }
public TerminalNode REPLACE_() { return getToken(SQLiteParser.REPLACE_, 0); }
public TerminalNode FAIL_() { return getToken(SQLiteParser.FAIL_, 0); }
public TerminalNode IGNORE_() { return getToken(SQLiteParser.IGNORE_, 0); }
public Order_by_stmtContext order_by_stmt() {
return getRuleContext(Order_by_stmtContext.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterUpdate_stmt_limited(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitUpdate_stmt_limited(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 114, RULE_update_stmt_limited);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1549);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH_) {
{
setState(1548);
with_clause();
}
}
setState(1551);
match(UPDATE_);
setState(1554);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,225,_ctx) ) {
case 1:
{
setState(1552);
match(OR_);
setState(1553);
_la = _input.LA(1);
if ( !(_la==ABORT_ || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & 19140298416325121L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1556);
qualified_table_name();
setState(1557);
match(SET_);
setState(1560);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,226,_ctx) ) {
case 1:
{
setState(1558);
column_name();
}
break;
case 2:
{
setState(1559);
column_name_list();
}
break;
}
setState(1562);
match(ASSIGN);
setState(1563);
expr(0);
setState(1574);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1564);
match(COMMA);
setState(1567);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,227,_ctx) ) {
case 1:
{
setState(1565);
column_name();
}
break;
case 2:
{
setState(1566);
column_name_list();
}
break;
}
setState(1569);
match(ASSIGN);
setState(1570);
expr(0);
}
}
setState(1576);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1579);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE_) {
{
setState(1577);
match(WHERE_);
setState(1578);
expr(0);
}
}
setState(1582);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING_) {
{
setState(1581);
returning_clause();
}
}
setState(1588);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIMIT_ || _la==ORDER_) {
{
setState(1585);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER_) {
{
setState(1584);
order_by_stmt();
}
}
setState(1587);
limit_stmt();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 DOT() { return getToken(SQLiteParser.DOT, 0); }
public TerminalNode AS_() { return getToken(SQLiteParser.AS_, 0); }
public AliasContext alias() {
return getRuleContext(AliasContext.class,0);
}
public TerminalNode INDEXED_() { return getToken(SQLiteParser.INDEXED_, 0); }
public TerminalNode BY_() { return getToken(SQLiteParser.BY_, 0); }
public Index_nameContext index_name() {
return getRuleContext(Index_nameContext.class,0);
}
public TerminalNode NOT_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterQualified_table_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitQualified_table_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 116, RULE_qualified_table_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1593);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,233,_ctx) ) {
case 1:
{
setState(1590);
schema_name();
setState(1591);
match(DOT);
}
break;
}
setState(1595);
table_name();
setState(1598);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS_) {
{
setState(1596);
match(AS_);
setState(1597);
alias();
}
}
setState(1605);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INDEXED_:
{
setState(1600);
match(INDEXED_);
setState(1601);
match(BY_);
setState(1602);
index_name();
}
break;
case NOT_:
{
setState(1603);
match(NOT_);
setState(1604);
match(INDEXED_);
}
break;
case EOF:
case SCOL:
case ALTER_:
case ANALYZE_:
case ATTACH_:
case BEGIN_:
case COMMIT_:
case CREATE_:
case DELETE_:
case DETACH_:
case DROP_:
case END_:
case EXPLAIN_:
case INSERT_:
case LIMIT_:
case ORDER_:
case PRAGMA_:
case REINDEX_:
case RELEASE_:
case REPLACE_:
case RETURNING_:
case ROLLBACK_:
case SAVEPOINT_:
case SELECT_:
case SET_:
case UPDATE_:
case VACUUM_:
case VALUES_:
case WHERE_:
case WITH_:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Vacuum_stmtContext extends ParserRuleContext {
public TerminalNode VACUUM_() { return getToken(SQLiteParser.VACUUM_, 0); }
public Schema_nameContext schema_name() {
return getRuleContext(Schema_nameContext.class,0);
}
public TerminalNode INTO_() { return getToken(SQLiteParser.INTO_, 0); }
public FilenameContext filename() {
return getRuleContext(FilenameContext.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterVacuum_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitVacuum_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 118, RULE_vacuum_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1607);
match(VACUUM_);
setState(1609);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,236,_ctx) ) {
case 1:
{
setState(1608);
schema_name();
}
break;
}
setState(1613);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INTO_) {
{
setState(1611);
match(INTO_);
setState(1612);
filename();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Filter_clauseContext extends ParserRuleContext {
public TerminalNode FILTER_() { return getToken(SQLiteParser.FILTER_, 0); }
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public TerminalNode WHERE_() { return getToken(SQLiteParser.WHERE_, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public Filter_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_filter_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterFilter_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitFilter_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitFilter_clause(this);
else return visitor.visitChildren(this);
}
}
public final Filter_clauseContext filter_clause() throws RecognitionException {
Filter_clauseContext _localctx = new Filter_clauseContext(_ctx, getState());
enterRule(_localctx, 120, RULE_filter_clause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1615);
match(FILTER_);
setState(1616);
match(OPEN_PAR);
setState(1617);
match(WHERE_);
setState(1618);
expr(0);
setState(1619);
match(CLOSE_PAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Window_defnContext extends ParserRuleContext {
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public TerminalNode ORDER_() { return getToken(SQLiteParser.ORDER_, 0); }
public List<TerminalNode> BY_() { return getTokens(SQLiteParser.BY_); }
public TerminalNode BY_(int i) {
return getToken(SQLiteParser.BY_, i);
}
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 Base_window_nameContext base_window_name() {
return getRuleContext(Base_window_nameContext.class,0);
}
public TerminalNode PARTITION_() { return getToken(SQLiteParser.PARTITION_, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public Frame_specContext frame_spec() {
return getRuleContext(Frame_specContext.class,0);
}
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public Window_defnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_window_defn; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterWindow_defn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitWindow_defn(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitWindow_defn(this);
else return visitor.visitChildren(this);
}
}
public final Window_defnContext window_defn() throws RecognitionException {
Window_defnContext _localctx = new Window_defnContext(_ctx, getState());
enterRule(_localctx, 122, RULE_window_defn);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1621);
match(OPEN_PAR);
setState(1623);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,238,_ctx) ) {
case 1:
{
setState(1622);
base_window_name();
}
break;
}
setState(1635);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION_) {
{
setState(1625);
match(PARTITION_);
setState(1626);
match(BY_);
setState(1627);
expr(0);
setState(1632);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1628);
match(COMMA);
setState(1629);
expr(0);
}
}
setState(1634);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
{
setState(1637);
match(ORDER_);
setState(1638);
match(BY_);
setState(1639);
ordering_term();
setState(1644);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1640);
match(COMMA);
setState(1641);
ordering_term();
}
}
setState(1646);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
setState(1648);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 2251799880794113L) != 0)) {
{
setState(1647);
frame_spec();
}
}
setState(1650);
match(CLOSE_PAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Over_clauseContext extends ParserRuleContext {
public TerminalNode OVER_() { return getToken(SQLiteParser.OVER_, 0); }
public Window_nameContext window_name() {
return getRuleContext(Window_nameContext.class,0);
}
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public Base_window_nameContext base_window_name() {
return getRuleContext(Base_window_nameContext.class,0);
}
public TerminalNode PARTITION_() { return getToken(SQLiteParser.PARTITION_, 0); }
public List<TerminalNode> BY_() { return getTokens(SQLiteParser.BY_); }
public TerminalNode BY_(int i) {
return getToken(SQLiteParser.BY_, i);
}
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode ORDER_() { return getToken(SQLiteParser.ORDER_, 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 Frame_specContext frame_spec() {
return getRuleContext(Frame_specContext.class,0);
}
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public Over_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_over_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterOver_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitOver_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitOver_clause(this);
else return visitor.visitChildren(this);
}
}
public final Over_clauseContext over_clause() throws RecognitionException {
Over_clauseContext _localctx = new Over_clauseContext(_ctx, getState());
enterRule(_localctx, 124, RULE_over_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1652);
match(OVER_);
setState(1686);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,249,_ctx) ) {
case 1:
{
setState(1653);
window_name();
}
break;
case 2:
{
setState(1654);
match(OPEN_PAR);
setState(1656);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,243,_ctx) ) {
case 1:
{
setState(1655);
base_window_name();
}
break;
}
setState(1668);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION_) {
{
setState(1658);
match(PARTITION_);
setState(1659);
match(BY_);
setState(1660);
expr(0);
setState(1665);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1661);
match(COMMA);
setState(1662);
expr(0);
}
}
setState(1667);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1680);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER_) {
{
setState(1670);
match(ORDER_);
setState(1671);
match(BY_);
setState(1672);
ordering_term();
setState(1677);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1673);
match(COMMA);
setState(1674);
ordering_term();
}
}
setState(1679);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1683);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 2251799880794113L) != 0)) {
{
setState(1682);
frame_spec();
}
}
setState(1685);
match(CLOSE_PAR);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Frame_specContext extends ParserRuleContext {
public Frame_clauseContext frame_clause() {
return getRuleContext(Frame_clauseContext.class,0);
}
public TerminalNode EXCLUDE_() { return getToken(SQLiteParser.EXCLUDE_, 0); }
public TerminalNode NO_() { return getToken(SQLiteParser.NO_, 0); }
public TerminalNode OTHERS_() { return getToken(SQLiteParser.OTHERS_, 0); }
public TerminalNode CURRENT_() { return getToken(SQLiteParser.CURRENT_, 0); }
public TerminalNode ROW_() { return getToken(SQLiteParser.ROW_, 0); }
public TerminalNode GROUP_() { return getToken(SQLiteParser.GROUP_, 0); }
public TerminalNode TIES_() { return getToken(SQLiteParser.TIES_, 0); }
public Frame_specContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frame_spec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterFrame_spec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitFrame_spec(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitFrame_spec(this);
else return visitor.visitChildren(this);
}
}
public final Frame_specContext frame_spec() throws RecognitionException {
Frame_specContext _localctx = new Frame_specContext(_ctx, getState());
enterRule(_localctx, 126, RULE_frame_spec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1688);
frame_clause();
setState(1698);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCLUDE_) {
{
setState(1689);
match(EXCLUDE_);
setState(1696);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NO_:
{
setState(1690);
match(NO_);
setState(1691);
match(OTHERS_);
}
break;
case CURRENT_:
{
setState(1692);
match(CURRENT_);
setState(1693);
match(ROW_);
}
break;
case GROUP_:
{
setState(1694);
match(GROUP_);
}
break;
case TIES_:
{
setState(1695);
match(TIES_);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Frame_clauseContext extends ParserRuleContext {
public TerminalNode RANGE_() { return getToken(SQLiteParser.RANGE_, 0); }
public TerminalNode ROWS_() { return getToken(SQLiteParser.ROWS_, 0); }
public TerminalNode GROUPS_() { return getToken(SQLiteParser.GROUPS_, 0); }
public Frame_singleContext frame_single() {
return getRuleContext(Frame_singleContext.class,0);
}
public TerminalNode BETWEEN_() { return getToken(SQLiteParser.BETWEEN_, 0); }
public Frame_leftContext frame_left() {
return getRuleContext(Frame_leftContext.class,0);
}
public TerminalNode AND_() { return getToken(SQLiteParser.AND_, 0); }
public Frame_rightContext frame_right() {
return getRuleContext(Frame_rightContext.class,0);
}
public Frame_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frame_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterFrame_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitFrame_clause(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitFrame_clause(this);
else return visitor.visitChildren(this);
}
}
public final Frame_clauseContext frame_clause() throws RecognitionException {
Frame_clauseContext _localctx = new Frame_clauseContext(_ctx, getState());
enterRule(_localctx, 128, RULE_frame_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1700);
_la = _input.LA(1);
if ( !(((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 2251799880794113L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1707);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,252,_ctx) ) {
case 1:
{
setState(1701);
frame_single();
}
break;
case 2:
{
setState(1702);
match(BETWEEN_);
setState(1703);
frame_left();
setState(1704);
match(AND_);
setState(1705);
frame_right();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Simple_function_invocationContext extends ParserRuleContext {
public Simple_funcContext simple_func() {
return getRuleContext(Simple_funcContext.class,0);
}
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode STAR() { return getToken(SQLiteParser.STAR, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public Simple_function_invocationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simple_function_invocation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterSimple_function_invocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitSimple_function_invocation(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitSimple_function_invocation(this);
else return visitor.visitChildren(this);
}
}
public final Simple_function_invocationContext simple_function_invocation() throws RecognitionException {
Simple_function_invocationContext _localctx = new Simple_function_invocationContext(_ctx, getState());
enterRule(_localctx, 130, RULE_simple_function_invocation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1709);
simple_func();
setState(1710);
match(OPEN_PAR);
setState(1720);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_PAR:
case PLUS:
case MINUS:
case TILDE:
case ABORT_:
case ACTION_:
case ADD_:
case AFTER_:
case ALL_:
case ALTER_:
case ANALYZE_:
case AND_:
case AS_:
case ASC_:
case ATTACH_:
case AUTOINCREMENT_:
case BEFORE_:
case BEGIN_:
case BETWEEN_:
case BY_:
case CASCADE_:
case CASE_:
case CAST_:
case CHECK_:
case COLLATE_:
case COLUMN_:
case COMMIT_:
case CONFLICT_:
case CONSTRAINT_:
case CREATE_:
case CROSS_:
case CURRENT_DATE_:
case CURRENT_TIME_:
case CURRENT_TIMESTAMP_:
case DATABASE_:
case DEFAULT_:
case DEFERRABLE_:
case DEFERRED_:
case DELETE_:
case DESC_:
case DETACH_:
case DISTINCT_:
case DROP_:
case EACH_:
case ELSE_:
case END_:
case ESCAPE_:
case EXCEPT_:
case EXCLUSIVE_:
case EXISTS_:
case EXPLAIN_:
case FAIL_:
case FOR_:
case FOREIGN_:
case FROM_:
case FULL_:
case GLOB_:
case GROUP_:
case HAVING_:
case IF_:
case IGNORE_:
case IMMEDIATE_:
case IN_:
case INDEX_:
case INDEXED_:
case INITIALLY_:
case INNER_:
case INSERT_:
case INSTEAD_:
case INTERSECT_:
case INTO_:
case IS_:
case ISNULL_:
case JOIN_:
case KEY_:
case LEFT_:
case LIKE_:
case LIMIT_:
case MATCH_:
case NATURAL_:
case NO_:
case NOT_:
case NOTNULL_:
case NULL_:
case OF_:
case OFFSET_:
case ON_:
case OR_:
case ORDER_:
case OUTER_:
case PLAN_:
case PRAGMA_:
case PRIMARY_:
case QUERY_:
case RAISE_:
case RECURSIVE_:
case REFERENCES_:
case REGEXP_:
case REINDEX_:
case RELEASE_:
case RENAME_:
case REPLACE_:
case RESTRICT_:
case RIGHT_:
case ROLLBACK_:
case ROW_:
case ROWS_:
case SAVEPOINT_:
case SELECT_:
case SET_:
case TABLE_:
case TEMP_:
case TEMPORARY_:
case THEN_:
case TO_:
case TRANSACTION_:
case TRIGGER_:
case UNION_:
case UNIQUE_:
case UPDATE_:
case USING_:
case VACUUM_:
case VALUES_:
case VIEW_:
case VIRTUAL_:
case WHEN_:
case WHERE_:
case WITH_:
case WITHOUT_:
case FIRST_VALUE_:
case OVER_:
case PARTITION_:
case RANGE_:
case PRECEDING_:
case UNBOUNDED_:
case CURRENT_:
case FOLLOWING_:
case CUME_DIST_:
case DENSE_RANK_:
case LAG_:
case LAST_VALUE_:
case LEAD_:
case NTH_VALUE_:
case NTILE_:
case PERCENT_RANK_:
case RANK_:
case ROW_NUMBER_:
case GENERATED_:
case ALWAYS_:
case STORED_:
case TRUE_:
case FALSE_:
case WINDOW_:
case NULLS_:
case FIRST_:
case LAST_:
case FILTER_:
case GROUPS_:
case EXCLUDE_:
case IDENTIFIER:
case NUMERIC_LITERAL:
case BIND_PARAMETER:
case STRING_LITERAL:
case BLOB_LITERAL:
{
setState(1711);
expr(0);
setState(1716);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1712);
match(COMMA);
setState(1713);
expr(0);
}
}
setState(1718);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case STAR:
{
setState(1719);
match(STAR);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1722);
match(CLOSE_PAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Aggregate_function_invocationContext extends ParserRuleContext {
public Aggregate_funcContext aggregate_func() {
return getRuleContext(Aggregate_funcContext.class,0);
}
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode STAR() { return getToken(SQLiteParser.STAR, 0); }
public Filter_clauseContext filter_clause() {
return getRuleContext(Filter_clauseContext.class,0);
}
public TerminalNode DISTINCT_() { return getToken(SQLiteParser.DISTINCT_, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public Aggregate_function_invocationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aggregate_function_invocation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterAggregate_function_invocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitAggregate_function_invocation(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitAggregate_function_invocation(this);
else return visitor.visitChildren(this);
}
}
public final Aggregate_function_invocationContext aggregate_function_invocation() throws RecognitionException {
Aggregate_function_invocationContext _localctx = new Aggregate_function_invocationContext(_ctx, getState());
enterRule(_localctx, 132, RULE_aggregate_function_invocation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1724);
aggregate_func();
setState(1725);
match(OPEN_PAR);
setState(1738);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_PAR:
case PLUS:
case MINUS:
case TILDE:
case ABORT_:
case ACTION_:
case ADD_:
case AFTER_:
case ALL_:
case ALTER_:
case ANALYZE_:
case AND_:
case AS_:
case ASC_:
case ATTACH_:
case AUTOINCREMENT_:
case BEFORE_:
case BEGIN_:
case BETWEEN_:
case BY_:
case CASCADE_:
case CASE_:
case CAST_:
case CHECK_:
case COLLATE_:
case COLUMN_:
case COMMIT_:
case CONFLICT_:
case CONSTRAINT_:
case CREATE_:
case CROSS_:
case CURRENT_DATE_:
case CURRENT_TIME_:
case CURRENT_TIMESTAMP_:
case DATABASE_:
case DEFAULT_:
case DEFERRABLE_:
case DEFERRED_:
case DELETE_:
case DESC_:
case DETACH_:
case DISTINCT_:
case DROP_:
case EACH_:
case ELSE_:
case END_:
case ESCAPE_:
case EXCEPT_:
case EXCLUSIVE_:
case EXISTS_:
case EXPLAIN_:
case FAIL_:
case FOR_:
case FOREIGN_:
case FROM_:
case FULL_:
case GLOB_:
case GROUP_:
case HAVING_:
case IF_:
case IGNORE_:
case IMMEDIATE_:
case IN_:
case INDEX_:
case INDEXED_:
case INITIALLY_:
case INNER_:
case INSERT_:
case INSTEAD_:
case INTERSECT_:
case INTO_:
case IS_:
case ISNULL_:
case JOIN_:
case KEY_:
case LEFT_:
case LIKE_:
case LIMIT_:
case MATCH_:
case NATURAL_:
case NO_:
case NOT_:
case NOTNULL_:
case NULL_:
case OF_:
case OFFSET_:
case ON_:
case OR_:
case ORDER_:
case OUTER_:
case PLAN_:
case PRAGMA_:
case PRIMARY_:
case QUERY_:
case RAISE_:
case RECURSIVE_:
case REFERENCES_:
case REGEXP_:
case REINDEX_:
case RELEASE_:
case RENAME_:
case REPLACE_:
case RESTRICT_:
case RIGHT_:
case ROLLBACK_:
case ROW_:
case ROWS_:
case SAVEPOINT_:
case SELECT_:
case SET_:
case TABLE_:
case TEMP_:
case TEMPORARY_:
case THEN_:
case TO_:
case TRANSACTION_:
case TRIGGER_:
case UNION_:
case UNIQUE_:
case UPDATE_:
case USING_:
case VACUUM_:
case VALUES_:
case VIEW_:
case VIRTUAL_:
case WHEN_:
case WHERE_:
case WITH_:
case WITHOUT_:
case FIRST_VALUE_:
case OVER_:
case PARTITION_:
case RANGE_:
case PRECEDING_:
case UNBOUNDED_:
case CURRENT_:
case FOLLOWING_:
case CUME_DIST_:
case DENSE_RANK_:
case LAG_:
case LAST_VALUE_:
case LEAD_:
case NTH_VALUE_:
case NTILE_:
case PERCENT_RANK_:
case RANK_:
case ROW_NUMBER_:
case GENERATED_:
case ALWAYS_:
case STORED_:
case TRUE_:
case FALSE_:
case WINDOW_:
case NULLS_:
case FIRST_:
case LAST_:
case FILTER_:
case GROUPS_:
case EXCLUDE_:
case IDENTIFIER:
case NUMERIC_LITERAL:
case BIND_PARAMETER:
case STRING_LITERAL:
case BLOB_LITERAL:
{
setState(1727);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,255,_ctx) ) {
case 1:
{
setState(1726);
match(DISTINCT_);
}
break;
}
setState(1729);
expr(0);
setState(1734);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1730);
match(COMMA);
setState(1731);
expr(0);
}
}
setState(1736);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case STAR:
{
setState(1737);
match(STAR);
}
break;
case CLOSE_PAR:
break;
default:
break;
}
setState(1740);
match(CLOSE_PAR);
setState(1742);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FILTER_) {
{
setState(1741);
filter_clause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Window_function_invocationContext extends ParserRuleContext {
public Window_functionContext window_function() {
return getRuleContext(Window_functionContext.class,0);
}
public TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 0); }
public TerminalNode OVER_() { return getToken(SQLiteParser.OVER_, 0); }
public Window_defnContext window_defn() {
return getRuleContext(Window_defnContext.class,0);
}
public Window_nameContext window_name() {
return getRuleContext(Window_nameContext.class,0);
}
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode STAR() { return getToken(SQLiteParser.STAR, 0); }
public Filter_clauseContext filter_clause() {
return getRuleContext(Filter_clauseContext.class,0);
}
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public Window_function_invocationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_window_function_invocation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterWindow_function_invocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitWindow_function_invocation(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitWindow_function_invocation(this);
else return visitor.visitChildren(this);
}
}
public final Window_function_invocationContext window_function_invocation() throws RecognitionException {
Window_function_invocationContext _localctx = new Window_function_invocationContext(_ctx, getState());
enterRule(_localctx, 134, RULE_window_function_invocation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1744);
window_function();
setState(1745);
match(OPEN_PAR);
setState(1755);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_PAR:
case PLUS:
case MINUS:
case TILDE:
case ABORT_:
case ACTION_:
case ADD_:
case AFTER_:
case ALL_:
case ALTER_:
case ANALYZE_:
case AND_:
case AS_:
case ASC_:
case ATTACH_:
case AUTOINCREMENT_:
case BEFORE_:
case BEGIN_:
case BETWEEN_:
case BY_:
case CASCADE_:
case CASE_:
case CAST_:
case CHECK_:
case COLLATE_:
case COLUMN_:
case COMMIT_:
case CONFLICT_:
case CONSTRAINT_:
case CREATE_:
case CROSS_:
case CURRENT_DATE_:
case CURRENT_TIME_:
case CURRENT_TIMESTAMP_:
case DATABASE_:
case DEFAULT_:
case DEFERRABLE_:
case DEFERRED_:
case DELETE_:
case DESC_:
case DETACH_:
case DISTINCT_:
case DROP_:
case EACH_:
case ELSE_:
case END_:
case ESCAPE_:
case EXCEPT_:
case EXCLUSIVE_:
case EXISTS_:
case EXPLAIN_:
case FAIL_:
case FOR_:
case FOREIGN_:
case FROM_:
case FULL_:
case GLOB_:
case GROUP_:
case HAVING_:
case IF_:
case IGNORE_:
case IMMEDIATE_:
case IN_:
case INDEX_:
case INDEXED_:
case INITIALLY_:
case INNER_:
case INSERT_:
case INSTEAD_:
case INTERSECT_:
case INTO_:
case IS_:
case ISNULL_:
case JOIN_:
case KEY_:
case LEFT_:
case LIKE_:
case LIMIT_:
case MATCH_:
case NATURAL_:
case NO_:
case NOT_:
case NOTNULL_:
case NULL_:
case OF_:
case OFFSET_:
case ON_:
case OR_:
case ORDER_:
case OUTER_:
case PLAN_:
case PRAGMA_:
case PRIMARY_:
case QUERY_:
case RAISE_:
case RECURSIVE_:
case REFERENCES_:
case REGEXP_:
case REINDEX_:
case RELEASE_:
case RENAME_:
case REPLACE_:
case RESTRICT_:
case RIGHT_:
case ROLLBACK_:
case ROW_:
case ROWS_:
case SAVEPOINT_:
case SELECT_:
case SET_:
case TABLE_:
case TEMP_:
case TEMPORARY_:
case THEN_:
case TO_:
case TRANSACTION_:
case TRIGGER_:
case UNION_:
case UNIQUE_:
case UPDATE_:
case USING_:
case VACUUM_:
case VALUES_:
case VIEW_:
case VIRTUAL_:
case WHEN_:
case WHERE_:
case WITH_:
case WITHOUT_:
case FIRST_VALUE_:
case OVER_:
case PARTITION_:
case RANGE_:
case PRECEDING_:
case UNBOUNDED_:
case CURRENT_:
case FOLLOWING_:
case CUME_DIST_:
case DENSE_RANK_:
case LAG_:
case LAST_VALUE_:
case LEAD_:
case NTH_VALUE_:
case NTILE_:
case PERCENT_RANK_:
case RANK_:
case ROW_NUMBER_:
case GENERATED_:
case ALWAYS_:
case STORED_:
case TRUE_:
case FALSE_:
case WINDOW_:
case NULLS_:
case FIRST_:
case LAST_:
case FILTER_:
case GROUPS_:
case EXCLUDE_:
case IDENTIFIER:
case NUMERIC_LITERAL:
case BIND_PARAMETER:
case STRING_LITERAL:
case BLOB_LITERAL:
{
setState(1746);
expr(0);
setState(1751);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1747);
match(COMMA);
setState(1748);
expr(0);
}
}
setState(1753);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case STAR:
{
setState(1754);
match(STAR);
}
break;
case CLOSE_PAR:
break;
default:
break;
}
setState(1757);
match(CLOSE_PAR);
setState(1759);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FILTER_) {
{
setState(1758);
filter_clause();
}
}
setState(1761);
match(OVER_);
setState(1764);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,262,_ctx) ) {
case 1:
{
setState(1762);
window_defn();
}
break;
case 2:
{
setState(1763);
window_name();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Common_table_stmtContext extends ParserRuleContext {
public TerminalNode WITH_() { return getToken(SQLiteParser.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 RECURSIVE_() { return getToken(SQLiteParser.RECURSIVE_, 0); }
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public Common_table_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_common_table_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterCommon_table_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitCommon_table_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitCommon_table_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Common_table_stmtContext common_table_stmt() throws RecognitionException {
Common_table_stmtContext _localctx = new Common_table_stmtContext(_ctx, getState());
enterRule(_localctx, 136, RULE_common_table_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1766);
match(WITH_);
setState(1768);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,263,_ctx) ) {
case 1:
{
setState(1767);
match(RECURSIVE_);
}
break;
}
setState(1770);
common_table_expression();
setState(1775);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1771);
match(COMMA);
setState(1772);
common_table_expression();
}
}
setState(1777);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class Order_by_stmtContext extends ParserRuleContext {
public TerminalNode ORDER_() { return getToken(SQLiteParser.ORDER_, 0); }
public TerminalNode BY_() { return getToken(SQLiteParser.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 List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public Order_by_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_order_by_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterOrder_by_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitOrder_by_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitOrder_by_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Order_by_stmtContext order_by_stmt() throws RecognitionException {
Order_by_stmtContext _localctx = new Order_by_stmtContext(_ctx, getState());
enterRule(_localctx, 138, RULE_order_by_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1778);
match(ORDER_);
setState(1779);
match(BY_);
setState(1780);
ordering_term();
setState(1785);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1781);
match(COMMA);
setState(1782);
ordering_term();
}
}
setState(1787);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class Limit_stmtContext extends ParserRuleContext {
public TerminalNode LIMIT_() { return getToken(SQLiteParser.LIMIT_, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode OFFSET_() { return getToken(SQLiteParser.OFFSET_, 0); }
public TerminalNode COMMA() { return getToken(SQLiteParser.COMMA, 0); }
public Limit_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_limit_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterLimit_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitLimit_stmt(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitLimit_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Limit_stmtContext limit_stmt() throws RecognitionException {
Limit_stmtContext _localctx = new Limit_stmtContext(_ctx, getState());
enterRule(_localctx, 140, RULE_limit_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1788);
match(LIMIT_);
setState(1789);
expr(0);
setState(1792);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA || _la==OFFSET_) {
{
setState(1790);
_la = _input.LA(1);
if ( !(_la==COMMA || _la==OFFSET_) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1791);
expr(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Ordering_termContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode COLLATE_() { return getToken(SQLiteParser.COLLATE_, 0); }
public Collation_nameContext collation_name() {
return getRuleContext(Collation_nameContext.class,0);
}
public Asc_descContext asc_desc() {
return getRuleContext(Asc_descContext.class,0);
}
public TerminalNode NULLS_() { return getToken(SQLiteParser.NULLS_, 0); }
public TerminalNode FIRST_() { return getToken(SQLiteParser.FIRST_, 0); }
public TerminalNode LAST_() { return getToken(SQLiteParser.LAST_, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterOrdering_term(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitOrdering_term(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 142, RULE_ordering_term);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1794);
expr(0);
setState(1797);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLLATE_) {
{
setState(1795);
match(COLLATE_);
setState(1796);
collation_name();
}
}
setState(1800);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC_ || _la==DESC_) {
{
setState(1799);
asc_desc();
}
}
setState(1804);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NULLS_) {
{
setState(1802);
match(NULLS_);
setState(1803);
_la = _input.LA(1);
if ( !(_la==FIRST_ || _la==LAST_) ) {
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class Asc_descContext extends ParserRuleContext {
public TerminalNode ASC_() { return getToken(SQLiteParser.ASC_, 0); }
public TerminalNode DESC_() { return getToken(SQLiteParser.DESC_, 0); }
public Asc_descContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_asc_desc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterAsc_desc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitAsc_desc(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitAsc_desc(this);
else return visitor.visitChildren(this);
}
}
public final Asc_descContext asc_desc() throws RecognitionException {
Asc_descContext _localctx = new Asc_descContext(_ctx, getState());
enterRule(_localctx, 144, RULE_asc_desc);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1806);
_la = _input.LA(1);
if ( !(_la==ASC_ || _la==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;
}
@SuppressWarnings("CheckReturnValue")
public static class Frame_leftContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode PRECEDING_() { return getToken(SQLiteParser.PRECEDING_, 0); }
public TerminalNode FOLLOWING_() { return getToken(SQLiteParser.FOLLOWING_, 0); }
public TerminalNode CURRENT_() { return getToken(SQLiteParser.CURRENT_, 0); }
public TerminalNode ROW_() { return getToken(SQLiteParser.ROW_, 0); }
public TerminalNode UNBOUNDED_() { return getToken(SQLiteParser.UNBOUNDED_, 0); }
public Frame_leftContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frame_left; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterFrame_left(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitFrame_left(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitFrame_left(this);
else return visitor.visitChildren(this);
}
}
public final Frame_leftContext frame_left() throws RecognitionException {
Frame_leftContext _localctx = new Frame_leftContext(_ctx, getState());
enterRule(_localctx, 146, RULE_frame_left);
try {
setState(1818);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,270,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1808);
expr(0);
setState(1809);
match(PRECEDING_);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1811);
expr(0);
setState(1812);
match(FOLLOWING_);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1814);
match(CURRENT_);
setState(1815);
match(ROW_);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1816);
match(UNBOUNDED_);
setState(1817);
match(PRECEDING_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Frame_rightContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode PRECEDING_() { return getToken(SQLiteParser.PRECEDING_, 0); }
public TerminalNode FOLLOWING_() { return getToken(SQLiteParser.FOLLOWING_, 0); }
public TerminalNode CURRENT_() { return getToken(SQLiteParser.CURRENT_, 0); }
public TerminalNode ROW_() { return getToken(SQLiteParser.ROW_, 0); }
public TerminalNode UNBOUNDED_() { return getToken(SQLiteParser.UNBOUNDED_, 0); }
public Frame_rightContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frame_right; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterFrame_right(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitFrame_right(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitFrame_right(this);
else return visitor.visitChildren(this);
}
}
public final Frame_rightContext frame_right() throws RecognitionException {
Frame_rightContext _localctx = new Frame_rightContext(_ctx, getState());
enterRule(_localctx, 148, RULE_frame_right);
try {
setState(1830);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,271,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1820);
expr(0);
setState(1821);
match(PRECEDING_);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1823);
expr(0);
setState(1824);
match(FOLLOWING_);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1826);
match(CURRENT_);
setState(1827);
match(ROW_);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1828);
match(UNBOUNDED_);
setState(1829);
match(FOLLOWING_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Frame_singleContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode PRECEDING_() { return getToken(SQLiteParser.PRECEDING_, 0); }
public TerminalNode UNBOUNDED_() { return getToken(SQLiteParser.UNBOUNDED_, 0); }
public TerminalNode CURRENT_() { return getToken(SQLiteParser.CURRENT_, 0); }
public TerminalNode ROW_() { return getToken(SQLiteParser.ROW_, 0); }
public Frame_singleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frame_single; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterFrame_single(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitFrame_single(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitFrame_single(this);
else return visitor.visitChildren(this);
}
}
public final Frame_singleContext frame_single() throws RecognitionException {
Frame_singleContext _localctx = new Frame_singleContext(_ctx, getState());
enterRule(_localctx, 150, RULE_frame_single);
try {
setState(1839);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,272,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1832);
expr(0);
setState(1833);
match(PRECEDING_);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1835);
match(UNBOUNDED_);
setState(1836);
match(PRECEDING_);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1837);
match(CURRENT_);
setState(1838);
match(ROW_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Window_functionContext extends ParserRuleContext {
public List<TerminalNode> OPEN_PAR() { return getTokens(SQLiteParser.OPEN_PAR); }
public TerminalNode OPEN_PAR(int i) {
return getToken(SQLiteParser.OPEN_PAR, i);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public List<TerminalNode> CLOSE_PAR() { return getTokens(SQLiteParser.CLOSE_PAR); }
public TerminalNode CLOSE_PAR(int i) {
return getToken(SQLiteParser.CLOSE_PAR, i);
}
public TerminalNode OVER_() { return getToken(SQLiteParser.OVER_, 0); }
public Order_by_expr_asc_descContext order_by_expr_asc_desc() {
return getRuleContext(Order_by_expr_asc_descContext.class,0);
}
public TerminalNode FIRST_VALUE_() { return getToken(SQLiteParser.FIRST_VALUE_, 0); }
public TerminalNode LAST_VALUE_() { return getToken(SQLiteParser.LAST_VALUE_, 0); }
public Partition_byContext partition_by() {
return getRuleContext(Partition_byContext.class,0);
}
public Frame_clauseContext frame_clause() {
return getRuleContext(Frame_clauseContext.class,0);
}
public TerminalNode CUME_DIST_() { return getToken(SQLiteParser.CUME_DIST_, 0); }
public TerminalNode PERCENT_RANK_() { return getToken(SQLiteParser.PERCENT_RANK_, 0); }
public Order_by_exprContext order_by_expr() {
return getRuleContext(Order_by_exprContext.class,0);
}
public TerminalNode DENSE_RANK_() { return getToken(SQLiteParser.DENSE_RANK_, 0); }
public TerminalNode RANK_() { return getToken(SQLiteParser.RANK_, 0); }
public TerminalNode ROW_NUMBER_() { return getToken(SQLiteParser.ROW_NUMBER_, 0); }
public TerminalNode LAG_() { return getToken(SQLiteParser.LAG_, 0); }
public TerminalNode LEAD_() { return getToken(SQLiteParser.LEAD_, 0); }
public OffsetContext offset() {
return getRuleContext(OffsetContext.class,0);
}
public Default_valueContext default_value() {
return getRuleContext(Default_valueContext.class,0);
}
public TerminalNode NTH_VALUE_() { return getToken(SQLiteParser.NTH_VALUE_, 0); }
public TerminalNode COMMA() { return getToken(SQLiteParser.COMMA, 0); }
public Signed_numberContext signed_number() {
return getRuleContext(Signed_numberContext.class,0);
}
public TerminalNode NTILE_() { return getToken(SQLiteParser.NTILE_, 0); }
public Window_functionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_window_function; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterWindow_function(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitWindow_function(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitWindow_function(this);
else return visitor.visitChildren(this);
}
}
public final Window_functionContext window_function() throws RecognitionException {
Window_functionContext _localctx = new Window_functionContext(_ctx, getState());
enterRule(_localctx, 152, RULE_window_function);
int _la;
try {
setState(1926);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FIRST_VALUE_:
case LAST_VALUE_:
enterOuterAlt(_localctx, 1);
{
setState(1841);
_la = _input.LA(1);
if ( !(_la==FIRST_VALUE_ || _la==LAST_VALUE_) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1842);
match(OPEN_PAR);
setState(1843);
expr(0);
setState(1844);
match(CLOSE_PAR);
setState(1845);
match(OVER_);
setState(1846);
match(OPEN_PAR);
setState(1848);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION_) {
{
setState(1847);
partition_by();
}
}
setState(1850);
order_by_expr_asc_desc();
setState(1852);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 2251799880794113L) != 0)) {
{
setState(1851);
frame_clause();
}
}
setState(1854);
match(CLOSE_PAR);
}
break;
case CUME_DIST_:
case PERCENT_RANK_:
enterOuterAlt(_localctx, 2);
{
setState(1856);
_la = _input.LA(1);
if ( !(_la==CUME_DIST_ || _la==PERCENT_RANK_) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1857);
match(OPEN_PAR);
setState(1858);
match(CLOSE_PAR);
setState(1859);
match(OVER_);
setState(1860);
match(OPEN_PAR);
setState(1862);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION_) {
{
setState(1861);
partition_by();
}
}
setState(1865);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER_) {
{
setState(1864);
order_by_expr();
}
}
setState(1867);
match(CLOSE_PAR);
}
break;
case DENSE_RANK_:
case RANK_:
case ROW_NUMBER_:
enterOuterAlt(_localctx, 3);
{
setState(1868);
_la = _input.LA(1);
if ( !(((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & 385L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1869);
match(OPEN_PAR);
setState(1870);
match(CLOSE_PAR);
setState(1871);
match(OVER_);
setState(1872);
match(OPEN_PAR);
setState(1874);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION_) {
{
setState(1873);
partition_by();
}
}
setState(1876);
order_by_expr_asc_desc();
setState(1877);
match(CLOSE_PAR);
}
break;
case LAG_:
case LEAD_:
enterOuterAlt(_localctx, 4);
{
setState(1879);
_la = _input.LA(1);
if ( !(_la==LAG_ || _la==LEAD_) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1880);
match(OPEN_PAR);
setState(1881);
expr(0);
setState(1883);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,278,_ctx) ) {
case 1:
{
setState(1882);
offset();
}
break;
}
setState(1886);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1885);
default_value();
}
}
setState(1888);
match(CLOSE_PAR);
setState(1889);
match(OVER_);
setState(1890);
match(OPEN_PAR);
setState(1892);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION_) {
{
setState(1891);
partition_by();
}
}
setState(1894);
order_by_expr_asc_desc();
setState(1895);
match(CLOSE_PAR);
}
break;
case NTH_VALUE_:
enterOuterAlt(_localctx, 5);
{
setState(1897);
match(NTH_VALUE_);
setState(1898);
match(OPEN_PAR);
setState(1899);
expr(0);
setState(1900);
match(COMMA);
setState(1901);
signed_number();
setState(1902);
match(CLOSE_PAR);
setState(1903);
match(OVER_);
setState(1904);
match(OPEN_PAR);
setState(1906);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION_) {
{
setState(1905);
partition_by();
}
}
setState(1908);
order_by_expr_asc_desc();
setState(1910);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 2251799880794113L) != 0)) {
{
setState(1909);
frame_clause();
}
}
setState(1912);
match(CLOSE_PAR);
}
break;
case NTILE_:
enterOuterAlt(_localctx, 6);
{
setState(1914);
match(NTILE_);
setState(1915);
match(OPEN_PAR);
setState(1916);
expr(0);
setState(1917);
match(CLOSE_PAR);
setState(1918);
match(OVER_);
setState(1919);
match(OPEN_PAR);
setState(1921);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION_) {
{
setState(1920);
partition_by();
}
}
setState(1923);
order_by_expr_asc_desc();
setState(1924);
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;
}
@SuppressWarnings("CheckReturnValue")
public static class OffsetContext extends ParserRuleContext {
public TerminalNode COMMA() { return getToken(SQLiteParser.COMMA, 0); }
public Signed_numberContext signed_number() {
return getRuleContext(Signed_numberContext.class,0);
}
public OffsetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_offset; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterOffset(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitOffset(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitOffset(this);
else return visitor.visitChildren(this);
}
}
public final OffsetContext offset() throws RecognitionException {
OffsetContext _localctx = new OffsetContext(_ctx, getState());
enterRule(_localctx, 154, RULE_offset);
try {
enterOuterAlt(_localctx, 1);
{
setState(1928);
match(COMMA);
setState(1929);
signed_number();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Default_valueContext extends ParserRuleContext {
public TerminalNode COMMA() { return getToken(SQLiteParser.COMMA, 0); }
public Signed_numberContext signed_number() {
return getRuleContext(Signed_numberContext.class,0);
}
public Default_valueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_default_value; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterDefault_value(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitDefault_value(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitDefault_value(this);
else return visitor.visitChildren(this);
}
}
public final Default_valueContext default_value() throws RecognitionException {
Default_valueContext _localctx = new Default_valueContext(_ctx, getState());
enterRule(_localctx, 156, RULE_default_value);
try {
enterOuterAlt(_localctx, 1);
{
setState(1931);
match(COMMA);
setState(1932);
signed_number();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Partition_byContext extends ParserRuleContext {
public TerminalNode PARTITION_() { return getToken(SQLiteParser.PARTITION_, 0); }
public TerminalNode BY_() { return getToken(SQLiteParser.BY_, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public Partition_byContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partition_by; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterPartition_by(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitPartition_by(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitPartition_by(this);
else return visitor.visitChildren(this);
}
}
public final Partition_byContext partition_by() throws RecognitionException {
Partition_byContext _localctx = new Partition_byContext(_ctx, getState());
enterRule(_localctx, 158, RULE_partition_by);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1934);
match(PARTITION_);
setState(1935);
match(BY_);
setState(1937);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1936);
expr(0);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1939);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,285,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Order_by_exprContext extends ParserRuleContext {
public TerminalNode ORDER_() { return getToken(SQLiteParser.ORDER_, 0); }
public TerminalNode BY_() { return getToken(SQLiteParser.BY_, 0); }
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public Order_by_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_order_by_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterOrder_by_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitOrder_by_expr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitOrder_by_expr(this);
else return visitor.visitChildren(this);
}
}
public final Order_by_exprContext order_by_expr() throws RecognitionException {
Order_by_exprContext _localctx = new Order_by_exprContext(_ctx, getState());
enterRule(_localctx, 160, RULE_order_by_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1941);
match(ORDER_);
setState(1942);
match(BY_);
setState(1944);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1943);
expr(0);
}
}
setState(1946);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & -33552632L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1152921504606846977L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 4476578029606273023L) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Order_by_expr_asc_descContext extends ParserRuleContext {
public TerminalNode ORDER_() { return getToken(SQLiteParser.ORDER_, 0); }
public TerminalNode BY_() { return getToken(SQLiteParser.BY_, 0); }
public Expr_asc_descContext expr_asc_desc() {
return getRuleContext(Expr_asc_descContext.class,0);
}
public Order_by_expr_asc_descContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_order_by_expr_asc_desc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterOrder_by_expr_asc_desc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitOrder_by_expr_asc_desc(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitOrder_by_expr_asc_desc(this);
else return visitor.visitChildren(this);
}
}
public final Order_by_expr_asc_descContext order_by_expr_asc_desc() throws RecognitionException {
Order_by_expr_asc_descContext _localctx = new Order_by_expr_asc_descContext(_ctx, getState());
enterRule(_localctx, 162, RULE_order_by_expr_asc_desc);
try {
enterOuterAlt(_localctx, 1);
{
setState(1948);
match(ORDER_);
setState(1949);
match(BY_);
setState(1950);
expr_asc_desc();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_asc_descContext extends ParserRuleContext {
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List<Asc_descContext> asc_desc() {
return getRuleContexts(Asc_descContext.class);
}
public Asc_descContext asc_desc(int i) {
return getRuleContext(Asc_descContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(SQLiteParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLiteParser.COMMA, i);
}
public Expr_asc_descContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_asc_desc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterExpr_asc_desc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitExpr_asc_desc(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitExpr_asc_desc(this);
else return visitor.visitChildren(this);
}
}
public final Expr_asc_descContext expr_asc_desc() throws RecognitionException {
Expr_asc_descContext _localctx = new Expr_asc_descContext(_ctx, getState());
enterRule(_localctx, 164, RULE_expr_asc_desc);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1952);
expr(0);
setState(1954);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC_ || _la==DESC_) {
{
setState(1953);
asc_desc();
}
}
setState(1963);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1956);
match(COMMA);
setState(1957);
expr(0);
setState(1959);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC_ || _la==DESC_) {
{
setState(1958);
asc_desc();
}
}
}
}
setState(1965);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class Initial_selectContext extends ParserRuleContext {
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public Initial_selectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_initial_select; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterInitial_select(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitInitial_select(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitInitial_select(this);
else return visitor.visitChildren(this);
}
}
public final Initial_selectContext initial_select() throws RecognitionException {
Initial_selectContext _localctx = new Initial_selectContext(_ctx, getState());
enterRule(_localctx, 166, RULE_initial_select);
try {
enterOuterAlt(_localctx, 1);
{
setState(1966);
select_stmt();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Recursive_selectContext extends ParserRuleContext {
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public Recursive_selectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_recursive_select; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterRecursive_select(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitRecursive_select(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitRecursive_select(this);
else return visitor.visitChildren(this);
}
}
public final Recursive_selectContext recursive_select() throws RecognitionException {
Recursive_selectContext _localctx = new Recursive_selectContext(_ctx, getState());
enterRule(_localctx, 168, RULE_recursive_select);
try {
enterOuterAlt(_localctx, 1);
{
setState(1968);
select_stmt();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Unary_operatorContext extends ParserRuleContext {
public TerminalNode MINUS() { return getToken(SQLiteParser.MINUS, 0); }
public TerminalNode PLUS() { return getToken(SQLiteParser.PLUS, 0); }
public TerminalNode TILDE() { return getToken(SQLiteParser.TILDE, 0); }
public TerminalNode NOT_() { return getToken(SQLiteParser.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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterUnary_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitUnary_operator(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 170, RULE_unary_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1970);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 1792L) != 0) || _la==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;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterError_message(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitError_message(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 172, RULE_error_message);
try {
enterOuterAlt(_localctx, 1);
{
setState(1972);
match(STRING_LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterModule_argument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitModule_argument(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 174, RULE_module_argument);
try {
setState(1976);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,290,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1974);
expr(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1975);
column_def();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterColumn_alias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitColumn_alias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 176, RULE_column_alias);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1978);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class KeywordContext extends ParserRuleContext {
public TerminalNode ABORT_() { return getToken(SQLiteParser.ABORT_, 0); }
public TerminalNode ACTION_() { return getToken(SQLiteParser.ACTION_, 0); }
public TerminalNode ADD_() { return getToken(SQLiteParser.ADD_, 0); }
public TerminalNode AFTER_() { return getToken(SQLiteParser.AFTER_, 0); }
public TerminalNode ALL_() { return getToken(SQLiteParser.ALL_, 0); }
public TerminalNode ALTER_() { return getToken(SQLiteParser.ALTER_, 0); }
public TerminalNode ANALYZE_() { return getToken(SQLiteParser.ANALYZE_, 0); }
public TerminalNode AND_() { return getToken(SQLiteParser.AND_, 0); }
public TerminalNode AS_() { return getToken(SQLiteParser.AS_, 0); }
public TerminalNode ASC_() { return getToken(SQLiteParser.ASC_, 0); }
public TerminalNode ATTACH_() { return getToken(SQLiteParser.ATTACH_, 0); }
public TerminalNode AUTOINCREMENT_() { return getToken(SQLiteParser.AUTOINCREMENT_, 0); }
public TerminalNode BEFORE_() { return getToken(SQLiteParser.BEFORE_, 0); }
public TerminalNode BEGIN_() { return getToken(SQLiteParser.BEGIN_, 0); }
public TerminalNode BETWEEN_() { return getToken(SQLiteParser.BETWEEN_, 0); }
public TerminalNode BY_() { return getToken(SQLiteParser.BY_, 0); }
public TerminalNode CASCADE_() { return getToken(SQLiteParser.CASCADE_, 0); }
public TerminalNode CASE_() { return getToken(SQLiteParser.CASE_, 0); }
public TerminalNode CAST_() { return getToken(SQLiteParser.CAST_, 0); }
public TerminalNode CHECK_() { return getToken(SQLiteParser.CHECK_, 0); }
public TerminalNode COLLATE_() { return getToken(SQLiteParser.COLLATE_, 0); }
public TerminalNode COLUMN_() { return getToken(SQLiteParser.COLUMN_, 0); }
public TerminalNode COMMIT_() { return getToken(SQLiteParser.COMMIT_, 0); }
public TerminalNode CONFLICT_() { return getToken(SQLiteParser.CONFLICT_, 0); }
public TerminalNode CONSTRAINT_() { return getToken(SQLiteParser.CONSTRAINT_, 0); }
public TerminalNode CREATE_() { return getToken(SQLiteParser.CREATE_, 0); }
public TerminalNode CROSS_() { return getToken(SQLiteParser.CROSS_, 0); }
public TerminalNode CURRENT_DATE_() { return getToken(SQLiteParser.CURRENT_DATE_, 0); }
public TerminalNode CURRENT_TIME_() { return getToken(SQLiteParser.CURRENT_TIME_, 0); }
public TerminalNode CURRENT_TIMESTAMP_() { return getToken(SQLiteParser.CURRENT_TIMESTAMP_, 0); }
public TerminalNode DATABASE_() { return getToken(SQLiteParser.DATABASE_, 0); }
public TerminalNode DEFAULT_() { return getToken(SQLiteParser.DEFAULT_, 0); }
public TerminalNode DEFERRABLE_() { return getToken(SQLiteParser.DEFERRABLE_, 0); }
public TerminalNode DEFERRED_() { return getToken(SQLiteParser.DEFERRED_, 0); }
public TerminalNode DELETE_() { return getToken(SQLiteParser.DELETE_, 0); }
public TerminalNode DESC_() { return getToken(SQLiteParser.DESC_, 0); }
public TerminalNode DETACH_() { return getToken(SQLiteParser.DETACH_, 0); }
public TerminalNode DISTINCT_() { return getToken(SQLiteParser.DISTINCT_, 0); }
public TerminalNode DROP_() { return getToken(SQLiteParser.DROP_, 0); }
public TerminalNode EACH_() { return getToken(SQLiteParser.EACH_, 0); }
public TerminalNode ELSE_() { return getToken(SQLiteParser.ELSE_, 0); }
public TerminalNode END_() { return getToken(SQLiteParser.END_, 0); }
public TerminalNode ESCAPE_() { return getToken(SQLiteParser.ESCAPE_, 0); }
public TerminalNode EXCEPT_() { return getToken(SQLiteParser.EXCEPT_, 0); }
public TerminalNode EXCLUSIVE_() { return getToken(SQLiteParser.EXCLUSIVE_, 0); }
public TerminalNode EXISTS_() { return getToken(SQLiteParser.EXISTS_, 0); }
public TerminalNode EXPLAIN_() { return getToken(SQLiteParser.EXPLAIN_, 0); }
public TerminalNode FAIL_() { return getToken(SQLiteParser.FAIL_, 0); }
public TerminalNode FOR_() { return getToken(SQLiteParser.FOR_, 0); }
public TerminalNode FOREIGN_() { return getToken(SQLiteParser.FOREIGN_, 0); }
public TerminalNode FROM_() { return getToken(SQLiteParser.FROM_, 0); }
public TerminalNode FULL_() { return getToken(SQLiteParser.FULL_, 0); }
public TerminalNode GLOB_() { return getToken(SQLiteParser.GLOB_, 0); }
public TerminalNode GROUP_() { return getToken(SQLiteParser.GROUP_, 0); }
public TerminalNode HAVING_() { return getToken(SQLiteParser.HAVING_, 0); }
public TerminalNode IF_() { return getToken(SQLiteParser.IF_, 0); }
public TerminalNode IGNORE_() { return getToken(SQLiteParser.IGNORE_, 0); }
public TerminalNode IMMEDIATE_() { return getToken(SQLiteParser.IMMEDIATE_, 0); }
public TerminalNode IN_() { return getToken(SQLiteParser.IN_, 0); }
public TerminalNode INDEX_() { return getToken(SQLiteParser.INDEX_, 0); }
public TerminalNode INDEXED_() { return getToken(SQLiteParser.INDEXED_, 0); }
public TerminalNode INITIALLY_() { return getToken(SQLiteParser.INITIALLY_, 0); }
public TerminalNode INNER_() { return getToken(SQLiteParser.INNER_, 0); }
public TerminalNode INSERT_() { return getToken(SQLiteParser.INSERT_, 0); }
public TerminalNode INSTEAD_() { return getToken(SQLiteParser.INSTEAD_, 0); }
public TerminalNode INTERSECT_() { return getToken(SQLiteParser.INTERSECT_, 0); }
public TerminalNode INTO_() { return getToken(SQLiteParser.INTO_, 0); }
public TerminalNode IS_() { return getToken(SQLiteParser.IS_, 0); }
public TerminalNode ISNULL_() { return getToken(SQLiteParser.ISNULL_, 0); }
public TerminalNode JOIN_() { return getToken(SQLiteParser.JOIN_, 0); }
public TerminalNode KEY_() { return getToken(SQLiteParser.KEY_, 0); }
public TerminalNode LEFT_() { return getToken(SQLiteParser.LEFT_, 0); }
public TerminalNode LIKE_() { return getToken(SQLiteParser.LIKE_, 0); }
public TerminalNode LIMIT_() { return getToken(SQLiteParser.LIMIT_, 0); }
public TerminalNode MATCH_() { return getToken(SQLiteParser.MATCH_, 0); }
public TerminalNode NATURAL_() { return getToken(SQLiteParser.NATURAL_, 0); }
public TerminalNode NO_() { return getToken(SQLiteParser.NO_, 0); }
public TerminalNode NOT_() { return getToken(SQLiteParser.NOT_, 0); }
public TerminalNode NOTNULL_() { return getToken(SQLiteParser.NOTNULL_, 0); }
public TerminalNode NULL_() { return getToken(SQLiteParser.NULL_, 0); }
public TerminalNode OF_() { return getToken(SQLiteParser.OF_, 0); }
public TerminalNode OFFSET_() { return getToken(SQLiteParser.OFFSET_, 0); }
public TerminalNode ON_() { return getToken(SQLiteParser.ON_, 0); }
public TerminalNode OR_() { return getToken(SQLiteParser.OR_, 0); }
public TerminalNode ORDER_() { return getToken(SQLiteParser.ORDER_, 0); }
public TerminalNode OUTER_() { return getToken(SQLiteParser.OUTER_, 0); }
public TerminalNode PLAN_() { return getToken(SQLiteParser.PLAN_, 0); }
public TerminalNode PRAGMA_() { return getToken(SQLiteParser.PRAGMA_, 0); }
public TerminalNode PRIMARY_() { return getToken(SQLiteParser.PRIMARY_, 0); }
public TerminalNode QUERY_() { return getToken(SQLiteParser.QUERY_, 0); }
public TerminalNode RAISE_() { return getToken(SQLiteParser.RAISE_, 0); }
public TerminalNode RECURSIVE_() { return getToken(SQLiteParser.RECURSIVE_, 0); }
public TerminalNode REFERENCES_() { return getToken(SQLiteParser.REFERENCES_, 0); }
public TerminalNode REGEXP_() { return getToken(SQLiteParser.REGEXP_, 0); }
public TerminalNode REINDEX_() { return getToken(SQLiteParser.REINDEX_, 0); }
public TerminalNode RELEASE_() { return getToken(SQLiteParser.RELEASE_, 0); }
public TerminalNode RENAME_() { return getToken(SQLiteParser.RENAME_, 0); }
public TerminalNode REPLACE_() { return getToken(SQLiteParser.REPLACE_, 0); }
public TerminalNode RESTRICT_() { return getToken(SQLiteParser.RESTRICT_, 0); }
public TerminalNode RIGHT_() { return getToken(SQLiteParser.RIGHT_, 0); }
public TerminalNode ROLLBACK_() { return getToken(SQLiteParser.ROLLBACK_, 0); }
public TerminalNode ROW_() { return getToken(SQLiteParser.ROW_, 0); }
public TerminalNode ROWS_() { return getToken(SQLiteParser.ROWS_, 0); }
public TerminalNode SAVEPOINT_() { return getToken(SQLiteParser.SAVEPOINT_, 0); }
public TerminalNode SELECT_() { return getToken(SQLiteParser.SELECT_, 0); }
public TerminalNode SET_() { return getToken(SQLiteParser.SET_, 0); }
public TerminalNode TABLE_() { return getToken(SQLiteParser.TABLE_, 0); }
public TerminalNode TEMP_() { return getToken(SQLiteParser.TEMP_, 0); }
public TerminalNode TEMPORARY_() { return getToken(SQLiteParser.TEMPORARY_, 0); }
public TerminalNode THEN_() { return getToken(SQLiteParser.THEN_, 0); }
public TerminalNode TO_() { return getToken(SQLiteParser.TO_, 0); }
public TerminalNode TRANSACTION_() { return getToken(SQLiteParser.TRANSACTION_, 0); }
public TerminalNode TRIGGER_() { return getToken(SQLiteParser.TRIGGER_, 0); }
public TerminalNode UNION_() { return getToken(SQLiteParser.UNION_, 0); }
public TerminalNode UNIQUE_() { return getToken(SQLiteParser.UNIQUE_, 0); }
public TerminalNode UPDATE_() { return getToken(SQLiteParser.UPDATE_, 0); }
public TerminalNode USING_() { return getToken(SQLiteParser.USING_, 0); }
public TerminalNode VACUUM_() { return getToken(SQLiteParser.VACUUM_, 0); }
public TerminalNode VALUES_() { return getToken(SQLiteParser.VALUES_, 0); }
public TerminalNode VIEW_() { return getToken(SQLiteParser.VIEW_, 0); }
public TerminalNode VIRTUAL_() { return getToken(SQLiteParser.VIRTUAL_, 0); }
public TerminalNode WHEN_() { return getToken(SQLiteParser.WHEN_, 0); }
public TerminalNode WHERE_() { return getToken(SQLiteParser.WHERE_, 0); }
public TerminalNode WITH_() { return getToken(SQLiteParser.WITH_, 0); }
public TerminalNode WITHOUT_() { return getToken(SQLiteParser.WITHOUT_, 0); }
public TerminalNode FIRST_VALUE_() { return getToken(SQLiteParser.FIRST_VALUE_, 0); }
public TerminalNode OVER_() { return getToken(SQLiteParser.OVER_, 0); }
public TerminalNode PARTITION_() { return getToken(SQLiteParser.PARTITION_, 0); }
public TerminalNode RANGE_() { return getToken(SQLiteParser.RANGE_, 0); }
public TerminalNode PRECEDING_() { return getToken(SQLiteParser.PRECEDING_, 0); }
public TerminalNode UNBOUNDED_() { return getToken(SQLiteParser.UNBOUNDED_, 0); }
public TerminalNode CURRENT_() { return getToken(SQLiteParser.CURRENT_, 0); }
public TerminalNode FOLLOWING_() { return getToken(SQLiteParser.FOLLOWING_, 0); }
public TerminalNode CUME_DIST_() { return getToken(SQLiteParser.CUME_DIST_, 0); }
public TerminalNode DENSE_RANK_() { return getToken(SQLiteParser.DENSE_RANK_, 0); }
public TerminalNode LAG_() { return getToken(SQLiteParser.LAG_, 0); }
public TerminalNode LAST_VALUE_() { return getToken(SQLiteParser.LAST_VALUE_, 0); }
public TerminalNode LEAD_() { return getToken(SQLiteParser.LEAD_, 0); }
public TerminalNode NTH_VALUE_() { return getToken(SQLiteParser.NTH_VALUE_, 0); }
public TerminalNode NTILE_() { return getToken(SQLiteParser.NTILE_, 0); }
public TerminalNode PERCENT_RANK_() { return getToken(SQLiteParser.PERCENT_RANK_, 0); }
public TerminalNode RANK_() { return getToken(SQLiteParser.RANK_, 0); }
public TerminalNode ROW_NUMBER_() { return getToken(SQLiteParser.ROW_NUMBER_, 0); }
public TerminalNode GENERATED_() { return getToken(SQLiteParser.GENERATED_, 0); }
public TerminalNode ALWAYS_() { return getToken(SQLiteParser.ALWAYS_, 0); }
public TerminalNode STORED_() { return getToken(SQLiteParser.STORED_, 0); }
public TerminalNode TRUE_() { return getToken(SQLiteParser.TRUE_, 0); }
public TerminalNode FALSE_() { return getToken(SQLiteParser.FALSE_, 0); }
public TerminalNode WINDOW_() { return getToken(SQLiteParser.WINDOW_, 0); }
public TerminalNode NULLS_() { return getToken(SQLiteParser.NULLS_, 0); }
public TerminalNode FIRST_() { return getToken(SQLiteParser.FIRST_, 0); }
public TerminalNode LAST_() { return getToken(SQLiteParser.LAST_, 0); }
public TerminalNode FILTER_() { return getToken(SQLiteParser.FILTER_, 0); }
public TerminalNode GROUPS_() { return getToken(SQLiteParser.GROUPS_, 0); }
public TerminalNode EXCLUDE_() { return getToken(SQLiteParser.EXCLUDE_, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterKeyword(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitKeyword(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitKeyword(this);
else return visitor.visitChildren(this);
}
}
public final KeywordContext keyword() throws RecognitionException {
KeywordContext _localctx = new KeywordContext(_ctx, getState());
enterRule(_localctx, 178, RULE_keyword);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1980);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & -33554432L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1152921504606846977L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 9007199254740991L) != 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;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitName(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitName(this);
else return visitor.visitChildren(this);
}
}
public final NameContext name() throws RecognitionException {
NameContext _localctx = new NameContext(_ctx, getState());
enterRule(_localctx, 180, RULE_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1982);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterFunction_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitFunction_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 182, RULE_function_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1984);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterSchema_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitSchema_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 184, RULE_schema_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1986);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterTable_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitTable_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 186, RULE_table_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1988);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterTable_or_index_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitTable_or_index_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 188, RULE_table_or_index_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1990);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterColumn_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitColumn_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 190, RULE_column_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1992);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterCollation_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitCollation_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 192, RULE_collation_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1994);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterForeign_table(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitForeign_table(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 194, RULE_foreign_table);
try {
enterOuterAlt(_localctx, 1);
{
setState(1996);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterIndex_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitIndex_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 196, RULE_index_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1998);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterTrigger_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitTrigger_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 198, RULE_trigger_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(2000);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterView_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitView_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 200, RULE_view_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(2002);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterModule_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitModule_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 202, RULE_module_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(2004);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterPragma_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitPragma_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 204, RULE_pragma_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(2006);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterSavepoint_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitSavepoint_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 206, RULE_savepoint_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(2008);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public Table_aliasContext table_alias() {
return getRuleContext(Table_aliasContext.class,0);
}
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterTable_alias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitTable_alias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 208, RULE_table_alias);
try {
setState(2016);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(2010);
match(IDENTIFIER);
}
break;
case STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(2011);
match(STRING_LITERAL);
}
break;
case OPEN_PAR:
enterOuterAlt(_localctx, 3);
{
setState(2012);
match(OPEN_PAR);
setState(2013);
table_alias();
setState(2014);
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;
}
@SuppressWarnings("CheckReturnValue")
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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterTransaction_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitTransaction_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 210, RULE_transaction_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(2018);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Window_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Window_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_window_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterWindow_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitWindow_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitWindow_name(this);
else return visitor.visitChildren(this);
}
}
public final Window_nameContext window_name() throws RecognitionException {
Window_nameContext _localctx = new Window_nameContext(_ctx, getState());
enterRule(_localctx, 212, RULE_window_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(2020);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AliasContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public AliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitAlias(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitAlias(this);
else return visitor.visitChildren(this);
}
}
public final AliasContext alias() throws RecognitionException {
AliasContext _localctx = new AliasContext(_ctx, getState());
enterRule(_localctx, 214, RULE_alias);
try {
enterOuterAlt(_localctx, 1);
{
setState(2022);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FilenameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public FilenameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_filename; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterFilename(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitFilename(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitFilename(this);
else return visitor.visitChildren(this);
}
}
public final FilenameContext filename() throws RecognitionException {
FilenameContext _localctx = new FilenameContext(_ctx, getState());
enterRule(_localctx, 216, RULE_filename);
try {
enterOuterAlt(_localctx, 1);
{
setState(2024);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Base_window_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Base_window_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_base_window_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterBase_window_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitBase_window_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitBase_window_name(this);
else return visitor.visitChildren(this);
}
}
public final Base_window_nameContext base_window_name() throws RecognitionException {
Base_window_nameContext _localctx = new Base_window_nameContext(_ctx, getState());
enterRule(_localctx, 218, RULE_base_window_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(2026);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Simple_funcContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Simple_funcContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simple_func; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterSimple_func(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitSimple_func(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitSimple_func(this);
else return visitor.visitChildren(this);
}
}
public final Simple_funcContext simple_func() throws RecognitionException {
Simple_funcContext _localctx = new Simple_funcContext(_ctx, getState());
enterRule(_localctx, 220, RULE_simple_func);
try {
enterOuterAlt(_localctx, 1);
{
setState(2028);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Aggregate_funcContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Aggregate_funcContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aggregate_func; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterAggregate_func(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitAggregate_func(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitAggregate_func(this);
else return visitor.visitChildren(this);
}
}
public final Aggregate_funcContext aggregate_func() throws RecognitionException {
Aggregate_funcContext _localctx = new Aggregate_funcContext(_ctx, getState());
enterRule(_localctx, 222, RULE_aggregate_func);
try {
enterOuterAlt(_localctx, 1);
{
setState(2030);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Table_function_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Table_function_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_function_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).enterTable_function_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitTable_function_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? extends T>)visitor).visitTable_function_name(this);
else return visitor.visitChildren(this);
}
}
public final Table_function_nameContext table_function_name() throws RecognitionException {
Table_function_nameContext _localctx = new Table_function_nameContext(_ctx, getState());
enterRule(_localctx, 224, RULE_table_function_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(2032);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 TerminalNode OPEN_PAR() { return getToken(SQLiteParser.OPEN_PAR, 0); }
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public TerminalNode CLOSE_PAR() { return getToken(SQLiteParser.CLOSE_PAR, 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 SQLiteParserListener ) ((SQLiteParserListener)listener).enterAny_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLiteParserListener ) ((SQLiteParserListener)listener).exitAny_name(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof SQLiteParserVisitor ) return ((SQLiteParserVisitor<? 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, 226, RULE_any_name);
try {
setState(2041);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(2034);
match(IDENTIFIER);
}
break;
case ABORT_:
case ACTION_:
case ADD_:
case AFTER_:
case ALL_:
case ALTER_:
case ANALYZE_:
case AND_:
case AS_:
case ASC_:
case ATTACH_:
case AUTOINCREMENT_:
case BEFORE_:
case BEGIN_:
case BETWEEN_:
case BY_:
case CASCADE_:
case CASE_:
case CAST_:
case CHECK_:
case COLLATE_:
case COLUMN_:
case COMMIT_:
case CONFLICT_:
case CONSTRAINT_:
case CREATE_:
case CROSS_:
case CURRENT_DATE_:
case CURRENT_TIME_:
case CURRENT_TIMESTAMP_:
case DATABASE_:
case DEFAULT_:
case DEFERRABLE_:
case DEFERRED_:
case DELETE_:
case DESC_:
case DETACH_:
case DISTINCT_:
case DROP_:
case EACH_:
case ELSE_:
case END_:
case ESCAPE_:
case EXCEPT_:
case EXCLUSIVE_:
case EXISTS_:
case EXPLAIN_:
case FAIL_:
case FOR_:
case FOREIGN_:
case FROM_:
case FULL_:
case GLOB_:
case GROUP_:
case HAVING_:
case IF_:
case IGNORE_:
case IMMEDIATE_:
case IN_:
case INDEX_:
case INDEXED_:
case INITIALLY_:
case INNER_:
case INSERT_:
case INSTEAD_:
case INTERSECT_:
case INTO_:
case IS_:
case ISNULL_:
case JOIN_:
case KEY_:
case LEFT_:
case LIKE_:
case LIMIT_:
case MATCH_:
case NATURAL_:
case NO_:
case NOT_:
case NOTNULL_:
case NULL_:
case OF_:
case OFFSET_:
case ON_:
case OR_:
case ORDER_:
case OUTER_:
case PLAN_:
case PRAGMA_:
case PRIMARY_:
case QUERY_:
case RAISE_:
case RECURSIVE_:
case REFERENCES_:
case REGEXP_:
case REINDEX_:
case RELEASE_:
case RENAME_:
case REPLACE_:
case RESTRICT_:
case RIGHT_:
case ROLLBACK_:
case ROW_:
case ROWS_:
case SAVEPOINT_:
case SELECT_:
case SET_:
case TABLE_:
case TEMP_:
case TEMPORARY_:
case THEN_:
case TO_:
case TRANSACTION_:
case TRIGGER_:
case UNION_:
case UNIQUE_:
case UPDATE_:
case USING_:
case VACUUM_:
case VALUES_:
case VIEW_:
case VIRTUAL_:
case WHEN_:
case WHERE_:
case WITH_:
case WITHOUT_:
case FIRST_VALUE_:
case OVER_:
case PARTITION_:
case RANGE_:
case PRECEDING_:
case UNBOUNDED_:
case CURRENT_:
case FOLLOWING_:
case CUME_DIST_:
case DENSE_RANK_:
case LAG_:
case LAST_VALUE_:
case LEAD_:
case NTH_VALUE_:
case NTILE_:
case PERCENT_RANK_:
case RANK_:
case ROW_NUMBER_:
case GENERATED_:
case ALWAYS_:
case STORED_:
case TRUE_:
case FALSE_:
case WINDOW_:
case NULLS_:
case FIRST_:
case LAST_:
case FILTER_:
case GROUPS_:
case EXCLUDE_:
enterOuterAlt(_localctx, 2);
{
setState(2035);
keyword();
}
break;
case STRING_LITERAL:
enterOuterAlt(_localctx, 3);
{
setState(2036);
match(STRING_LITERAL);
}
break;
case OPEN_PAR:
enterOuterAlt(_localctx, 4);
{
setState(2037);
match(OPEN_PAR);
setState(2038);
any_name();
setState(2039);
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 32:
return expr_sempred((ExprContext)_localctx, predIndex);
}
return true;
}
private boolean expr_sempred(ExprContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 20);
case 1:
return precpred(_ctx, 19);
case 2:
return precpred(_ctx, 18);
case 3:
return precpred(_ctx, 17);
case 4:
return precpred(_ctx, 16);
case 5:
return precpred(_ctx, 15);
case 6:
return precpred(_ctx, 14);
case 7:
return precpred(_ctx, 13);
case 8:
return precpred(_ctx, 6);
case 9:
return precpred(_ctx, 5);
case 10:
return precpred(_ctx, 9);
case 11:
return precpred(_ctx, 8);
case 12:
return precpred(_ctx, 7);
case 13:
return precpred(_ctx, 4);
}
return true;
}
public static final String _serializedATN =
"\u0004\u0001\u00c1\u07fc\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+
"\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+
"\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+
"\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+
"\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+
"\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+
"\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+
"\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007"+
"\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007"+
"\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007"+
"\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007"+
"\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002