Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1# Generated from \SQLiteParser.g4 by ANTLR 4.9 

2# encoding: utf-8 

3from antlr4 import * 

4from io import StringIO 

5import sys 

6if sys.version_info[1] > 5: 

7 from typing import TextIO 

8else: 

9 from typing.io import TextIO 

10 

11 

12def serializedATN(): 

13 with StringIO() as buf: 

14 buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00c2") 

15 buf.write("\u07fb\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7") 

16 buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16") 

17 buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23") 

18 buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31") 

19 buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36") 

20 buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t") 

21 buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4") 

22 buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64") 

23 buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t") 

24 buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t") 

25 buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t") 

26 buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t") 

27 buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4") 

28 buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4") 

29 buf.write("h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\3") 

30 buf.write("\2\7\2\u00e2\n\2\f\2\16\2\u00e5\13\2\3\2\3\2\3\3\7\3\u00ea") 

31 buf.write("\n\3\f\3\16\3\u00ed\13\3\3\3\3\3\6\3\u00f1\n\3\r\3\16") 

32 buf.write("\3\u00f2\3\3\7\3\u00f6\n\3\f\3\16\3\u00f9\13\3\3\3\7\3") 

33 buf.write("\u00fc\n\3\f\3\16\3\u00ff\13\3\3\4\3\4\3\4\5\4\u0104\n") 

34 buf.write("\4\5\4\u0106\n\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3") 

35 buf.write("\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4") 

36 buf.write("\3\4\5\4\u0120\n\4\3\5\3\5\3\5\3\5\3\5\5\5\u0127\n\5\3") 

37 buf.write("\5\3\5\3\5\3\5\3\5\5\5\u012e\n\5\3\5\3\5\3\5\3\5\5\5\u0134") 

38 buf.write("\n\5\3\5\3\5\5\5\u0138\n\5\3\5\5\5\u013b\n\5\3\6\3\6\3") 

39 buf.write("\6\3\6\3\6\5\6\u0142\n\6\3\6\5\6\u0145\n\6\3\7\3\7\5\7") 

40 buf.write("\u0149\n\7\3\7\3\7\3\7\3\7\3\b\3\b\5\b\u0151\n\b\3\b\3") 

41 buf.write("\b\5\b\u0155\n\b\5\b\u0157\n\b\3\t\3\t\5\t\u015b\n\t\3") 

42 buf.write("\n\3\n\5\n\u015f\n\n\3\n\3\n\5\n\u0163\n\n\3\n\5\n\u0166") 

43 buf.write("\n\n\3\13\3\13\3\13\3\f\3\f\5\f\u016d\n\f\3\f\3\f\3\r") 

44 buf.write("\3\r\5\r\u0173\n\r\3\r\3\r\3\r\3\r\5\r\u0179\n\r\3\r\3") 

45 buf.write("\r\3\r\5\r\u017e\n\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\7\r\u0187") 

46 buf.write("\n\r\f\r\16\r\u018a\13\r\3\r\3\r\3\r\5\r\u018f\n\r\3\16") 

47 buf.write("\3\16\5\16\u0193\n\16\3\16\3\16\5\16\u0197\n\16\3\16\5") 

48 buf.write("\16\u019a\n\16\3\17\3\17\5\17\u019e\n\17\3\17\3\17\3\17") 

49 buf.write("\3\17\5\17\u01a4\n\17\3\17\3\17\3\17\5\17\u01a9\n\17\3") 

50 buf.write("\17\3\17\3\17\3\17\3\17\7\17\u01b0\n\17\f\17\16\17\u01b3") 

51 buf.write("\13\17\3\17\3\17\7\17\u01b7\n\17\f\17\16\17\u01ba\13\17") 

52 buf.write("\3\17\3\17\3\17\5\17\u01bf\n\17\3\17\3\17\5\17\u01c3\n") 

53 buf.write("\17\3\20\3\20\5\20\u01c7\n\20\3\20\7\20\u01ca\n\20\f\20") 

54 buf.write("\16\20\u01cd\13\20\3\21\6\21\u01d0\n\21\r\21\16\21\u01d1") 

55 buf.write("\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21") 

56 buf.write("\u01de\n\21\3\22\3\22\5\22\u01e2\n\22\3\22\3\22\3\22\5") 

57 buf.write("\22\u01e7\n\22\3\22\5\22\u01ea\n\22\3\22\5\22\u01ed\n") 

58 buf.write("\22\3\22\3\22\3\22\5\22\u01f2\n\22\3\22\5\22\u01f5\n\22") 

59 buf.write("\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22") 

60 buf.write("\3\22\5\22\u0203\n\22\3\22\3\22\3\22\3\22\3\22\5\22\u020a") 

61 buf.write("\n\22\3\22\3\22\3\22\3\22\3\22\5\22\u0211\n\22\5\22\u0213") 

62 buf.write("\n\22\3\23\5\23\u0216\n\23\3\23\3\23\3\24\3\24\5\24\u021c") 

63 buf.write("\n\24\3\24\3\24\3\24\5\24\u0221\n\24\3\24\3\24\3\24\3") 

64 buf.write("\24\7\24\u0227\n\24\f\24\16\24\u022a\13\24\3\24\3\24\5") 

65 buf.write("\24\u022e\n\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24") 

66 buf.write("\3\24\3\24\3\24\7\24\u023b\n\24\f\24\16\24\u023e\13\24") 

67 buf.write("\3\24\3\24\3\24\5\24\u0243\n\24\3\25\3\25\3\25\3\25\3") 

68 buf.write("\25\3\25\7\25\u024b\n\25\f\25\16\25\u024e\13\25\3\25\3") 

69 buf.write("\25\5\25\u0252\n\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25") 

70 buf.write("\3\25\5\25\u025c\n\25\3\25\3\25\7\25\u0260\n\25\f\25\16") 

71 buf.write("\25\u0263\13\25\3\25\5\25\u0266\n\25\3\25\3\25\3\25\5") 

72 buf.write("\25\u026b\n\25\5\25\u026d\n\25\3\26\3\26\3\26\3\26\3\27") 

73 buf.write("\3\27\5\27\u0275\n\27\3\27\3\27\3\27\3\27\5\27\u027b\n") 

74 buf.write("\27\3\27\3\27\3\27\5\27\u0280\n\27\3\27\3\27\3\27\3\27") 

75 buf.write("\3\27\5\27\u0287\n\27\3\27\3\27\3\27\3\27\3\27\3\27\3") 

76 buf.write("\27\7\27\u0290\n\27\f\27\16\27\u0293\13\27\5\27\u0295") 

77 buf.write("\n\27\5\27\u0297\n\27\3\27\3\27\3\27\3\27\3\27\5\27\u029e") 

78 buf.write("\n\27\3\27\3\27\5\27\u02a2\n\27\3\27\3\27\3\27\3\27\3") 

79 buf.write("\27\5\27\u02a9\n\27\3\27\3\27\6\27\u02ad\n\27\r\27\16") 

80 buf.write("\27\u02ae\3\27\3\27\3\30\3\30\5\30\u02b5\n\30\3\30\3\30") 

81 buf.write("\3\30\3\30\5\30\u02bb\n\30\3\30\3\30\3\30\5\30\u02c0\n") 

82 buf.write("\30\3\30\3\30\3\30\3\30\3\30\7\30\u02c7\n\30\f\30\16\30") 

83 buf.write("\u02ca\13\30\3\30\3\30\5\30\u02ce\n\30\3\30\3\30\3\30") 

84 buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u02d9\n\31\3\31\3") 

85 buf.write("\31\3\31\5\31\u02de\n\31\3\31\3\31\3\31\3\31\3\31\3\31") 

86 buf.write("\3\31\7\31\u02e7\n\31\f\31\16\31\u02ea\13\31\3\31\3\31") 

87 buf.write("\5\31\u02ee\n\31\3\32\3\32\5\32\u02f2\n\32\3\32\3\32\3") 

88 buf.write("\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\7\32") 

89 buf.write("\u0300\n\32\f\32\16\32\u0303\13\32\3\33\3\33\3\33\3\33") 

90 buf.write("\3\33\7\33\u030a\n\33\f\33\16\33\u030d\13\33\3\33\3\33") 

91 buf.write("\5\33\u0311\n\33\3\34\3\34\3\34\3\34\3\34\3\34\5\34\u0319") 

92 buf.write("\n\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\7\35\u0323") 

93 buf.write("\n\35\f\35\16\35\u0326\13\35\3\35\3\35\5\35\u032a\n\35") 

94 buf.write("\3\35\3\35\3\35\3\35\3\35\3\36\5\36\u0332\n\36\3\36\3") 

95 buf.write("\36\3\36\3\36\3\36\5\36\u0339\n\36\3\37\5\37\u033c\n\37") 

96 buf.write("\3\37\3\37\3\37\3\37\3\37\5\37\u0343\n\37\3\37\5\37\u0346") 

97 buf.write("\n\37\3\37\5\37\u0349\n\37\3 \3 \5 \u034d\n \3 \3 \3!") 

98 buf.write("\3!\3!\3!\5!\u0355\n!\3!\3!\3!\5!\u035a\n!\3!\3!\3\"\3") 

99 buf.write("\"\3\"\3\"\3\"\3\"\5\"\u0364\n\"\3\"\3\"\3\"\5\"\u0369") 

100 buf.write("\n\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u0372\n\"\3\"\3\"") 

101 buf.write("\3\"\7\"\u0377\n\"\f\"\16\"\u037a\13\"\3\"\5\"\u037d\n") 

102 buf.write("\"\3\"\3\"\5\"\u0381\n\"\3\"\5\"\u0384\n\"\3\"\3\"\3\"") 

103 buf.write("\3\"\7\"\u038a\n\"\f\"\16\"\u038d\13\"\3\"\3\"\3\"\3\"") 

104 buf.write("\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u0399\n\"\3\"\5\"\u039c\n") 

105 buf.write("\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u03a4\n\"\3\"\3\"\3\"\3") 

106 buf.write("\"\3\"\6\"\u03ab\n\"\r\"\16\"\u03ac\3\"\3\"\5\"\u03b1") 

107 buf.write("\n\"\3\"\3\"\3\"\5\"\u03b6\n\"\3\"\3\"\3\"\3\"\3\"\3\"") 

108 buf.write("\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3") 

109 buf.write("\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u03d4\n\"\3\"\3") 

110 buf.write("\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u03e0\n\"\3\"\3") 

111 buf.write("\"\3\"\5\"\u03e5\n\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3") 

112 buf.write("\"\3\"\5\"\u03f1\n\"\3\"\3\"\3\"\3\"\5\"\u03f7\n\"\3\"") 

113 buf.write("\3\"\3\"\3\"\3\"\5\"\u03fe\n\"\3\"\3\"\5\"\u0402\n\"\3") 

114 buf.write("\"\3\"\3\"\3\"\3\"\3\"\7\"\u040a\n\"\f\"\16\"\u040d\13") 

115 buf.write("\"\5\"\u040f\n\"\3\"\3\"\3\"\3\"\5\"\u0415\n\"\3\"\3\"") 

116 buf.write("\3\"\3\"\5\"\u041b\n\"\3\"\3\"\3\"\3\"\3\"\7\"\u0422\n") 

117 buf.write("\"\f\"\16\"\u0425\13\"\5\"\u0427\n\"\3\"\3\"\5\"\u042b") 

118 buf.write("\n\"\7\"\u042d\n\"\f\"\16\"\u0430\13\"\3#\3#\3#\3#\3#") 

119 buf.write("\3#\5#\u0438\n#\3#\3#\3$\3$\3%\5%\u043f\n%\3%\3%\3%\3") 

120 buf.write("%\3%\5%\u0446\n%\3%\3%\3%\3%\5%\u044c\n%\3%\3%\3%\5%\u0451") 

121 buf.write("\n%\3%\3%\3%\3%\7%\u0457\n%\f%\16%\u045a\13%\3%\3%\5%") 

122 buf.write("\u045e\n%\3%\3%\3%\3%\3%\7%\u0465\n%\f%\16%\u0468\13%") 

123 buf.write("\3%\3%\3%\3%\3%\3%\7%\u0470\n%\f%\16%\u0473\13%\3%\3%") 

124 buf.write("\7%\u0477\n%\f%\16%\u047a\13%\3%\5%\u047d\n%\3%\5%\u0480") 

125 buf.write("\n%\3%\3%\5%\u0484\n%\3&\3&\3&\3&\3&\3&\7&\u048c\n&\f") 

126 buf.write("&\16&\u048f\13&\3&\3&\3&\5&\u0494\n&\5&\u0496\n&\3&\3") 

127 buf.write("&\3&\3&\3&\3&\5&\u049e\n&\3&\3&\3&\3&\3&\5&\u04a5\n&\3") 

128 buf.write("&\3&\3&\7&\u04aa\n&\f&\16&\u04ad\13&\3&\3&\5&\u04b1\n") 

129 buf.write("&\5&\u04b3\n&\3\'\3\'\3\'\3\'\5\'\u04b9\n\'\3\'\3\'\3") 

130 buf.write("\'\3\'\3\'\3\'\3\'\5\'\u04c2\n\'\3(\3(\3(\5(\u04c7\n(") 

131 buf.write("\3)\3)\3)\3)\3)\5)\u04ce\n)\3)\3)\5)\u04d2\n)\5)\u04d4") 

132 buf.write("\n)\3*\5*\u04d7\n*\3*\3*\3*\3*\7*\u04dd\n*\f*\16*\u04e0") 

133 buf.write("\13*\3*\5*\u04e3\n*\3*\5*\u04e6\n*\3+\3+\3+\3+\5+\u04ec") 

134 buf.write("\n+\7+\u04ee\n+\f+\16+\u04f1\13+\3,\3,\5,\u04f5\n,\3,") 

135 buf.write("\3,\3,\7,\u04fa\n,\f,\16,\u04fd\13,\3,\3,\3,\3,\7,\u0503") 

136 buf.write("\n,\f,\16,\u0506\13,\3,\5,\u0509\n,\5,\u050b\n,\3,\3,") 

137 buf.write("\5,\u050f\n,\3,\3,\3,\3,\3,\7,\u0516\n,\f,\16,\u0519\13") 

138 buf.write(",\3,\3,\5,\u051d\n,\5,\u051f\n,\3,\3,\3,\3,\3,\3,\3,\3") 

139 buf.write(",\3,\7,\u052a\n,\f,\16,\u052d\13,\5,\u052f\n,\3,\3,\3") 

140 buf.write(",\3,\3,\7,\u0536\n,\f,\16,\u0539\13,\3,\3,\3,\3,\3,\3") 

141 buf.write(",\7,\u0541\n,\f,\16,\u0544\13,\3,\3,\7,\u0548\n,\f,\16") 

142 buf.write(",\u054b\13,\5,\u054d\n,\3-\3-\3.\5.\u0552\n.\3.\3.\5.") 

143 buf.write("\u0556\n.\3.\5.\u0559\n.\3/\5/\u055c\n/\3/\3/\3/\5/\u0561") 

144 buf.write("\n/\3/\3/\5/\u0565\n/\3/\6/\u0568\n/\r/\16/\u0569\3/\5") 

145 buf.write("/\u056d\n/\3/\5/\u0570\n/\3\60\3\60\3\60\5\60\u0575\n") 

146 buf.write("\60\3\60\3\60\5\60\u0579\n\60\3\60\5\60\u057c\n\60\3\60") 

147 buf.write("\3\60\3\60\3\60\3\60\5\60\u0583\n\60\3\60\3\60\3\60\5") 

148 buf.write("\60\u0588\n\60\3\60\3\60\3\60\3\60\3\60\7\60\u058f\n\60") 

149 buf.write("\f\60\16\60\u0592\13\60\3\60\3\60\5\60\u0596\n\60\3\60") 

150 buf.write("\5\60\u0599\n\60\3\60\3\60\3\60\3\60\7\60\u059f\n\60\f") 

151 buf.write("\60\16\60\u05a2\13\60\3\60\5\60\u05a5\n\60\3\60\3\60\3") 

152 buf.write("\60\3\60\3\60\3\60\5\60\u05ad\n\60\3\60\5\60\u05b0\n\60") 

153 buf.write("\5\60\u05b2\n\60\3\61\3\61\3\61\3\61\3\61\3\61\3\61\5") 

154 buf.write("\61\u05bb\n\61\3\61\5\61\u05be\n\61\5\61\u05c0\n\61\3") 

155 buf.write("\62\3\62\5\62\u05c4\n\62\3\62\3\62\5\62\u05c8\n\62\3\62") 

156 buf.write("\3\62\5\62\u05cc\n\62\3\62\5\62\u05cf\n\62\3\63\3\63\3") 

157 buf.write("\63\3\63\3\63\3\63\3\63\7\63\u05d8\n\63\f\63\16\63\u05db") 

158 buf.write("\13\63\3\63\3\63\5\63\u05df\n\63\3\64\3\64\5\64\u05e3") 

159 buf.write("\n\64\3\64\3\64\5\64\u05e7\n\64\3\65\5\65\u05ea\n\65\3") 

160 buf.write("\65\3\65\3\65\5\65\u05ef\n\65\3\65\3\65\3\65\3\65\5\65") 

161 buf.write("\u05f5\n\65\3\65\3\65\3\65\3\65\3\65\5\65\u05fc\n\65\3") 

162 buf.write("\65\3\65\3\65\7\65\u0601\n\65\f\65\16\65\u0604\13\65\3") 

163 buf.write("\65\3\65\5\65\u0608\n\65\3\66\3\66\3\66\3\66\7\66\u060e") 

164 buf.write("\n\66\f\66\16\66\u0611\13\66\3\66\3\66\3\67\5\67\u0616") 

165 buf.write("\n\67\3\67\3\67\3\67\5\67\u061b\n\67\3\67\3\67\3\67\3") 

166 buf.write("\67\5\67\u0621\n\67\3\67\3\67\3\67\3\67\3\67\5\67\u0628") 

167 buf.write("\n\67\3\67\3\67\3\67\7\67\u062d\n\67\f\67\16\67\u0630") 

168 buf.write("\13\67\3\67\3\67\5\67\u0634\n\67\3\67\5\67\u0637\n\67") 

169 buf.write("\3\67\5\67\u063a\n\67\38\38\38\58\u063f\n8\38\38\38\5") 

170 buf.write("8\u0644\n8\38\38\38\38\38\58\u064b\n8\39\39\59\u064f\n") 

171 buf.write("9\39\39\59\u0653\n9\3:\3:\3:\3:\3:\3:\3;\3;\5;\u065d\n") 

172 buf.write(";\3;\3;\3;\3;\3;\7;\u0664\n;\f;\16;\u0667\13;\5;\u0669") 

173 buf.write("\n;\3;\3;\3;\3;\3;\7;\u0670\n;\f;\16;\u0673\13;\3;\5;") 

174 buf.write("\u0676\n;\3;\3;\3<\3<\3<\3<\5<\u067e\n<\3<\3<\3<\3<\3") 

175 buf.write("<\7<\u0685\n<\f<\16<\u0688\13<\5<\u068a\n<\3<\3<\3<\3") 

176 buf.write("<\3<\7<\u0691\n<\f<\16<\u0694\13<\5<\u0696\n<\3<\5<\u0699") 

177 buf.write("\n<\3<\5<\u069c\n<\3=\3=\3=\3=\3=\3=\3=\3=\5=\u06a6\n") 

178 buf.write("=\3>\3>\3>\3>\3>\3>\3>\5>\u06af\n>\3?\3?\3?\3?\3?\7?\u06b6") 

179 buf.write("\n?\f?\16?\u06b9\13?\3?\5?\u06bc\n?\3?\3?\3@\3@\3@\5@") 

180 buf.write("\u06c3\n@\3@\3@\3@\7@\u06c8\n@\f@\16@\u06cb\13@\3@\5@") 

181 buf.write("\u06ce\n@\3@\3@\5@\u06d2\n@\3A\3A\3A\3A\3A\7A\u06d9\n") 

182 buf.write("A\fA\16A\u06dc\13A\3A\5A\u06df\nA\3A\3A\5A\u06e3\nA\3") 

183 buf.write("A\3A\3A\5A\u06e8\nA\3B\3B\5B\u06ec\nB\3B\3B\3B\7B\u06f1") 

184 buf.write("\nB\fB\16B\u06f4\13B\3C\3C\3C\3C\3C\7C\u06fb\nC\fC\16") 

185 buf.write("C\u06fe\13C\3D\3D\3D\3D\5D\u0704\nD\3E\3E\3E\5E\u0709") 

186 buf.write("\nE\3E\5E\u070c\nE\3E\3E\5E\u0710\nE\3F\3F\3G\3G\3G\3") 

187 buf.write("G\3G\3G\3G\3G\3G\3G\5G\u071e\nG\3H\3H\3H\3H\3H\3H\3H\3") 

188 buf.write("H\3H\3H\5H\u072a\nH\3I\3I\3I\3I\3I\3I\3I\5I\u0733\nI\3") 

189 buf.write("J\3J\3J\3J\3J\3J\3J\5J\u073c\nJ\3J\3J\5J\u0740\nJ\3J\3") 

190 buf.write("J\3J\3J\3J\3J\3J\3J\5J\u074a\nJ\3J\5J\u074d\nJ\3J\3J\3") 

191 buf.write("J\3J\3J\3J\3J\5J\u0756\nJ\3J\3J\3J\3J\3J\3J\3J\5J\u075f") 

192 buf.write("\nJ\3J\5J\u0762\nJ\3J\3J\3J\3J\5J\u0768\nJ\3J\3J\3J\3") 

193 buf.write("J\3J\3J\3J\3J\3J\3J\3J\3J\5J\u0776\nJ\3J\3J\5J\u077a\n") 

194 buf.write("J\3J\3J\3J\3J\3J\3J\3J\3J\3J\5J\u0785\nJ\3J\3J\3J\5J\u078a") 

195 buf.write("\nJ\3K\3K\3K\3L\3L\3L\3M\3M\3M\6M\u0795\nM\rM\16M\u0796") 

196 buf.write("\3N\3N\3N\6N\u079c\nN\rN\16N\u079d\3O\3O\3O\3O\3P\3P\5") 

197 buf.write("P\u07a6\nP\3P\3P\3P\5P\u07ab\nP\7P\u07ad\nP\fP\16P\u07b0") 

198 buf.write("\13P\3Q\3Q\3R\3R\3S\3S\3T\3T\3U\3U\5U\u07bc\nU\3V\3V\3") 

199 buf.write("W\3W\3X\3X\3Y\3Y\3Z\3Z\3[\3[\3\\\3\\\3]\3]\3^\3^\3_\3") 

200 buf.write("_\3`\3`\3a\3a\3b\3b\3c\3c\3d\3d\3e\3e\3f\3f\3g\3g\3h\3") 

201 buf.write("h\3i\3i\3j\3j\3k\3k\3l\3l\3m\3m\3n\3n\3o\3o\3p\3p\3p\3") 

202 buf.write("p\3p\3p\3p\5p\u07f9\np\3p\4\u01b1\u01d1\3Bq\2\4\6\b\n") 

203 buf.write("\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<") 

204 buf.write(">@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086") 

205 buf.write("\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098") 

206 buf.write("\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa") 

207 buf.write("\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc") 

208 buf.write("\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce") 

209 buf.write("\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\2\36") 

210 buf.write("\5\2<<GGTT\4\2\61\61DD\3\2\u0086\u0087\4\2\u0093\u0093") 

211 buf.write("\u00ac\u00ac\3\2\n\13\4\2==\u008e\u008e\4\2::jj\4\2<<") 

212 buf.write("TT\7\2\33\33JJSS||\177\177\6\2VV\u0085\u0085\u008b\u008b") 

213 buf.write("\u0092\u0092\4\2\t\t\16\17\3\2\20\23\3\2\24\27\6\2OOc") 

214 buf.write("ceexx\5\2\33\33JJ\177\177\7\2\668jj\u00ad\u00ae\u00bb") 

215 buf.write("\u00bb\u00bd\u00be\4\2\37\37@@\5\2\u0081\u0081\u009b\u009b") 

216 buf.write("\u00b4\u00b4\4\2\7\7ll\3\2\u00b1\u00b2\4\2$$>>\4\2\u0098") 

217 buf.write("\u0098\u00a3\u00a3\4\2\u00a0\u00a0\u00a7\u00a7\4\2\u00a1") 

218 buf.write("\u00a1\u00a8\u00a9\4\2\u00a2\u00a2\u00a4\u00a4\4\2\n\f") 

219 buf.write("hh\4\2\u00ba\u00ba\u00bd\u00bd\3\2\33\u00b5\2\u090f\2") 

220 buf.write("\u00e3\3\2\2\2\4\u00eb\3\2\2\2\6\u0105\3\2\2\2\b\u0121") 

221 buf.write("\3\2\2\2\n\u013c\3\2\2\2\f\u0146\3\2\2\2\16\u014e\3\2") 

222 buf.write("\2\2\20\u0158\3\2\2\2\22\u015c\3\2\2\2\24\u0167\3\2\2") 

223 buf.write("\2\26\u016a\3\2\2\2\30\u0170\3\2\2\2\32\u0192\3\2\2\2") 

224 buf.write("\34\u019b\3\2\2\2\36\u01c4\3\2\2\2 \u01cf\3\2\2\2\"\u01e1") 

225 buf.write("\3\2\2\2$\u0215\3\2\2\2&\u021b\3\2\2\2(\u0244\3\2\2\2") 

226 buf.write("*\u026e\3\2\2\2,\u0272\3\2\2\2.\u02b2\3\2\2\2\60\u02d2") 

227 buf.write("\3\2\2\2\62\u02ef\3\2\2\2\64\u0304\3\2\2\2\66\u0312\3") 

228 buf.write("\2\2\28\u031d\3\2\2\2:\u0331\3\2\2\2<\u033b\3\2\2\2>\u034a") 

229 buf.write("\3\2\2\2@\u0350\3\2\2\2B\u03b5\3\2\2\2D\u0431\3\2\2\2") 

230 buf.write("F\u043b\3\2\2\2H\u0483\3\2\2\2J\u0485\3\2\2\2L\u04b4\3") 

231 buf.write("\2\2\2N\u04c6\3\2\2\2P\u04c8\3\2\2\2R\u04d6\3\2\2\2T\u04e7") 

232 buf.write("\3\2\2\2V\u054c\3\2\2\2X\u054e\3\2\2\2Z\u0551\3\2\2\2") 

233 buf.write("\\\u055b\3\2\2\2^\u05b1\3\2\2\2`\u05bf\3\2\2\2b\u05ce") 

234 buf.write("\3\2\2\2d\u05de\3\2\2\2f\u05e6\3\2\2\2h\u05e9\3\2\2\2") 

235 buf.write("j\u0609\3\2\2\2l\u0615\3\2\2\2n\u063e\3\2\2\2p\u064c\3") 

236 buf.write("\2\2\2r\u0654\3\2\2\2t\u065a\3\2\2\2v\u0679\3\2\2\2x\u069d") 

237 buf.write("\3\2\2\2z\u06a7\3\2\2\2|\u06b0\3\2\2\2~\u06bf\3\2\2\2") 

238 buf.write("\u0080\u06d3\3\2\2\2\u0082\u06e9\3\2\2\2\u0084\u06f5\3") 

239 buf.write("\2\2\2\u0086\u06ff\3\2\2\2\u0088\u0705\3\2\2\2\u008a\u0711") 

240 buf.write("\3\2\2\2\u008c\u071d\3\2\2\2\u008e\u0729\3\2\2\2\u0090") 

241 buf.write("\u0732\3\2\2\2\u0092\u0789\3\2\2\2\u0094\u078b\3\2\2\2") 

242 buf.write("\u0096\u078e\3\2\2\2\u0098\u0791\3\2\2\2\u009a\u0798\3") 

243 buf.write("\2\2\2\u009c\u079f\3\2\2\2\u009e\u07a3\3\2\2\2\u00a0\u07b1") 

244 buf.write("\3\2\2\2\u00a2\u07b3\3\2\2\2\u00a4\u07b5\3\2\2\2\u00a6") 

245 buf.write("\u07b7\3\2\2\2\u00a8\u07bb\3\2\2\2\u00aa\u07bd\3\2\2\2") 

246 buf.write("\u00ac\u07bf\3\2\2\2\u00ae\u07c1\3\2\2\2\u00b0\u07c3\3") 

247 buf.write("\2\2\2\u00b2\u07c5\3\2\2\2\u00b4\u07c7\3\2\2\2\u00b6\u07c9") 

248 buf.write("\3\2\2\2\u00b8\u07cb\3\2\2\2\u00ba\u07cd\3\2\2\2\u00bc") 

249 buf.write("\u07cf\3\2\2\2\u00be\u07d1\3\2\2\2\u00c0\u07d3\3\2\2\2") 

250 buf.write("\u00c2\u07d5\3\2\2\2\u00c4\u07d7\3\2\2\2\u00c6\u07d9\3") 

251 buf.write("\2\2\2\u00c8\u07db\3\2\2\2\u00ca\u07dd\3\2\2\2\u00cc\u07df") 

252 buf.write("\3\2\2\2\u00ce\u07e1\3\2\2\2\u00d0\u07e3\3\2\2\2\u00d2") 

253 buf.write("\u07e5\3\2\2\2\u00d4\u07e7\3\2\2\2\u00d6\u07e9\3\2\2\2") 

254 buf.write("\u00d8\u07eb\3\2\2\2\u00da\u07ed\3\2\2\2\u00dc\u07ef\3") 

255 buf.write("\2\2\2\u00de\u07f8\3\2\2\2\u00e0\u00e2\5\4\3\2\u00e1\u00e0") 

256 buf.write("\3\2\2\2\u00e2\u00e5\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e3") 

257 buf.write("\u00e4\3\2\2\2\u00e4\u00e6\3\2\2\2\u00e5\u00e3\3\2\2\2") 

258 buf.write("\u00e6\u00e7\7\2\2\3\u00e7\3\3\2\2\2\u00e8\u00ea\7\3\2") 

259 buf.write("\2\u00e9\u00e8\3\2\2\2\u00ea\u00ed\3\2\2\2\u00eb\u00e9") 

260 buf.write("\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ee\3\2\2\2\u00ed") 

261 buf.write("\u00eb\3\2\2\2\u00ee\u00f7\5\6\4\2\u00ef\u00f1\7\3\2\2") 

262 buf.write("\u00f0\u00ef\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\u00f0\3") 

263 buf.write("\2\2\2\u00f2\u00f3\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4\u00f6") 

264 buf.write("\5\6\4\2\u00f5\u00f0\3\2\2\2\u00f6\u00f9\3\2\2\2\u00f7") 

265 buf.write("\u00f5\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8\u00fd\3\2\2\2") 

266 buf.write("\u00f9\u00f7\3\2\2\2\u00fa\u00fc\7\3\2\2\u00fb\u00fa\3") 

267 buf.write("\2\2\2\u00fc\u00ff\3\2\2\2\u00fd\u00fb\3\2\2\2\u00fd\u00fe") 

268 buf.write("\3\2\2\2\u00fe\5\3\2\2\2\u00ff\u00fd\3\2\2\2\u0100\u0103") 

269 buf.write("\7I\2\2\u0101\u0102\7t\2\2\u0102\u0104\7q\2\2\u0103\u0101") 

270 buf.write("\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105") 

271 buf.write("\u0100\3\2\2\2\u0105\u0106\3\2\2\2\u0106\u011f\3\2\2\2") 

272 buf.write("\u0107\u0120\5\b\5\2\u0108\u0120\5\n\6\2\u0109\u0120\5") 

273 buf.write("\f\7\2\u010a\u0120\5\16\b\2\u010b\u0120\5\20\t\2\u010c") 

274 buf.write("\u0120\5\30\r\2\u010d\u0120\5\34\17\2\u010e\u0120\5,\27") 

275 buf.write("\2\u010f\u0120\5.\30\2\u0110\u0120\5\60\31\2\u0111\u0120") 

276 buf.write("\5:\36\2\u0112\u0120\5<\37\2\u0113\u0120\5> \2\u0114\u0120") 

277 buf.write("\5@!\2\u0115\u0120\5H%\2\u0116\u0120\5L\'\2\u0117\u0120") 

278 buf.write("\5P)\2\u0118\u0120\5\26\f\2\u0119\u0120\5\22\n\2\u011a") 

279 buf.write("\u0120\5\24\13\2\u011b\u0120\5R*\2\u011c\u0120\5h\65\2") 

280 buf.write("\u011d\u0120\5l\67\2\u011e\u0120\5p9\2\u011f\u0107\3\2") 

281 buf.write("\2\2\u011f\u0108\3\2\2\2\u011f\u0109\3\2\2\2\u011f\u010a") 

282 buf.write("\3\2\2\2\u011f\u010b\3\2\2\2\u011f\u010c\3\2\2\2\u011f") 

283 buf.write("\u010d\3\2\2\2\u011f\u010e\3\2\2\2\u011f\u010f\3\2\2\2") 

284 buf.write("\u011f\u0110\3\2\2\2\u011f\u0111\3\2\2\2\u011f\u0112\3") 

285 buf.write("\2\2\2\u011f\u0113\3\2\2\2\u011f\u0114\3\2\2\2\u011f\u0115") 

286 buf.write("\3\2\2\2\u011f\u0116\3\2\2\2\u011f\u0117\3\2\2\2\u011f") 

287 buf.write("\u0118\3\2\2\2\u011f\u0119\3\2\2\2\u011f\u011a\3\2\2\2") 

288 buf.write("\u011f\u011b\3\2\2\2\u011f\u011c\3\2\2\2\u011f\u011d\3") 

289 buf.write("\2\2\2\u011f\u011e\3\2\2\2\u0120\7\3\2\2\2\u0121\u0122") 

290 buf.write("\7 \2\2\u0122\u0126\7\u0085\2\2\u0123\u0124\5\u00b2Z\2") 

291 buf.write("\u0124\u0125\7\4\2\2\u0125\u0127\3\2\2\2\u0126\u0123\3") 

292 buf.write("\2\2\2\u0126\u0127\3\2\2\2\u0127\u0128\3\2\2\2\u0128\u013a") 

293 buf.write("\5\u00b4[\2\u0129\u0133\7{\2\2\u012a\u012b\7\u0089\2\2") 

294 buf.write("\u012b\u0134\5\u00b8]\2\u012c\u012e\7\60\2\2\u012d\u012c") 

295 buf.write("\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u012f\3\2\2\2\u012f") 

296 buf.write("\u0130\5\u00ba^\2\u0130\u0131\7\u0089\2\2\u0131\u0132") 

297 buf.write("\5\u00ba^\2\u0132\u0134\3\2\2\2\u0133\u012a\3\2\2\2\u0133") 

298 buf.write("\u012d\3\2\2\2\u0134\u013b\3\2\2\2\u0135\u0137\7\35\2") 

299 buf.write("\2\u0136\u0138\7\60\2\2\u0137\u0136\3\2\2\2\u0137\u0138") 

300 buf.write("\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013b\5\36\20\2\u013a") 

301 buf.write("\u0129\3\2\2\2\u013a\u0135\3\2\2\2\u013b\t\3\2\2\2\u013c") 

302 buf.write("\u0144\7!\2\2\u013d\u0145\5\u00b2Z\2\u013e\u013f\5\u00b2") 

303 buf.write("Z\2\u013f\u0140\7\4\2\2\u0140\u0142\3\2\2\2\u0141\u013e") 

304 buf.write("\3\2\2\2\u0141\u0142\3\2\2\2\u0142\u0143\3\2\2\2\u0143") 

305 buf.write("\u0145\5\u00b6\\\2\u0144\u013d\3\2\2\2\u0144\u0141\3\2") 

306 buf.write("\2\2\u0144\u0145\3\2\2\2\u0145\13\3\2\2\2\u0146\u0148") 

307 buf.write("\7%\2\2\u0147\u0149\79\2\2\u0148\u0147\3\2\2\2\u0148\u0149") 

308 buf.write("\3\2\2\2\u0149\u014a\3\2\2\2\u014a\u014b\5B\"\2\u014b") 

309 buf.write("\u014c\7#\2\2\u014c\u014d\5\u00b2Z\2\u014d\r\3\2\2\2\u014e") 

310 buf.write("\u0150\7(\2\2\u014f\u0151\t\2\2\2\u0150\u014f\3\2\2\2") 

311 buf.write("\u0150\u0151\3\2\2\2\u0151\u0156\3\2\2\2\u0152\u0154\7") 

312 buf.write("\u008a\2\2\u0153\u0155\5\u00ceh\2\u0154\u0153\3\2\2\2") 

313 buf.write("\u0154\u0155\3\2\2\2\u0155\u0157\3\2\2\2\u0156\u0152\3") 

314 buf.write("\2\2\2\u0156\u0157\3\2\2\2\u0157\17\3\2\2\2\u0158\u015a") 

315 buf.write("\t\3\2\2\u0159\u015b\7\u008a\2\2\u015a\u0159\3\2\2\2\u015a") 

316 buf.write("\u015b\3\2\2\2\u015b\21\3\2\2\2\u015c\u015e\7\177\2\2") 

317 buf.write("\u015d\u015f\7\u008a\2\2\u015e\u015d\3\2\2\2\u015e\u015f") 

318 buf.write("\3\2\2\2\u015f\u0165\3\2\2\2\u0160\u0162\7\u0089\2\2\u0161") 

319 buf.write("\u0163\7\u0082\2\2\u0162\u0161\3\2\2\2\u0162\u0163\3\2") 

320 buf.write("\2\2\u0163\u0164\3\2\2\2\u0164\u0166\5\u00caf\2\u0165") 

321 buf.write("\u0160\3\2\2\2\u0165\u0166\3\2\2\2\u0166\23\3\2\2\2\u0167") 

322 buf.write("\u0168\7\u0082\2\2\u0168\u0169\5\u00caf\2\u0169\25\3\2") 

323 buf.write("\2\2\u016a\u016c\7z\2\2\u016b\u016d\7\u0082\2\2\u016c") 

324 buf.write("\u016b\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016e\3\2\2\2") 

325 buf.write("\u016e\u016f\5\u00caf\2\u016f\27\3\2\2\2\u0170\u0172\7") 

326 buf.write("\64\2\2\u0171\u0173\7\u008d\2\2\u0172\u0171\3\2\2\2\u0172") 

327 buf.write("\u0173\3\2\2\2\u0173\u0174\3\2\2\2\u0174\u0178\7V\2\2") 

328 buf.write("\u0175\u0176\7R\2\2\u0176\u0177\7h\2\2\u0177\u0179\7H") 

329 buf.write("\2\2\u0178\u0175\3\2\2\2\u0178\u0179\3\2\2\2\u0179\u017d") 

330 buf.write("\3\2\2\2\u017a\u017b\5\u00b2Z\2\u017b\u017c\7\4\2\2\u017c") 

331 buf.write("\u017e\3\2\2\2\u017d\u017a\3\2\2\2\u017d\u017e\3\2\2\2") 

332 buf.write("\u017e\u017f\3\2\2\2\u017f\u0180\5\u00c0a\2\u0180\u0181") 

333 buf.write("\7m\2\2\u0181\u0182\5\u00b4[\2\u0182\u0183\7\5\2\2\u0183") 

334 buf.write("\u0188\5\32\16\2\u0184\u0185\7\7\2\2\u0185\u0187\5\32") 

335 buf.write("\16\2\u0186\u0184\3\2\2\2\u0187\u018a\3\2\2\2\u0188\u0186") 

336 buf.write("\3\2\2\2\u0188\u0189\3\2\2\2\u0189\u018b\3\2\2\2\u018a") 

337 buf.write("\u0188\3\2\2\2\u018b\u018e\7\6\2\2\u018c\u018d\7\u0095") 

338 buf.write("\2\2\u018d\u018f\5B\"\2\u018e\u018c\3\2\2\2\u018e\u018f") 

339 buf.write("\3\2\2\2\u018f\31\3\2\2\2\u0190\u0193\5\u00ba^\2\u0191") 

340 buf.write("\u0193\5B\"\2\u0192\u0190\3\2\2\2\u0192\u0191\3\2\2\2") 

341 buf.write("\u0193\u0196\3\2\2\2\u0194\u0195\7/\2\2\u0195\u0197\5") 

342 buf.write("\u00bc_\2\u0196\u0194\3\2\2\2\u0196\u0197\3\2\2\2\u0197") 

343 buf.write("\u0199\3\2\2\2\u0198\u019a\5\u008aF\2\u0199\u0198\3\2") 

344 buf.write("\2\2\u0199\u019a\3\2\2\2\u019a\33\3\2\2\2\u019b\u019d") 

345 buf.write("\7\64\2\2\u019c\u019e\t\4\2\2\u019d\u019c\3\2\2\2\u019d") 

346 buf.write("\u019e\3\2\2\2\u019e\u019f\3\2\2\2\u019f\u01a3\7\u0085") 

347 buf.write("\2\2\u01a0\u01a1\7R\2\2\u01a1\u01a2\7h\2\2\u01a2\u01a4") 

348 buf.write("\7H\2\2\u01a3\u01a0\3\2\2\2\u01a3\u01a4\3\2\2\2\u01a4") 

349 buf.write("\u01a8\3\2\2\2\u01a5\u01a6\5\u00b2Z\2\u01a6\u01a7\7\4") 

350 buf.write("\2\2\u01a7\u01a9\3\2\2\2\u01a8\u01a5\3\2\2\2\u01a8\u01a9") 

351 buf.write("\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa\u01c2\5\u00b4[\2\u01ab") 

352 buf.write("\u01ac\7\5\2\2\u01ac\u01b1\5\36\20\2\u01ad\u01ae\7\7\2") 

353 buf.write("\2\u01ae\u01b0\5\36\20\2\u01af\u01ad\3\2\2\2\u01b0\u01b3") 

354 buf.write("\3\2\2\2\u01b1\u01b2\3\2\2\2\u01b1\u01af\3\2\2\2\u01b2") 

355 buf.write("\u01b8\3\2\2\2\u01b3\u01b1\3\2\2\2\u01b4\u01b5\7\7\2\2") 

356 buf.write("\u01b5\u01b7\5&\24\2\u01b6\u01b4\3\2\2\2\u01b7\u01ba\3") 

357 buf.write("\2\2\2\u01b8\u01b6\3\2\2\2\u01b8\u01b9\3\2\2\2\u01b9\u01bb") 

358 buf.write("\3\2\2\2\u01ba\u01b8\3\2\2\2\u01bb\u01be\7\6\2\2\u01bc") 

359 buf.write("\u01bd\7\u0097\2\2\u01bd\u01bf\7\u00ba\2\2\u01be\u01bc") 

360 buf.write("\3\2\2\2\u01be\u01bf\3\2\2\2\u01bf\u01c3\3\2\2\2\u01c0") 

361 buf.write("\u01c1\7#\2\2\u01c1\u01c3\5R*\2\u01c2\u01ab\3\2\2\2\u01c2") 

362 buf.write("\u01c0\3\2\2\2\u01c3\35\3\2\2\2\u01c4\u01c6\5\u00ba^\2") 

363 buf.write("\u01c5\u01c7\5 \21\2\u01c6\u01c5\3\2\2\2\u01c6\u01c7\3") 

364 buf.write("\2\2\2\u01c7\u01cb\3\2\2\2\u01c8\u01ca\5\"\22\2\u01c9") 

365 buf.write("\u01c8\3\2\2\2\u01ca\u01cd\3\2\2\2\u01cb\u01c9\3\2\2\2") 

366 buf.write("\u01cb\u01cc\3\2\2\2\u01cc\37\3\2\2\2\u01cd\u01cb\3\2") 

367 buf.write("\2\2\u01ce\u01d0\5\u00aeX\2\u01cf\u01ce\3\2\2\2\u01d0") 

368 buf.write("\u01d1\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d1\u01cf\3\2\2\2") 

369 buf.write("\u01d2\u01dd\3\2\2\2\u01d3\u01d4\7\5\2\2\u01d4\u01d5\5") 

370 buf.write("$\23\2\u01d5\u01d6\7\6\2\2\u01d6\u01de\3\2\2\2\u01d7\u01d8") 

371 buf.write("\7\5\2\2\u01d8\u01d9\5$\23\2\u01d9\u01da\7\7\2\2\u01da") 

372 buf.write("\u01db\5$\23\2\u01db\u01dc\7\6\2\2\u01dc\u01de\3\2\2\2") 

373 buf.write("\u01dd\u01d3\3\2\2\2\u01dd\u01d7\3\2\2\2\u01dd\u01de\3") 

374 buf.write("\2\2\2\u01de!\3\2\2\2\u01df\u01e0\7\63\2\2\u01e0\u01e2") 

375 buf.write("\5\u00aeX\2\u01e1\u01df\3\2\2\2\u01e1\u01e2\3\2\2\2\u01e2") 

376 buf.write("\u0212\3\2\2\2\u01e3\u01e4\7s\2\2\u01e4\u01e6\7a\2\2\u01e5") 

377 buf.write("\u01e7\5\u008aF\2\u01e6\u01e5\3\2\2\2\u01e6\u01e7\3\2") 

378 buf.write("\2\2\u01e7\u01e9\3\2\2\2\u01e8\u01ea\5*\26\2\u01e9\u01e8") 

379 buf.write("\3\2\2\2\u01e9\u01ea\3\2\2\2\u01ea\u01ec\3\2\2\2\u01eb") 

380 buf.write("\u01ed\7&\2\2\u01ec\u01eb\3\2\2\2\u01ec\u01ed\3\2\2\2") 

381 buf.write("\u01ed\u0213\3\2\2\2\u01ee\u01ef\7h\2\2\u01ef\u01f2\7") 

382 buf.write("j\2\2\u01f0\u01f2\7\u008d\2\2\u01f1\u01ee\3\2\2\2\u01f1") 

383 buf.write("\u01f0\3\2\2\2\u01f2\u01f4\3\2\2\2\u01f3\u01f5\5*\26\2") 

384 buf.write("\u01f4\u01f3\3\2\2\2\u01f4\u01f5\3\2\2\2\u01f5\u0213\3") 

385 buf.write("\2\2\2\u01f6\u01f7\7.\2\2\u01f7\u01f8\7\5\2\2\u01f8\u01f9") 

386 buf.write("\5B\"\2\u01f9\u01fa\7\6\2\2\u01fa\u0213\3\2\2\2\u01fb") 

387 buf.write("\u0202\7:\2\2\u01fc\u0203\5$\23\2\u01fd\u0203\5F$\2\u01fe") 

388 buf.write("\u01ff\7\5\2\2\u01ff\u0200\5B\"\2\u0200\u0201\7\6\2\2") 

389 buf.write("\u0201\u0203\3\2\2\2\u0202\u01fc\3\2\2\2\u0202\u01fd\3") 

390 buf.write("\2\2\2\u0202\u01fe\3\2\2\2\u0203\u0213\3\2\2\2\u0204\u0205") 

391 buf.write("\7/\2\2\u0205\u0213\5\u00bc_\2\u0206\u0213\5(\25\2\u0207") 

392 buf.write("\u0208\7\u00aa\2\2\u0208\u020a\7\u00ab\2\2\u0209\u0207") 

393 buf.write("\3\2\2\2\u0209\u020a\3\2\2\2\u020a\u020b\3\2\2\2\u020b") 

394 buf.write("\u020c\7#\2\2\u020c\u020d\7\5\2\2\u020d\u020e\5B\"\2\u020e") 

395 buf.write("\u0210\7\6\2\2\u020f\u0211\t\5\2\2\u0210\u020f\3\2\2\2") 

396 buf.write("\u0210\u0211\3\2\2\2\u0211\u0213\3\2\2\2\u0212\u01e3\3") 

397 buf.write("\2\2\2\u0212\u01f1\3\2\2\2\u0212\u01f6\3\2\2\2\u0212\u01fb") 

398 buf.write("\3\2\2\2\u0212\u0204\3\2\2\2\u0212\u0206\3\2\2\2\u0212") 

399 buf.write("\u0209\3\2\2\2\u0213#\3\2\2\2\u0214\u0216\t\6\2\2\u0215") 

400 buf.write("\u0214\3\2\2\2\u0215\u0216\3\2\2\2\u0216\u0217\3\2\2\2") 

401 buf.write("\u0217\u0218\7\u00bb\2\2\u0218%\3\2\2\2\u0219\u021a\7") 

402 buf.write("\63\2\2\u021a\u021c\5\u00aeX\2\u021b\u0219\3\2\2\2\u021b") 

403 buf.write("\u021c\3\2\2\2\u021c\u0242\3\2\2\2\u021d\u021e\7s\2\2") 

404 buf.write("\u021e\u0221\7a\2\2\u021f\u0221\7\u008d\2\2\u0220\u021d") 

405 buf.write("\3\2\2\2\u0220\u021f\3\2\2\2\u0221\u0222\3\2\2\2\u0222") 

406 buf.write("\u0223\7\5\2\2\u0223\u0228\5\32\16\2\u0224\u0225\7\7\2") 

407 buf.write("\2\u0225\u0227\5\32\16\2\u0226\u0224\3\2\2\2\u0227\u022a") 

408 buf.write("\3\2\2\2\u0228\u0226\3\2\2\2\u0228\u0229\3\2\2\2\u0229") 

409 buf.write("\u022b\3\2\2\2\u022a\u0228\3\2\2\2\u022b\u022d\7\6\2\2") 

410 buf.write("\u022c\u022e\5*\26\2\u022d\u022c\3\2\2\2\u022d\u022e\3") 

411 buf.write("\2\2\2\u022e\u0243\3\2\2\2\u022f\u0230\7.\2\2\u0230\u0231") 

412 buf.write("\7\5\2\2\u0231\u0232\5B\"\2\u0232\u0233\7\6\2\2\u0233") 

413 buf.write("\u0243\3\2\2\2\u0234\u0235\7L\2\2\u0235\u0236\7a\2\2\u0236") 

414 buf.write("\u0237\7\5\2\2\u0237\u023c\5\u00ba^\2\u0238\u0239\7\7") 

415 buf.write("\2\2\u0239\u023b\5\u00ba^\2\u023a\u0238\3\2\2\2\u023b") 

416 buf.write("\u023e\3\2\2\2\u023c\u023a\3\2\2\2\u023c\u023d\3\2\2\2") 

417 buf.write("\u023d\u023f\3\2\2\2\u023e\u023c\3\2\2\2\u023f\u0240\7") 

418 buf.write("\6\2\2\u0240\u0241\5(\25\2\u0241\u0243\3\2\2\2\u0242\u0220") 

419 buf.write("\3\2\2\2\u0242\u022f\3\2\2\2\u0242\u0234\3\2\2\2\u0243") 

420 buf.write("\'\3\2\2\2\u0244\u0245\7w\2\2\u0245\u0251\5\u00be`\2\u0246") 

421 buf.write("\u0247\7\5\2\2\u0247\u024c\5\u00ba^\2\u0248\u0249\7\7") 

422 buf.write("\2\2\u0249\u024b\5\u00ba^\2\u024a\u0248\3\2\2\2\u024b") 

423 buf.write("\u024e\3\2\2\2\u024c\u024a\3\2\2\2\u024c\u024d\3\2\2\2") 

424 buf.write("\u024d\u024f\3\2\2\2\u024e\u024c\3\2\2\2\u024f\u0250\7") 

425 buf.write("\6\2\2\u0250\u0252\3\2\2\2\u0251\u0246\3\2\2\2\u0251\u0252") 

426 buf.write("\3\2\2\2\u0252\u0261\3\2\2\2\u0253\u0254\7m\2\2\u0254") 

427 buf.write("\u025b\t\7\2\2\u0255\u0256\7\u0084\2\2\u0256\u025c\t\b") 

428 buf.write("\2\2\u0257\u025c\7+\2\2\u0258\u025c\7}\2\2\u0259\u025a") 

429 buf.write("\7g\2\2\u025a\u025c\7\34\2\2\u025b\u0255\3\2\2\2\u025b") 

430 buf.write("\u0257\3\2\2\2\u025b\u0258\3\2\2\2\u025b\u0259\3\2\2\2") 

431 buf.write("\u025c\u0260\3\2\2\2\u025d\u025e\7e\2\2\u025e\u0260\5") 

432 buf.write("\u00aeX\2\u025f\u0253\3\2\2\2\u025f\u025d\3\2\2\2\u0260") 

433 buf.write("\u0263\3\2\2\2\u0261\u025f\3\2\2\2\u0261\u0262\3\2\2\2") 

434 buf.write("\u0262\u026c\3\2\2\2\u0263\u0261\3\2\2\2\u0264\u0266\7") 

435 buf.write("h\2\2\u0265\u0264\3\2\2\2\u0265\u0266\3\2\2\2\u0266\u0267") 

436 buf.write("\3\2\2\2\u0267\u026a\7;\2\2\u0268\u0269\7X\2\2\u0269\u026b") 

437 buf.write("\t\t\2\2\u026a\u0268\3\2\2\2\u026a\u026b\3\2\2\2\u026b") 

438 buf.write("\u026d\3\2\2\2\u026c\u0265\3\2\2\2\u026c\u026d\3\2\2\2") 

439 buf.write("\u026d)\3\2\2\2\u026e\u026f\7m\2\2\u026f\u0270\7\62\2") 

440 buf.write("\2\u0270\u0271\t\n\2\2\u0271+\3\2\2\2\u0272\u0274\7\64") 

441 buf.write("\2\2\u0273\u0275\t\4\2\2\u0274\u0273\3\2\2\2\u0274\u0275") 

442 buf.write("\3\2\2\2\u0275\u0276\3\2\2\2\u0276\u027a\7\u008b\2\2\u0277") 

443 buf.write("\u0278\7R\2\2\u0278\u0279\7h\2\2\u0279\u027b\7H\2\2\u027a") 

444 buf.write("\u0277\3\2\2\2\u027a\u027b\3\2\2\2\u027b\u027f\3\2\2\2") 

445 buf.write("\u027c\u027d\5\u00b2Z\2\u027d\u027e\7\4\2\2\u027e\u0280") 

446 buf.write("\3\2\2\2\u027f\u027c\3\2\2\2\u027f\u0280\3\2\2\2\u0280") 

447 buf.write("\u0281\3\2\2\2\u0281\u0286\5\u00c2b\2\u0282\u0287\7\'") 

448 buf.write("\2\2\u0283\u0287\7\36\2\2\u0284\u0285\7[\2\2\u0285\u0287") 

449 buf.write("\7k\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286") 

450 buf.write("\u0284\3\2\2\2\u0286\u0287\3\2\2\2\u0287\u0296\3\2\2\2") 

451 buf.write("\u0288\u0297\7=\2\2\u0289\u0297\7Z\2\2\u028a\u0294\7\u008e") 

452 buf.write("\2\2\u028b\u028c\7k\2\2\u028c\u0291\5\u00ba^\2\u028d\u028e") 

453 buf.write("\7\7\2\2\u028e\u0290\5\u00ba^\2\u028f\u028d\3\2\2\2\u0290") 

454 buf.write("\u0293\3\2\2\2\u0291\u028f\3\2\2\2\u0291\u0292\3\2\2\2") 

455 buf.write("\u0292\u0295\3\2\2\2\u0293\u0291\3\2\2\2\u0294\u028b\3") 

456 buf.write("\2\2\2\u0294\u0295\3\2\2\2\u0295\u0297\3\2\2\2\u0296\u0288") 

457 buf.write("\3\2\2\2\u0296\u0289\3\2\2\2\u0296\u028a\3\2\2\2\u0297") 

458 buf.write("\u0298\3\2\2\2\u0298\u0299\7m\2\2\u0299\u029d\5\u00b4") 

459 buf.write("[\2\u029a\u029b\7K\2\2\u029b\u029c\7B\2\2\u029c\u029e") 

460 buf.write("\7\u0080\2\2\u029d\u029a\3\2\2\2\u029d\u029e\3\2\2\2\u029e") 

461 buf.write("\u02a1\3\2\2\2\u029f\u02a0\7\u0094\2\2\u02a0\u02a2\5B") 

462 buf.write("\"\2\u02a1\u029f\3\2\2\2\u02a1\u02a2\3\2\2\2\u02a2\u02a3") 

463 buf.write("\3\2\2\2\u02a3\u02ac\7(\2\2\u02a4\u02a9\5h\65\2\u02a5") 

464 buf.write("\u02a9\5H%\2\u02a6\u02a9\5:\36\2\u02a7\u02a9\5R*\2\u02a8") 

465 buf.write("\u02a4\3\2\2\2\u02a8\u02a5\3\2\2\2\u02a8\u02a6\3\2\2\2") 

466 buf.write("\u02a8\u02a7\3\2\2\2\u02a9\u02aa\3\2\2\2\u02aa\u02ab\7") 

467 buf.write("\3\2\2\u02ab\u02ad\3\2\2\2\u02ac\u02a8\3\2\2\2\u02ad\u02ae") 

468 buf.write("\3\2\2\2\u02ae\u02ac\3\2\2\2\u02ae\u02af\3\2\2\2\u02af") 

469 buf.write("\u02b0\3\2\2\2\u02b0\u02b1\7D\2\2\u02b1-\3\2\2\2\u02b2") 

470 buf.write("\u02b4\7\64\2\2\u02b3\u02b5\t\4\2\2\u02b4\u02b3\3\2\2") 

471 buf.write("\2\u02b4\u02b5\3\2\2\2\u02b5\u02b6\3\2\2\2\u02b6\u02ba") 

472 buf.write("\7\u0092\2\2\u02b7\u02b8\7R\2\2\u02b8\u02b9\7h\2\2\u02b9") 

473 buf.write("\u02bb\7H\2\2\u02ba\u02b7\3\2\2\2\u02ba\u02bb\3\2\2\2") 

474 buf.write("\u02bb\u02bf\3\2\2\2\u02bc\u02bd\5\u00b2Z\2\u02bd\u02be") 

475 buf.write("\7\4\2\2\u02be\u02c0\3\2\2\2\u02bf\u02bc\3\2\2\2\u02bf") 

476 buf.write("\u02c0\3\2\2\2\u02c0\u02c1\3\2\2\2\u02c1\u02cd\5\u00c4") 

477 buf.write("c\2\u02c2\u02c3\7\5\2\2\u02c3\u02c8\5\u00ba^\2\u02c4\u02c5") 

478 buf.write("\7\7\2\2\u02c5\u02c7\5\u00ba^\2\u02c6\u02c4\3\2\2\2\u02c7") 

479 buf.write("\u02ca\3\2\2\2\u02c8\u02c6\3\2\2\2\u02c8\u02c9\3\2\2\2") 

480 buf.write("\u02c9\u02cb\3\2\2\2\u02ca\u02c8\3\2\2\2\u02cb\u02cc\7") 

481 buf.write("\6\2\2\u02cc\u02ce\3\2\2\2\u02cd\u02c2\3\2\2\2\u02cd\u02ce") 

482 buf.write("\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02d0\7#\2\2\u02d0") 

483 buf.write("\u02d1\5R*\2\u02d1/\3\2\2\2\u02d2\u02d3\7\64\2\2\u02d3") 

484 buf.write("\u02d4\7\u0093\2\2\u02d4\u02d8\7\u0085\2\2\u02d5\u02d6") 

485 buf.write("\7R\2\2\u02d6\u02d7\7h\2\2\u02d7\u02d9\7H\2\2\u02d8\u02d5") 

486 buf.write("\3\2\2\2\u02d8\u02d9\3\2\2\2\u02d9\u02dd\3\2\2\2\u02da") 

487 buf.write("\u02db\5\u00b2Z\2\u02db\u02dc\7\4\2\2\u02dc\u02de\3\2") 

488 buf.write("\2\2\u02dd\u02da\3\2\2\2\u02dd\u02de\3\2\2\2\u02de\u02df") 

489 buf.write("\3\2\2\2\u02df\u02e0\5\u00b4[\2\u02e0\u02e1\7\u008f\2") 

490 buf.write("\2\u02e1\u02ed\5\u00c6d\2\u02e2\u02e3\7\5\2\2\u02e3\u02e8") 

491 buf.write("\5\u00a8U\2\u02e4\u02e5\7\7\2\2\u02e5\u02e7\5\u00a8U\2") 

492 buf.write("\u02e6\u02e4\3\2\2\2\u02e7\u02ea\3\2\2\2\u02e8\u02e6\3") 

493 buf.write("\2\2\2\u02e8\u02e9\3\2\2\2\u02e9\u02eb\3\2\2\2\u02ea\u02e8") 

494 buf.write("\3\2\2\2\u02eb\u02ec\7\6\2\2\u02ec\u02ee\3\2\2\2\u02ed") 

495 buf.write("\u02e2\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee\61\3\2\2\2\u02ef") 

496 buf.write("\u02f1\7\u0096\2\2\u02f0\u02f2\7v\2\2\u02f1\u02f0\3\2") 

497 buf.write("\2\2\u02f1\u02f2\3\2\2\2\u02f2\u02f3\3\2\2\2\u02f3\u02f4") 

498 buf.write("\5\64\33\2\u02f4\u02f5\7#\2\2\u02f5\u02f6\7\5\2\2\u02f6") 

499 buf.write("\u02f7\5R*\2\u02f7\u0301\7\6\2\2\u02f8\u02f9\7\7\2\2\u02f9") 

500 buf.write("\u02fa\5\64\33\2\u02fa\u02fb\7#\2\2\u02fb\u02fc\7\5\2") 

501 buf.write("\2\u02fc\u02fd\5R*\2\u02fd\u02fe\7\6\2\2\u02fe\u0300\3") 

502 buf.write("\2\2\2\u02ff\u02f8\3\2\2\2\u0300\u0303\3\2\2\2\u0301\u02ff") 

503 buf.write("\3\2\2\2\u0301\u0302\3\2\2\2\u0302\63\3\2\2\2\u0303\u0301") 

504 buf.write("\3\2\2\2\u0304\u0310\5\u00b4[\2\u0305\u0306\7\5\2\2\u0306") 

505 buf.write("\u030b\5\u00ba^\2\u0307\u0308\7\7\2\2\u0308\u030a\5\u00ba") 

506 buf.write("^\2\u0309\u0307\3\2\2\2\u030a\u030d\3\2\2\2\u030b\u0309") 

507 buf.write("\3\2\2\2\u030b\u030c\3\2\2\2\u030c\u030e\3\2\2\2\u030d") 

508 buf.write("\u030b\3\2\2\2\u030e\u030f\7\6\2\2\u030f\u0311\3\2\2\2") 

509 buf.write("\u0310\u0305\3\2\2\2\u0310\u0311\3\2\2\2\u0311\65\3\2") 

510 buf.write("\2\2\u0312\u0313\5\64\33\2\u0313\u0314\7#\2\2\u0314\u0315") 

511 buf.write("\7\5\2\2\u0315\u0316\5\u00a0Q\2\u0316\u0318\7\u008c\2") 

512 buf.write("\2\u0317\u0319\7\37\2\2\u0318\u0317\3\2\2\2\u0318\u0319") 

513 buf.write("\3\2\2\2\u0319\u031a\3\2\2\2\u031a\u031b\5\u00a2R\2\u031b") 

514 buf.write("\u031c\7\6\2\2\u031c\67\3\2\2\2\u031d\u0329\5\u00b4[\2") 

515 buf.write("\u031e\u031f\7\5\2\2\u031f\u0324\5\u00ba^\2\u0320\u0321") 

516 buf.write("\7\7\2\2\u0321\u0323\5\u00ba^\2\u0322\u0320\3\2\2\2\u0323") 

517 buf.write("\u0326\3\2\2\2\u0324\u0322\3\2\2\2\u0324\u0325\3\2\2\2") 

518 buf.write("\u0325\u0327\3\2\2\2\u0326\u0324\3\2\2\2\u0327\u0328\7") 

519 buf.write("\6\2\2\u0328\u032a\3\2\2\2\u0329\u031e\3\2\2\2\u0329\u032a") 

520 buf.write("\3\2\2\2\u032a\u032b\3\2\2\2\u032b\u032c\7#\2\2\u032c") 

521 buf.write("\u032d\7\5\2\2\u032d\u032e\5R*\2\u032e\u032f\7\6\2\2\u032f") 

522 buf.write("9\3\2\2\2\u0330\u0332\5\62\32\2\u0331\u0330\3\2\2\2\u0331") 

523 buf.write("\u0332\3\2\2\2\u0332\u0333\3\2\2\2\u0333\u0334\7=\2\2") 

524 buf.write("\u0334\u0335\7M\2\2\u0335\u0338\5n8\2\u0336\u0337\7\u0095") 

525 buf.write("\2\2\u0337\u0339\5B\"\2\u0338\u0336\3\2\2\2\u0338\u0339") 

526 buf.write("\3\2\2\2\u0339;\3\2\2\2\u033a\u033c\5\62\32\2\u033b\u033a") 

527 buf.write("\3\2\2\2\u033b\u033c\3\2\2\2\u033c\u033d\3\2\2\2\u033d") 

528 buf.write("\u033e\7=\2\2\u033e\u033f\7M\2\2\u033f\u0342\5n8\2\u0340") 

529 buf.write("\u0341\7\u0095\2\2\u0341\u0343\5B\"\2\u0342\u0340\3\2") 

530 buf.write("\2\2\u0342\u0343\3\2\2\2\u0343\u0348\3\2\2\2\u0344\u0346") 

531 buf.write("\5\u0084C\2\u0345\u0344\3\2\2\2\u0345\u0346\3\2\2\2\u0346") 

532 buf.write("\u0347\3\2\2\2\u0347\u0349\5\u0086D\2\u0348\u0345\3\2") 

533 buf.write("\2\2\u0348\u0349\3\2\2\2\u0349=\3\2\2\2\u034a\u034c\7") 

534 buf.write("?\2\2\u034b\u034d\79\2\2\u034c\u034b\3\2\2\2\u034c\u034d") 

535 buf.write("\3\2\2\2\u034d\u034e\3\2\2\2\u034e\u034f\5\u00b2Z\2\u034f") 

536 buf.write("?\3\2\2\2\u0350\u0351\7A\2\2\u0351\u0354\t\13\2\2\u0352") 

537 buf.write("\u0353\7R\2\2\u0353\u0355\7H\2\2\u0354\u0352\3\2\2\2\u0354") 

538 buf.write("\u0355\3\2\2\2\u0355\u0359\3\2\2\2\u0356\u0357\5\u00b2") 

539 buf.write("Z\2\u0357\u0358\7\4\2\2\u0358\u035a\3\2\2\2\u0359\u0356") 

540 buf.write("\3\2\2\2\u0359\u035a\3\2\2\2\u035a\u035b\3\2\2\2\u035b") 

541 buf.write("\u035c\5\u00dep\2\u035cA\3\2\2\2\u035d\u035e\b\"\1\2\u035e") 

542 buf.write("\u03b6\5F$\2\u035f\u03b6\7\u00bc\2\2\u0360\u0361\5\u00b2") 

543 buf.write("Z\2\u0361\u0362\7\4\2\2\u0362\u0364\3\2\2\2\u0363\u0360") 

544 buf.write("\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u0365\3\2\2\2\u0365") 

545 buf.write("\u0366\5\u00b4[\2\u0366\u0367\7\4\2\2\u0367\u0369\3\2") 

546 buf.write("\2\2\u0368\u0363\3\2\2\2\u0368\u0369\3\2\2\2\u0369\u036a") 

547 buf.write("\3\2\2\2\u036a\u03b6\5\u00ba^\2\u036b\u036c\5\u00a4S\2") 

548 buf.write("\u036c\u036d\5B\"\27\u036d\u03b6\3\2\2\2\u036e\u036f\5") 

549 buf.write("\u00b0Y\2\u036f\u037c\7\5\2\2\u0370\u0372\7@\2\2\u0371") 

550 buf.write("\u0370\3\2\2\2\u0371\u0372\3\2\2\2\u0372\u0373\3\2\2\2") 

551 buf.write("\u0373\u0378\5B\"\2\u0374\u0375\7\7\2\2\u0375\u0377\5") 

552 buf.write("B\"\2\u0376\u0374\3\2\2\2\u0377\u037a\3\2\2\2\u0378\u0376") 

553 buf.write("\3\2\2\2\u0378\u0379\3\2\2\2\u0379\u037d\3\2\2\2\u037a") 

554 buf.write("\u0378\3\2\2\2\u037b\u037d\7\t\2\2\u037c\u0371\3\2\2\2") 

555 buf.write("\u037c\u037b\3\2\2\2\u037c\u037d\3\2\2\2\u037d\u037e\3") 

556 buf.write("\2\2\2\u037e\u0380\7\6\2\2\u037f\u0381\5r:\2\u0380\u037f") 

557 buf.write("\3\2\2\2\u0380\u0381\3\2\2\2\u0381\u0383\3\2\2\2\u0382") 

558 buf.write("\u0384\5v<\2\u0383\u0382\3\2\2\2\u0383\u0384\3\2\2\2\u0384") 

559 buf.write("\u03b6\3\2\2\2\u0385\u0386\7\5\2\2\u0386\u038b\5B\"\2") 

560 buf.write("\u0387\u0388\7\7\2\2\u0388\u038a\5B\"\2\u0389\u0387\3") 

561 buf.write("\2\2\2\u038a\u038d\3\2\2\2\u038b\u0389\3\2\2\2\u038b\u038c") 

562 buf.write("\3\2\2\2\u038c\u038e\3\2\2\2\u038d\u038b\3\2\2\2\u038e") 

563 buf.write("\u038f\7\6\2\2\u038f\u03b6\3\2\2\2\u0390\u0391\7-\2\2") 

564 buf.write("\u0391\u0392\7\5\2\2\u0392\u0393\5B\"\2\u0393\u0394\7") 

565 buf.write("#\2\2\u0394\u0395\5 \21\2\u0395\u0396\7\6\2\2\u0396\u03b6") 

566 buf.write("\3\2\2\2\u0397\u0399\7h\2\2\u0398\u0397\3\2\2\2\u0398") 

567 buf.write("\u0399\3\2\2\2\u0399\u039a\3\2\2\2\u039a\u039c\7H\2\2") 

568 buf.write("\u039b\u0398\3\2\2\2\u039b\u039c\3\2\2\2\u039c\u039d\3") 

569 buf.write("\2\2\2\u039d\u039e\7\5\2\2\u039e\u039f\5R*\2\u039f\u03a0") 

570 buf.write("\7\6\2\2\u03a0\u03b6\3\2\2\2\u03a1\u03a3\7,\2\2\u03a2") 

571 buf.write("\u03a4\5B\"\2\u03a3\u03a2\3\2\2\2\u03a3\u03a4\3\2\2\2") 

572 buf.write("\u03a4\u03aa\3\2\2\2\u03a5\u03a6\7\u0094\2\2\u03a6\u03a7") 

573 buf.write("\5B\"\2\u03a7\u03a8\7\u0088\2\2\u03a8\u03a9\5B\"\2\u03a9") 

574 buf.write("\u03ab\3\2\2\2\u03aa\u03a5\3\2\2\2\u03ab\u03ac\3\2\2\2") 

575 buf.write("\u03ac\u03aa\3\2\2\2\u03ac\u03ad\3\2\2\2\u03ad\u03b0\3") 

576 buf.write("\2\2\2\u03ae\u03af\7C\2\2\u03af\u03b1\5B\"\2\u03b0\u03ae") 

577 buf.write("\3\2\2\2\u03b0\u03b1\3\2\2\2\u03b1\u03b2\3\2\2\2\u03b2") 

578 buf.write("\u03b3\7D\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b6\5D#\2\u03b5") 

579 buf.write("\u035d\3\2\2\2\u03b5\u035f\3\2\2\2\u03b5\u0368\3\2\2\2") 

580 buf.write("\u03b5\u036b\3\2\2\2\u03b5\u036e\3\2\2\2\u03b5\u0385\3") 

581 buf.write("\2\2\2\u03b5\u0390\3\2\2\2\u03b5\u039b\3\2\2\2\u03b5\u03a1") 

582 buf.write("\3\2\2\2\u03b5\u03b4\3\2\2\2\u03b6\u042e\3\2\2\2\u03b7") 

583 buf.write("\u03b8\f\26\2\2\u03b8\u03b9\7\r\2\2\u03b9\u042d\5B\"\27") 

584 buf.write("\u03ba\u03bb\f\25\2\2\u03bb\u03bc\t\f\2\2\u03bc\u042d") 

585 buf.write("\5B\"\26\u03bd\u03be\f\24\2\2\u03be\u03bf\t\6\2\2\u03bf") 

586 buf.write("\u042d\5B\"\25\u03c0\u03c1\f\23\2\2\u03c1\u03c2\t\r\2") 

587 buf.write("\2\u03c2\u042d\5B\"\24\u03c3\u03c4\f\22\2\2\u03c4\u03c5") 

588 buf.write("\t\16\2\2\u03c5\u042d\5B\"\23\u03c6\u03d3\f\21\2\2\u03c7") 

589 buf.write("\u03d4\7\b\2\2\u03c8\u03d4\7\30\2\2\u03c9\u03d4\7\31\2") 

590 buf.write("\2\u03ca\u03d4\7\32\2\2\u03cb\u03d4\7^\2\2\u03cc\u03cd") 

591 buf.write("\7^\2\2\u03cd\u03d4\7h\2\2\u03ce\u03d4\7U\2\2\u03cf\u03d4") 

592 buf.write("\7c\2\2\u03d0\u03d4\7O\2\2\u03d1\u03d4\7e\2\2\u03d2\u03d4") 

593 buf.write("\7x\2\2\u03d3\u03c7\3\2\2\2\u03d3\u03c8\3\2\2\2\u03d3") 

594 buf.write("\u03c9\3\2\2\2\u03d3\u03ca\3\2\2\2\u03d3\u03cb\3\2\2\2") 

595 buf.write("\u03d3\u03cc\3\2\2\2\u03d3\u03ce\3\2\2\2\u03d3\u03cf\3") 

596 buf.write("\2\2\2\u03d3\u03d0\3\2\2\2\u03d3\u03d1\3\2\2\2\u03d3\u03d2") 

597 buf.write("\3\2\2\2\u03d4\u03d5\3\2\2\2\u03d5\u042d\5B\"\22\u03d6") 

598 buf.write("\u03d7\f\20\2\2\u03d7\u03d8\7\"\2\2\u03d8\u042d\5B\"\21") 

599 buf.write("\u03d9\u03da\f\17\2\2\u03da\u03db\7n\2\2\u03db\u042d\5") 

600 buf.write("B\"\20\u03dc\u03dd\f\b\2\2\u03dd\u03df\7^\2\2\u03de\u03e0") 

601 buf.write("\7h\2\2\u03df\u03de\3\2\2\2\u03df\u03e0\3\2\2\2\u03e0") 

602 buf.write("\u03e1\3\2\2\2\u03e1\u042d\5B\"\t\u03e2\u03e4\f\7\2\2") 

603 buf.write("\u03e3\u03e5\7h\2\2\u03e4\u03e3\3\2\2\2\u03e4\u03e5\3") 

604 buf.write("\2\2\2\u03e5\u03e6\3\2\2\2\u03e6\u03e7\7)\2\2\u03e7\u03e8") 

605 buf.write("\5B\"\2\u03e8\u03e9\7\"\2\2\u03e9\u03ea\5B\"\b\u03ea\u042d") 

606 buf.write("\3\2\2\2\u03eb\u03ec\f\13\2\2\u03ec\u03ed\7/\2\2\u03ed") 

607 buf.write("\u042d\5\u00bc_\2\u03ee\u03f0\f\n\2\2\u03ef\u03f1\7h\2") 

608 buf.write("\2\u03f0\u03ef\3\2\2\2\u03f0\u03f1\3\2\2\2\u03f1\u03f2") 

609 buf.write("\3\2\2\2\u03f2\u03f3\t\17\2\2\u03f3\u03f6\5B\"\2\u03f4") 

610 buf.write("\u03f5\7E\2\2\u03f5\u03f7\5B\"\2\u03f6\u03f4\3\2\2\2\u03f6") 

611 buf.write("\u03f7\3\2\2\2\u03f7\u042d\3\2\2\2\u03f8\u03fd\f\t\2\2") 

612 buf.write("\u03f9\u03fe\7_\2\2\u03fa\u03fe\7i\2\2\u03fb\u03fc\7h") 

613 buf.write("\2\2\u03fc\u03fe\7j\2\2\u03fd\u03f9\3\2\2\2\u03fd\u03fa") 

614 buf.write("\3\2\2\2\u03fd\u03fb\3\2\2\2\u03fe\u042d\3\2\2\2\u03ff") 

615 buf.write("\u0401\f\6\2\2\u0400\u0402\7h\2\2\u0401\u0400\3\2\2\2") 

616 buf.write("\u0401\u0402\3\2\2\2\u0402\u0403\3\2\2\2\u0403\u042a\7") 

617 buf.write("U\2\2\u0404\u040e\7\5\2\2\u0405\u040f\5R*\2\u0406\u040b") 

618 buf.write("\5B\"\2\u0407\u0408\7\7\2\2\u0408\u040a\5B\"\2\u0409\u0407") 

619 buf.write("\3\2\2\2\u040a\u040d\3\2\2\2\u040b\u0409\3\2\2\2\u040b") 

620 buf.write("\u040c\3\2\2\2\u040c\u040f\3\2\2\2\u040d\u040b\3\2\2\2") 

621 buf.write("\u040e\u0405\3\2\2\2\u040e\u0406\3\2\2\2\u040e\u040f\3") 

622 buf.write("\2\2\2\u040f\u0410\3\2\2\2\u0410\u042b\7\6\2\2\u0411\u0412") 

623 buf.write("\5\u00b2Z\2\u0412\u0413\7\4\2\2\u0413\u0415\3\2\2\2\u0414") 

624 buf.write("\u0411\3\2\2\2\u0414\u0415\3\2\2\2\u0415\u0416\3\2\2\2") 

625 buf.write("\u0416\u042b\5\u00b4[\2\u0417\u0418\5\u00b2Z\2\u0418\u0419") 

626 buf.write("\7\4\2\2\u0419\u041b\3\2\2\2\u041a\u0417\3\2\2\2\u041a") 

627 buf.write("\u041b\3\2\2\2\u041b\u041c\3\2\2\2\u041c\u041d\5\u00dc") 

628 buf.write("o\2\u041d\u0426\7\5\2\2\u041e\u0423\5B\"\2\u041f\u0420") 

629 buf.write("\7\7\2\2\u0420\u0422\5B\"\2\u0421\u041f\3\2\2\2\u0422") 

630 buf.write("\u0425\3\2\2\2\u0423\u0421\3\2\2\2\u0423\u0424\3\2\2\2") 

631 buf.write("\u0424\u0427\3\2\2\2\u0425\u0423\3\2\2\2\u0426\u041e\3") 

632 buf.write("\2\2\2\u0426\u0427\3\2\2\2\u0427\u0428\3\2\2\2\u0428\u0429") 

633 buf.write("\7\6\2\2\u0429\u042b\3\2\2\2\u042a\u0404\3\2\2\2\u042a") 

634 buf.write("\u0414\3\2\2\2\u042a\u041a\3\2\2\2\u042b\u042d\3\2\2\2") 

635 buf.write("\u042c\u03b7\3\2\2\2\u042c\u03ba\3\2\2\2\u042c\u03bd\3") 

636 buf.write("\2\2\2\u042c\u03c0\3\2\2\2\u042c\u03c3\3\2\2\2\u042c\u03c6") 

637 buf.write("\3\2\2\2\u042c\u03d6\3\2\2\2\u042c\u03d9\3\2\2\2\u042c") 

638 buf.write("\u03dc\3\2\2\2\u042c\u03e2\3\2\2\2\u042c\u03eb\3\2\2\2") 

639 buf.write("\u042c\u03ee\3\2\2\2\u042c\u03f8\3\2\2\2\u042c\u03ff\3") 

640 buf.write("\2\2\2\u042d\u0430\3\2\2\2\u042e\u042c\3\2\2\2\u042e\u042f") 

641 buf.write("\3\2\2\2\u042fC\3\2\2\2\u0430\u042e\3\2\2\2\u0431\u0432") 

642 buf.write("\7u\2\2\u0432\u0437\7\5\2\2\u0433\u0438\7S\2\2\u0434\u0435") 

643 buf.write("\t\20\2\2\u0435\u0436\7\7\2\2\u0436\u0438\5\u00a6T\2\u0437") 

644 buf.write("\u0433\3\2\2\2\u0437\u0434\3\2\2\2\u0438\u0439\3\2\2\2") 

645 buf.write("\u0439\u043a\7\6\2\2\u043aE\3\2\2\2\u043b\u043c\t\21\2") 

646 buf.write("\2\u043cG\3\2\2\2\u043d\u043f\5\62\32\2\u043e\u043d\3") 

647 buf.write("\2\2\2\u043e\u043f\3\2\2\2\u043f\u0445\3\2\2\2\u0440\u0446") 

648 buf.write("\7Z\2\2\u0441\u0446\7|\2\2\u0442\u0443\7Z\2\2\u0443\u0444") 

649 buf.write("\7n\2\2\u0444\u0446\t\n\2\2\u0445\u0440\3\2\2\2\u0445") 

650 buf.write("\u0441\3\2\2\2\u0445\u0442\3\2\2\2\u0446\u0447\3\2\2\2") 

651 buf.write("\u0447\u044b\7]\2\2\u0448\u0449\5\u00b2Z\2\u0449\u044a") 

652 buf.write("\7\4\2\2\u044a\u044c\3\2\2\2\u044b\u0448\3\2\2\2\u044b") 

653 buf.write("\u044c\3\2\2\2\u044c\u044d\3\2\2\2\u044d\u0450\5\u00b4") 

654 buf.write("[\2\u044e\u044f\7#\2\2\u044f\u0451\5\u00ccg\2\u0450\u044e") 

655 buf.write("\3\2\2\2\u0450\u0451\3\2\2\2\u0451\u045d\3\2\2\2\u0452") 

656 buf.write("\u0453\7\5\2\2\u0453\u0458\5\u00ba^\2\u0454\u0455\7\7") 

657 buf.write("\2\2\u0455\u0457\5\u00ba^\2\u0456\u0454\3\2\2\2\u0457") 

658 buf.write("\u045a\3\2\2\2\u0458\u0456\3\2\2\2\u0458\u0459\3\2\2\2") 

659 buf.write("\u0459\u045b\3\2\2\2\u045a\u0458\3\2\2\2\u045b\u045c\7") 

660 buf.write("\6\2\2\u045c\u045e\3\2\2\2\u045d\u0452\3\2\2\2\u045d\u045e") 

661 buf.write("\3\2\2\2\u045e\u047c\3\2\2\2\u045f\u0460\7\u0091\2\2\u0460") 

662 buf.write("\u0461\7\5\2\2\u0461\u0466\5B\"\2\u0462\u0463\7\7\2\2") 

663 buf.write("\u0463\u0465\5B\"\2\u0464\u0462\3\2\2\2\u0465\u0468\3") 

664 buf.write("\2\2\2\u0466\u0464\3\2\2\2\u0466\u0467\3\2\2\2\u0467\u0469") 

665 buf.write("\3\2\2\2\u0468\u0466\3\2\2\2\u0469\u0478\7\6\2\2\u046a") 

666 buf.write("\u046b\7\7\2\2\u046b\u046c\7\5\2\2\u046c\u0471\5B\"\2") 

667 buf.write("\u046d\u046e\7\7\2\2\u046e\u0470\5B\"\2\u046f\u046d\3") 

668 buf.write("\2\2\2\u0470\u0473\3\2\2\2\u0471\u046f\3\2\2\2\u0471\u0472") 

669 buf.write("\3\2\2\2\u0472\u0474\3\2\2\2\u0473\u0471\3\2\2\2\u0474") 

670 buf.write("\u0475\7\6\2\2\u0475\u0477\3\2\2\2\u0476\u046a\3\2\2\2") 

671 buf.write("\u0477\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3") 

672 buf.write("\2\2\2\u0479\u047d\3\2\2\2\u047a\u0478\3\2\2\2\u047b\u047d") 

673 buf.write("\5R*\2\u047c\u045f\3\2\2\2\u047c\u047b\3\2\2\2\u047d\u047f") 

674 buf.write("\3\2\2\2\u047e\u0480\5J&\2\u047f\u047e\3\2\2\2\u047f\u0480") 

675 buf.write("\3\2\2\2\u0480\u0484\3\2\2\2\u0481\u0482\7:\2\2\u0482") 

676 buf.write("\u0484\7\u0091\2\2\u0483\u043e\3\2\2\2\u0483\u0481\3\2") 

677 buf.write("\2\2\u0484I\3\2\2\2\u0485\u0486\7m\2\2\u0486\u0495\7\62") 

678 buf.write("\2\2\u0487\u0488\7\5\2\2\u0488\u048d\5\32\16\2\u0489\u048a") 

679 buf.write("\7\7\2\2\u048a\u048c\5\32\16\2\u048b\u0489\3\2\2\2\u048c") 

680 buf.write("\u048f\3\2\2\2\u048d\u048b\3\2\2\2\u048d\u048e\3\2\2\2") 

681 buf.write("\u048e\u0490\3\2\2\2\u048f\u048d\3\2\2\2\u0490\u0493\7") 

682 buf.write("\6\2\2\u0491\u0492\7\u0095\2\2\u0492\u0494\5B\"\2\u0493") 

683 buf.write("\u0491\3\2\2\2\u0493\u0494\3\2\2\2\u0494\u0496\3\2\2\2") 

684 buf.write("\u0495\u0487\3\2\2\2\u0495\u0496\3\2\2\2\u0496\u0497\3") 

685 buf.write("\2\2\2\u0497\u04b2\7\u00b8\2\2\u0498\u04b3\7\u00b9\2\2") 

686 buf.write("\u0499\u049a\7\u008e\2\2\u049a\u049d\7\u0084\2\2\u049b") 

687 buf.write("\u049e\5\u00ba^\2\u049c\u049e\5j\66\2\u049d\u049b\3\2") 

688 buf.write("\2\2\u049d\u049c\3\2\2\2\u049e\u049f\3\2\2\2\u049f\u04a0") 

689 buf.write("\7\30\2\2\u04a0\u04ab\5B\"\2\u04a1\u04a4\7\7\2\2\u04a2") 

690 buf.write("\u04a5\5\u00ba^\2\u04a3\u04a5\5j\66\2\u04a4\u04a2\3\2") 

691 buf.write("\2\2\u04a4\u04a3\3\2\2\2\u04a5\u04a6\3\2\2\2\u04a6\u04a7") 

692 buf.write("\7\30\2\2\u04a7\u04a8\5B\"\2\u04a8\u04aa\3\2\2\2\u04a9") 

693 buf.write("\u04a1\3\2\2\2\u04aa\u04ad\3\2\2\2\u04ab\u04a9\3\2\2\2") 

694 buf.write("\u04ab\u04ac\3\2\2\2\u04ac\u04b0\3\2\2\2\u04ad\u04ab\3") 

695 buf.write("\2\2\2\u04ae\u04af\7\u0095\2\2\u04af\u04b1\5B\"\2\u04b0") 

696 buf.write("\u04ae\3\2\2\2\u04b0\u04b1\3\2\2\2\u04b1\u04b3\3\2\2\2") 

697 buf.write("\u04b2\u0498\3\2\2\2\u04b2\u0499\3\2\2\2\u04b3K\3\2\2") 

698 buf.write("\2\u04b4\u04b8\7r\2\2\u04b5\u04b6\5\u00b2Z\2\u04b6\u04b7") 

699 buf.write("\7\4\2\2\u04b7\u04b9\3\2\2\2\u04b8\u04b5\3\2\2\2\u04b8") 

700 buf.write("\u04b9\3\2\2\2\u04b9\u04ba\3\2\2\2\u04ba\u04c1\5\u00c8") 

701 buf.write("e\2\u04bb\u04bc\7\b\2\2\u04bc\u04c2\5N(\2\u04bd\u04be") 

702 buf.write("\7\5\2\2\u04be\u04bf\5N(\2\u04bf\u04c0\7\6\2\2\u04c0\u04c2") 

703 buf.write("\3\2\2\2\u04c1\u04bb\3\2\2\2\u04c1\u04bd\3\2\2\2\u04c1") 

704 buf.write("\u04c2\3\2\2\2\u04c2M\3\2\2\2\u04c3\u04c7\5$\23\2\u04c4") 

705 buf.write("\u04c7\5\u00aeX\2\u04c5\u04c7\7\u00bd\2\2\u04c6\u04c3") 

706 buf.write("\3\2\2\2\u04c6\u04c4\3\2\2\2\u04c6\u04c5\3\2\2\2\u04c7") 

707 buf.write("O\3\2\2\2\u04c8\u04d3\7y\2\2\u04c9\u04d4\5\u00bc_\2\u04ca") 

708 buf.write("\u04cb\5\u00b2Z\2\u04cb\u04cc\7\4\2\2\u04cc\u04ce\3\2") 

709 buf.write("\2\2\u04cd\u04ca\3\2\2\2\u04cd\u04ce\3\2\2\2\u04ce\u04d1") 

710 buf.write("\3\2\2\2\u04cf\u04d2\5\u00b4[\2\u04d0\u04d2\5\u00c0a\2") 

711 buf.write("\u04d1\u04cf\3\2\2\2\u04d1\u04d0\3\2\2\2\u04d2\u04d4\3") 

712 buf.write("\2\2\2\u04d3\u04c9\3\2\2\2\u04d3\u04cd\3\2\2\2\u04d3\u04d4") 

713 buf.write("\3\2\2\2\u04d4Q\3\2\2\2\u04d5\u04d7\5\u0082B\2\u04d6\u04d5") 

714 buf.write("\3\2\2\2\u04d6\u04d7\3\2\2\2\u04d7\u04d8\3\2\2\2\u04d8") 

715 buf.write("\u04de\5V,\2\u04d9\u04da\5f\64\2\u04da\u04db\5V,\2\u04db") 

716 buf.write("\u04dd\3\2\2\2\u04dc\u04d9\3\2\2\2\u04dd\u04e0\3\2\2\2") 

717 buf.write("\u04de\u04dc\3\2\2\2\u04de\u04df\3\2\2\2\u04df\u04e2\3") 

718 buf.write("\2\2\2\u04e0\u04de\3\2\2\2\u04e1\u04e3\5\u0084C\2\u04e2") 

719 buf.write("\u04e1\3\2\2\2\u04e2\u04e3\3\2\2\2\u04e3\u04e5\3\2\2\2") 

720 buf.write("\u04e4\u04e6\5\u0086D\2\u04e5\u04e4\3\2\2\2\u04e5\u04e6") 

721 buf.write("\3\2\2\2\u04e6S\3\2\2\2\u04e7\u04ef\5^\60\2\u04e8\u04e9") 

722 buf.write("\5b\62\2\u04e9\u04eb\5^\60\2\u04ea\u04ec\5d\63\2\u04eb") 

723 buf.write("\u04ea\3\2\2\2\u04eb\u04ec\3\2\2\2\u04ec\u04ee\3\2\2\2") 

724 buf.write("\u04ed\u04e8\3\2\2\2\u04ee\u04f1\3\2\2\2\u04ef\u04ed\3") 

725 buf.write("\2\2\2\u04ef\u04f0\3\2\2\2\u04f0U\3\2\2\2\u04f1\u04ef") 

726 buf.write("\3\2\2\2\u04f2\u04f4\7\u0083\2\2\u04f3\u04f5\t\22\2\2") 

727 buf.write("\u04f4\u04f3\3\2\2\2\u04f4\u04f5\3\2\2\2\u04f5\u04f6\3") 

728 buf.write("\2\2\2\u04f6\u04fb\5`\61\2\u04f7\u04f8\7\7\2\2\u04f8\u04fa") 

729 buf.write("\5`\61\2\u04f9\u04f7\3\2\2\2\u04fa\u04fd\3\2\2\2\u04fb") 

730 buf.write("\u04f9\3\2\2\2\u04fb\u04fc\3\2\2\2\u04fc\u050a\3\2\2\2") 

731 buf.write("\u04fd\u04fb\3\2\2\2\u04fe\u0508\7M\2\2\u04ff\u0504\5") 

732 buf.write("^\60\2\u0500\u0501\7\7\2\2\u0501\u0503\5^\60\2\u0502\u0500") 

733 buf.write("\3\2\2\2\u0503\u0506\3\2\2\2\u0504\u0502\3\2\2\2\u0504") 

734 buf.write("\u0505\3\2\2\2\u0505\u0509\3\2\2\2\u0506\u0504\3\2\2\2") 

735 buf.write("\u0507\u0509\5T+\2\u0508\u04ff\3\2\2\2\u0508\u0507\3\2") 

736 buf.write("\2\2\u0509\u050b\3\2\2\2\u050a\u04fe\3\2\2\2\u050a\u050b") 

737 buf.write("\3\2\2\2\u050b\u050e\3\2\2\2\u050c\u050d\7\u0095\2\2\u050d") 

738 buf.write("\u050f\5B\"\2\u050e\u050c\3\2\2\2\u050e\u050f\3\2\2\2") 

739 buf.write("\u050f\u051e\3\2\2\2\u0510\u0511\7P\2\2\u0511\u0512\7") 

740 buf.write("*\2\2\u0512\u0517\5B\"\2\u0513\u0514\7\7\2\2\u0514\u0516") 

741 buf.write("\5B\"\2\u0515\u0513\3\2\2\2\u0516\u0519\3\2\2\2\u0517") 

742 buf.write("\u0515\3\2\2\2\u0517\u0518\3\2\2\2\u0518\u051c\3\2\2\2") 

743 buf.write("\u0519\u0517\3\2\2\2\u051a\u051b\7Q\2\2\u051b\u051d\5") 

744 buf.write("B\"\2\u051c\u051a\3\2\2\2\u051c\u051d\3\2\2\2\u051d\u051f") 

745 buf.write("\3\2\2\2\u051e\u0510\3\2\2\2\u051e\u051f\3\2\2\2\u051f") 

746 buf.write("\u052e\3\2\2\2\u0520\u0521\7\u00af\2\2\u0521\u0522\5\u00d0") 

747 buf.write("i\2\u0522\u0523\7#\2\2\u0523\u052b\5t;\2\u0524\u0525\7") 

748 buf.write("\7\2\2\u0525\u0526\5\u00d0i\2\u0526\u0527\7#\2\2\u0527") 

749 buf.write("\u0528\5t;\2\u0528\u052a\3\2\2\2\u0529\u0524\3\2\2\2\u052a") 

750 buf.write("\u052d\3\2\2\2\u052b\u0529\3\2\2\2\u052b\u052c\3\2\2\2") 

751 buf.write("\u052c\u052f\3\2\2\2\u052d\u052b\3\2\2\2\u052e\u0520\3") 

752 buf.write("\2\2\2\u052e\u052f\3\2\2\2\u052f\u054d\3\2\2\2\u0530\u0531") 

753 buf.write("\7\u0091\2\2\u0531\u0532\7\5\2\2\u0532\u0537\5B\"\2\u0533") 

754 buf.write("\u0534\7\7\2\2\u0534\u0536\5B\"\2\u0535\u0533\3\2\2\2") 

755 buf.write("\u0536\u0539\3\2\2\2\u0537\u0535\3\2\2\2\u0537\u0538\3") 

756 buf.write("\2\2\2\u0538\u053a\3\2\2\2\u0539\u0537\3\2\2\2\u053a\u0549") 

757 buf.write("\7\6\2\2\u053b\u053c\7\7\2\2\u053c\u053d\7\5\2\2\u053d") 

758 buf.write("\u0542\5B\"\2\u053e\u053f\7\7\2\2\u053f\u0541\5B\"\2\u0540") 

759 buf.write("\u053e\3\2\2\2\u0541\u0544\3\2\2\2\u0542\u0540\3\2\2\2") 

760 buf.write("\u0542\u0543\3\2\2\2\u0543\u0545\3\2\2\2\u0544\u0542\3") 

761 buf.write("\2\2\2\u0545\u0546\7\6\2\2\u0546\u0548\3\2\2\2\u0547\u053b") 

762 buf.write("\3\2\2\2\u0548\u054b\3\2\2\2\u0549\u0547\3\2\2\2\u0549") 

763 buf.write("\u054a\3\2\2\2\u054a\u054d\3\2\2\2\u054b\u0549\3\2\2\2") 

764 buf.write("\u054c\u04f2\3\2\2\2\u054c\u0530\3\2\2\2\u054dW\3\2\2") 

765 buf.write("\2\u054e\u054f\5R*\2\u054fY\3\2\2\2\u0550\u0552\5\u0082") 

766 buf.write("B\2\u0551\u0550\3\2\2\2\u0551\u0552\3\2\2\2\u0552\u0553") 

767 buf.write("\3\2\2\2\u0553\u0555\5V,\2\u0554\u0556\5\u0084C\2\u0555") 

768 buf.write("\u0554\3\2\2\2\u0555\u0556\3\2\2\2\u0556\u0558\3\2\2\2") 

769 buf.write("\u0557\u0559\5\u0086D\2\u0558\u0557\3\2\2\2\u0558\u0559") 

770 buf.write("\3\2\2\2\u0559[\3\2\2\2\u055a\u055c\5\u0082B\2\u055b\u055a") 

771 buf.write("\3\2\2\2\u055b\u055c\3\2\2\2\u055c\u055d\3\2\2\2\u055d") 

772 buf.write("\u0567\5V,\2\u055e\u0560\7\u008c\2\2\u055f\u0561\7\37") 

773 buf.write("\2\2\u0560\u055f\3\2\2\2\u0560\u0561\3\2\2\2\u0561\u0565") 

774 buf.write("\3\2\2\2\u0562\u0565\7\\\2\2\u0563\u0565\7F\2\2\u0564") 

775 buf.write("\u055e\3\2\2\2\u0564\u0562\3\2\2\2\u0564\u0563\3\2\2\2") 

776 buf.write("\u0565\u0566\3\2\2\2\u0566\u0568\5V,\2\u0567\u0564\3\2") 

777 buf.write("\2\2\u0568\u0569\3\2\2\2\u0569\u0567\3\2\2\2\u0569\u056a") 

778 buf.write("\3\2\2\2\u056a\u056c\3\2\2\2\u056b\u056d\5\u0084C\2\u056c") 

779 buf.write("\u056b\3\2\2\2\u056c\u056d\3\2\2\2\u056d\u056f\3\2\2\2") 

780 buf.write("\u056e\u0570\5\u0086D\2\u056f\u056e\3\2\2\2\u056f\u0570") 

781 buf.write("\3\2\2\2\u0570]\3\2\2\2\u0571\u0572\5\u00b2Z\2\u0572\u0573") 

782 buf.write("\7\4\2\2\u0573\u0575\3\2\2\2\u0574\u0571\3\2\2\2\u0574") 

783 buf.write("\u0575\3\2\2\2\u0575\u0576\3\2\2\2\u0576\u057b\5\u00b4") 

784 buf.write("[\2\u0577\u0579\7#\2\2\u0578\u0577\3\2\2\2\u0578\u0579") 

785 buf.write("\3\2\2\2\u0579\u057a\3\2\2\2\u057a\u057c\5\u00ccg\2\u057b") 

786 buf.write("\u0578\3\2\2\2\u057b\u057c\3\2\2\2\u057c\u0582\3\2\2\2") 

787 buf.write("\u057d\u057e\7W\2\2\u057e\u057f\7*\2\2\u057f\u0583\5\u00c0") 

788 buf.write("a\2\u0580\u0581\7h\2\2\u0581\u0583\7W\2\2\u0582\u057d") 

789 buf.write("\3\2\2\2\u0582\u0580\3\2\2\2\u0582\u0583\3\2\2\2\u0583") 

790 buf.write("\u05b2\3\2\2\2\u0584\u0585\5\u00b2Z\2\u0585\u0586\7\4") 

791 buf.write("\2\2\u0586\u0588\3\2\2\2\u0587\u0584\3\2\2\2\u0587\u0588") 

792 buf.write("\3\2\2\2\u0588\u0589\3\2\2\2\u0589\u058a\5\u00dco\2\u058a") 

793 buf.write("\u058b\7\5\2\2\u058b\u0590\5B\"\2\u058c\u058d\7\7\2\2") 

794 buf.write("\u058d\u058f\5B\"\2\u058e\u058c\3\2\2\2\u058f\u0592\3") 

795 buf.write("\2\2\2\u0590\u058e\3\2\2\2\u0590\u0591\3\2\2\2\u0591\u0593") 

796 buf.write("\3\2\2\2\u0592\u0590\3\2\2\2\u0593\u0598\7\6\2\2\u0594") 

797 buf.write("\u0596\7#\2\2\u0595\u0594\3\2\2\2\u0595\u0596\3\2\2\2") 

798 buf.write("\u0596\u0597\3\2\2\2\u0597\u0599\5\u00ccg\2\u0598\u0595") 

799 buf.write("\3\2\2\2\u0598\u0599\3\2\2\2\u0599\u05b2\3\2\2\2\u059a") 

800 buf.write("\u05a4\7\5\2\2\u059b\u05a0\5^\60\2\u059c\u059d\7\7\2\2") 

801 buf.write("\u059d\u059f\5^\60\2\u059e\u059c\3\2\2\2\u059f\u05a2\3") 

802 buf.write("\2\2\2\u05a0\u059e\3\2\2\2\u05a0\u05a1\3\2\2\2\u05a1\u05a5") 

803 buf.write("\3\2\2\2\u05a2\u05a0\3\2\2\2\u05a3\u05a5\5T+\2\u05a4\u059b") 

804 buf.write("\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a6\3\2\2\2\u05a6") 

805 buf.write("\u05a7\7\6\2\2\u05a7\u05b2\3\2\2\2\u05a8\u05a9\7\5\2\2") 

806 buf.write("\u05a9\u05aa\5R*\2\u05aa\u05af\7\6\2\2\u05ab\u05ad\7#") 

807 buf.write("\2\2\u05ac\u05ab\3\2\2\2\u05ac\u05ad\3\2\2\2\u05ad\u05ae") 

808 buf.write("\3\2\2\2\u05ae\u05b0\5\u00ccg\2\u05af\u05ac\3\2\2\2\u05af") 

809 buf.write("\u05b0\3\2\2\2\u05b0\u05b2\3\2\2\2\u05b1\u0574\3\2\2\2") 

810 buf.write("\u05b1\u0587\3\2\2\2\u05b1\u059a\3\2\2\2\u05b1\u05a8\3") 

811 buf.write("\2\2\2\u05b2_\3\2\2\2\u05b3\u05c0\7\t\2\2\u05b4\u05b5") 

812 buf.write("\5\u00b4[\2\u05b5\u05b6\7\4\2\2\u05b6\u05b7\7\t\2\2\u05b7") 

813 buf.write("\u05c0\3\2\2\2\u05b8\u05bd\5B\"\2\u05b9\u05bb\7#\2\2\u05ba") 

814 buf.write("\u05b9\3\2\2\2\u05ba\u05bb\3\2\2\2\u05bb\u05bc\3\2\2\2") 

815 buf.write("\u05bc\u05be\5\u00aaV\2\u05bd\u05ba\3\2\2\2\u05bd\u05be") 

816 buf.write("\3\2\2\2\u05be\u05c0\3\2\2\2\u05bf\u05b3\3\2\2\2\u05bf") 

817 buf.write("\u05b4\3\2\2\2\u05bf\u05b8\3\2\2\2\u05c0a\3\2\2\2\u05c1") 

818 buf.write("\u05cf\7\7\2\2\u05c2\u05c4\7f\2\2\u05c3\u05c2\3\2\2\2") 

819 buf.write("\u05c3\u05c4\3\2\2\2\u05c4\u05cb\3\2\2\2\u05c5\u05c7\7") 

820 buf.write("b\2\2\u05c6\u05c8\7p\2\2\u05c7\u05c6\3\2\2\2\u05c7\u05c8") 

821 buf.write("\3\2\2\2\u05c8\u05cc\3\2\2\2\u05c9\u05cc\7Y\2\2\u05ca") 

822 buf.write("\u05cc\7\65\2\2\u05cb\u05c5\3\2\2\2\u05cb\u05c9\3\2\2") 

823 buf.write("\2\u05cb\u05ca\3\2\2\2\u05cb\u05cc\3\2\2\2\u05cc\u05cd") 

824 buf.write("\3\2\2\2\u05cd\u05cf\7`\2\2\u05ce\u05c1\3\2\2\2\u05ce") 

825 buf.write("\u05c3\3\2\2\2\u05cfc\3\2\2\2\u05d0\u05d1\7m\2\2\u05d1") 

826 buf.write("\u05df\5B\"\2\u05d2\u05d3\7\u008f\2\2\u05d3\u05d4\7\5") 

827 buf.write("\2\2\u05d4\u05d9\5\u00ba^\2\u05d5\u05d6\7\7\2\2\u05d6") 

828 buf.write("\u05d8\5\u00ba^\2\u05d7\u05d5\3\2\2\2\u05d8\u05db\3\2") 

829 buf.write("\2\2\u05d9\u05d7\3\2\2\2\u05d9\u05da\3\2\2\2\u05da\u05dc") 

830 buf.write("\3\2\2\2\u05db\u05d9\3\2\2\2\u05dc\u05dd\7\6\2\2\u05dd") 

831 buf.write("\u05df\3\2\2\2\u05de\u05d0\3\2\2\2\u05de\u05d2\3\2\2\2") 

832 buf.write("\u05dfe\3\2\2\2\u05e0\u05e2\7\u008c\2\2\u05e1\u05e3\7") 

833 buf.write("\37\2\2\u05e2\u05e1\3\2\2\2\u05e2\u05e3\3\2\2\2\u05e3") 

834 buf.write("\u05e7\3\2\2\2\u05e4\u05e7\7\\\2\2\u05e5\u05e7\7F\2\2") 

835 buf.write("\u05e6\u05e0\3\2\2\2\u05e6\u05e4\3\2\2\2\u05e6\u05e5\3") 

836 buf.write("\2\2\2\u05e7g\3\2\2\2\u05e8\u05ea\5\62\32\2\u05e9\u05e8") 

837 buf.write("\3\2\2\2\u05e9\u05ea\3\2\2\2\u05ea\u05eb\3\2\2\2\u05eb") 

838 buf.write("\u05ee\7\u008e\2\2\u05ec\u05ed\7n\2\2\u05ed\u05ef\t\n") 

839 buf.write("\2\2\u05ee\u05ec\3\2\2\2\u05ee\u05ef\3\2\2\2\u05ef\u05f0") 

840 buf.write("\3\2\2\2\u05f0\u05f1\5n8\2\u05f1\u05f4\7\u0084\2\2\u05f2") 

841 buf.write("\u05f5\5\u00ba^\2\u05f3\u05f5\5j\66\2\u05f4\u05f2\3\2") 

842 buf.write("\2\2\u05f4\u05f3\3\2\2\2\u05f5\u05f6\3\2\2\2\u05f6\u05f7") 

843 buf.write("\7\b\2\2\u05f7\u0602\5B\"\2\u05f8\u05fb\7\7\2\2\u05f9") 

844 buf.write("\u05fc\5\u00ba^\2\u05fa\u05fc\5j\66\2\u05fb\u05f9\3\2") 

845 buf.write("\2\2\u05fb\u05fa\3\2\2\2\u05fc\u05fd\3\2\2\2\u05fd\u05fe") 

846 buf.write("\7\b\2\2\u05fe\u05ff\5B\"\2\u05ff\u0601\3\2\2\2\u0600") 

847 buf.write("\u05f8\3\2\2\2\u0601\u0604\3\2\2\2\u0602\u0600\3\2\2\2") 

848 buf.write("\u0602\u0603\3\2\2\2\u0603\u0607\3\2\2\2\u0604\u0602\3") 

849 buf.write("\2\2\2\u0605\u0606\7\u0095\2\2\u0606\u0608\5B\"\2\u0607") 

850 buf.write("\u0605\3\2\2\2\u0607\u0608\3\2\2\2\u0608i\3\2\2\2\u0609") 

851 buf.write("\u060a\7\5\2\2\u060a\u060f\5\u00ba^\2\u060b\u060c\7\7") 

852 buf.write("\2\2\u060c\u060e\5\u00ba^\2\u060d\u060b\3\2\2\2\u060e") 

853 buf.write("\u0611\3\2\2\2\u060f\u060d\3\2\2\2\u060f\u0610\3\2\2\2") 

854 buf.write("\u0610\u0612\3\2\2\2\u0611\u060f\3\2\2\2\u0612\u0613\7") 

855 buf.write("\6\2\2\u0613k\3\2\2\2\u0614\u0616\5\62\32\2\u0615\u0614") 

856 buf.write("\3\2\2\2\u0615\u0616\3\2\2\2\u0616\u0617\3\2\2\2\u0617") 

857 buf.write("\u061a\7\u008e\2\2\u0618\u0619\7n\2\2\u0619\u061b\t\n") 

858 buf.write("\2\2\u061a\u0618\3\2\2\2\u061a\u061b\3\2\2\2\u061b\u061c") 

859 buf.write("\3\2\2\2\u061c\u061d\5n8\2\u061d\u0620\7\u0084\2\2\u061e") 

860 buf.write("\u0621\5\u00ba^\2\u061f\u0621\5j\66\2\u0620\u061e\3\2") 

861 buf.write("\2\2\u0620\u061f\3\2\2\2\u0621\u0622\3\2\2\2\u0622\u0623") 

862 buf.write("\7\b\2\2\u0623\u062e\5B\"\2\u0624\u0627\7\7\2\2\u0625") 

863 buf.write("\u0628\5\u00ba^\2\u0626\u0628\5j\66\2\u0627\u0625\3\2") 

864 buf.write("\2\2\u0627\u0626\3\2\2\2\u0628\u0629\3\2\2\2\u0629\u062a") 

865 buf.write("\7\b\2\2\u062a\u062b\5B\"\2\u062b\u062d\3\2\2\2\u062c") 

866 buf.write("\u0624\3\2\2\2\u062d\u0630\3\2\2\2\u062e\u062c\3\2\2\2") 

867 buf.write("\u062e\u062f\3\2\2\2\u062f\u0633\3\2\2\2\u0630\u062e\3") 

868 buf.write("\2\2\2\u0631\u0632\7\u0095\2\2\u0632\u0634\5B\"\2\u0633") 

869 buf.write("\u0631\3\2\2\2\u0633\u0634\3\2\2\2\u0634\u0639\3\2\2\2") 

870 buf.write("\u0635\u0637\5\u0084C\2\u0636\u0635\3\2\2\2\u0636\u0637") 

871 buf.write("\3\2\2\2\u0637\u0638\3\2\2\2\u0638\u063a\5\u0086D\2\u0639") 

872 buf.write("\u0636\3\2\2\2\u0639\u063a\3\2\2\2\u063am\3\2\2\2\u063b") 

873 buf.write("\u063c\5\u00b2Z\2\u063c\u063d\7\4\2\2\u063d\u063f\3\2") 

874 buf.write("\2\2\u063e\u063b\3\2\2\2\u063e\u063f\3\2\2\2\u063f\u0640") 

875 buf.write("\3\2\2\2\u0640\u0643\5\u00b4[\2\u0641\u0642\7#\2\2\u0642") 

876 buf.write("\u0644\5\u00d2j\2\u0643\u0641\3\2\2\2\u0643\u0644\3\2") 

877 buf.write("\2\2\u0644\u064a\3\2\2\2\u0645\u0646\7W\2\2\u0646\u0647") 

878 buf.write("\7*\2\2\u0647\u064b\5\u00c0a\2\u0648\u0649\7h\2\2\u0649") 

879 buf.write("\u064b\7W\2\2\u064a\u0645\3\2\2\2\u064a\u0648\3\2\2\2") 

880 buf.write("\u064a\u064b\3\2\2\2\u064bo\3\2\2\2\u064c\u064e\7\u0090") 

881 buf.write("\2\2\u064d\u064f\5\u00b2Z\2\u064e\u064d\3\2\2\2\u064e") 

882 buf.write("\u064f\3\2\2\2\u064f\u0652\3\2\2\2\u0650\u0651\7]\2\2") 

883 buf.write("\u0651\u0653\5\u00d4k\2\u0652\u0650\3\2\2\2\u0652\u0653") 

884 buf.write("\3\2\2\2\u0653q\3\2\2\2\u0654\u0655\7\u00b3\2\2\u0655") 

885 buf.write("\u0656\7\5\2\2\u0656\u0657\7\u0095\2\2\u0657\u0658\5B") 

886 buf.write("\"\2\u0658\u0659\7\6\2\2\u0659s\3\2\2\2\u065a\u065c\7") 

887 buf.write("\5\2\2\u065b\u065d\5\u00d6l\2\u065c\u065b\3\2\2\2\u065c") 

888 buf.write("\u065d\3\2\2\2\u065d\u0668\3\2\2\2\u065e\u065f\7\u009a") 

889 buf.write("\2\2\u065f\u0660\7*\2\2\u0660\u0665\5B\"\2\u0661\u0662") 

890 buf.write("\7\7\2\2\u0662\u0664\5B\"\2\u0663\u0661\3\2\2\2\u0664") 

891 buf.write("\u0667\3\2\2\2\u0665\u0663\3\2\2\2\u0665\u0666\3\2\2\2") 

892 buf.write("\u0666\u0669\3\2\2\2\u0667\u0665\3\2\2\2\u0668\u065e\3") 

893 buf.write("\2\2\2\u0668\u0669\3\2\2\2\u0669\u066a\3\2\2\2\u066a\u066b") 

894 buf.write("\7o\2\2\u066b\u066c\7*\2\2\u066c\u0671\5\u0088E\2\u066d") 

895 buf.write("\u066e\7\7\2\2\u066e\u0670\5\u0088E\2\u066f\u066d\3\2") 

896 buf.write("\2\2\u0670\u0673\3\2\2\2\u0671\u066f\3\2\2\2\u0671\u0672") 

897 buf.write("\3\2\2\2\u0672\u0675\3\2\2\2\u0673\u0671\3\2\2\2\u0674") 

898 buf.write("\u0676\5x=\2\u0675\u0674\3\2\2\2\u0675\u0676\3\2\2\2\u0676") 

899 buf.write("\u0677\3\2\2\2\u0677\u0678\7\6\2\2\u0678u\3\2\2\2\u0679") 

900 buf.write("\u069b\7\u0099\2\2\u067a\u069c\5\u00d0i\2\u067b\u067d") 

901 buf.write("\7\5\2\2\u067c\u067e\5\u00d6l\2\u067d\u067c\3\2\2\2\u067d") 

902 buf.write("\u067e\3\2\2\2\u067e\u0689\3\2\2\2\u067f\u0680\7\u009a") 

903 buf.write("\2\2\u0680\u0681\7*\2\2\u0681\u0686\5B\"\2\u0682\u0683") 

904 buf.write("\7\7\2\2\u0683\u0685\5B\"\2\u0684\u0682\3\2\2\2\u0685") 

905 buf.write("\u0688\3\2\2\2\u0686\u0684\3\2\2\2\u0686\u0687\3\2\2\2") 

906 buf.write("\u0687\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0689\u067f\3") 

907 buf.write("\2\2\2\u0689\u068a\3\2\2\2\u068a\u0695\3\2\2\2\u068b\u068c") 

908 buf.write("\7o\2\2\u068c\u068d\7*\2\2\u068d\u0692\5\u0088E\2\u068e") 

909 buf.write("\u068f\7\7\2\2\u068f\u0691\5\u0088E\2\u0690\u068e\3\2") 

910 buf.write("\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692\u0693") 

911 buf.write("\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695") 

912 buf.write("\u068b\3\2\2\2\u0695\u0696\3\2\2\2\u0696\u0698\3\2\2\2") 

913 buf.write("\u0697\u0699\5x=\2\u0698\u0697\3\2\2\2\u0698\u0699\3\2") 

914 buf.write("\2\2\u0699\u069a\3\2\2\2\u069a\u069c\7\6\2\2\u069b\u067a") 

915 buf.write("\3\2\2\2\u069b\u067b\3\2\2\2\u069cw\3\2\2\2\u069d\u06a5") 

916 buf.write("\5z>\2\u069e\u069f\7\u00b5\2\2\u069f\u06a0\7g\2\2\u06a0") 

917 buf.write("\u06a6\7\u00b7\2\2\u06a1\u06a2\7\u009e\2\2\u06a2\u06a6") 

918 buf.write("\7\u0080\2\2\u06a3\u06a6\7P\2\2\u06a4\u06a6\7\u00b6\2") 

919 buf.write("\2\u06a5\u069e\3\2\2\2\u06a5\u06a1\3\2\2\2\u06a5\u06a3") 

920 buf.write("\3\2\2\2\u06a5\u06a4\3\2\2\2\u06a5\u06a6\3\2\2\2\u06a6") 

921 buf.write("y\3\2\2\2\u06a7\u06ae\t\23\2\2\u06a8\u06af\5\u0090I\2") 

922 buf.write("\u06a9\u06aa\7)\2\2\u06aa\u06ab\5\u008cG\2\u06ab\u06ac") 

923 buf.write("\7\"\2\2\u06ac\u06ad\5\u008eH\2\u06ad\u06af\3\2\2\2\u06ae") 

924 buf.write("\u06a8\3\2\2\2\u06ae\u06a9\3\2\2\2\u06af{\3\2\2\2\u06b0") 

925 buf.write("\u06b1\5\u00d8m\2\u06b1\u06bb\7\5\2\2\u06b2\u06b7\5B\"") 

926 buf.write("\2\u06b3\u06b4\7\7\2\2\u06b4\u06b6\5B\"\2\u06b5\u06b3") 

927 buf.write("\3\2\2\2\u06b6\u06b9\3\2\2\2\u06b7\u06b5\3\2\2\2\u06b7") 

928 buf.write("\u06b8\3\2\2\2\u06b8\u06bc\3\2\2\2\u06b9\u06b7\3\2\2\2") 

929 buf.write("\u06ba\u06bc\7\t\2\2\u06bb\u06b2\3\2\2\2\u06bb\u06ba\3") 

930 buf.write("\2\2\2\u06bc\u06bd\3\2\2\2\u06bd\u06be\7\6\2\2\u06be}") 

931 buf.write("\3\2\2\2\u06bf\u06c0\5\u00dan\2\u06c0\u06cd\7\5\2\2\u06c1") 

932 buf.write("\u06c3\7@\2\2\u06c2\u06c1\3\2\2\2\u06c2\u06c3\3\2\2\2") 

933 buf.write("\u06c3\u06c4\3\2\2\2\u06c4\u06c9\5B\"\2\u06c5\u06c6\7") 

934 buf.write("\7\2\2\u06c6\u06c8\5B\"\2\u06c7\u06c5\3\2\2\2\u06c8\u06cb") 

935 buf.write("\3\2\2\2\u06c9\u06c7\3\2\2\2\u06c9\u06ca\3\2\2\2\u06ca") 

936 buf.write("\u06ce\3\2\2\2\u06cb\u06c9\3\2\2\2\u06cc\u06ce\7\t\2\2") 

937 buf.write("\u06cd\u06c2\3\2\2\2\u06cd\u06cc\3\2\2\2\u06cd\u06ce\3") 

938 buf.write("\2\2\2\u06ce\u06cf\3\2\2\2\u06cf\u06d1\7\6\2\2\u06d0\u06d2") 

939 buf.write("\5r:\2\u06d1\u06d0\3\2\2\2\u06d1\u06d2\3\2\2\2\u06d2\177") 

940 buf.write("\3\2\2\2\u06d3\u06d4\5\u0092J\2\u06d4\u06de\7\5\2\2\u06d5") 

941 buf.write("\u06da\5B\"\2\u06d6\u06d7\7\7\2\2\u06d7\u06d9\5B\"\2\u06d8") 

942 buf.write("\u06d6\3\2\2\2\u06d9\u06dc\3\2\2\2\u06da\u06d8\3\2\2\2") 

943 buf.write("\u06da\u06db\3\2\2\2\u06db\u06df\3\2\2\2\u06dc\u06da\3") 

944 buf.write("\2\2\2\u06dd\u06df\7\t\2\2\u06de\u06d5\3\2\2\2\u06de\u06dd") 

945 buf.write("\3\2\2\2\u06de\u06df\3\2\2\2\u06df\u06e0\3\2\2\2\u06e0") 

946 buf.write("\u06e2\7\6\2\2\u06e1\u06e3\5r:\2\u06e2\u06e1\3\2\2\2\u06e2") 

947 buf.write("\u06e3\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u06e7\7\u0099") 

948 buf.write("\2\2\u06e5\u06e8\5t;\2\u06e6\u06e8\5\u00d0i\2\u06e7\u06e5") 

949 buf.write("\3\2\2\2\u06e7\u06e6\3\2\2\2\u06e8\u0081\3\2\2\2\u06e9") 

950 buf.write("\u06eb\7\u0096\2\2\u06ea\u06ec\7v\2\2\u06eb\u06ea\3\2") 

951 buf.write("\2\2\u06eb\u06ec\3\2\2\2\u06ec\u06ed\3\2\2\2\u06ed\u06f2") 

952 buf.write("\58\35\2\u06ee\u06ef\7\7\2\2\u06ef\u06f1\58\35\2\u06f0") 

953 buf.write("\u06ee\3\2\2\2\u06f1\u06f4\3\2\2\2\u06f2\u06f0\3\2\2\2") 

954 buf.write("\u06f2\u06f3\3\2\2\2\u06f3\u0083\3\2\2\2\u06f4\u06f2\3") 

955 buf.write("\2\2\2\u06f5\u06f6\7o\2\2\u06f6\u06f7\7*\2\2\u06f7\u06fc") 

956 buf.write("\5\u0088E\2\u06f8\u06f9\7\7\2\2\u06f9\u06fb\5\u0088E\2") 

957 buf.write("\u06fa\u06f8\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3") 

958 buf.write("\2\2\2\u06fc\u06fd\3\2\2\2\u06fd\u0085\3\2\2\2\u06fe\u06fc") 

959 buf.write("\3\2\2\2\u06ff\u0700\7d\2\2\u0700\u0703\5B\"\2\u0701\u0702") 

960 buf.write("\t\24\2\2\u0702\u0704\5B\"\2\u0703\u0701\3\2\2\2\u0703") 

961 buf.write("\u0704\3\2\2\2\u0704\u0087\3\2\2\2\u0705\u0708\5B\"\2") 

962 buf.write("\u0706\u0707\7/\2\2\u0707\u0709\5\u00bc_\2\u0708\u0706") 

963 buf.write("\3\2\2\2\u0708\u0709\3\2\2\2\u0709\u070b\3\2\2\2\u070a") 

964 buf.write("\u070c\5\u008aF\2\u070b\u070a\3\2\2\2\u070b\u070c\3\2") 

965 buf.write("\2\2\u070c\u070f\3\2\2\2\u070d\u070e\7\u00b0\2\2\u070e") 

966 buf.write("\u0710\t\25\2\2\u070f\u070d\3\2\2\2\u070f\u0710\3\2\2") 

967 buf.write("\2\u0710\u0089\3\2\2\2\u0711\u0712\t\26\2\2\u0712\u008b") 

968 buf.write("\3\2\2\2\u0713\u0714\5B\"\2\u0714\u0715\7\u009c\2\2\u0715") 

969 buf.write("\u071e\3\2\2\2\u0716\u0717\5B\"\2\u0717\u0718\7\u009f") 

970 buf.write("\2\2\u0718\u071e\3\2\2\2\u0719\u071a\7\u009e\2\2\u071a") 

971 buf.write("\u071e\7\u0080\2\2\u071b\u071c\7\u009d\2\2\u071c\u071e") 

972 buf.write("\7\u009c\2\2\u071d\u0713\3\2\2\2\u071d\u0716\3\2\2\2\u071d") 

973 buf.write("\u0719\3\2\2\2\u071d\u071b\3\2\2\2\u071e\u008d\3\2\2\2") 

974 buf.write("\u071f\u0720\5B\"\2\u0720\u0721\7\u009c\2\2\u0721\u072a") 

975 buf.write("\3\2\2\2\u0722\u0723\5B\"\2\u0723\u0724\7\u009f\2\2\u0724") 

976 buf.write("\u072a\3\2\2\2\u0725\u0726\7\u009e\2\2\u0726\u072a\7\u0080") 

977 buf.write("\2\2\u0727\u0728\7\u009d\2\2\u0728\u072a\7\u009f\2\2\u0729") 

978 buf.write("\u071f\3\2\2\2\u0729\u0722\3\2\2\2\u0729\u0725\3\2\2\2") 

979 buf.write("\u0729\u0727\3\2\2\2\u072a\u008f\3\2\2\2\u072b\u072c\5") 

980 buf.write("B\"\2\u072c\u072d\7\u009c\2\2\u072d\u0733\3\2\2\2\u072e") 

981 buf.write("\u072f\7\u009d\2\2\u072f\u0733\7\u009c\2\2\u0730\u0731") 

982 buf.write("\7\u009e\2\2\u0731\u0733\7\u0080\2\2\u0732\u072b\3\2\2") 

983 buf.write("\2\u0732\u072e\3\2\2\2\u0732\u0730\3\2\2\2\u0733\u0091") 

984 buf.write("\3\2\2\2\u0734\u0735\t\27\2\2\u0735\u0736\7\5\2\2\u0736") 

985 buf.write("\u0737\5B\"\2\u0737\u0738\7\6\2\2\u0738\u0739\7\u0099") 

986 buf.write("\2\2\u0739\u073b\7\5\2\2\u073a\u073c\5\u0098M\2\u073b") 

987 buf.write("\u073a\3\2\2\2\u073b\u073c\3\2\2\2\u073c\u073d\3\2\2\2") 

988 buf.write("\u073d\u073f\5\u009cO\2\u073e\u0740\5z>\2\u073f\u073e") 

989 buf.write("\3\2\2\2\u073f\u0740\3\2\2\2\u0740\u0741\3\2\2\2\u0741") 

990 buf.write("\u0742\7\6\2\2\u0742\u078a\3\2\2\2\u0743\u0744\t\30\2") 

991 buf.write("\2\u0744\u0745\7\5\2\2\u0745\u0746\7\6\2\2\u0746\u0747") 

992 buf.write("\7\u0099\2\2\u0747\u0749\7\5\2\2\u0748\u074a\5\u0098M") 

993 buf.write("\2\u0749\u0748\3\2\2\2\u0749\u074a\3\2\2\2\u074a\u074c") 

994 buf.write("\3\2\2\2\u074b\u074d\5\u009aN\2\u074c\u074b\3\2\2\2\u074c") 

995 buf.write("\u074d\3\2\2\2\u074d\u074e\3\2\2\2\u074e\u078a\7\6\2\2") 

996 buf.write("\u074f\u0750\t\31\2\2\u0750\u0751\7\5\2\2\u0751\u0752") 

997 buf.write("\7\6\2\2\u0752\u0753\7\u0099\2\2\u0753\u0755\7\5\2\2\u0754") 

998 buf.write("\u0756\5\u0098M\2\u0755\u0754\3\2\2\2\u0755\u0756\3\2") 

999 buf.write("\2\2\u0756\u0757\3\2\2\2\u0757\u0758\5\u009cO\2\u0758") 

1000 buf.write("\u0759\7\6\2\2\u0759\u078a\3\2\2\2\u075a\u075b\t\32\2") 

1001 buf.write("\2\u075b\u075c\7\5\2\2\u075c\u075e\5B\"\2\u075d\u075f") 

1002 buf.write("\5\u0094K\2\u075e\u075d\3\2\2\2\u075e\u075f\3\2\2\2\u075f") 

1003 buf.write("\u0761\3\2\2\2\u0760\u0762\5\u0096L\2\u0761\u0760\3\2") 

1004 buf.write("\2\2\u0761\u0762\3\2\2\2\u0762\u0763\3\2\2\2\u0763\u0764") 

1005 buf.write("\7\6\2\2\u0764\u0765\7\u0099\2\2\u0765\u0767\7\5\2\2\u0766") 

1006 buf.write("\u0768\5\u0098M\2\u0767\u0766\3\2\2\2\u0767\u0768\3\2") 

1007 buf.write("\2\2\u0768\u0769\3\2\2\2\u0769\u076a\5\u009cO\2\u076a") 

1008 buf.write("\u076b\7\6\2\2\u076b\u078a\3\2\2\2\u076c\u076d\7\u00a5") 

1009 buf.write("\2\2\u076d\u076e\7\5\2\2\u076e\u076f\5B\"\2\u076f\u0770") 

1010 buf.write("\7\7\2\2\u0770\u0771\5$\23\2\u0771\u0772\7\6\2\2\u0772") 

1011 buf.write("\u0773\7\u0099\2\2\u0773\u0775\7\5\2\2\u0774\u0776\5\u0098") 

1012 buf.write("M\2\u0775\u0774\3\2\2\2\u0775\u0776\3\2\2\2\u0776\u0777") 

1013 buf.write("\3\2\2\2\u0777\u0779\5\u009cO\2\u0778\u077a\5z>\2\u0779") 

1014 buf.write("\u0778\3\2\2\2\u0779\u077a\3\2\2\2\u077a\u077b\3\2\2\2") 

1015 buf.write("\u077b\u077c\7\6\2\2\u077c\u078a\3\2\2\2\u077d\u077e\7") 

1016 buf.write("\u00a6\2\2\u077e\u077f\7\5\2\2\u077f\u0780\5B\"\2\u0780") 

1017 buf.write("\u0781\7\6\2\2\u0781\u0782\7\u0099\2\2\u0782\u0784\7\5") 

1018 buf.write("\2\2\u0783\u0785\5\u0098M\2\u0784\u0783\3\2\2\2\u0784") 

1019 buf.write("\u0785\3\2\2\2\u0785\u0786\3\2\2\2\u0786\u0787\5\u009c") 

1020 buf.write("O\2\u0787\u0788\7\6\2\2\u0788\u078a\3\2\2\2\u0789\u0734") 

1021 buf.write("\3\2\2\2\u0789\u0743\3\2\2\2\u0789\u074f\3\2\2\2\u0789") 

1022 buf.write("\u075a\3\2\2\2\u0789\u076c\3\2\2\2\u0789\u077d\3\2\2\2") 

1023 buf.write("\u078a\u0093\3\2\2\2\u078b\u078c\7\7\2\2\u078c\u078d\5") 

1024 buf.write("$\23\2\u078d\u0095\3\2\2\2\u078e\u078f\7\7\2\2\u078f\u0790") 

1025 buf.write("\5$\23\2\u0790\u0097\3\2\2\2\u0791\u0792\7\u009a\2\2\u0792") 

1026 buf.write("\u0794\7*\2\2\u0793\u0795\5B\"\2\u0794\u0793\3\2\2\2\u0795") 

1027 buf.write("\u0796\3\2\2\2\u0796\u0794\3\2\2\2\u0796\u0797\3\2\2\2") 

1028 buf.write("\u0797\u0099\3\2\2\2\u0798\u0799\7o\2\2\u0799\u079b\7") 

1029 buf.write("*\2\2\u079a\u079c\5B\"\2\u079b\u079a\3\2\2\2\u079c\u079d") 

1030 buf.write("\3\2\2\2\u079d\u079b\3\2\2\2\u079d\u079e\3\2\2\2\u079e") 

1031 buf.write("\u009b\3\2\2\2\u079f\u07a0\7o\2\2\u07a0\u07a1\7*\2\2\u07a1") 

1032 buf.write("\u07a2\5\u009cO\2\u07a2\u009d\3\2\2\2\u07a3\u07a5\5B\"") 

1033 buf.write("\2\u07a4\u07a6\5\u008aF\2\u07a5\u07a4\3\2\2\2\u07a5\u07a6") 

1034 buf.write("\3\2\2\2\u07a6\u07ae\3\2\2\2\u07a7\u07a8\7\7\2\2\u07a8") 

1035 buf.write("\u07aa\5B\"\2\u07a9\u07ab\5\u008aF\2\u07aa\u07a9\3\2\2") 

1036 buf.write("\2\u07aa\u07ab\3\2\2\2\u07ab\u07ad\3\2\2\2\u07ac\u07a7") 

1037 buf.write("\3\2\2\2\u07ad\u07b0\3\2\2\2\u07ae\u07ac\3\2\2\2\u07ae") 

1038 buf.write("\u07af\3\2\2\2\u07af\u009f\3\2\2\2\u07b0\u07ae\3\2\2\2") 

1039 buf.write("\u07b1\u07b2\5R*\2\u07b2\u00a1\3\2\2\2\u07b3\u07b4\5R") 

1040 buf.write("*\2\u07b4\u00a3\3\2\2\2\u07b5\u07b6\t\33\2\2\u07b6\u00a5") 

1041 buf.write("\3\2\2\2\u07b7\u07b8\7\u00bd\2\2\u07b8\u00a7\3\2\2\2\u07b9") 

1042 buf.write("\u07bc\5B\"\2\u07ba\u07bc\5\36\20\2\u07bb\u07b9\3\2\2") 

1043 buf.write("\2\u07bb\u07ba\3\2\2\2\u07bc\u00a9\3\2\2\2\u07bd\u07be") 

1044 buf.write("\t\34\2\2\u07be\u00ab\3\2\2\2\u07bf\u07c0\t\35\2\2\u07c0") 

1045 buf.write("\u00ad\3\2\2\2\u07c1\u07c2\5\u00dep\2\u07c2\u00af\3\2") 

1046 buf.write("\2\2\u07c3\u07c4\5\u00dep\2\u07c4\u00b1\3\2\2\2\u07c5") 

1047 buf.write("\u07c6\5\u00dep\2\u07c6\u00b3\3\2\2\2\u07c7\u07c8\5\u00de") 

1048 buf.write("p\2\u07c8\u00b5\3\2\2\2\u07c9\u07ca\5\u00dep\2\u07ca\u00b7") 

1049 buf.write("\3\2\2\2\u07cb\u07cc\5\u00dep\2\u07cc\u00b9\3\2\2\2\u07cd") 

1050 buf.write("\u07ce\5\u00dep\2\u07ce\u00bb\3\2\2\2\u07cf\u07d0\5\u00de") 

1051 buf.write("p\2\u07d0\u00bd\3\2\2\2\u07d1\u07d2\5\u00dep\2\u07d2\u00bf") 

1052 buf.write("\3\2\2\2\u07d3\u07d4\5\u00dep\2\u07d4\u00c1\3\2\2\2\u07d5") 

1053 buf.write("\u07d6\5\u00dep\2\u07d6\u00c3\3\2\2\2\u07d7\u07d8\5\u00de") 

1054 buf.write("p\2\u07d8\u00c5\3\2\2\2\u07d9\u07da\5\u00dep\2\u07da\u00c7") 

1055 buf.write("\3\2\2\2\u07db\u07dc\5\u00dep\2\u07dc\u00c9\3\2\2\2\u07dd") 

1056 buf.write("\u07de\5\u00dep\2\u07de\u00cb\3\2\2\2\u07df\u07e0\5\u00de") 

1057 buf.write("p\2\u07e0\u00cd\3\2\2\2\u07e1\u07e2\5\u00dep\2\u07e2\u00cf") 

1058 buf.write("\3\2\2\2\u07e3\u07e4\5\u00dep\2\u07e4\u00d1\3\2\2\2\u07e5") 

1059 buf.write("\u07e6\5\u00dep\2\u07e6\u00d3\3\2\2\2\u07e7\u07e8\5\u00de") 

1060 buf.write("p\2\u07e8\u00d5\3\2\2\2\u07e9\u07ea\5\u00dep\2\u07ea\u00d7") 

1061 buf.write("\3\2\2\2\u07eb\u07ec\5\u00dep\2\u07ec\u00d9\3\2\2\2\u07ed") 

1062 buf.write("\u07ee\5\u00dep\2\u07ee\u00db\3\2\2\2\u07ef\u07f0\5\u00de") 

1063 buf.write("p\2\u07f0\u00dd\3\2\2\2\u07f1\u07f9\7\u00ba\2\2\u07f2") 

1064 buf.write("\u07f9\5\u00acW\2\u07f3\u07f9\7\u00bd\2\2\u07f4\u07f5") 

1065 buf.write("\7\5\2\2\u07f5\u07f6\5\u00dep\2\u07f6\u07f7\7\6\2\2\u07f7") 

1066 buf.write("\u07f9\3\2\2\2\u07f8\u07f1\3\2\2\2\u07f8\u07f2\3\2\2\2") 

1067 buf.write("\u07f8\u07f3\3\2\2\2\u07f8\u07f4\3\2\2\2\u07f9\u00df\3") 

1068 buf.write("\2\2\2\u0122\u00e3\u00eb\u00f2\u00f7\u00fd\u0103\u0105") 

1069 buf.write("\u011f\u0126\u012d\u0133\u0137\u013a\u0141\u0144\u0148") 

1070 buf.write("\u0150\u0154\u0156\u015a\u015e\u0162\u0165\u016c\u0172") 

1071 buf.write("\u0178\u017d\u0188\u018e\u0192\u0196\u0199\u019d\u01a3") 

1072 buf.write("\u01a8\u01b1\u01b8\u01be\u01c2\u01c6\u01cb\u01d1\u01dd") 

1073 buf.write("\u01e1\u01e6\u01e9\u01ec\u01f1\u01f4\u0202\u0209\u0210") 

1074 buf.write("\u0212\u0215\u021b\u0220\u0228\u022d\u023c\u0242\u024c") 

1075 buf.write("\u0251\u025b\u025f\u0261\u0265\u026a\u026c\u0274\u027a") 

1076 buf.write("\u027f\u0286\u0291\u0294\u0296\u029d\u02a1\u02a8\u02ae") 

1077 buf.write("\u02b4\u02ba\u02bf\u02c8\u02cd\u02d8\u02dd\u02e8\u02ed") 

1078 buf.write("\u02f1\u0301\u030b\u0310\u0318\u0324\u0329\u0331\u0338") 

1079 buf.write("\u033b\u0342\u0345\u0348\u034c\u0354\u0359\u0363\u0368") 

1080 buf.write("\u0371\u0378\u037c\u0380\u0383\u038b\u0398\u039b\u03a3") 

1081 buf.write("\u03ac\u03b0\u03b5\u03d3\u03df\u03e4\u03f0\u03f6\u03fd") 

1082 buf.write("\u0401\u040b\u040e\u0414\u041a\u0423\u0426\u042a\u042c") 

1083 buf.write("\u042e\u0437\u043e\u0445\u044b\u0450\u0458\u045d\u0466") 

1084 buf.write("\u0471\u0478\u047c\u047f\u0483\u048d\u0493\u0495\u049d") 

1085 buf.write("\u04a4\u04ab\u04b0\u04b2\u04b8\u04c1\u04c6\u04cd\u04d1") 

1086 buf.write("\u04d3\u04d6\u04de\u04e2\u04e5\u04eb\u04ef\u04f4\u04fb") 

1087 buf.write("\u0504\u0508\u050a\u050e\u0517\u051c\u051e\u052b\u052e") 

1088 buf.write("\u0537\u0542\u0549\u054c\u0551\u0555\u0558\u055b\u0560") 

1089 buf.write("\u0564\u0569\u056c\u056f\u0574\u0578\u057b\u0582\u0587") 

1090 buf.write("\u0590\u0595\u0598\u05a0\u05a4\u05ac\u05af\u05b1\u05ba") 

1091 buf.write("\u05bd\u05bf\u05c3\u05c7\u05cb\u05ce\u05d9\u05de\u05e2") 

1092 buf.write("\u05e6\u05e9\u05ee\u05f4\u05fb\u0602\u0607\u060f\u0615") 

1093 buf.write("\u061a\u0620\u0627\u062e\u0633\u0636\u0639\u063e\u0643") 

1094 buf.write("\u064a\u064e\u0652\u065c\u0665\u0668\u0671\u0675\u067d") 

1095 buf.write("\u0686\u0689\u0692\u0695\u0698\u069b\u06a5\u06ae\u06b7") 

1096 buf.write("\u06bb\u06c2\u06c9\u06cd\u06d1\u06da\u06de\u06e2\u06e7") 

1097 buf.write("\u06eb\u06f2\u06fc\u0703\u0708\u070b\u070f\u071d\u0729") 

1098 buf.write("\u0732\u073b\u073f\u0749\u074c\u0755\u075e\u0761\u0767") 

1099 buf.write("\u0775\u0779\u0784\u0789\u0796\u079d\u07a5\u07aa\u07ae") 

1100 buf.write("\u07bb\u07f8") 

1101 return buf.getvalue() 

1102 

1103 

1104class SQLiteParser ( Parser ): 

1105 

1106 grammarFileName = "SQLiteParser.g4" 

1107 

1108 atn = ATNDeserializer().deserialize(serializedATN()) 

1109 

1110 decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] 

1111 

1112 sharedContextCache = PredictionContextCache() 

1113 

1114 literalNames = [ "<INVALID>", "';'", "'.'", "'('", "')'", "','", "'='", 

1115 "'*'", "'+'", "'-'", "'~'", "'||'", "'/'", "'%'", "'<<'", 

1116 "'>>'", "'&'", "'|'", "'<'", "'<='", "'>'", "'>='", 

1117 "'=='", "'!='", "'<>'" ] 

1118 

1119 symbolicNames = [ "<INVALID>", "SCOL", "DOT", "OPEN_PAR", "CLOSE_PAR", 

1120 "COMMA", "ASSIGN", "STAR", "PLUS", "MINUS", "TILDE", 

1121 "PIPE2", "DIV", "MOD", "LT2", "GT2", "AMP", "PIPE", 

1122 "LT", "LT_EQ", "GT", "GT_EQ", "EQ", "NOT_EQ1", "NOT_EQ2", 

1123 "ABORT_", "ACTION_", "ADD_", "AFTER_", "ALL_", "ALTER_", 

1124 "ANALYZE_", "AND_", "AS_", "ASC_", "ATTACH_", "AUTOINCREMENT_", 

1125 "BEFORE_", "BEGIN_", "BETWEEN_", "BY_", "CASCADE_", 

1126 "CASE_", "CAST_", "CHECK_", "COLLATE_", "COLUMN_", 

1127 "COMMIT_", "CONFLICT_", "CONSTRAINT_", "CREATE_", 

1128 "CROSS_", "CURRENT_DATE_", "CURRENT_TIME_", "CURRENT_TIMESTAMP_", 

1129 "DATABASE_", "DEFAULT_", "DEFERRABLE_", "DEFERRED_", 

1130 "DELETE_", "DESC_", "DETACH_", "DISTINCT_", "DROP_", 

1131 "EACH_", "ELSE_", "END_", "ESCAPE_", "EXCEPT_", "EXCLUSIVE_", 

1132 "EXISTS_", "EXPLAIN_", "FAIL_", "FOR_", "FOREIGN_", 

1133 "FROM_", "FULL_", "GLOB_", "GROUP_", "HAVING_", "IF_", 

1134 "IGNORE_", "IMMEDIATE_", "IN_", "INDEX_", "INDEXED_", 

1135 "INITIALLY_", "INNER_", "INSERT_", "INSTEAD_", "INTERSECT_", 

1136 "INTO_", "IS_", "ISNULL_", "JOIN_", "KEY_", "LEFT_", 

1137 "LIKE_", "LIMIT_", "MATCH_", "NATURAL_", "NO_", "NOT_", 

1138 "NOTNULL_", "NULL_", "OF_", "OFFSET_", "ON_", "OR_", 

1139 "ORDER_", "OUTER_", "PLAN_", "PRAGMA_", "PRIMARY_", 

1140 "QUERY_", "RAISE_", "RECURSIVE_", "REFERENCES_", "REGEXP_", 

1141 "REINDEX_", "RELEASE_", "RENAME_", "REPLACE_", "RESTRICT_", 

1142 "RIGHT_", "ROLLBACK_", "ROW_", "ROWS_", "SAVEPOINT_", 

1143 "SELECT_", "SET_", "TABLE_", "TEMP_", "TEMPORARY_", 

1144 "THEN_", "TO_", "TRANSACTION_", "TRIGGER_", "UNION_", 

1145 "UNIQUE_", "UPDATE_", "USING_", "VACUUM_", "VALUES_", 

1146 "VIEW_", "VIRTUAL_", "WHEN_", "WHERE_", "WITH_", "WITHOUT_", 

1147 "FIRST_VALUE_", "OVER_", "PARTITION_", "RANGE_", "PRECEDING_", 

1148 "UNBOUNDED_", "CURRENT_", "FOLLOWING_", "CUME_DIST_", 

1149 "DENSE_RANK_", "LAG_", "LAST_VALUE_", "LEAD_", "NTH_VALUE_", 

1150 "NTILE_", "PERCENT_RANK_", "RANK_", "ROW_NUMBER_", 

1151 "GENERATED_", "ALWAYS_", "STORED_", "TRUE_", "FALSE_", 

1152 "WINDOW_", "NULLS_", "FIRST_", "LAST_", "FILTER_", 

1153 "GROUPS_", "EXCLUDE_", "TIES_", "OTHERS_", "DO_", 

1154 "NOTHING_", "IDENTIFIER", "NUMERIC_LITERAL", "BIND_PARAMETER", 

1155 "STRING_LITERAL", "BLOB_LITERAL", "SINGLE_LINE_COMMENT", 

1156 "MULTILINE_COMMENT", "SPACES", "UNEXPECTED_CHAR" ] 

1157 

1158 RULE_parse = 0 

1159 RULE_sql_stmt_list = 1 

1160 RULE_sql_stmt = 2 

1161 RULE_alter_table_stmt = 3 

1162 RULE_analyze_stmt = 4 

1163 RULE_attach_stmt = 5 

1164 RULE_begin_stmt = 6 

1165 RULE_commit_stmt = 7 

1166 RULE_rollback_stmt = 8 

1167 RULE_savepoint_stmt = 9 

1168 RULE_release_stmt = 10 

1169 RULE_create_index_stmt = 11 

1170 RULE_indexed_column = 12 

1171 RULE_create_table_stmt = 13 

1172 RULE_column_def = 14 

1173 RULE_type_name = 15 

1174 RULE_column_constraint = 16 

1175 RULE_signed_number = 17 

1176 RULE_table_constraint = 18 

1177 RULE_foreign_key_clause = 19 

1178 RULE_conflict_clause = 20 

1179 RULE_create_trigger_stmt = 21 

1180 RULE_create_view_stmt = 22 

1181 RULE_create_virtual_table_stmt = 23 

1182 RULE_with_clause = 24 

1183 RULE_cte_table_name = 25 

1184 RULE_recursive_cte = 26 

1185 RULE_common_table_expression = 27 

1186 RULE_delete_stmt = 28 

1187 RULE_delete_stmt_limited = 29 

1188 RULE_detach_stmt = 30 

1189 RULE_drop_stmt = 31 

1190 RULE_expr = 32 

1191 RULE_raise_function = 33 

1192 RULE_literal_value = 34 

1193 RULE_insert_stmt = 35 

1194 RULE_upsert_clause = 36 

1195 RULE_pragma_stmt = 37 

1196 RULE_pragma_value = 38 

1197 RULE_reindex_stmt = 39 

1198 RULE_select_stmt = 40 

1199 RULE_join_clause = 41 

1200 RULE_select_core = 42 

1201 RULE_factored_select_stmt = 43 

1202 RULE_simple_select_stmt = 44 

1203 RULE_compound_select_stmt = 45 

1204 RULE_table_or_subquery = 46 

1205 RULE_result_column = 47 

1206 RULE_join_operator = 48 

1207 RULE_join_constraint = 49 

1208 RULE_compound_operator = 50 

1209 RULE_update_stmt = 51 

1210 RULE_column_name_list = 52 

1211 RULE_update_stmt_limited = 53 

1212 RULE_qualified_table_name = 54 

1213 RULE_vacuum_stmt = 55 

1214 RULE_filter_clause = 56 

1215 RULE_window_defn = 57 

1216 RULE_over_clause = 58 

1217 RULE_frame_spec = 59 

1218 RULE_frame_clause = 60 

1219 RULE_simple_function_invocation = 61 

1220 RULE_aggregate_function_invocation = 62 

1221 RULE_window_function_invocation = 63 

1222 RULE_common_table_stmt = 64 

1223 RULE_order_by_stmt = 65 

1224 RULE_limit_stmt = 66 

1225 RULE_ordering_term = 67 

1226 RULE_asc_desc = 68 

1227 RULE_frame_left = 69 

1228 RULE_frame_right = 70 

1229 RULE_frame_single = 71 

1230 RULE_window_function = 72 

1231 RULE_of_OF_fset = 73 

1232 RULE_default_DEFAULT__value = 74 

1233 RULE_partition_by = 75 

1234 RULE_order_by_expr = 76 

1235 RULE_order_by_expr_asc_desc = 77 

1236 RULE_expr_asc_desc = 78 

1237 RULE_initial_select = 79 

1238 RULE_recursive__select = 80 

1239 RULE_unary_operator = 81 

1240 RULE_error_message = 82 

1241 RULE_module_argument = 83 

1242 RULE_column_alias = 84 

1243 RULE_keyword = 85 

1244 RULE_name = 86 

1245 RULE_function_name = 87 

1246 RULE_schema_name = 88 

1247 RULE_table_name = 89 

1248 RULE_table_or_index_name = 90 

1249 RULE_new_table_name = 91 

1250 RULE_column_name = 92 

1251 RULE_collation_name = 93 

1252 RULE_foreign_table = 94 

1253 RULE_index_name = 95 

1254 RULE_trigger_name = 96 

1255 RULE_view_name = 97 

1256 RULE_module_name = 98 

1257 RULE_pragma_name = 99 

1258 RULE_savepoint_name = 100 

1259 RULE_table_alias = 101 

1260 RULE_transaction_name = 102 

1261 RULE_window_name = 103 

1262 RULE_alias = 104 

1263 RULE_filename = 105 

1264 RULE_base_window_name = 106 

1265 RULE_simple_func = 107 

1266 RULE_aggregate_func = 108 

1267 RULE_table_function_name = 109 

1268 RULE_any_name = 110 

1269 

1270 ruleNames = [ "parse", "sql_stmt_list", "sql_stmt", "alter_table_stmt", 

1271 "analyze_stmt", "attach_stmt", "begin_stmt", "commit_stmt", 

1272 "rollback_stmt", "savepoint_stmt", "release_stmt", "create_index_stmt", 

1273 "indexed_column", "create_table_stmt", "column_def", 

1274 "type_name", "column_constraint", "signed_number", "table_constraint", 

1275 "foreign_key_clause", "conflict_clause", "create_trigger_stmt", 

1276 "create_view_stmt", "create_virtual_table_stmt", "with_clause", 

1277 "cte_table_name", "recursive_cte", "common_table_expression", 

1278 "delete_stmt", "delete_stmt_limited", "detach_stmt", 

1279 "drop_stmt", "expr", "raise_function", "literal_value", 

1280 "insert_stmt", "upsert_clause", "pragma_stmt", "pragma_value", 

1281 "reindex_stmt", "select_stmt", "join_clause", "select_core", 

1282 "factored_select_stmt", "simple_select_stmt", "compound_select_stmt", 

1283 "table_or_subquery", "result_column", "join_operator", 

1284 "join_constraint", "compound_operator", "update_stmt", 

1285 "column_name_list", "update_stmt_limited", "qualified_table_name", 

1286 "vacuum_stmt", "filter_clause", "window_defn", "over_clause", 

1287 "frame_spec", "frame_clause", "simple_function_invocation", 

1288 "aggregate_function_invocation", "window_function_invocation", 

1289 "common_table_stmt", "order_by_stmt", "limit_stmt", "ordering_term", 

1290 "asc_desc", "frame_left", "frame_right", "frame_single", 

1291 "window_function", "of_OF_fset", "default_DEFAULT__value", 

1292 "partition_by", "order_by_expr", "order_by_expr_asc_desc", 

1293 "expr_asc_desc", "initial_select", "recursive__select", 

1294 "unary_operator", "error_message", "module_argument", 

1295 "column_alias", "keyword", "name", "function_name", "schema_name", 

1296 "table_name", "table_or_index_name", "new_table_name", 

1297 "column_name", "collation_name", "foreign_table", "index_name", 

1298 "trigger_name", "view_name", "module_name", "pragma_name", 

1299 "savepoint_name", "table_alias", "transaction_name", 

1300 "window_name", "alias", "filename", "base_window_name", 

1301 "simple_func", "aggregate_func", "table_function_name", 

1302 "any_name" ] 

1303 

1304 EOF = Token.EOF 

1305 SCOL=1 

1306 DOT=2 

1307 OPEN_PAR=3 

1308 CLOSE_PAR=4 

1309 COMMA=5 

1310 ASSIGN=6 

1311 STAR=7 

1312 PLUS=8 

1313 MINUS=9 

1314 TILDE=10 

1315 PIPE2=11 

1316 DIV=12 

1317 MOD=13 

1318 LT2=14 

1319 GT2=15 

1320 AMP=16 

1321 PIPE=17 

1322 LT=18 

1323 LT_EQ=19 

1324 GT=20 

1325 GT_EQ=21 

1326 EQ=22 

1327 NOT_EQ1=23 

1328 NOT_EQ2=24 

1329 ABORT_=25 

1330 ACTION_=26 

1331 ADD_=27 

1332 AFTER_=28 

1333 ALL_=29 

1334 ALTER_=30 

1335 ANALYZE_=31 

1336 AND_=32 

1337 AS_=33 

1338 ASC_=34 

1339 ATTACH_=35 

1340 AUTOINCREMENT_=36 

1341 BEFORE_=37 

1342 BEGIN_=38 

1343 BETWEEN_=39 

1344 BY_=40 

1345 CASCADE_=41 

1346 CASE_=42 

1347 CAST_=43 

1348 CHECK_=44 

1349 COLLATE_=45 

1350 COLUMN_=46 

1351 COMMIT_=47 

1352 CONFLICT_=48 

1353 CONSTRAINT_=49 

1354 CREATE_=50 

1355 CROSS_=51 

1356 CURRENT_DATE_=52 

1357 CURRENT_TIME_=53 

1358 CURRENT_TIMESTAMP_=54 

1359 DATABASE_=55 

1360 DEFAULT_=56 

1361 DEFERRABLE_=57 

1362 DEFERRED_=58 

1363 DELETE_=59 

1364 DESC_=60 

1365 DETACH_=61 

1366 DISTINCT_=62 

1367 DROP_=63 

1368 EACH_=64 

1369 ELSE_=65 

1370 END_=66 

1371 ESCAPE_=67 

1372 EXCEPT_=68 

1373 EXCLUSIVE_=69 

1374 EXISTS_=70 

1375 EXPLAIN_=71 

1376 FAIL_=72 

1377 FOR_=73 

1378 FOREIGN_=74 

1379 FROM_=75 

1380 FULL_=76 

1381 GLOB_=77 

1382 GROUP_=78 

1383 HAVING_=79 

1384 IF_=80 

1385 IGNORE_=81 

1386 IMMEDIATE_=82 

1387 IN_=83 

1388 INDEX_=84 

1389 INDEXED_=85 

1390 INITIALLY_=86 

1391 INNER_=87 

1392 INSERT_=88 

1393 INSTEAD_=89 

1394 INTERSECT_=90 

1395 INTO_=91 

1396 IS_=92 

1397 ISNULL_=93 

1398 JOIN_=94 

1399 KEY_=95 

1400 LEFT_=96 

1401 LIKE_=97 

1402 LIMIT_=98 

1403 MATCH_=99 

1404 NATURAL_=100 

1405 NO_=101 

1406 NOT_=102 

1407 NOTNULL_=103 

1408 NULL_=104 

1409 OF_=105 

1410 OFFSET_=106 

1411 ON_=107 

1412 OR_=108 

1413 ORDER_=109 

1414 OUTER_=110 

1415 PLAN_=111 

1416 PRAGMA_=112 

1417 PRIMARY_=113 

1418 QUERY_=114 

1419 RAISE_=115 

1420 RECURSIVE_=116 

1421 REFERENCES_=117 

1422 REGEXP_=118 

1423 REINDEX_=119 

1424 RELEASE_=120 

1425 RENAME_=121 

1426 REPLACE_=122 

1427 RESTRICT_=123 

1428 RIGHT_=124 

1429 ROLLBACK_=125 

1430 ROW_=126 

1431 ROWS_=127 

1432 SAVEPOINT_=128 

1433 SELECT_=129 

1434 SET_=130 

1435 TABLE_=131 

1436 TEMP_=132 

1437 TEMPORARY_=133 

1438 THEN_=134 

1439 TO_=135 

1440 TRANSACTION_=136 

1441 TRIGGER_=137 

1442 UNION_=138 

1443 UNIQUE_=139 

1444 UPDATE_=140 

1445 USING_=141 

1446 VACUUM_=142 

1447 VALUES_=143 

1448 VIEW_=144 

1449 VIRTUAL_=145 

1450 WHEN_=146 

1451 WHERE_=147 

1452 WITH_=148 

1453 WITHOUT_=149 

1454 FIRST_VALUE_=150 

1455 OVER_=151 

1456 PARTITION_=152 

1457 RANGE_=153 

1458 PRECEDING_=154 

1459 UNBOUNDED_=155 

1460 CURRENT_=156 

1461 FOLLOWING_=157 

1462 CUME_DIST_=158 

1463 DENSE_RANK_=159 

1464 LAG_=160 

1465 LAST_VALUE_=161 

1466 LEAD_=162 

1467 NTH_VALUE_=163 

1468 NTILE_=164 

1469 PERCENT_RANK_=165 

1470 RANK_=166 

1471 ROW_NUMBER_=167 

1472 GENERATED_=168 

1473 ALWAYS_=169 

1474 STORED_=170 

1475 TRUE_=171 

1476 FALSE_=172 

1477 WINDOW_=173 

1478 NULLS_=174 

1479 FIRST_=175 

1480 LAST_=176 

1481 FILTER_=177 

1482 GROUPS_=178 

1483 EXCLUDE_=179 

1484 TIES_=180 

1485 OTHERS_=181 

1486 DO_=182 

1487 NOTHING_=183 

1488 IDENTIFIER=184 

1489 NUMERIC_LITERAL=185 

1490 BIND_PARAMETER=186 

1491 STRING_LITERAL=187 

1492 BLOB_LITERAL=188 

1493 SINGLE_LINE_COMMENT=189 

1494 MULTILINE_COMMENT=190 

1495 SPACES=191 

1496 UNEXPECTED_CHAR=192 

1497 

1498 def __init__(self, input:TokenStream, output:TextIO = sys.stdout): 

1499 super().__init__(input, output) 

1500 self.checkVersion("4.9") 

1501 self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) 

1502 self._predicates = None 

1503 

1504 

1505 

1506 

1507 class ParseContext(ParserRuleContext): 

1508 

1509 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

1510 super().__init__(parent, invokingState) 

1511 self.parser = parser 

1512 

1513 def EOF(self): 

1514 return self.getToken(SQLiteParser.EOF, 0) 

1515 

1516 def sql_stmt_list(self, i:int=None): 

1517 if i is None: 

1518 return self.getTypedRuleContexts(SQLiteParser.Sql_stmt_listContext) 

1519 else: 

1520 return self.getTypedRuleContext(SQLiteParser.Sql_stmt_listContext,i) 

1521 

1522 

1523 def getRuleIndex(self): 

1524 return SQLiteParser.RULE_parse 

1525 

1526 def enterRule(self, listener:ParseTreeListener): 

1527 if hasattr( listener, "enterParse" ): 

1528 listener.enterParse(self) 

1529 

1530 def exitRule(self, listener:ParseTreeListener): 

1531 if hasattr( listener, "exitParse" ): 

1532 listener.exitParse(self) 

1533 

1534 

1535 

1536 

1537 def parse(self): 

1538 

1539 localctx = SQLiteParser.ParseContext(self, self._ctx, self.state) 

1540 self.enterRule(localctx, 0, self.RULE_parse) 

1541 self._la = 0 # Token type 

1542 try: 

1543 self.enterOuterAlt(localctx, 1) 

1544 self.state = 225 

1545 self._errHandler.sync(self) 

1546 _la = self._input.LA(1) 

1547 while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.SCOL) | (1 << SQLiteParser.ALTER_) | (1 << SQLiteParser.ANALYZE_) | (1 << SQLiteParser.ATTACH_) | (1 << SQLiteParser.BEGIN_) | (1 << SQLiteParser.COMMIT_) | (1 << SQLiteParser.CREATE_) | (1 << SQLiteParser.DEFAULT_) | (1 << SQLiteParser.DELETE_) | (1 << SQLiteParser.DETACH_) | (1 << SQLiteParser.DROP_))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (SQLiteParser.END_ - 66)) | (1 << (SQLiteParser.EXPLAIN_ - 66)) | (1 << (SQLiteParser.INSERT_ - 66)) | (1 << (SQLiteParser.PRAGMA_ - 66)) | (1 << (SQLiteParser.REINDEX_ - 66)) | (1 << (SQLiteParser.RELEASE_ - 66)) | (1 << (SQLiteParser.REPLACE_ - 66)) | (1 << (SQLiteParser.ROLLBACK_ - 66)) | (1 << (SQLiteParser.SAVEPOINT_ - 66)) | (1 << (SQLiteParser.SELECT_ - 66)))) != 0) or ((((_la - 140)) & ~0x3f) == 0 and ((1 << (_la - 140)) & ((1 << (SQLiteParser.UPDATE_ - 140)) | (1 << (SQLiteParser.VACUUM_ - 140)) | (1 << (SQLiteParser.VALUES_ - 140)) | (1 << (SQLiteParser.WITH_ - 140)))) != 0): 

1548 self.state = 222 

1549 self.sql_stmt_list() 

1550 self.state = 227 

1551 self._errHandler.sync(self) 

1552 _la = self._input.LA(1) 

1553 

1554 self.state = 228 

1555 self.match(SQLiteParser.EOF) 

1556 except RecognitionException as re: 

1557 localctx.exception = re 

1558 self._errHandler.reportError(self, re) 

1559 self._errHandler.recover(self, re) 

1560 finally: 

1561 self.exitRule() 

1562 return localctx 

1563 

1564 

1565 class Sql_stmt_listContext(ParserRuleContext): 

1566 

1567 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

1568 super().__init__(parent, invokingState) 

1569 self.parser = parser 

1570 

1571 def sql_stmt(self, i:int=None): 

1572 if i is None: 

1573 return self.getTypedRuleContexts(SQLiteParser.Sql_stmtContext) 

1574 else: 

1575 return self.getTypedRuleContext(SQLiteParser.Sql_stmtContext,i) 

1576 

1577 

1578 def SCOL(self, i:int=None): 

1579 if i is None: 

1580 return self.getTokens(SQLiteParser.SCOL) 

1581 else: 

1582 return self.getToken(SQLiteParser.SCOL, i) 

1583 

1584 def getRuleIndex(self): 

1585 return SQLiteParser.RULE_sql_stmt_list 

1586 

1587 def enterRule(self, listener:ParseTreeListener): 

1588 if hasattr( listener, "enterSql_stmt_list" ): 

1589 listener.enterSql_stmt_list(self) 

1590 

1591 def exitRule(self, listener:ParseTreeListener): 

1592 if hasattr( listener, "exitSql_stmt_list" ): 

1593 listener.exitSql_stmt_list(self) 

1594 

1595 

1596 

1597 

1598 def sql_stmt_list(self): 

1599 

1600 localctx = SQLiteParser.Sql_stmt_listContext(self, self._ctx, self.state) 

1601 self.enterRule(localctx, 2, self.RULE_sql_stmt_list) 

1602 self._la = 0 # Token type 

1603 try: 

1604 self.enterOuterAlt(localctx, 1) 

1605 self.state = 233 

1606 self._errHandler.sync(self) 

1607 _la = self._input.LA(1) 

1608 while _la==SQLiteParser.SCOL: 

1609 self.state = 230 

1610 self.match(SQLiteParser.SCOL) 

1611 self.state = 235 

1612 self._errHandler.sync(self) 

1613 _la = self._input.LA(1) 

1614 

1615 self.state = 236 

1616 self.sql_stmt() 

1617 self.state = 245 

1618 self._errHandler.sync(self) 

1619 _alt = self._interp.adaptivePredict(self._input,3,self._ctx) 

1620 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: 

1621 if _alt==1: 

1622 self.state = 238 

1623 self._errHandler.sync(self) 

1624 _la = self._input.LA(1) 

1625 while True: 

1626 self.state = 237 

1627 self.match(SQLiteParser.SCOL) 

1628 self.state = 240 

1629 self._errHandler.sync(self) 

1630 _la = self._input.LA(1) 

1631 if not (_la==SQLiteParser.SCOL): 

1632 break 

1633 

1634 self.state = 242 

1635 self.sql_stmt() 

1636 self.state = 247 

1637 self._errHandler.sync(self) 

1638 _alt = self._interp.adaptivePredict(self._input,3,self._ctx) 

1639 

1640 self.state = 251 

1641 self._errHandler.sync(self) 

1642 _alt = self._interp.adaptivePredict(self._input,4,self._ctx) 

1643 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: 

1644 if _alt==1: 

1645 self.state = 248 

1646 self.match(SQLiteParser.SCOL) 

1647 self.state = 253 

1648 self._errHandler.sync(self) 

1649 _alt = self._interp.adaptivePredict(self._input,4,self._ctx) 

1650 

1651 except RecognitionException as re: 

1652 localctx.exception = re 

1653 self._errHandler.reportError(self, re) 

1654 self._errHandler.recover(self, re) 

1655 finally: 

1656 self.exitRule() 

1657 return localctx 

1658 

1659 

1660 class Sql_stmtContext(ParserRuleContext): 

1661 

1662 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

1663 super().__init__(parent, invokingState) 

1664 self.parser = parser 

1665 

1666 def alter_table_stmt(self): 

1667 return self.getTypedRuleContext(SQLiteParser.Alter_table_stmtContext,0) 

1668 

1669 

1670 def analyze_stmt(self): 

1671 return self.getTypedRuleContext(SQLiteParser.Analyze_stmtContext,0) 

1672 

1673 

1674 def attach_stmt(self): 

1675 return self.getTypedRuleContext(SQLiteParser.Attach_stmtContext,0) 

1676 

1677 

1678 def begin_stmt(self): 

1679 return self.getTypedRuleContext(SQLiteParser.Begin_stmtContext,0) 

1680 

1681 

1682 def commit_stmt(self): 

1683 return self.getTypedRuleContext(SQLiteParser.Commit_stmtContext,0) 

1684 

1685 

1686 def create_index_stmt(self): 

1687 return self.getTypedRuleContext(SQLiteParser.Create_index_stmtContext,0) 

1688 

1689 

1690 def create_table_stmt(self): 

1691 return self.getTypedRuleContext(SQLiteParser.Create_table_stmtContext,0) 

1692 

1693 

1694 def create_trigger_stmt(self): 

1695 return self.getTypedRuleContext(SQLiteParser.Create_trigger_stmtContext,0) 

1696 

1697 

1698 def create_view_stmt(self): 

1699 return self.getTypedRuleContext(SQLiteParser.Create_view_stmtContext,0) 

1700 

1701 

1702 def create_virtual_table_stmt(self): 

1703 return self.getTypedRuleContext(SQLiteParser.Create_virtual_table_stmtContext,0) 

1704 

1705 

1706 def delete_stmt(self): 

1707 return self.getTypedRuleContext(SQLiteParser.Delete_stmtContext,0) 

1708 

1709 

1710 def delete_stmt_limited(self): 

1711 return self.getTypedRuleContext(SQLiteParser.Delete_stmt_limitedContext,0) 

1712 

1713 

1714 def detach_stmt(self): 

1715 return self.getTypedRuleContext(SQLiteParser.Detach_stmtContext,0) 

1716 

1717 

1718 def drop_stmt(self): 

1719 return self.getTypedRuleContext(SQLiteParser.Drop_stmtContext,0) 

1720 

1721 

1722 def insert_stmt(self): 

1723 return self.getTypedRuleContext(SQLiteParser.Insert_stmtContext,0) 

1724 

1725 

1726 def pragma_stmt(self): 

1727 return self.getTypedRuleContext(SQLiteParser.Pragma_stmtContext,0) 

1728 

1729 

1730 def reindex_stmt(self): 

1731 return self.getTypedRuleContext(SQLiteParser.Reindex_stmtContext,0) 

1732 

1733 

1734 def release_stmt(self): 

1735 return self.getTypedRuleContext(SQLiteParser.Release_stmtContext,0) 

1736 

1737 

1738 def rollback_stmt(self): 

1739 return self.getTypedRuleContext(SQLiteParser.Rollback_stmtContext,0) 

1740 

1741 

1742 def savepoint_stmt(self): 

1743 return self.getTypedRuleContext(SQLiteParser.Savepoint_stmtContext,0) 

1744 

1745 

1746 def select_stmt(self): 

1747 return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0) 

1748 

1749 

1750 def update_stmt(self): 

1751 return self.getTypedRuleContext(SQLiteParser.Update_stmtContext,0) 

1752 

1753 

1754 def update_stmt_limited(self): 

1755 return self.getTypedRuleContext(SQLiteParser.Update_stmt_limitedContext,0) 

1756 

1757 

1758 def vacuum_stmt(self): 

1759 return self.getTypedRuleContext(SQLiteParser.Vacuum_stmtContext,0) 

1760 

1761 

1762 def EXPLAIN_(self): 

1763 return self.getToken(SQLiteParser.EXPLAIN_, 0) 

1764 

1765 def QUERY_(self): 

1766 return self.getToken(SQLiteParser.QUERY_, 0) 

1767 

1768 def PLAN_(self): 

1769 return self.getToken(SQLiteParser.PLAN_, 0) 

1770 

1771 def getRuleIndex(self): 

1772 return SQLiteParser.RULE_sql_stmt 

1773 

1774 def enterRule(self, listener:ParseTreeListener): 

1775 if hasattr( listener, "enterSql_stmt" ): 

1776 listener.enterSql_stmt(self) 

1777 

1778 def exitRule(self, listener:ParseTreeListener): 

1779 if hasattr( listener, "exitSql_stmt" ): 

1780 listener.exitSql_stmt(self) 

1781 

1782 

1783 

1784 

1785 def sql_stmt(self): 

1786 

1787 localctx = SQLiteParser.Sql_stmtContext(self, self._ctx, self.state) 

1788 self.enterRule(localctx, 4, self.RULE_sql_stmt) 

1789 self._la = 0 # Token type 

1790 try: 

1791 self.enterOuterAlt(localctx, 1) 

1792 self.state = 259 

1793 self._errHandler.sync(self) 

1794 _la = self._input.LA(1) 

1795 if _la==SQLiteParser.EXPLAIN_: 

1796 self.state = 254 

1797 self.match(SQLiteParser.EXPLAIN_) 

1798 self.state = 257 

1799 self._errHandler.sync(self) 

1800 _la = self._input.LA(1) 

1801 if _la==SQLiteParser.QUERY_: 

1802 self.state = 255 

1803 self.match(SQLiteParser.QUERY_) 

1804 self.state = 256 

1805 self.match(SQLiteParser.PLAN_) 

1806 

1807 

1808 

1809 

1810 self.state = 285 

1811 self._errHandler.sync(self) 

1812 la_ = self._interp.adaptivePredict(self._input,7,self._ctx) 

1813 if la_ == 1: 

1814 self.state = 261 

1815 self.alter_table_stmt() 

1816 pass 

1817 

1818 elif la_ == 2: 

1819 self.state = 262 

1820 self.analyze_stmt() 

1821 pass 

1822 

1823 elif la_ == 3: 

1824 self.state = 263 

1825 self.attach_stmt() 

1826 pass 

1827 

1828 elif la_ == 4: 

1829 self.state = 264 

1830 self.begin_stmt() 

1831 pass 

1832 

1833 elif la_ == 5: 

1834 self.state = 265 

1835 self.commit_stmt() 

1836 pass 

1837 

1838 elif la_ == 6: 

1839 self.state = 266 

1840 self.create_index_stmt() 

1841 pass 

1842 

1843 elif la_ == 7: 

1844 self.state = 267 

1845 self.create_table_stmt() 

1846 pass 

1847 

1848 elif la_ == 8: 

1849 self.state = 268 

1850 self.create_trigger_stmt() 

1851 pass 

1852 

1853 elif la_ == 9: 

1854 self.state = 269 

1855 self.create_view_stmt() 

1856 pass 

1857 

1858 elif la_ == 10: 

1859 self.state = 270 

1860 self.create_virtual_table_stmt() 

1861 pass 

1862 

1863 elif la_ == 11: 

1864 self.state = 271 

1865 self.delete_stmt() 

1866 pass 

1867 

1868 elif la_ == 12: 

1869 self.state = 272 

1870 self.delete_stmt_limited() 

1871 pass 

1872 

1873 elif la_ == 13: 

1874 self.state = 273 

1875 self.detach_stmt() 

1876 pass 

1877 

1878 elif la_ == 14: 

1879 self.state = 274 

1880 self.drop_stmt() 

1881 pass 

1882 

1883 elif la_ == 15: 

1884 self.state = 275 

1885 self.insert_stmt() 

1886 pass 

1887 

1888 elif la_ == 16: 

1889 self.state = 276 

1890 self.pragma_stmt() 

1891 pass 

1892 

1893 elif la_ == 17: 

1894 self.state = 277 

1895 self.reindex_stmt() 

1896 pass 

1897 

1898 elif la_ == 18: 

1899 self.state = 278 

1900 self.release_stmt() 

1901 pass 

1902 

1903 elif la_ == 19: 

1904 self.state = 279 

1905 self.rollback_stmt() 

1906 pass 

1907 

1908 elif la_ == 20: 

1909 self.state = 280 

1910 self.savepoint_stmt() 

1911 pass 

1912 

1913 elif la_ == 21: 

1914 self.state = 281 

1915 self.select_stmt() 

1916 pass 

1917 

1918 elif la_ == 22: 

1919 self.state = 282 

1920 self.update_stmt() 

1921 pass 

1922 

1923 elif la_ == 23: 

1924 self.state = 283 

1925 self.update_stmt_limited() 

1926 pass 

1927 

1928 elif la_ == 24: 

1929 self.state = 284 

1930 self.vacuum_stmt() 

1931 pass 

1932 

1933 

1934 except RecognitionException as re: 

1935 localctx.exception = re 

1936 self._errHandler.reportError(self, re) 

1937 self._errHandler.recover(self, re) 

1938 finally: 

1939 self.exitRule() 

1940 return localctx 

1941 

1942 

1943 class Alter_table_stmtContext(ParserRuleContext): 

1944 

1945 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

1946 super().__init__(parent, invokingState) 

1947 self.parser = parser 

1948 self.old_column_name = None # Column_nameContext 

1949 self.new_column_name = None # Column_nameContext 

1950 

1951 def ALTER_(self): 

1952 return self.getToken(SQLiteParser.ALTER_, 0) 

1953 

1954 def TABLE_(self): 

1955 return self.getToken(SQLiteParser.TABLE_, 0) 

1956 

1957 def table_name(self): 

1958 return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0) 

1959 

1960 

1961 def RENAME_(self): 

1962 return self.getToken(SQLiteParser.RENAME_, 0) 

1963 

1964 def ADD_(self): 

1965 return self.getToken(SQLiteParser.ADD_, 0) 

1966 

1967 def column_def(self): 

1968 return self.getTypedRuleContext(SQLiteParser.Column_defContext,0) 

1969 

1970 

1971 def schema_name(self): 

1972 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

1973 

1974 

1975 def DOT(self): 

1976 return self.getToken(SQLiteParser.DOT, 0) 

1977 

1978 def TO_(self): 

1979 return self.getToken(SQLiteParser.TO_, 0) 

1980 

1981 def new_table_name(self): 

1982 return self.getTypedRuleContext(SQLiteParser.New_table_nameContext,0) 

1983 

1984 

1985 def column_name(self, i:int=None): 

1986 if i is None: 

1987 return self.getTypedRuleContexts(SQLiteParser.Column_nameContext) 

1988 else: 

1989 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i) 

1990 

1991 

1992 def COLUMN_(self): 

1993 return self.getToken(SQLiteParser.COLUMN_, 0) 

1994 

1995 def getRuleIndex(self): 

1996 return SQLiteParser.RULE_alter_table_stmt 

1997 

1998 def enterRule(self, listener:ParseTreeListener): 

1999 if hasattr( listener, "enterAlter_table_stmt" ): 

2000 listener.enterAlter_table_stmt(self) 

2001 

2002 def exitRule(self, listener:ParseTreeListener): 

2003 if hasattr( listener, "exitAlter_table_stmt" ): 

2004 listener.exitAlter_table_stmt(self) 

2005 

2006 

2007 

2008 

2009 def alter_table_stmt(self): 

2010 

2011 localctx = SQLiteParser.Alter_table_stmtContext(self, self._ctx, self.state) 

2012 self.enterRule(localctx, 6, self.RULE_alter_table_stmt) 

2013 try: 

2014 self.enterOuterAlt(localctx, 1) 

2015 self.state = 287 

2016 self.match(SQLiteParser.ALTER_) 

2017 self.state = 288 

2018 self.match(SQLiteParser.TABLE_) 

2019 self.state = 292 

2020 self._errHandler.sync(self) 

2021 la_ = self._interp.adaptivePredict(self._input,8,self._ctx) 

2022 if la_ == 1: 

2023 self.state = 289 

2024 self.schema_name() 

2025 self.state = 290 

2026 self.match(SQLiteParser.DOT) 

2027 

2028 

2029 self.state = 294 

2030 self.table_name() 

2031 self.state = 312 

2032 self._errHandler.sync(self) 

2033 token = self._input.LA(1) 

2034 if token in [SQLiteParser.RENAME_]: 

2035 self.state = 295 

2036 self.match(SQLiteParser.RENAME_) 

2037 self.state = 305 

2038 self._errHandler.sync(self) 

2039 la_ = self._interp.adaptivePredict(self._input,10,self._ctx) 

2040 if la_ == 1: 

2041 self.state = 296 

2042 self.match(SQLiteParser.TO_) 

2043 self.state = 297 

2044 self.new_table_name() 

2045 pass 

2046 

2047 elif la_ == 2: 

2048 self.state = 299 

2049 self._errHandler.sync(self) 

2050 la_ = self._interp.adaptivePredict(self._input,9,self._ctx) 

2051 if la_ == 1: 

2052 self.state = 298 

2053 self.match(SQLiteParser.COLUMN_) 

2054 

2055 

2056 self.state = 301 

2057 localctx.old_column_name = self.column_name() 

2058 self.state = 302 

2059 self.match(SQLiteParser.TO_) 

2060 self.state = 303 

2061 localctx.new_column_name = self.column_name() 

2062 pass 

2063 

2064 

2065 pass 

2066 elif token in [SQLiteParser.ADD_]: 

2067 self.state = 307 

2068 self.match(SQLiteParser.ADD_) 

2069 self.state = 309 

2070 self._errHandler.sync(self) 

2071 la_ = self._interp.adaptivePredict(self._input,11,self._ctx) 

2072 if la_ == 1: 

2073 self.state = 308 

2074 self.match(SQLiteParser.COLUMN_) 

2075 

2076 

2077 self.state = 311 

2078 self.column_def() 

2079 pass 

2080 else: 

2081 raise NoViableAltException(self) 

2082 

2083 except RecognitionException as re: 

2084 localctx.exception = re 

2085 self._errHandler.reportError(self, re) 

2086 self._errHandler.recover(self, re) 

2087 finally: 

2088 self.exitRule() 

2089 return localctx 

2090 

2091 

2092 class Analyze_stmtContext(ParserRuleContext): 

2093 

2094 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

2095 super().__init__(parent, invokingState) 

2096 self.parser = parser 

2097 

2098 def ANALYZE_(self): 

2099 return self.getToken(SQLiteParser.ANALYZE_, 0) 

2100 

2101 def schema_name(self): 

2102 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

2103 

2104 

2105 def table_or_index_name(self): 

2106 return self.getTypedRuleContext(SQLiteParser.Table_or_index_nameContext,0) 

2107 

2108 

2109 def DOT(self): 

2110 return self.getToken(SQLiteParser.DOT, 0) 

2111 

2112 def getRuleIndex(self): 

2113 return SQLiteParser.RULE_analyze_stmt 

2114 

2115 def enterRule(self, listener:ParseTreeListener): 

2116 if hasattr( listener, "enterAnalyze_stmt" ): 

2117 listener.enterAnalyze_stmt(self) 

2118 

2119 def exitRule(self, listener:ParseTreeListener): 

2120 if hasattr( listener, "exitAnalyze_stmt" ): 

2121 listener.exitAnalyze_stmt(self) 

2122 

2123 

2124 

2125 

2126 def analyze_stmt(self): 

2127 

2128 localctx = SQLiteParser.Analyze_stmtContext(self, self._ctx, self.state) 

2129 self.enterRule(localctx, 8, self.RULE_analyze_stmt) 

2130 try: 

2131 self.enterOuterAlt(localctx, 1) 

2132 self.state = 314 

2133 self.match(SQLiteParser.ANALYZE_) 

2134 self.state = 322 

2135 self._errHandler.sync(self) 

2136 la_ = self._interp.adaptivePredict(self._input,14,self._ctx) 

2137 if la_ == 1: 

2138 self.state = 315 

2139 self.schema_name() 

2140 

2141 elif la_ == 2: 

2142 self.state = 319 

2143 self._errHandler.sync(self) 

2144 la_ = self._interp.adaptivePredict(self._input,13,self._ctx) 

2145 if la_ == 1: 

2146 self.state = 316 

2147 self.schema_name() 

2148 self.state = 317 

2149 self.match(SQLiteParser.DOT) 

2150 

2151 

2152 self.state = 321 

2153 self.table_or_index_name() 

2154 

2155 

2156 except RecognitionException as re: 

2157 localctx.exception = re 

2158 self._errHandler.reportError(self, re) 

2159 self._errHandler.recover(self, re) 

2160 finally: 

2161 self.exitRule() 

2162 return localctx 

2163 

2164 

2165 class Attach_stmtContext(ParserRuleContext): 

2166 

2167 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

2168 super().__init__(parent, invokingState) 

2169 self.parser = parser 

2170 

2171 def ATTACH_(self): 

2172 return self.getToken(SQLiteParser.ATTACH_, 0) 

2173 

2174 def expr(self): 

2175 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

2176 

2177 

2178 def AS_(self): 

2179 return self.getToken(SQLiteParser.AS_, 0) 

2180 

2181 def schema_name(self): 

2182 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

2183 

2184 

2185 def DATABASE_(self): 

2186 return self.getToken(SQLiteParser.DATABASE_, 0) 

2187 

2188 def getRuleIndex(self): 

2189 return SQLiteParser.RULE_attach_stmt 

2190 

2191 def enterRule(self, listener:ParseTreeListener): 

2192 if hasattr( listener, "enterAttach_stmt" ): 

2193 listener.enterAttach_stmt(self) 

2194 

2195 def exitRule(self, listener:ParseTreeListener): 

2196 if hasattr( listener, "exitAttach_stmt" ): 

2197 listener.exitAttach_stmt(self) 

2198 

2199 

2200 

2201 

2202 def attach_stmt(self): 

2203 

2204 localctx = SQLiteParser.Attach_stmtContext(self, self._ctx, self.state) 

2205 self.enterRule(localctx, 10, self.RULE_attach_stmt) 

2206 try: 

2207 self.enterOuterAlt(localctx, 1) 

2208 self.state = 324 

2209 self.match(SQLiteParser.ATTACH_) 

2210 self.state = 326 

2211 self._errHandler.sync(self) 

2212 la_ = self._interp.adaptivePredict(self._input,15,self._ctx) 

2213 if la_ == 1: 

2214 self.state = 325 

2215 self.match(SQLiteParser.DATABASE_) 

2216 

2217 

2218 self.state = 328 

2219 self.expr(0) 

2220 self.state = 329 

2221 self.match(SQLiteParser.AS_) 

2222 self.state = 330 

2223 self.schema_name() 

2224 except RecognitionException as re: 

2225 localctx.exception = re 

2226 self._errHandler.reportError(self, re) 

2227 self._errHandler.recover(self, re) 

2228 finally: 

2229 self.exitRule() 

2230 return localctx 

2231 

2232 

2233 class Begin_stmtContext(ParserRuleContext): 

2234 

2235 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

2236 super().__init__(parent, invokingState) 

2237 self.parser = parser 

2238 

2239 def BEGIN_(self): 

2240 return self.getToken(SQLiteParser.BEGIN_, 0) 

2241 

2242 def TRANSACTION_(self): 

2243 return self.getToken(SQLiteParser.TRANSACTION_, 0) 

2244 

2245 def DEFERRED_(self): 

2246 return self.getToken(SQLiteParser.DEFERRED_, 0) 

2247 

2248 def IMMEDIATE_(self): 

2249 return self.getToken(SQLiteParser.IMMEDIATE_, 0) 

2250 

2251 def EXCLUSIVE_(self): 

2252 return self.getToken(SQLiteParser.EXCLUSIVE_, 0) 

2253 

2254 def transaction_name(self): 

2255 return self.getTypedRuleContext(SQLiteParser.Transaction_nameContext,0) 

2256 

2257 

2258 def getRuleIndex(self): 

2259 return SQLiteParser.RULE_begin_stmt 

2260 

2261 def enterRule(self, listener:ParseTreeListener): 

2262 if hasattr( listener, "enterBegin_stmt" ): 

2263 listener.enterBegin_stmt(self) 

2264 

2265 def exitRule(self, listener:ParseTreeListener): 

2266 if hasattr( listener, "exitBegin_stmt" ): 

2267 listener.exitBegin_stmt(self) 

2268 

2269 

2270 

2271 

2272 def begin_stmt(self): 

2273 

2274 localctx = SQLiteParser.Begin_stmtContext(self, self._ctx, self.state) 

2275 self.enterRule(localctx, 12, self.RULE_begin_stmt) 

2276 self._la = 0 # Token type 

2277 try: 

2278 self.enterOuterAlt(localctx, 1) 

2279 self.state = 332 

2280 self.match(SQLiteParser.BEGIN_) 

2281 self.state = 334 

2282 self._errHandler.sync(self) 

2283 _la = self._input.LA(1) 

2284 if ((((_la - 58)) & ~0x3f) == 0 and ((1 << (_la - 58)) & ((1 << (SQLiteParser.DEFERRED_ - 58)) | (1 << (SQLiteParser.EXCLUSIVE_ - 58)) | (1 << (SQLiteParser.IMMEDIATE_ - 58)))) != 0): 

2285 self.state = 333 

2286 _la = self._input.LA(1) 

2287 if not(((((_la - 58)) & ~0x3f) == 0 and ((1 << (_la - 58)) & ((1 << (SQLiteParser.DEFERRED_ - 58)) | (1 << (SQLiteParser.EXCLUSIVE_ - 58)) | (1 << (SQLiteParser.IMMEDIATE_ - 58)))) != 0)): 

2288 self._errHandler.recoverInline(self) 

2289 else: 

2290 self._errHandler.reportMatch(self) 

2291 self.consume() 

2292 

2293 

2294 self.state = 340 

2295 self._errHandler.sync(self) 

2296 _la = self._input.LA(1) 

2297 if _la==SQLiteParser.TRANSACTION_: 

2298 self.state = 336 

2299 self.match(SQLiteParser.TRANSACTION_) 

2300 self.state = 338 

2301 self._errHandler.sync(self) 

2302 la_ = self._interp.adaptivePredict(self._input,17,self._ctx) 

2303 if la_ == 1: 

2304 self.state = 337 

2305 self.transaction_name() 

2306 

2307 

2308 

2309 

2310 except RecognitionException as re: 

2311 localctx.exception = re 

2312 self._errHandler.reportError(self, re) 

2313 self._errHandler.recover(self, re) 

2314 finally: 

2315 self.exitRule() 

2316 return localctx 

2317 

2318 

2319 class Commit_stmtContext(ParserRuleContext): 

2320 

2321 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

2322 super().__init__(parent, invokingState) 

2323 self.parser = parser 

2324 

2325 def COMMIT_(self): 

2326 return self.getToken(SQLiteParser.COMMIT_, 0) 

2327 

2328 def END_(self): 

2329 return self.getToken(SQLiteParser.END_, 0) 

2330 

2331 def TRANSACTION_(self): 

2332 return self.getToken(SQLiteParser.TRANSACTION_, 0) 

2333 

2334 def getRuleIndex(self): 

2335 return SQLiteParser.RULE_commit_stmt 

2336 

2337 def enterRule(self, listener:ParseTreeListener): 

2338 if hasattr( listener, "enterCommit_stmt" ): 

2339 listener.enterCommit_stmt(self) 

2340 

2341 def exitRule(self, listener:ParseTreeListener): 

2342 if hasattr( listener, "exitCommit_stmt" ): 

2343 listener.exitCommit_stmt(self) 

2344 

2345 

2346 

2347 

2348 def commit_stmt(self): 

2349 

2350 localctx = SQLiteParser.Commit_stmtContext(self, self._ctx, self.state) 

2351 self.enterRule(localctx, 14, self.RULE_commit_stmt) 

2352 self._la = 0 # Token type 

2353 try: 

2354 self.enterOuterAlt(localctx, 1) 

2355 self.state = 342 

2356 _la = self._input.LA(1) 

2357 if not(_la==SQLiteParser.COMMIT_ or _la==SQLiteParser.END_): 

2358 self._errHandler.recoverInline(self) 

2359 else: 

2360 self._errHandler.reportMatch(self) 

2361 self.consume() 

2362 self.state = 344 

2363 self._errHandler.sync(self) 

2364 _la = self._input.LA(1) 

2365 if _la==SQLiteParser.TRANSACTION_: 

2366 self.state = 343 

2367 self.match(SQLiteParser.TRANSACTION_) 

2368 

2369 

2370 except RecognitionException as re: 

2371 localctx.exception = re 

2372 self._errHandler.reportError(self, re) 

2373 self._errHandler.recover(self, re) 

2374 finally: 

2375 self.exitRule() 

2376 return localctx 

2377 

2378 

2379 class Rollback_stmtContext(ParserRuleContext): 

2380 

2381 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

2382 super().__init__(parent, invokingState) 

2383 self.parser = parser 

2384 

2385 def ROLLBACK_(self): 

2386 return self.getToken(SQLiteParser.ROLLBACK_, 0) 

2387 

2388 def TRANSACTION_(self): 

2389 return self.getToken(SQLiteParser.TRANSACTION_, 0) 

2390 

2391 def TO_(self): 

2392 return self.getToken(SQLiteParser.TO_, 0) 

2393 

2394 def savepoint_name(self): 

2395 return self.getTypedRuleContext(SQLiteParser.Savepoint_nameContext,0) 

2396 

2397 

2398 def SAVEPOINT_(self): 

2399 return self.getToken(SQLiteParser.SAVEPOINT_, 0) 

2400 

2401 def getRuleIndex(self): 

2402 return SQLiteParser.RULE_rollback_stmt 

2403 

2404 def enterRule(self, listener:ParseTreeListener): 

2405 if hasattr( listener, "enterRollback_stmt" ): 

2406 listener.enterRollback_stmt(self) 

2407 

2408 def exitRule(self, listener:ParseTreeListener): 

2409 if hasattr( listener, "exitRollback_stmt" ): 

2410 listener.exitRollback_stmt(self) 

2411 

2412 

2413 

2414 

2415 def rollback_stmt(self): 

2416 

2417 localctx = SQLiteParser.Rollback_stmtContext(self, self._ctx, self.state) 

2418 self.enterRule(localctx, 16, self.RULE_rollback_stmt) 

2419 self._la = 0 # Token type 

2420 try: 

2421 self.enterOuterAlt(localctx, 1) 

2422 self.state = 346 

2423 self.match(SQLiteParser.ROLLBACK_) 

2424 self.state = 348 

2425 self._errHandler.sync(self) 

2426 _la = self._input.LA(1) 

2427 if _la==SQLiteParser.TRANSACTION_: 

2428 self.state = 347 

2429 self.match(SQLiteParser.TRANSACTION_) 

2430 

2431 

2432 self.state = 355 

2433 self._errHandler.sync(self) 

2434 _la = self._input.LA(1) 

2435 if _la==SQLiteParser.TO_: 

2436 self.state = 350 

2437 self.match(SQLiteParser.TO_) 

2438 self.state = 352 

2439 self._errHandler.sync(self) 

2440 la_ = self._interp.adaptivePredict(self._input,21,self._ctx) 

2441 if la_ == 1: 

2442 self.state = 351 

2443 self.match(SQLiteParser.SAVEPOINT_) 

2444 

2445 

2446 self.state = 354 

2447 self.savepoint_name() 

2448 

2449 

2450 except RecognitionException as re: 

2451 localctx.exception = re 

2452 self._errHandler.reportError(self, re) 

2453 self._errHandler.recover(self, re) 

2454 finally: 

2455 self.exitRule() 

2456 return localctx 

2457 

2458 

2459 class Savepoint_stmtContext(ParserRuleContext): 

2460 

2461 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

2462 super().__init__(parent, invokingState) 

2463 self.parser = parser 

2464 

2465 def SAVEPOINT_(self): 

2466 return self.getToken(SQLiteParser.SAVEPOINT_, 0) 

2467 

2468 def savepoint_name(self): 

2469 return self.getTypedRuleContext(SQLiteParser.Savepoint_nameContext,0) 

2470 

2471 

2472 def getRuleIndex(self): 

2473 return SQLiteParser.RULE_savepoint_stmt 

2474 

2475 def enterRule(self, listener:ParseTreeListener): 

2476 if hasattr( listener, "enterSavepoint_stmt" ): 

2477 listener.enterSavepoint_stmt(self) 

2478 

2479 def exitRule(self, listener:ParseTreeListener): 

2480 if hasattr( listener, "exitSavepoint_stmt" ): 

2481 listener.exitSavepoint_stmt(self) 

2482 

2483 

2484 

2485 

2486 def savepoint_stmt(self): 

2487 

2488 localctx = SQLiteParser.Savepoint_stmtContext(self, self._ctx, self.state) 

2489 self.enterRule(localctx, 18, self.RULE_savepoint_stmt) 

2490 try: 

2491 self.enterOuterAlt(localctx, 1) 

2492 self.state = 357 

2493 self.match(SQLiteParser.SAVEPOINT_) 

2494 self.state = 358 

2495 self.savepoint_name() 

2496 except RecognitionException as re: 

2497 localctx.exception = re 

2498 self._errHandler.reportError(self, re) 

2499 self._errHandler.recover(self, re) 

2500 finally: 

2501 self.exitRule() 

2502 return localctx 

2503 

2504 

2505 class Release_stmtContext(ParserRuleContext): 

2506 

2507 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

2508 super().__init__(parent, invokingState) 

2509 self.parser = parser 

2510 

2511 def RELEASE_(self): 

2512 return self.getToken(SQLiteParser.RELEASE_, 0) 

2513 

2514 def savepoint_name(self): 

2515 return self.getTypedRuleContext(SQLiteParser.Savepoint_nameContext,0) 

2516 

2517 

2518 def SAVEPOINT_(self): 

2519 return self.getToken(SQLiteParser.SAVEPOINT_, 0) 

2520 

2521 def getRuleIndex(self): 

2522 return SQLiteParser.RULE_release_stmt 

2523 

2524 def enterRule(self, listener:ParseTreeListener): 

2525 if hasattr( listener, "enterRelease_stmt" ): 

2526 listener.enterRelease_stmt(self) 

2527 

2528 def exitRule(self, listener:ParseTreeListener): 

2529 if hasattr( listener, "exitRelease_stmt" ): 

2530 listener.exitRelease_stmt(self) 

2531 

2532 

2533 

2534 

2535 def release_stmt(self): 

2536 

2537 localctx = SQLiteParser.Release_stmtContext(self, self._ctx, self.state) 

2538 self.enterRule(localctx, 20, self.RULE_release_stmt) 

2539 try: 

2540 self.enterOuterAlt(localctx, 1) 

2541 self.state = 360 

2542 self.match(SQLiteParser.RELEASE_) 

2543 self.state = 362 

2544 self._errHandler.sync(self) 

2545 la_ = self._interp.adaptivePredict(self._input,23,self._ctx) 

2546 if la_ == 1: 

2547 self.state = 361 

2548 self.match(SQLiteParser.SAVEPOINT_) 

2549 

2550 

2551 self.state = 364 

2552 self.savepoint_name() 

2553 except RecognitionException as re: 

2554 localctx.exception = re 

2555 self._errHandler.reportError(self, re) 

2556 self._errHandler.recover(self, re) 

2557 finally: 

2558 self.exitRule() 

2559 return localctx 

2560 

2561 

2562 class Create_index_stmtContext(ParserRuleContext): 

2563 

2564 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

2565 super().__init__(parent, invokingState) 

2566 self.parser = parser 

2567 

2568 def CREATE_(self): 

2569 return self.getToken(SQLiteParser.CREATE_, 0) 

2570 

2571 def INDEX_(self): 

2572 return self.getToken(SQLiteParser.INDEX_, 0) 

2573 

2574 def index_name(self): 

2575 return self.getTypedRuleContext(SQLiteParser.Index_nameContext,0) 

2576 

2577 

2578 def ON_(self): 

2579 return self.getToken(SQLiteParser.ON_, 0) 

2580 

2581 def table_name(self): 

2582 return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0) 

2583 

2584 

2585 def OPEN_PAR(self): 

2586 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

2587 

2588 def indexed_column(self, i:int=None): 

2589 if i is None: 

2590 return self.getTypedRuleContexts(SQLiteParser.Indexed_columnContext) 

2591 else: 

2592 return self.getTypedRuleContext(SQLiteParser.Indexed_columnContext,i) 

2593 

2594 

2595 def CLOSE_PAR(self): 

2596 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

2597 

2598 def UNIQUE_(self): 

2599 return self.getToken(SQLiteParser.UNIQUE_, 0) 

2600 

2601 def IF_(self): 

2602 return self.getToken(SQLiteParser.IF_, 0) 

2603 

2604 def NOT_(self): 

2605 return self.getToken(SQLiteParser.NOT_, 0) 

2606 

2607 def EXISTS_(self): 

2608 return self.getToken(SQLiteParser.EXISTS_, 0) 

2609 

2610 def schema_name(self): 

2611 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

2612 

2613 

2614 def DOT(self): 

2615 return self.getToken(SQLiteParser.DOT, 0) 

2616 

2617 def COMMA(self, i:int=None): 

2618 if i is None: 

2619 return self.getTokens(SQLiteParser.COMMA) 

2620 else: 

2621 return self.getToken(SQLiteParser.COMMA, i) 

2622 

2623 def WHERE_(self): 

2624 return self.getToken(SQLiteParser.WHERE_, 0) 

2625 

2626 def expr(self): 

2627 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

2628 

2629 

2630 def getRuleIndex(self): 

2631 return SQLiteParser.RULE_create_index_stmt 

2632 

2633 def enterRule(self, listener:ParseTreeListener): 

2634 if hasattr( listener, "enterCreate_index_stmt" ): 

2635 listener.enterCreate_index_stmt(self) 

2636 

2637 def exitRule(self, listener:ParseTreeListener): 

2638 if hasattr( listener, "exitCreate_index_stmt" ): 

2639 listener.exitCreate_index_stmt(self) 

2640 

2641 

2642 

2643 

2644 def create_index_stmt(self): 

2645 

2646 localctx = SQLiteParser.Create_index_stmtContext(self, self._ctx, self.state) 

2647 self.enterRule(localctx, 22, self.RULE_create_index_stmt) 

2648 self._la = 0 # Token type 

2649 try: 

2650 self.enterOuterAlt(localctx, 1) 

2651 self.state = 366 

2652 self.match(SQLiteParser.CREATE_) 

2653 self.state = 368 

2654 self._errHandler.sync(self) 

2655 _la = self._input.LA(1) 

2656 if _la==SQLiteParser.UNIQUE_: 

2657 self.state = 367 

2658 self.match(SQLiteParser.UNIQUE_) 

2659 

2660 

2661 self.state = 370 

2662 self.match(SQLiteParser.INDEX_) 

2663 self.state = 374 

2664 self._errHandler.sync(self) 

2665 la_ = self._interp.adaptivePredict(self._input,25,self._ctx) 

2666 if la_ == 1: 

2667 self.state = 371 

2668 self.match(SQLiteParser.IF_) 

2669 self.state = 372 

2670 self.match(SQLiteParser.NOT_) 

2671 self.state = 373 

2672 self.match(SQLiteParser.EXISTS_) 

2673 

2674 

2675 self.state = 379 

2676 self._errHandler.sync(self) 

2677 la_ = self._interp.adaptivePredict(self._input,26,self._ctx) 

2678 if la_ == 1: 

2679 self.state = 376 

2680 self.schema_name() 

2681 self.state = 377 

2682 self.match(SQLiteParser.DOT) 

2683 

2684 

2685 self.state = 381 

2686 self.index_name() 

2687 self.state = 382 

2688 self.match(SQLiteParser.ON_) 

2689 self.state = 383 

2690 self.table_name() 

2691 self.state = 384 

2692 self.match(SQLiteParser.OPEN_PAR) 

2693 self.state = 385 

2694 self.indexed_column() 

2695 self.state = 390 

2696 self._errHandler.sync(self) 

2697 _la = self._input.LA(1) 

2698 while _la==SQLiteParser.COMMA: 

2699 self.state = 386 

2700 self.match(SQLiteParser.COMMA) 

2701 self.state = 387 

2702 self.indexed_column() 

2703 self.state = 392 

2704 self._errHandler.sync(self) 

2705 _la = self._input.LA(1) 

2706 

2707 self.state = 393 

2708 self.match(SQLiteParser.CLOSE_PAR) 

2709 self.state = 396 

2710 self._errHandler.sync(self) 

2711 _la = self._input.LA(1) 

2712 if _la==SQLiteParser.WHERE_: 

2713 self.state = 394 

2714 self.match(SQLiteParser.WHERE_) 

2715 self.state = 395 

2716 self.expr(0) 

2717 

2718 

2719 except RecognitionException as re: 

2720 localctx.exception = re 

2721 self._errHandler.reportError(self, re) 

2722 self._errHandler.recover(self, re) 

2723 finally: 

2724 self.exitRule() 

2725 return localctx 

2726 

2727 

2728 class Indexed_columnContext(ParserRuleContext): 

2729 

2730 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

2731 super().__init__(parent, invokingState) 

2732 self.parser = parser 

2733 

2734 def column_name(self): 

2735 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,0) 

2736 

2737 

2738 def expr(self): 

2739 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

2740 

2741 

2742 def COLLATE_(self): 

2743 return self.getToken(SQLiteParser.COLLATE_, 0) 

2744 

2745 def collation_name(self): 

2746 return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0) 

2747 

2748 

2749 def asc_desc(self): 

2750 return self.getTypedRuleContext(SQLiteParser.Asc_descContext,0) 

2751 

2752 

2753 def getRuleIndex(self): 

2754 return SQLiteParser.RULE_indexed_column 

2755 

2756 def enterRule(self, listener:ParseTreeListener): 

2757 if hasattr( listener, "enterIndexed_column" ): 

2758 listener.enterIndexed_column(self) 

2759 

2760 def exitRule(self, listener:ParseTreeListener): 

2761 if hasattr( listener, "exitIndexed_column" ): 

2762 listener.exitIndexed_column(self) 

2763 

2764 

2765 

2766 

2767 def indexed_column(self): 

2768 

2769 localctx = SQLiteParser.Indexed_columnContext(self, self._ctx, self.state) 

2770 self.enterRule(localctx, 24, self.RULE_indexed_column) 

2771 self._la = 0 # Token type 

2772 try: 

2773 self.enterOuterAlt(localctx, 1) 

2774 self.state = 400 

2775 self._errHandler.sync(self) 

2776 la_ = self._interp.adaptivePredict(self._input,29,self._ctx) 

2777 if la_ == 1: 

2778 self.state = 398 

2779 self.column_name() 

2780 pass 

2781 

2782 elif la_ == 2: 

2783 self.state = 399 

2784 self.expr(0) 

2785 pass 

2786 

2787 

2788 self.state = 404 

2789 self._errHandler.sync(self) 

2790 _la = self._input.LA(1) 

2791 if _la==SQLiteParser.COLLATE_: 

2792 self.state = 402 

2793 self.match(SQLiteParser.COLLATE_) 

2794 self.state = 403 

2795 self.collation_name() 

2796 

2797 

2798 self.state = 407 

2799 self._errHandler.sync(self) 

2800 _la = self._input.LA(1) 

2801 if _la==SQLiteParser.ASC_ or _la==SQLiteParser.DESC_: 

2802 self.state = 406 

2803 self.asc_desc() 

2804 

2805 

2806 except RecognitionException as re: 

2807 localctx.exception = re 

2808 self._errHandler.reportError(self, re) 

2809 self._errHandler.recover(self, re) 

2810 finally: 

2811 self.exitRule() 

2812 return localctx 

2813 

2814 

2815 class Create_table_stmtContext(ParserRuleContext): 

2816 

2817 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

2818 super().__init__(parent, invokingState) 

2819 self.parser = parser 

2820 self.row_ROW_ID = None # Token 

2821 

2822 def CREATE_(self): 

2823 return self.getToken(SQLiteParser.CREATE_, 0) 

2824 

2825 def TABLE_(self): 

2826 return self.getToken(SQLiteParser.TABLE_, 0) 

2827 

2828 def table_name(self): 

2829 return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0) 

2830 

2831 

2832 def OPEN_PAR(self): 

2833 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

2834 

2835 def column_def(self, i:int=None): 

2836 if i is None: 

2837 return self.getTypedRuleContexts(SQLiteParser.Column_defContext) 

2838 else: 

2839 return self.getTypedRuleContext(SQLiteParser.Column_defContext,i) 

2840 

2841 

2842 def CLOSE_PAR(self): 

2843 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

2844 

2845 def AS_(self): 

2846 return self.getToken(SQLiteParser.AS_, 0) 

2847 

2848 def select_stmt(self): 

2849 return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0) 

2850 

2851 

2852 def IF_(self): 

2853 return self.getToken(SQLiteParser.IF_, 0) 

2854 

2855 def NOT_(self): 

2856 return self.getToken(SQLiteParser.NOT_, 0) 

2857 

2858 def EXISTS_(self): 

2859 return self.getToken(SQLiteParser.EXISTS_, 0) 

2860 

2861 def schema_name(self): 

2862 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

2863 

2864 

2865 def DOT(self): 

2866 return self.getToken(SQLiteParser.DOT, 0) 

2867 

2868 def TEMP_(self): 

2869 return self.getToken(SQLiteParser.TEMP_, 0) 

2870 

2871 def TEMPORARY_(self): 

2872 return self.getToken(SQLiteParser.TEMPORARY_, 0) 

2873 

2874 def COMMA(self, i:int=None): 

2875 if i is None: 

2876 return self.getTokens(SQLiteParser.COMMA) 

2877 else: 

2878 return self.getToken(SQLiteParser.COMMA, i) 

2879 

2880 def table_constraint(self, i:int=None): 

2881 if i is None: 

2882 return self.getTypedRuleContexts(SQLiteParser.Table_constraintContext) 

2883 else: 

2884 return self.getTypedRuleContext(SQLiteParser.Table_constraintContext,i) 

2885 

2886 

2887 def WITHOUT_(self): 

2888 return self.getToken(SQLiteParser.WITHOUT_, 0) 

2889 

2890 def IDENTIFIER(self): 

2891 return self.getToken(SQLiteParser.IDENTIFIER, 0) 

2892 

2893 def getRuleIndex(self): 

2894 return SQLiteParser.RULE_create_table_stmt 

2895 

2896 def enterRule(self, listener:ParseTreeListener): 

2897 if hasattr( listener, "enterCreate_table_stmt" ): 

2898 listener.enterCreate_table_stmt(self) 

2899 

2900 def exitRule(self, listener:ParseTreeListener): 

2901 if hasattr( listener, "exitCreate_table_stmt" ): 

2902 listener.exitCreate_table_stmt(self) 

2903 

2904 

2905 

2906 

2907 def create_table_stmt(self): 

2908 

2909 localctx = SQLiteParser.Create_table_stmtContext(self, self._ctx, self.state) 

2910 self.enterRule(localctx, 26, self.RULE_create_table_stmt) 

2911 self._la = 0 # Token type 

2912 try: 

2913 self.enterOuterAlt(localctx, 1) 

2914 self.state = 409 

2915 self.match(SQLiteParser.CREATE_) 

2916 self.state = 411 

2917 self._errHandler.sync(self) 

2918 _la = self._input.LA(1) 

2919 if _la==SQLiteParser.TEMP_ or _la==SQLiteParser.TEMPORARY_: 

2920 self.state = 410 

2921 _la = self._input.LA(1) 

2922 if not(_la==SQLiteParser.TEMP_ or _la==SQLiteParser.TEMPORARY_): 

2923 self._errHandler.recoverInline(self) 

2924 else: 

2925 self._errHandler.reportMatch(self) 

2926 self.consume() 

2927 

2928 

2929 self.state = 413 

2930 self.match(SQLiteParser.TABLE_) 

2931 self.state = 417 

2932 self._errHandler.sync(self) 

2933 la_ = self._interp.adaptivePredict(self._input,33,self._ctx) 

2934 if la_ == 1: 

2935 self.state = 414 

2936 self.match(SQLiteParser.IF_) 

2937 self.state = 415 

2938 self.match(SQLiteParser.NOT_) 

2939 self.state = 416 

2940 self.match(SQLiteParser.EXISTS_) 

2941 

2942 

2943 self.state = 422 

2944 self._errHandler.sync(self) 

2945 la_ = self._interp.adaptivePredict(self._input,34,self._ctx) 

2946 if la_ == 1: 

2947 self.state = 419 

2948 self.schema_name() 

2949 self.state = 420 

2950 self.match(SQLiteParser.DOT) 

2951 

2952 

2953 self.state = 424 

2954 self.table_name() 

2955 self.state = 448 

2956 self._errHandler.sync(self) 

2957 token = self._input.LA(1) 

2958 if token in [SQLiteParser.OPEN_PAR]: 

2959 self.state = 425 

2960 self.match(SQLiteParser.OPEN_PAR) 

2961 self.state = 426 

2962 self.column_def() 

2963 self.state = 431 

2964 self._errHandler.sync(self) 

2965 _alt = self._interp.adaptivePredict(self._input,35,self._ctx) 

2966 while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER: 

2967 if _alt==1+1: 

2968 self.state = 427 

2969 self.match(SQLiteParser.COMMA) 

2970 self.state = 428 

2971 self.column_def() 

2972 self.state = 433 

2973 self._errHandler.sync(self) 

2974 _alt = self._interp.adaptivePredict(self._input,35,self._ctx) 

2975 

2976 self.state = 438 

2977 self._errHandler.sync(self) 

2978 _la = self._input.LA(1) 

2979 while _la==SQLiteParser.COMMA: 

2980 self.state = 434 

2981 self.match(SQLiteParser.COMMA) 

2982 self.state = 435 

2983 self.table_constraint() 

2984 self.state = 440 

2985 self._errHandler.sync(self) 

2986 _la = self._input.LA(1) 

2987 

2988 self.state = 441 

2989 self.match(SQLiteParser.CLOSE_PAR) 

2990 self.state = 444 

2991 self._errHandler.sync(self) 

2992 _la = self._input.LA(1) 

2993 if _la==SQLiteParser.WITHOUT_: 

2994 self.state = 442 

2995 self.match(SQLiteParser.WITHOUT_) 

2996 self.state = 443 

2997 localctx.row_ROW_ID = self.match(SQLiteParser.IDENTIFIER) 

2998 

2999 

3000 pass 

3001 elif token in [SQLiteParser.AS_]: 

3002 self.state = 446 

3003 self.match(SQLiteParser.AS_) 

3004 self.state = 447 

3005 self.select_stmt() 

3006 pass 

3007 else: 

3008 raise NoViableAltException(self) 

3009 

3010 except RecognitionException as re: 

3011 localctx.exception = re 

3012 self._errHandler.reportError(self, re) 

3013 self._errHandler.recover(self, re) 

3014 finally: 

3015 self.exitRule() 

3016 return localctx 

3017 

3018 

3019 class Column_defContext(ParserRuleContext): 

3020 

3021 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

3022 super().__init__(parent, invokingState) 

3023 self.parser = parser 

3024 

3025 def column_name(self): 

3026 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,0) 

3027 

3028 

3029 def type_name(self): 

3030 return self.getTypedRuleContext(SQLiteParser.Type_nameContext,0) 

3031 

3032 

3033 def column_constraint(self, i:int=None): 

3034 if i is None: 

3035 return self.getTypedRuleContexts(SQLiteParser.Column_constraintContext) 

3036 else: 

3037 return self.getTypedRuleContext(SQLiteParser.Column_constraintContext,i) 

3038 

3039 

3040 def getRuleIndex(self): 

3041 return SQLiteParser.RULE_column_def 

3042 

3043 def enterRule(self, listener:ParseTreeListener): 

3044 if hasattr( listener, "enterColumn_def" ): 

3045 listener.enterColumn_def(self) 

3046 

3047 def exitRule(self, listener:ParseTreeListener): 

3048 if hasattr( listener, "exitColumn_def" ): 

3049 listener.exitColumn_def(self) 

3050 

3051 

3052 

3053 

3054 def column_def(self): 

3055 

3056 localctx = SQLiteParser.Column_defContext(self, self._ctx, self.state) 

3057 self.enterRule(localctx, 28, self.RULE_column_def) 

3058 try: 

3059 self.enterOuterAlt(localctx, 1) 

3060 self.state = 450 

3061 self.column_name() 

3062 self.state = 452 

3063 self._errHandler.sync(self) 

3064 la_ = self._interp.adaptivePredict(self._input,39,self._ctx) 

3065 if la_ == 1: 

3066 self.state = 451 

3067 self.type_name() 

3068 

3069 

3070 self.state = 457 

3071 self._errHandler.sync(self) 

3072 _alt = self._interp.adaptivePredict(self._input,40,self._ctx) 

3073 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: 

3074 if _alt==1: 

3075 self.state = 454 

3076 self.column_constraint() 

3077 self.state = 459 

3078 self._errHandler.sync(self) 

3079 _alt = self._interp.adaptivePredict(self._input,40,self._ctx) 

3080 

3081 except RecognitionException as re: 

3082 localctx.exception = re 

3083 self._errHandler.reportError(self, re) 

3084 self._errHandler.recover(self, re) 

3085 finally: 

3086 self.exitRule() 

3087 return localctx 

3088 

3089 

3090 class Type_nameContext(ParserRuleContext): 

3091 

3092 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

3093 super().__init__(parent, invokingState) 

3094 self.parser = parser 

3095 

3096 def name(self, i:int=None): 

3097 if i is None: 

3098 return self.getTypedRuleContexts(SQLiteParser.NameContext) 

3099 else: 

3100 return self.getTypedRuleContext(SQLiteParser.NameContext,i) 

3101 

3102 

3103 def OPEN_PAR(self): 

3104 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

3105 

3106 def signed_number(self, i:int=None): 

3107 if i is None: 

3108 return self.getTypedRuleContexts(SQLiteParser.Signed_numberContext) 

3109 else: 

3110 return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,i) 

3111 

3112 

3113 def CLOSE_PAR(self): 

3114 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

3115 

3116 def COMMA(self): 

3117 return self.getToken(SQLiteParser.COMMA, 0) 

3118 

3119 def getRuleIndex(self): 

3120 return SQLiteParser.RULE_type_name 

3121 

3122 def enterRule(self, listener:ParseTreeListener): 

3123 if hasattr( listener, "enterType_name" ): 

3124 listener.enterType_name(self) 

3125 

3126 def exitRule(self, listener:ParseTreeListener): 

3127 if hasattr( listener, "exitType_name" ): 

3128 listener.exitType_name(self) 

3129 

3130 

3131 

3132 

3133 def type_name(self): 

3134 

3135 localctx = SQLiteParser.Type_nameContext(self, self._ctx, self.state) 

3136 self.enterRule(localctx, 30, self.RULE_type_name) 

3137 try: 

3138 self.enterOuterAlt(localctx, 1) 

3139 self.state = 461 

3140 self._errHandler.sync(self) 

3141 _alt = 1+1 

3142 while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER: 

3143 if _alt == 1+1: 

3144 self.state = 460 

3145 self.name() 

3146 

3147 else: 

3148 raise NoViableAltException(self) 

3149 self.state = 463 

3150 self._errHandler.sync(self) 

3151 _alt = self._interp.adaptivePredict(self._input,41,self._ctx) 

3152 

3153 self.state = 475 

3154 self._errHandler.sync(self) 

3155 la_ = self._interp.adaptivePredict(self._input,42,self._ctx) 

3156 if la_ == 1: 

3157 self.state = 465 

3158 self.match(SQLiteParser.OPEN_PAR) 

3159 self.state = 466 

3160 self.signed_number() 

3161 self.state = 467 

3162 self.match(SQLiteParser.CLOSE_PAR) 

3163 

3164 elif la_ == 2: 

3165 self.state = 469 

3166 self.match(SQLiteParser.OPEN_PAR) 

3167 self.state = 470 

3168 self.signed_number() 

3169 self.state = 471 

3170 self.match(SQLiteParser.COMMA) 

3171 self.state = 472 

3172 self.signed_number() 

3173 self.state = 473 

3174 self.match(SQLiteParser.CLOSE_PAR) 

3175 

3176 

3177 except RecognitionException as re: 

3178 localctx.exception = re 

3179 self._errHandler.reportError(self, re) 

3180 self._errHandler.recover(self, re) 

3181 finally: 

3182 self.exitRule() 

3183 return localctx 

3184 

3185 

3186 class Column_constraintContext(ParserRuleContext): 

3187 

3188 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

3189 super().__init__(parent, invokingState) 

3190 self.parser = parser 

3191 

3192 def CHECK_(self): 

3193 return self.getToken(SQLiteParser.CHECK_, 0) 

3194 

3195 def OPEN_PAR(self): 

3196 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

3197 

3198 def expr(self): 

3199 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

3200 

3201 

3202 def CLOSE_PAR(self): 

3203 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

3204 

3205 def DEFAULT_(self): 

3206 return self.getToken(SQLiteParser.DEFAULT_, 0) 

3207 

3208 def COLLATE_(self): 

3209 return self.getToken(SQLiteParser.COLLATE_, 0) 

3210 

3211 def collation_name(self): 

3212 return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0) 

3213 

3214 

3215 def foreign_key_clause(self): 

3216 return self.getTypedRuleContext(SQLiteParser.Foreign_key_clauseContext,0) 

3217 

3218 

3219 def AS_(self): 

3220 return self.getToken(SQLiteParser.AS_, 0) 

3221 

3222 def CONSTRAINT_(self): 

3223 return self.getToken(SQLiteParser.CONSTRAINT_, 0) 

3224 

3225 def name(self): 

3226 return self.getTypedRuleContext(SQLiteParser.NameContext,0) 

3227 

3228 

3229 def PRIMARY_(self): 

3230 return self.getToken(SQLiteParser.PRIMARY_, 0) 

3231 

3232 def KEY_(self): 

3233 return self.getToken(SQLiteParser.KEY_, 0) 

3234 

3235 def NOT_(self): 

3236 return self.getToken(SQLiteParser.NOT_, 0) 

3237 

3238 def NULL_(self): 

3239 return self.getToken(SQLiteParser.NULL_, 0) 

3240 

3241 def UNIQUE_(self): 

3242 return self.getToken(SQLiteParser.UNIQUE_, 0) 

3243 

3244 def signed_number(self): 

3245 return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,0) 

3246 

3247 

3248 def literal_value(self): 

3249 return self.getTypedRuleContext(SQLiteParser.Literal_valueContext,0) 

3250 

3251 

3252 def conflict_clause(self): 

3253 return self.getTypedRuleContext(SQLiteParser.Conflict_clauseContext,0) 

3254 

3255 

3256 def GENERATED_(self): 

3257 return self.getToken(SQLiteParser.GENERATED_, 0) 

3258 

3259 def ALWAYS_(self): 

3260 return self.getToken(SQLiteParser.ALWAYS_, 0) 

3261 

3262 def STORED_(self): 

3263 return self.getToken(SQLiteParser.STORED_, 0) 

3264 

3265 def VIRTUAL_(self): 

3266 return self.getToken(SQLiteParser.VIRTUAL_, 0) 

3267 

3268 def asc_desc(self): 

3269 return self.getTypedRuleContext(SQLiteParser.Asc_descContext,0) 

3270 

3271 

3272 def AUTOINCREMENT_(self): 

3273 return self.getToken(SQLiteParser.AUTOINCREMENT_, 0) 

3274 

3275 def getRuleIndex(self): 

3276 return SQLiteParser.RULE_column_constraint 

3277 

3278 def enterRule(self, listener:ParseTreeListener): 

3279 if hasattr( listener, "enterColumn_constraint" ): 

3280 listener.enterColumn_constraint(self) 

3281 

3282 def exitRule(self, listener:ParseTreeListener): 

3283 if hasattr( listener, "exitColumn_constraint" ): 

3284 listener.exitColumn_constraint(self) 

3285 

3286 

3287 

3288 

3289 def column_constraint(self): 

3290 

3291 localctx = SQLiteParser.Column_constraintContext(self, self._ctx, self.state) 

3292 self.enterRule(localctx, 32, self.RULE_column_constraint) 

3293 self._la = 0 # Token type 

3294 try: 

3295 self.enterOuterAlt(localctx, 1) 

3296 self.state = 479 

3297 self._errHandler.sync(self) 

3298 _la = self._input.LA(1) 

3299 if _la==SQLiteParser.CONSTRAINT_: 

3300 self.state = 477 

3301 self.match(SQLiteParser.CONSTRAINT_) 

3302 self.state = 478 

3303 self.name() 

3304 

3305 

3306 self.state = 528 

3307 self._errHandler.sync(self) 

3308 token = self._input.LA(1) 

3309 if token in [SQLiteParser.PRIMARY_]: 

3310 self.state = 481 

3311 self.match(SQLiteParser.PRIMARY_) 

3312 self.state = 482 

3313 self.match(SQLiteParser.KEY_) 

3314 self.state = 484 

3315 self._errHandler.sync(self) 

3316 _la = self._input.LA(1) 

3317 if _la==SQLiteParser.ASC_ or _la==SQLiteParser.DESC_: 

3318 self.state = 483 

3319 self.asc_desc() 

3320 

3321 

3322 self.state = 487 

3323 self._errHandler.sync(self) 

3324 _la = self._input.LA(1) 

3325 if _la==SQLiteParser.ON_: 

3326 self.state = 486 

3327 self.conflict_clause() 

3328 

3329 

3330 self.state = 490 

3331 self._errHandler.sync(self) 

3332 _la = self._input.LA(1) 

3333 if _la==SQLiteParser.AUTOINCREMENT_: 

3334 self.state = 489 

3335 self.match(SQLiteParser.AUTOINCREMENT_) 

3336 

3337 

3338 pass 

3339 elif token in [SQLiteParser.NOT_, SQLiteParser.UNIQUE_]: 

3340 self.state = 495 

3341 self._errHandler.sync(self) 

3342 token = self._input.LA(1) 

3343 if token in [SQLiteParser.NOT_]: 

3344 self.state = 492 

3345 self.match(SQLiteParser.NOT_) 

3346 self.state = 493 

3347 self.match(SQLiteParser.NULL_) 

3348 pass 

3349 elif token in [SQLiteParser.UNIQUE_]: 

3350 self.state = 494 

3351 self.match(SQLiteParser.UNIQUE_) 

3352 pass 

3353 else: 

3354 raise NoViableAltException(self) 

3355 

3356 self.state = 498 

3357 self._errHandler.sync(self) 

3358 _la = self._input.LA(1) 

3359 if _la==SQLiteParser.ON_: 

3360 self.state = 497 

3361 self.conflict_clause() 

3362 

3363 

3364 pass 

3365 elif token in [SQLiteParser.CHECK_]: 

3366 self.state = 500 

3367 self.match(SQLiteParser.CHECK_) 

3368 self.state = 501 

3369 self.match(SQLiteParser.OPEN_PAR) 

3370 self.state = 502 

3371 self.expr(0) 

3372 self.state = 503 

3373 self.match(SQLiteParser.CLOSE_PAR) 

3374 pass 

3375 elif token in [SQLiteParser.DEFAULT_]: 

3376 self.state = 505 

3377 self.match(SQLiteParser.DEFAULT_) 

3378 self.state = 512 

3379 self._errHandler.sync(self) 

3380 la_ = self._interp.adaptivePredict(self._input,49,self._ctx) 

3381 if la_ == 1: 

3382 self.state = 506 

3383 self.signed_number() 

3384 pass 

3385 

3386 elif la_ == 2: 

3387 self.state = 507 

3388 self.literal_value() 

3389 pass 

3390 

3391 elif la_ == 3: 

3392 self.state = 508 

3393 self.match(SQLiteParser.OPEN_PAR) 

3394 self.state = 509 

3395 self.expr(0) 

3396 self.state = 510 

3397 self.match(SQLiteParser.CLOSE_PAR) 

3398 pass 

3399 

3400 

3401 pass 

3402 elif token in [SQLiteParser.COLLATE_]: 

3403 self.state = 514 

3404 self.match(SQLiteParser.COLLATE_) 

3405 self.state = 515 

3406 self.collation_name() 

3407 pass 

3408 elif token in [SQLiteParser.REFERENCES_]: 

3409 self.state = 516 

3410 self.foreign_key_clause() 

3411 pass 

3412 elif token in [SQLiteParser.AS_, SQLiteParser.GENERATED_]: 

3413 self.state = 519 

3414 self._errHandler.sync(self) 

3415 _la = self._input.LA(1) 

3416 if _la==SQLiteParser.GENERATED_: 

3417 self.state = 517 

3418 self.match(SQLiteParser.GENERATED_) 

3419 self.state = 518 

3420 self.match(SQLiteParser.ALWAYS_) 

3421 

3422 

3423 self.state = 521 

3424 self.match(SQLiteParser.AS_) 

3425 self.state = 522 

3426 self.match(SQLiteParser.OPEN_PAR) 

3427 self.state = 523 

3428 self.expr(0) 

3429 self.state = 524 

3430 self.match(SQLiteParser.CLOSE_PAR) 

3431 self.state = 526 

3432 self._errHandler.sync(self) 

3433 _la = self._input.LA(1) 

3434 if _la==SQLiteParser.VIRTUAL_ or _la==SQLiteParser.STORED_: 

3435 self.state = 525 

3436 _la = self._input.LA(1) 

3437 if not(_la==SQLiteParser.VIRTUAL_ or _la==SQLiteParser.STORED_): 

3438 self._errHandler.recoverInline(self) 

3439 else: 

3440 self._errHandler.reportMatch(self) 

3441 self.consume() 

3442 

3443 

3444 pass 

3445 else: 

3446 raise NoViableAltException(self) 

3447 

3448 except RecognitionException as re: 

3449 localctx.exception = re 

3450 self._errHandler.reportError(self, re) 

3451 self._errHandler.recover(self, re) 

3452 finally: 

3453 self.exitRule() 

3454 return localctx 

3455 

3456 

3457 class Signed_numberContext(ParserRuleContext): 

3458 

3459 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

3460 super().__init__(parent, invokingState) 

3461 self.parser = parser 

3462 

3463 def NUMERIC_LITERAL(self): 

3464 return self.getToken(SQLiteParser.NUMERIC_LITERAL, 0) 

3465 

3466 def PLUS(self): 

3467 return self.getToken(SQLiteParser.PLUS, 0) 

3468 

3469 def MINUS(self): 

3470 return self.getToken(SQLiteParser.MINUS, 0) 

3471 

3472 def getRuleIndex(self): 

3473 return SQLiteParser.RULE_signed_number 

3474 

3475 def enterRule(self, listener:ParseTreeListener): 

3476 if hasattr( listener, "enterSigned_number" ): 

3477 listener.enterSigned_number(self) 

3478 

3479 def exitRule(self, listener:ParseTreeListener): 

3480 if hasattr( listener, "exitSigned_number" ): 

3481 listener.exitSigned_number(self) 

3482 

3483 

3484 

3485 

3486 def signed_number(self): 

3487 

3488 localctx = SQLiteParser.Signed_numberContext(self, self._ctx, self.state) 

3489 self.enterRule(localctx, 34, self.RULE_signed_number) 

3490 self._la = 0 # Token type 

3491 try: 

3492 self.enterOuterAlt(localctx, 1) 

3493 self.state = 531 

3494 self._errHandler.sync(self) 

3495 _la = self._input.LA(1) 

3496 if _la==SQLiteParser.PLUS or _la==SQLiteParser.MINUS: 

3497 self.state = 530 

3498 _la = self._input.LA(1) 

3499 if not(_la==SQLiteParser.PLUS or _la==SQLiteParser.MINUS): 

3500 self._errHandler.recoverInline(self) 

3501 else: 

3502 self._errHandler.reportMatch(self) 

3503 self.consume() 

3504 

3505 

3506 self.state = 533 

3507 self.match(SQLiteParser.NUMERIC_LITERAL) 

3508 except RecognitionException as re: 

3509 localctx.exception = re 

3510 self._errHandler.reportError(self, re) 

3511 self._errHandler.recover(self, re) 

3512 finally: 

3513 self.exitRule() 

3514 return localctx 

3515 

3516 

3517 class Table_constraintContext(ParserRuleContext): 

3518 

3519 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

3520 super().__init__(parent, invokingState) 

3521 self.parser = parser 

3522 

3523 def OPEN_PAR(self): 

3524 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

3525 

3526 def indexed_column(self, i:int=None): 

3527 if i is None: 

3528 return self.getTypedRuleContexts(SQLiteParser.Indexed_columnContext) 

3529 else: 

3530 return self.getTypedRuleContext(SQLiteParser.Indexed_columnContext,i) 

3531 

3532 

3533 def CLOSE_PAR(self): 

3534 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

3535 

3536 def CHECK_(self): 

3537 return self.getToken(SQLiteParser.CHECK_, 0) 

3538 

3539 def expr(self): 

3540 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

3541 

3542 

3543 def FOREIGN_(self): 

3544 return self.getToken(SQLiteParser.FOREIGN_, 0) 

3545 

3546 def KEY_(self): 

3547 return self.getToken(SQLiteParser.KEY_, 0) 

3548 

3549 def column_name(self, i:int=None): 

3550 if i is None: 

3551 return self.getTypedRuleContexts(SQLiteParser.Column_nameContext) 

3552 else: 

3553 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i) 

3554 

3555 

3556 def foreign_key_clause(self): 

3557 return self.getTypedRuleContext(SQLiteParser.Foreign_key_clauseContext,0) 

3558 

3559 

3560 def CONSTRAINT_(self): 

3561 return self.getToken(SQLiteParser.CONSTRAINT_, 0) 

3562 

3563 def name(self): 

3564 return self.getTypedRuleContext(SQLiteParser.NameContext,0) 

3565 

3566 

3567 def PRIMARY_(self): 

3568 return self.getToken(SQLiteParser.PRIMARY_, 0) 

3569 

3570 def UNIQUE_(self): 

3571 return self.getToken(SQLiteParser.UNIQUE_, 0) 

3572 

3573 def COMMA(self, i:int=None): 

3574 if i is None: 

3575 return self.getTokens(SQLiteParser.COMMA) 

3576 else: 

3577 return self.getToken(SQLiteParser.COMMA, i) 

3578 

3579 def conflict_clause(self): 

3580 return self.getTypedRuleContext(SQLiteParser.Conflict_clauseContext,0) 

3581 

3582 

3583 def getRuleIndex(self): 

3584 return SQLiteParser.RULE_table_constraint 

3585 

3586 def enterRule(self, listener:ParseTreeListener): 

3587 if hasattr( listener, "enterTable_constraint" ): 

3588 listener.enterTable_constraint(self) 

3589 

3590 def exitRule(self, listener:ParseTreeListener): 

3591 if hasattr( listener, "exitTable_constraint" ): 

3592 listener.exitTable_constraint(self) 

3593 

3594 

3595 

3596 

3597 def table_constraint(self): 

3598 

3599 localctx = SQLiteParser.Table_constraintContext(self, self._ctx, self.state) 

3600 self.enterRule(localctx, 36, self.RULE_table_constraint) 

3601 self._la = 0 # Token type 

3602 try: 

3603 self.enterOuterAlt(localctx, 1) 

3604 self.state = 537 

3605 self._errHandler.sync(self) 

3606 _la = self._input.LA(1) 

3607 if _la==SQLiteParser.CONSTRAINT_: 

3608 self.state = 535 

3609 self.match(SQLiteParser.CONSTRAINT_) 

3610 self.state = 536 

3611 self.name() 

3612 

3613 

3614 self.state = 576 

3615 self._errHandler.sync(self) 

3616 token = self._input.LA(1) 

3617 if token in [SQLiteParser.PRIMARY_, SQLiteParser.UNIQUE_]: 

3618 self.state = 542 

3619 self._errHandler.sync(self) 

3620 token = self._input.LA(1) 

3621 if token in [SQLiteParser.PRIMARY_]: 

3622 self.state = 539 

3623 self.match(SQLiteParser.PRIMARY_) 

3624 self.state = 540 

3625 self.match(SQLiteParser.KEY_) 

3626 pass 

3627 elif token in [SQLiteParser.UNIQUE_]: 

3628 self.state = 541 

3629 self.match(SQLiteParser.UNIQUE_) 

3630 pass 

3631 else: 

3632 raise NoViableAltException(self) 

3633 

3634 self.state = 544 

3635 self.match(SQLiteParser.OPEN_PAR) 

3636 self.state = 545 

3637 self.indexed_column() 

3638 self.state = 550 

3639 self._errHandler.sync(self) 

3640 _la = self._input.LA(1) 

3641 while _la==SQLiteParser.COMMA: 

3642 self.state = 546 

3643 self.match(SQLiteParser.COMMA) 

3644 self.state = 547 

3645 self.indexed_column() 

3646 self.state = 552 

3647 self._errHandler.sync(self) 

3648 _la = self._input.LA(1) 

3649 

3650 self.state = 553 

3651 self.match(SQLiteParser.CLOSE_PAR) 

3652 self.state = 555 

3653 self._errHandler.sync(self) 

3654 _la = self._input.LA(1) 

3655 if _la==SQLiteParser.ON_: 

3656 self.state = 554 

3657 self.conflict_clause() 

3658 

3659 

3660 pass 

3661 elif token in [SQLiteParser.CHECK_]: 

3662 self.state = 557 

3663 self.match(SQLiteParser.CHECK_) 

3664 self.state = 558 

3665 self.match(SQLiteParser.OPEN_PAR) 

3666 self.state = 559 

3667 self.expr(0) 

3668 self.state = 560 

3669 self.match(SQLiteParser.CLOSE_PAR) 

3670 pass 

3671 elif token in [SQLiteParser.FOREIGN_]: 

3672 self.state = 562 

3673 self.match(SQLiteParser.FOREIGN_) 

3674 self.state = 563 

3675 self.match(SQLiteParser.KEY_) 

3676 self.state = 564 

3677 self.match(SQLiteParser.OPEN_PAR) 

3678 self.state = 565 

3679 self.column_name() 

3680 self.state = 570 

3681 self._errHandler.sync(self) 

3682 _la = self._input.LA(1) 

3683 while _la==SQLiteParser.COMMA: 

3684 self.state = 566 

3685 self.match(SQLiteParser.COMMA) 

3686 self.state = 567 

3687 self.column_name() 

3688 self.state = 572 

3689 self._errHandler.sync(self) 

3690 _la = self._input.LA(1) 

3691 

3692 self.state = 573 

3693 self.match(SQLiteParser.CLOSE_PAR) 

3694 self.state = 574 

3695 self.foreign_key_clause() 

3696 pass 

3697 else: 

3698 raise NoViableAltException(self) 

3699 

3700 except RecognitionException as re: 

3701 localctx.exception = re 

3702 self._errHandler.reportError(self, re) 

3703 self._errHandler.recover(self, re) 

3704 finally: 

3705 self.exitRule() 

3706 return localctx 

3707 

3708 

3709 class Foreign_key_clauseContext(ParserRuleContext): 

3710 

3711 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

3712 super().__init__(parent, invokingState) 

3713 self.parser = parser 

3714 

3715 def REFERENCES_(self): 

3716 return self.getToken(SQLiteParser.REFERENCES_, 0) 

3717 

3718 def foreign_table(self): 

3719 return self.getTypedRuleContext(SQLiteParser.Foreign_tableContext,0) 

3720 

3721 

3722 def OPEN_PAR(self): 

3723 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

3724 

3725 def column_name(self, i:int=None): 

3726 if i is None: 

3727 return self.getTypedRuleContexts(SQLiteParser.Column_nameContext) 

3728 else: 

3729 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i) 

3730 

3731 

3732 def CLOSE_PAR(self): 

3733 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

3734 

3735 def ON_(self, i:int=None): 

3736 if i is None: 

3737 return self.getTokens(SQLiteParser.ON_) 

3738 else: 

3739 return self.getToken(SQLiteParser.ON_, i) 

3740 

3741 def MATCH_(self, i:int=None): 

3742 if i is None: 

3743 return self.getTokens(SQLiteParser.MATCH_) 

3744 else: 

3745 return self.getToken(SQLiteParser.MATCH_, i) 

3746 

3747 def name(self, i:int=None): 

3748 if i is None: 

3749 return self.getTypedRuleContexts(SQLiteParser.NameContext) 

3750 else: 

3751 return self.getTypedRuleContext(SQLiteParser.NameContext,i) 

3752 

3753 

3754 def DEFERRABLE_(self): 

3755 return self.getToken(SQLiteParser.DEFERRABLE_, 0) 

3756 

3757 def DELETE_(self, i:int=None): 

3758 if i is None: 

3759 return self.getTokens(SQLiteParser.DELETE_) 

3760 else: 

3761 return self.getToken(SQLiteParser.DELETE_, i) 

3762 

3763 def UPDATE_(self, i:int=None): 

3764 if i is None: 

3765 return self.getTokens(SQLiteParser.UPDATE_) 

3766 else: 

3767 return self.getToken(SQLiteParser.UPDATE_, i) 

3768 

3769 def SET_(self, i:int=None): 

3770 if i is None: 

3771 return self.getTokens(SQLiteParser.SET_) 

3772 else: 

3773 return self.getToken(SQLiteParser.SET_, i) 

3774 

3775 def CASCADE_(self, i:int=None): 

3776 if i is None: 

3777 return self.getTokens(SQLiteParser.CASCADE_) 

3778 else: 

3779 return self.getToken(SQLiteParser.CASCADE_, i) 

3780 

3781 def RESTRICT_(self, i:int=None): 

3782 if i is None: 

3783 return self.getTokens(SQLiteParser.RESTRICT_) 

3784 else: 

3785 return self.getToken(SQLiteParser.RESTRICT_, i) 

3786 

3787 def NO_(self, i:int=None): 

3788 if i is None: 

3789 return self.getTokens(SQLiteParser.NO_) 

3790 else: 

3791 return self.getToken(SQLiteParser.NO_, i) 

3792 

3793 def ACTION_(self, i:int=None): 

3794 if i is None: 

3795 return self.getTokens(SQLiteParser.ACTION_) 

3796 else: 

3797 return self.getToken(SQLiteParser.ACTION_, i) 

3798 

3799 def COMMA(self, i:int=None): 

3800 if i is None: 

3801 return self.getTokens(SQLiteParser.COMMA) 

3802 else: 

3803 return self.getToken(SQLiteParser.COMMA, i) 

3804 

3805 def NULL_(self, i:int=None): 

3806 if i is None: 

3807 return self.getTokens(SQLiteParser.NULL_) 

3808 else: 

3809 return self.getToken(SQLiteParser.NULL_, i) 

3810 

3811 def DEFAULT_(self, i:int=None): 

3812 if i is None: 

3813 return self.getTokens(SQLiteParser.DEFAULT_) 

3814 else: 

3815 return self.getToken(SQLiteParser.DEFAULT_, i) 

3816 

3817 def NOT_(self): 

3818 return self.getToken(SQLiteParser.NOT_, 0) 

3819 

3820 def INITIALLY_(self): 

3821 return self.getToken(SQLiteParser.INITIALLY_, 0) 

3822 

3823 def DEFERRED_(self): 

3824 return self.getToken(SQLiteParser.DEFERRED_, 0) 

3825 

3826 def IMMEDIATE_(self): 

3827 return self.getToken(SQLiteParser.IMMEDIATE_, 0) 

3828 

3829 def getRuleIndex(self): 

3830 return SQLiteParser.RULE_foreign_key_clause 

3831 

3832 def enterRule(self, listener:ParseTreeListener): 

3833 if hasattr( listener, "enterForeign_key_clause" ): 

3834 listener.enterForeign_key_clause(self) 

3835 

3836 def exitRule(self, listener:ParseTreeListener): 

3837 if hasattr( listener, "exitForeign_key_clause" ): 

3838 listener.exitForeign_key_clause(self) 

3839 

3840 

3841 

3842 

3843 def foreign_key_clause(self): 

3844 

3845 localctx = SQLiteParser.Foreign_key_clauseContext(self, self._ctx, self.state) 

3846 self.enterRule(localctx, 38, self.RULE_foreign_key_clause) 

3847 self._la = 0 # Token type 

3848 try: 

3849 self.enterOuterAlt(localctx, 1) 

3850 self.state = 578 

3851 self.match(SQLiteParser.REFERENCES_) 

3852 self.state = 579 

3853 self.foreign_table() 

3854 self.state = 591 

3855 self._errHandler.sync(self) 

3856 _la = self._input.LA(1) 

3857 if _la==SQLiteParser.OPEN_PAR: 

3858 self.state = 580 

3859 self.match(SQLiteParser.OPEN_PAR) 

3860 self.state = 581 

3861 self.column_name() 

3862 self.state = 586 

3863 self._errHandler.sync(self) 

3864 _la = self._input.LA(1) 

3865 while _la==SQLiteParser.COMMA: 

3866 self.state = 582 

3867 self.match(SQLiteParser.COMMA) 

3868 self.state = 583 

3869 self.column_name() 

3870 self.state = 588 

3871 self._errHandler.sync(self) 

3872 _la = self._input.LA(1) 

3873 

3874 self.state = 589 

3875 self.match(SQLiteParser.CLOSE_PAR) 

3876 

3877 

3878 self.state = 607 

3879 self._errHandler.sync(self) 

3880 _la = self._input.LA(1) 

3881 while _la==SQLiteParser.MATCH_ or _la==SQLiteParser.ON_: 

3882 self.state = 605 

3883 self._errHandler.sync(self) 

3884 token = self._input.LA(1) 

3885 if token in [SQLiteParser.ON_]: 

3886 self.state = 593 

3887 self.match(SQLiteParser.ON_) 

3888 self.state = 594 

3889 _la = self._input.LA(1) 

3890 if not(_la==SQLiteParser.DELETE_ or _la==SQLiteParser.UPDATE_): 

3891 self._errHandler.recoverInline(self) 

3892 else: 

3893 self._errHandler.reportMatch(self) 

3894 self.consume() 

3895 self.state = 601 

3896 self._errHandler.sync(self) 

3897 token = self._input.LA(1) 

3898 if token in [SQLiteParser.SET_]: 

3899 self.state = 595 

3900 self.match(SQLiteParser.SET_) 

3901 self.state = 596 

3902 _la = self._input.LA(1) 

3903 if not(_la==SQLiteParser.DEFAULT_ or _la==SQLiteParser.NULL_): 

3904 self._errHandler.recoverInline(self) 

3905 else: 

3906 self._errHandler.reportMatch(self) 

3907 self.consume() 

3908 pass 

3909 elif token in [SQLiteParser.CASCADE_]: 

3910 self.state = 597 

3911 self.match(SQLiteParser.CASCADE_) 

3912 pass 

3913 elif token in [SQLiteParser.RESTRICT_]: 

3914 self.state = 598 

3915 self.match(SQLiteParser.RESTRICT_) 

3916 pass 

3917 elif token in [SQLiteParser.NO_]: 

3918 self.state = 599 

3919 self.match(SQLiteParser.NO_) 

3920 self.state = 600 

3921 self.match(SQLiteParser.ACTION_) 

3922 pass 

3923 else: 

3924 raise NoViableAltException(self) 

3925 

3926 pass 

3927 elif token in [SQLiteParser.MATCH_]: 

3928 self.state = 603 

3929 self.match(SQLiteParser.MATCH_) 

3930 self.state = 604 

3931 self.name() 

3932 pass 

3933 else: 

3934 raise NoViableAltException(self) 

3935 

3936 self.state = 609 

3937 self._errHandler.sync(self) 

3938 _la = self._input.LA(1) 

3939 

3940 self.state = 618 

3941 self._errHandler.sync(self) 

3942 la_ = self._interp.adaptivePredict(self._input,67,self._ctx) 

3943 if la_ == 1: 

3944 self.state = 611 

3945 self._errHandler.sync(self) 

3946 _la = self._input.LA(1) 

3947 if _la==SQLiteParser.NOT_: 

3948 self.state = 610 

3949 self.match(SQLiteParser.NOT_) 

3950 

3951 

3952 self.state = 613 

3953 self.match(SQLiteParser.DEFERRABLE_) 

3954 self.state = 616 

3955 self._errHandler.sync(self) 

3956 _la = self._input.LA(1) 

3957 if _la==SQLiteParser.INITIALLY_: 

3958 self.state = 614 

3959 self.match(SQLiteParser.INITIALLY_) 

3960 self.state = 615 

3961 _la = self._input.LA(1) 

3962 if not(_la==SQLiteParser.DEFERRED_ or _la==SQLiteParser.IMMEDIATE_): 

3963 self._errHandler.recoverInline(self) 

3964 else: 

3965 self._errHandler.reportMatch(self) 

3966 self.consume() 

3967 

3968 

3969 

3970 

3971 except RecognitionException as re: 

3972 localctx.exception = re 

3973 self._errHandler.reportError(self, re) 

3974 self._errHandler.recover(self, re) 

3975 finally: 

3976 self.exitRule() 

3977 return localctx 

3978 

3979 

3980 class Conflict_clauseContext(ParserRuleContext): 

3981 

3982 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

3983 super().__init__(parent, invokingState) 

3984 self.parser = parser 

3985 

3986 def ON_(self): 

3987 return self.getToken(SQLiteParser.ON_, 0) 

3988 

3989 def CONFLICT_(self): 

3990 return self.getToken(SQLiteParser.CONFLICT_, 0) 

3991 

3992 def ROLLBACK_(self): 

3993 return self.getToken(SQLiteParser.ROLLBACK_, 0) 

3994 

3995 def ABORT_(self): 

3996 return self.getToken(SQLiteParser.ABORT_, 0) 

3997 

3998 def FAIL_(self): 

3999 return self.getToken(SQLiteParser.FAIL_, 0) 

4000 

4001 def IGNORE_(self): 

4002 return self.getToken(SQLiteParser.IGNORE_, 0) 

4003 

4004 def REPLACE_(self): 

4005 return self.getToken(SQLiteParser.REPLACE_, 0) 

4006 

4007 def getRuleIndex(self): 

4008 return SQLiteParser.RULE_conflict_clause 

4009 

4010 def enterRule(self, listener:ParseTreeListener): 

4011 if hasattr( listener, "enterConflict_clause" ): 

4012 listener.enterConflict_clause(self) 

4013 

4014 def exitRule(self, listener:ParseTreeListener): 

4015 if hasattr( listener, "exitConflict_clause" ): 

4016 listener.exitConflict_clause(self) 

4017 

4018 

4019 

4020 

4021 def conflict_clause(self): 

4022 

4023 localctx = SQLiteParser.Conflict_clauseContext(self, self._ctx, self.state) 

4024 self.enterRule(localctx, 40, self.RULE_conflict_clause) 

4025 self._la = 0 # Token type 

4026 try: 

4027 self.enterOuterAlt(localctx, 1) 

4028 self.state = 620 

4029 self.match(SQLiteParser.ON_) 

4030 self.state = 621 

4031 self.match(SQLiteParser.CONFLICT_) 

4032 self.state = 622 

4033 _la = self._input.LA(1) 

4034 if not(_la==SQLiteParser.ABORT_ or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (SQLiteParser.FAIL_ - 72)) | (1 << (SQLiteParser.IGNORE_ - 72)) | (1 << (SQLiteParser.REPLACE_ - 72)) | (1 << (SQLiteParser.ROLLBACK_ - 72)))) != 0)): 

4035 self._errHandler.recoverInline(self) 

4036 else: 

4037 self._errHandler.reportMatch(self) 

4038 self.consume() 

4039 except RecognitionException as re: 

4040 localctx.exception = re 

4041 self._errHandler.reportError(self, re) 

4042 self._errHandler.recover(self, re) 

4043 finally: 

4044 self.exitRule() 

4045 return localctx 

4046 

4047 

4048 class Create_trigger_stmtContext(ParserRuleContext): 

4049 

4050 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

4051 super().__init__(parent, invokingState) 

4052 self.parser = parser 

4053 

4054 def CREATE_(self): 

4055 return self.getToken(SQLiteParser.CREATE_, 0) 

4056 

4057 def TRIGGER_(self): 

4058 return self.getToken(SQLiteParser.TRIGGER_, 0) 

4059 

4060 def trigger_name(self): 

4061 return self.getTypedRuleContext(SQLiteParser.Trigger_nameContext,0) 

4062 

4063 

4064 def ON_(self): 

4065 return self.getToken(SQLiteParser.ON_, 0) 

4066 

4067 def table_name(self): 

4068 return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0) 

4069 

4070 

4071 def BEGIN_(self): 

4072 return self.getToken(SQLiteParser.BEGIN_, 0) 

4073 

4074 def END_(self): 

4075 return self.getToken(SQLiteParser.END_, 0) 

4076 

4077 def DELETE_(self): 

4078 return self.getToken(SQLiteParser.DELETE_, 0) 

4079 

4080 def INSERT_(self): 

4081 return self.getToken(SQLiteParser.INSERT_, 0) 

4082 

4083 def UPDATE_(self): 

4084 return self.getToken(SQLiteParser.UPDATE_, 0) 

4085 

4086 def IF_(self): 

4087 return self.getToken(SQLiteParser.IF_, 0) 

4088 

4089 def NOT_(self): 

4090 return self.getToken(SQLiteParser.NOT_, 0) 

4091 

4092 def EXISTS_(self): 

4093 return self.getToken(SQLiteParser.EXISTS_, 0) 

4094 

4095 def schema_name(self): 

4096 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

4097 

4098 

4099 def DOT(self): 

4100 return self.getToken(SQLiteParser.DOT, 0) 

4101 

4102 def BEFORE_(self): 

4103 return self.getToken(SQLiteParser.BEFORE_, 0) 

4104 

4105 def AFTER_(self): 

4106 return self.getToken(SQLiteParser.AFTER_, 0) 

4107 

4108 def INSTEAD_(self): 

4109 return self.getToken(SQLiteParser.INSTEAD_, 0) 

4110 

4111 def OF_(self, i:int=None): 

4112 if i is None: 

4113 return self.getTokens(SQLiteParser.OF_) 

4114 else: 

4115 return self.getToken(SQLiteParser.OF_, i) 

4116 

4117 def FOR_(self): 

4118 return self.getToken(SQLiteParser.FOR_, 0) 

4119 

4120 def EACH_(self): 

4121 return self.getToken(SQLiteParser.EACH_, 0) 

4122 

4123 def ROW_(self): 

4124 return self.getToken(SQLiteParser.ROW_, 0) 

4125 

4126 def WHEN_(self): 

4127 return self.getToken(SQLiteParser.WHEN_, 0) 

4128 

4129 def expr(self): 

4130 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

4131 

4132 

4133 def SCOL(self, i:int=None): 

4134 if i is None: 

4135 return self.getTokens(SQLiteParser.SCOL) 

4136 else: 

4137 return self.getToken(SQLiteParser.SCOL, i) 

4138 

4139 def TEMP_(self): 

4140 return self.getToken(SQLiteParser.TEMP_, 0) 

4141 

4142 def TEMPORARY_(self): 

4143 return self.getToken(SQLiteParser.TEMPORARY_, 0) 

4144 

4145 def column_name(self, i:int=None): 

4146 if i is None: 

4147 return self.getTypedRuleContexts(SQLiteParser.Column_nameContext) 

4148 else: 

4149 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i) 

4150 

4151 

4152 def update_stmt(self, i:int=None): 

4153 if i is None: 

4154 return self.getTypedRuleContexts(SQLiteParser.Update_stmtContext) 

4155 else: 

4156 return self.getTypedRuleContext(SQLiteParser.Update_stmtContext,i) 

4157 

4158 

4159 def insert_stmt(self, i:int=None): 

4160 if i is None: 

4161 return self.getTypedRuleContexts(SQLiteParser.Insert_stmtContext) 

4162 else: 

4163 return self.getTypedRuleContext(SQLiteParser.Insert_stmtContext,i) 

4164 

4165 

4166 def delete_stmt(self, i:int=None): 

4167 if i is None: 

4168 return self.getTypedRuleContexts(SQLiteParser.Delete_stmtContext) 

4169 else: 

4170 return self.getTypedRuleContext(SQLiteParser.Delete_stmtContext,i) 

4171 

4172 

4173 def select_stmt(self, i:int=None): 

4174 if i is None: 

4175 return self.getTypedRuleContexts(SQLiteParser.Select_stmtContext) 

4176 else: 

4177 return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,i) 

4178 

4179 

4180 def COMMA(self, i:int=None): 

4181 if i is None: 

4182 return self.getTokens(SQLiteParser.COMMA) 

4183 else: 

4184 return self.getToken(SQLiteParser.COMMA, i) 

4185 

4186 def getRuleIndex(self): 

4187 return SQLiteParser.RULE_create_trigger_stmt 

4188 

4189 def enterRule(self, listener:ParseTreeListener): 

4190 if hasattr( listener, "enterCreate_trigger_stmt" ): 

4191 listener.enterCreate_trigger_stmt(self) 

4192 

4193 def exitRule(self, listener:ParseTreeListener): 

4194 if hasattr( listener, "exitCreate_trigger_stmt" ): 

4195 listener.exitCreate_trigger_stmt(self) 

4196 

4197 

4198 

4199 

4200 def create_trigger_stmt(self): 

4201 

4202 localctx = SQLiteParser.Create_trigger_stmtContext(self, self._ctx, self.state) 

4203 self.enterRule(localctx, 42, self.RULE_create_trigger_stmt) 

4204 self._la = 0 # Token type 

4205 try: 

4206 self.enterOuterAlt(localctx, 1) 

4207 self.state = 624 

4208 self.match(SQLiteParser.CREATE_) 

4209 self.state = 626 

4210 self._errHandler.sync(self) 

4211 _la = self._input.LA(1) 

4212 if _la==SQLiteParser.TEMP_ or _la==SQLiteParser.TEMPORARY_: 

4213 self.state = 625 

4214 _la = self._input.LA(1) 

4215 if not(_la==SQLiteParser.TEMP_ or _la==SQLiteParser.TEMPORARY_): 

4216 self._errHandler.recoverInline(self) 

4217 else: 

4218 self._errHandler.reportMatch(self) 

4219 self.consume() 

4220 

4221 

4222 self.state = 628 

4223 self.match(SQLiteParser.TRIGGER_) 

4224 self.state = 632 

4225 self._errHandler.sync(self) 

4226 la_ = self._interp.adaptivePredict(self._input,69,self._ctx) 

4227 if la_ == 1: 

4228 self.state = 629 

4229 self.match(SQLiteParser.IF_) 

4230 self.state = 630 

4231 self.match(SQLiteParser.NOT_) 

4232 self.state = 631 

4233 self.match(SQLiteParser.EXISTS_) 

4234 

4235 

4236 self.state = 637 

4237 self._errHandler.sync(self) 

4238 la_ = self._interp.adaptivePredict(self._input,70,self._ctx) 

4239 if la_ == 1: 

4240 self.state = 634 

4241 self.schema_name() 

4242 self.state = 635 

4243 self.match(SQLiteParser.DOT) 

4244 

4245 

4246 self.state = 639 

4247 self.trigger_name() 

4248 self.state = 644 

4249 self._errHandler.sync(self) 

4250 token = self._input.LA(1) 

4251 if token in [SQLiteParser.BEFORE_]: 

4252 self.state = 640 

4253 self.match(SQLiteParser.BEFORE_) 

4254 pass 

4255 elif token in [SQLiteParser.AFTER_]: 

4256 self.state = 641 

4257 self.match(SQLiteParser.AFTER_) 

4258 pass 

4259 elif token in [SQLiteParser.INSTEAD_]: 

4260 self.state = 642 

4261 self.match(SQLiteParser.INSTEAD_) 

4262 self.state = 643 

4263 self.match(SQLiteParser.OF_) 

4264 pass 

4265 elif token in [SQLiteParser.DELETE_, SQLiteParser.INSERT_, SQLiteParser.UPDATE_]: 

4266 pass 

4267 else: 

4268 pass 

4269 self.state = 660 

4270 self._errHandler.sync(self) 

4271 token = self._input.LA(1) 

4272 if token in [SQLiteParser.DELETE_]: 

4273 self.state = 646 

4274 self.match(SQLiteParser.DELETE_) 

4275 pass 

4276 elif token in [SQLiteParser.INSERT_]: 

4277 self.state = 647 

4278 self.match(SQLiteParser.INSERT_) 

4279 pass 

4280 elif token in [SQLiteParser.UPDATE_]: 

4281 self.state = 648 

4282 self.match(SQLiteParser.UPDATE_) 

4283 self.state = 658 

4284 self._errHandler.sync(self) 

4285 _la = self._input.LA(1) 

4286 if _la==SQLiteParser.OF_: 

4287 self.state = 649 

4288 self.match(SQLiteParser.OF_) 

4289 self.state = 650 

4290 self.column_name() 

4291 self.state = 655 

4292 self._errHandler.sync(self) 

4293 _la = self._input.LA(1) 

4294 while _la==SQLiteParser.COMMA: 

4295 self.state = 651 

4296 self.match(SQLiteParser.COMMA) 

4297 self.state = 652 

4298 self.column_name() 

4299 self.state = 657 

4300 self._errHandler.sync(self) 

4301 _la = self._input.LA(1) 

4302 

4303 

4304 

4305 pass 

4306 else: 

4307 raise NoViableAltException(self) 

4308 

4309 self.state = 662 

4310 self.match(SQLiteParser.ON_) 

4311 self.state = 663 

4312 self.table_name() 

4313 self.state = 667 

4314 self._errHandler.sync(self) 

4315 _la = self._input.LA(1) 

4316 if _la==SQLiteParser.FOR_: 

4317 self.state = 664 

4318 self.match(SQLiteParser.FOR_) 

4319 self.state = 665 

4320 self.match(SQLiteParser.EACH_) 

4321 self.state = 666 

4322 self.match(SQLiteParser.ROW_) 

4323 

4324 

4325 self.state = 671 

4326 self._errHandler.sync(self) 

4327 _la = self._input.LA(1) 

4328 if _la==SQLiteParser.WHEN_: 

4329 self.state = 669 

4330 self.match(SQLiteParser.WHEN_) 

4331 self.state = 670 

4332 self.expr(0) 

4333 

4334 

4335 self.state = 673 

4336 self.match(SQLiteParser.BEGIN_) 

4337 self.state = 682 

4338 self._errHandler.sync(self) 

4339 _la = self._input.LA(1) 

4340 while True: 

4341 self.state = 678 

4342 self._errHandler.sync(self) 

4343 la_ = self._interp.adaptivePredict(self._input,77,self._ctx) 

4344 if la_ == 1: 

4345 self.state = 674 

4346 self.update_stmt() 

4347 pass 

4348 

4349 elif la_ == 2: 

4350 self.state = 675 

4351 self.insert_stmt() 

4352 pass 

4353 

4354 elif la_ == 3: 

4355 self.state = 676 

4356 self.delete_stmt() 

4357 pass 

4358 

4359 elif la_ == 4: 

4360 self.state = 677 

4361 self.select_stmt() 

4362 pass 

4363 

4364 

4365 self.state = 680 

4366 self.match(SQLiteParser.SCOL) 

4367 self.state = 684 

4368 self._errHandler.sync(self) 

4369 _la = self._input.LA(1) 

4370 if not (_la==SQLiteParser.DEFAULT_ or _la==SQLiteParser.DELETE_ or ((((_la - 88)) & ~0x3f) == 0 and ((1 << (_la - 88)) & ((1 << (SQLiteParser.INSERT_ - 88)) | (1 << (SQLiteParser.REPLACE_ - 88)) | (1 << (SQLiteParser.SELECT_ - 88)) | (1 << (SQLiteParser.UPDATE_ - 88)) | (1 << (SQLiteParser.VALUES_ - 88)) | (1 << (SQLiteParser.WITH_ - 88)))) != 0)): 

4371 break 

4372 

4373 self.state = 686 

4374 self.match(SQLiteParser.END_) 

4375 except RecognitionException as re: 

4376 localctx.exception = re 

4377 self._errHandler.reportError(self, re) 

4378 self._errHandler.recover(self, re) 

4379 finally: 

4380 self.exitRule() 

4381 return localctx 

4382 

4383 

4384 class Create_view_stmtContext(ParserRuleContext): 

4385 

4386 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

4387 super().__init__(parent, invokingState) 

4388 self.parser = parser 

4389 

4390 def CREATE_(self): 

4391 return self.getToken(SQLiteParser.CREATE_, 0) 

4392 

4393 def VIEW_(self): 

4394 return self.getToken(SQLiteParser.VIEW_, 0) 

4395 

4396 def view_name(self): 

4397 return self.getTypedRuleContext(SQLiteParser.View_nameContext,0) 

4398 

4399 

4400 def AS_(self): 

4401 return self.getToken(SQLiteParser.AS_, 0) 

4402 

4403 def select_stmt(self): 

4404 return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0) 

4405 

4406 

4407 def IF_(self): 

4408 return self.getToken(SQLiteParser.IF_, 0) 

4409 

4410 def NOT_(self): 

4411 return self.getToken(SQLiteParser.NOT_, 0) 

4412 

4413 def EXISTS_(self): 

4414 return self.getToken(SQLiteParser.EXISTS_, 0) 

4415 

4416 def schema_name(self): 

4417 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

4418 

4419 

4420 def DOT(self): 

4421 return self.getToken(SQLiteParser.DOT, 0) 

4422 

4423 def OPEN_PAR(self): 

4424 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

4425 

4426 def column_name(self, i:int=None): 

4427 if i is None: 

4428 return self.getTypedRuleContexts(SQLiteParser.Column_nameContext) 

4429 else: 

4430 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i) 

4431 

4432 

4433 def CLOSE_PAR(self): 

4434 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

4435 

4436 def TEMP_(self): 

4437 return self.getToken(SQLiteParser.TEMP_, 0) 

4438 

4439 def TEMPORARY_(self): 

4440 return self.getToken(SQLiteParser.TEMPORARY_, 0) 

4441 

4442 def COMMA(self, i:int=None): 

4443 if i is None: 

4444 return self.getTokens(SQLiteParser.COMMA) 

4445 else: 

4446 return self.getToken(SQLiteParser.COMMA, i) 

4447 

4448 def getRuleIndex(self): 

4449 return SQLiteParser.RULE_create_view_stmt 

4450 

4451 def enterRule(self, listener:ParseTreeListener): 

4452 if hasattr( listener, "enterCreate_view_stmt" ): 

4453 listener.enterCreate_view_stmt(self) 

4454 

4455 def exitRule(self, listener:ParseTreeListener): 

4456 if hasattr( listener, "exitCreate_view_stmt" ): 

4457 listener.exitCreate_view_stmt(self) 

4458 

4459 

4460 

4461 

4462 def create_view_stmt(self): 

4463 

4464 localctx = SQLiteParser.Create_view_stmtContext(self, self._ctx, self.state) 

4465 self.enterRule(localctx, 44, self.RULE_create_view_stmt) 

4466 self._la = 0 # Token type 

4467 try: 

4468 self.enterOuterAlt(localctx, 1) 

4469 self.state = 688 

4470 self.match(SQLiteParser.CREATE_) 

4471 self.state = 690 

4472 self._errHandler.sync(self) 

4473 _la = self._input.LA(1) 

4474 if _la==SQLiteParser.TEMP_ or _la==SQLiteParser.TEMPORARY_: 

4475 self.state = 689 

4476 _la = self._input.LA(1) 

4477 if not(_la==SQLiteParser.TEMP_ or _la==SQLiteParser.TEMPORARY_): 

4478 self._errHandler.recoverInline(self) 

4479 else: 

4480 self._errHandler.reportMatch(self) 

4481 self.consume() 

4482 

4483 

4484 self.state = 692 

4485 self.match(SQLiteParser.VIEW_) 

4486 self.state = 696 

4487 self._errHandler.sync(self) 

4488 la_ = self._interp.adaptivePredict(self._input,80,self._ctx) 

4489 if la_ == 1: 

4490 self.state = 693 

4491 self.match(SQLiteParser.IF_) 

4492 self.state = 694 

4493 self.match(SQLiteParser.NOT_) 

4494 self.state = 695 

4495 self.match(SQLiteParser.EXISTS_) 

4496 

4497 

4498 self.state = 701 

4499 self._errHandler.sync(self) 

4500 la_ = self._interp.adaptivePredict(self._input,81,self._ctx) 

4501 if la_ == 1: 

4502 self.state = 698 

4503 self.schema_name() 

4504 self.state = 699 

4505 self.match(SQLiteParser.DOT) 

4506 

4507 

4508 self.state = 703 

4509 self.view_name() 

4510 self.state = 715 

4511 self._errHandler.sync(self) 

4512 _la = self._input.LA(1) 

4513 if _la==SQLiteParser.OPEN_PAR: 

4514 self.state = 704 

4515 self.match(SQLiteParser.OPEN_PAR) 

4516 self.state = 705 

4517 self.column_name() 

4518 self.state = 710 

4519 self._errHandler.sync(self) 

4520 _la = self._input.LA(1) 

4521 while _la==SQLiteParser.COMMA: 

4522 self.state = 706 

4523 self.match(SQLiteParser.COMMA) 

4524 self.state = 707 

4525 self.column_name() 

4526 self.state = 712 

4527 self._errHandler.sync(self) 

4528 _la = self._input.LA(1) 

4529 

4530 self.state = 713 

4531 self.match(SQLiteParser.CLOSE_PAR) 

4532 

4533 

4534 self.state = 717 

4535 self.match(SQLiteParser.AS_) 

4536 self.state = 718 

4537 self.select_stmt() 

4538 except RecognitionException as re: 

4539 localctx.exception = re 

4540 self._errHandler.reportError(self, re) 

4541 self._errHandler.recover(self, re) 

4542 finally: 

4543 self.exitRule() 

4544 return localctx 

4545 

4546 

4547 class Create_virtual_table_stmtContext(ParserRuleContext): 

4548 

4549 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

4550 super().__init__(parent, invokingState) 

4551 self.parser = parser 

4552 

4553 def CREATE_(self): 

4554 return self.getToken(SQLiteParser.CREATE_, 0) 

4555 

4556 def VIRTUAL_(self): 

4557 return self.getToken(SQLiteParser.VIRTUAL_, 0) 

4558 

4559 def TABLE_(self): 

4560 return self.getToken(SQLiteParser.TABLE_, 0) 

4561 

4562 def table_name(self): 

4563 return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0) 

4564 

4565 

4566 def USING_(self): 

4567 return self.getToken(SQLiteParser.USING_, 0) 

4568 

4569 def module_name(self): 

4570 return self.getTypedRuleContext(SQLiteParser.Module_nameContext,0) 

4571 

4572 

4573 def IF_(self): 

4574 return self.getToken(SQLiteParser.IF_, 0) 

4575 

4576 def NOT_(self): 

4577 return self.getToken(SQLiteParser.NOT_, 0) 

4578 

4579 def EXISTS_(self): 

4580 return self.getToken(SQLiteParser.EXISTS_, 0) 

4581 

4582 def schema_name(self): 

4583 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

4584 

4585 

4586 def DOT(self): 

4587 return self.getToken(SQLiteParser.DOT, 0) 

4588 

4589 def OPEN_PAR(self): 

4590 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

4591 

4592 def module_argument(self, i:int=None): 

4593 if i is None: 

4594 return self.getTypedRuleContexts(SQLiteParser.Module_argumentContext) 

4595 else: 

4596 return self.getTypedRuleContext(SQLiteParser.Module_argumentContext,i) 

4597 

4598 

4599 def CLOSE_PAR(self): 

4600 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

4601 

4602 def COMMA(self, i:int=None): 

4603 if i is None: 

4604 return self.getTokens(SQLiteParser.COMMA) 

4605 else: 

4606 return self.getToken(SQLiteParser.COMMA, i) 

4607 

4608 def getRuleIndex(self): 

4609 return SQLiteParser.RULE_create_virtual_table_stmt 

4610 

4611 def enterRule(self, listener:ParseTreeListener): 

4612 if hasattr( listener, "enterCreate_virtual_table_stmt" ): 

4613 listener.enterCreate_virtual_table_stmt(self) 

4614 

4615 def exitRule(self, listener:ParseTreeListener): 

4616 if hasattr( listener, "exitCreate_virtual_table_stmt" ): 

4617 listener.exitCreate_virtual_table_stmt(self) 

4618 

4619 

4620 

4621 

4622 def create_virtual_table_stmt(self): 

4623 

4624 localctx = SQLiteParser.Create_virtual_table_stmtContext(self, self._ctx, self.state) 

4625 self.enterRule(localctx, 46, self.RULE_create_virtual_table_stmt) 

4626 self._la = 0 # Token type 

4627 try: 

4628 self.enterOuterAlt(localctx, 1) 

4629 self.state = 720 

4630 self.match(SQLiteParser.CREATE_) 

4631 self.state = 721 

4632 self.match(SQLiteParser.VIRTUAL_) 

4633 self.state = 722 

4634 self.match(SQLiteParser.TABLE_) 

4635 self.state = 726 

4636 self._errHandler.sync(self) 

4637 la_ = self._interp.adaptivePredict(self._input,84,self._ctx) 

4638 if la_ == 1: 

4639 self.state = 723 

4640 self.match(SQLiteParser.IF_) 

4641 self.state = 724 

4642 self.match(SQLiteParser.NOT_) 

4643 self.state = 725 

4644 self.match(SQLiteParser.EXISTS_) 

4645 

4646 

4647 self.state = 731 

4648 self._errHandler.sync(self) 

4649 la_ = self._interp.adaptivePredict(self._input,85,self._ctx) 

4650 if la_ == 1: 

4651 self.state = 728 

4652 self.schema_name() 

4653 self.state = 729 

4654 self.match(SQLiteParser.DOT) 

4655 

4656 

4657 self.state = 733 

4658 self.table_name() 

4659 self.state = 734 

4660 self.match(SQLiteParser.USING_) 

4661 self.state = 735 

4662 self.module_name() 

4663 self.state = 747 

4664 self._errHandler.sync(self) 

4665 _la = self._input.LA(1) 

4666 if _la==SQLiteParser.OPEN_PAR: 

4667 self.state = 736 

4668 self.match(SQLiteParser.OPEN_PAR) 

4669 self.state = 737 

4670 self.module_argument() 

4671 self.state = 742 

4672 self._errHandler.sync(self) 

4673 _la = self._input.LA(1) 

4674 while _la==SQLiteParser.COMMA: 

4675 self.state = 738 

4676 self.match(SQLiteParser.COMMA) 

4677 self.state = 739 

4678 self.module_argument() 

4679 self.state = 744 

4680 self._errHandler.sync(self) 

4681 _la = self._input.LA(1) 

4682 

4683 self.state = 745 

4684 self.match(SQLiteParser.CLOSE_PAR) 

4685 

4686 

4687 except RecognitionException as re: 

4688 localctx.exception = re 

4689 self._errHandler.reportError(self, re) 

4690 self._errHandler.recover(self, re) 

4691 finally: 

4692 self.exitRule() 

4693 return localctx 

4694 

4695 

4696 class With_clauseContext(ParserRuleContext): 

4697 

4698 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

4699 super().__init__(parent, invokingState) 

4700 self.parser = parser 

4701 

4702 def WITH_(self): 

4703 return self.getToken(SQLiteParser.WITH_, 0) 

4704 

4705 def cte_table_name(self, i:int=None): 

4706 if i is None: 

4707 return self.getTypedRuleContexts(SQLiteParser.Cte_table_nameContext) 

4708 else: 

4709 return self.getTypedRuleContext(SQLiteParser.Cte_table_nameContext,i) 

4710 

4711 

4712 def AS_(self, i:int=None): 

4713 if i is None: 

4714 return self.getTokens(SQLiteParser.AS_) 

4715 else: 

4716 return self.getToken(SQLiteParser.AS_, i) 

4717 

4718 def OPEN_PAR(self, i:int=None): 

4719 if i is None: 

4720 return self.getTokens(SQLiteParser.OPEN_PAR) 

4721 else: 

4722 return self.getToken(SQLiteParser.OPEN_PAR, i) 

4723 

4724 def select_stmt(self, i:int=None): 

4725 if i is None: 

4726 return self.getTypedRuleContexts(SQLiteParser.Select_stmtContext) 

4727 else: 

4728 return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,i) 

4729 

4730 

4731 def CLOSE_PAR(self, i:int=None): 

4732 if i is None: 

4733 return self.getTokens(SQLiteParser.CLOSE_PAR) 

4734 else: 

4735 return self.getToken(SQLiteParser.CLOSE_PAR, i) 

4736 

4737 def RECURSIVE_(self): 

4738 return self.getToken(SQLiteParser.RECURSIVE_, 0) 

4739 

4740 def COMMA(self, i:int=None): 

4741 if i is None: 

4742 return self.getTokens(SQLiteParser.COMMA) 

4743 else: 

4744 return self.getToken(SQLiteParser.COMMA, i) 

4745 

4746 def getRuleIndex(self): 

4747 return SQLiteParser.RULE_with_clause 

4748 

4749 def enterRule(self, listener:ParseTreeListener): 

4750 if hasattr( listener, "enterWith_clause" ): 

4751 listener.enterWith_clause(self) 

4752 

4753 def exitRule(self, listener:ParseTreeListener): 

4754 if hasattr( listener, "exitWith_clause" ): 

4755 listener.exitWith_clause(self) 

4756 

4757 

4758 

4759 

4760 def with_clause(self): 

4761 

4762 localctx = SQLiteParser.With_clauseContext(self, self._ctx, self.state) 

4763 self.enterRule(localctx, 48, self.RULE_with_clause) 

4764 self._la = 0 # Token type 

4765 try: 

4766 self.enterOuterAlt(localctx, 1) 

4767 self.state = 749 

4768 self.match(SQLiteParser.WITH_) 

4769 self.state = 751 

4770 self._errHandler.sync(self) 

4771 la_ = self._interp.adaptivePredict(self._input,88,self._ctx) 

4772 if la_ == 1: 

4773 self.state = 750 

4774 self.match(SQLiteParser.RECURSIVE_) 

4775 

4776 

4777 self.state = 753 

4778 self.cte_table_name() 

4779 self.state = 754 

4780 self.match(SQLiteParser.AS_) 

4781 self.state = 755 

4782 self.match(SQLiteParser.OPEN_PAR) 

4783 self.state = 756 

4784 self.select_stmt() 

4785 self.state = 757 

4786 self.match(SQLiteParser.CLOSE_PAR) 

4787 self.state = 767 

4788 self._errHandler.sync(self) 

4789 _la = self._input.LA(1) 

4790 while _la==SQLiteParser.COMMA: 

4791 self.state = 758 

4792 self.match(SQLiteParser.COMMA) 

4793 self.state = 759 

4794 self.cte_table_name() 

4795 self.state = 760 

4796 self.match(SQLiteParser.AS_) 

4797 self.state = 761 

4798 self.match(SQLiteParser.OPEN_PAR) 

4799 self.state = 762 

4800 self.select_stmt() 

4801 self.state = 763 

4802 self.match(SQLiteParser.CLOSE_PAR) 

4803 self.state = 769 

4804 self._errHandler.sync(self) 

4805 _la = self._input.LA(1) 

4806 

4807 except RecognitionException as re: 

4808 localctx.exception = re 

4809 self._errHandler.reportError(self, re) 

4810 self._errHandler.recover(self, re) 

4811 finally: 

4812 self.exitRule() 

4813 return localctx 

4814 

4815 

4816 class Cte_table_nameContext(ParserRuleContext): 

4817 

4818 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

4819 super().__init__(parent, invokingState) 

4820 self.parser = parser 

4821 

4822 def table_name(self): 

4823 return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0) 

4824 

4825 

4826 def OPEN_PAR(self): 

4827 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

4828 

4829 def column_name(self, i:int=None): 

4830 if i is None: 

4831 return self.getTypedRuleContexts(SQLiteParser.Column_nameContext) 

4832 else: 

4833 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i) 

4834 

4835 

4836 def CLOSE_PAR(self): 

4837 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

4838 

4839 def COMMA(self, i:int=None): 

4840 if i is None: 

4841 return self.getTokens(SQLiteParser.COMMA) 

4842 else: 

4843 return self.getToken(SQLiteParser.COMMA, i) 

4844 

4845 def getRuleIndex(self): 

4846 return SQLiteParser.RULE_cte_table_name 

4847 

4848 def enterRule(self, listener:ParseTreeListener): 

4849 if hasattr( listener, "enterCte_table_name" ): 

4850 listener.enterCte_table_name(self) 

4851 

4852 def exitRule(self, listener:ParseTreeListener): 

4853 if hasattr( listener, "exitCte_table_name" ): 

4854 listener.exitCte_table_name(self) 

4855 

4856 

4857 

4858 

4859 def cte_table_name(self): 

4860 

4861 localctx = SQLiteParser.Cte_table_nameContext(self, self._ctx, self.state) 

4862 self.enterRule(localctx, 50, self.RULE_cte_table_name) 

4863 self._la = 0 # Token type 

4864 try: 

4865 self.enterOuterAlt(localctx, 1) 

4866 self.state = 770 

4867 self.table_name() 

4868 self.state = 782 

4869 self._errHandler.sync(self) 

4870 _la = self._input.LA(1) 

4871 if _la==SQLiteParser.OPEN_PAR: 

4872 self.state = 771 

4873 self.match(SQLiteParser.OPEN_PAR) 

4874 self.state = 772 

4875 self.column_name() 

4876 self.state = 777 

4877 self._errHandler.sync(self) 

4878 _la = self._input.LA(1) 

4879 while _la==SQLiteParser.COMMA: 

4880 self.state = 773 

4881 self.match(SQLiteParser.COMMA) 

4882 self.state = 774 

4883 self.column_name() 

4884 self.state = 779 

4885 self._errHandler.sync(self) 

4886 _la = self._input.LA(1) 

4887 

4888 self.state = 780 

4889 self.match(SQLiteParser.CLOSE_PAR) 

4890 

4891 

4892 except RecognitionException as re: 

4893 localctx.exception = re 

4894 self._errHandler.reportError(self, re) 

4895 self._errHandler.recover(self, re) 

4896 finally: 

4897 self.exitRule() 

4898 return localctx 

4899 

4900 

4901 class Recursive_cteContext(ParserRuleContext): 

4902 

4903 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

4904 super().__init__(parent, invokingState) 

4905 self.parser = parser 

4906 

4907 def cte_table_name(self): 

4908 return self.getTypedRuleContext(SQLiteParser.Cte_table_nameContext,0) 

4909 

4910 

4911 def AS_(self): 

4912 return self.getToken(SQLiteParser.AS_, 0) 

4913 

4914 def OPEN_PAR(self): 

4915 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

4916 

4917 def initial_select(self): 

4918 return self.getTypedRuleContext(SQLiteParser.Initial_selectContext,0) 

4919 

4920 

4921 def UNION_(self): 

4922 return self.getToken(SQLiteParser.UNION_, 0) 

4923 

4924 def recursive__select(self): 

4925 return self.getTypedRuleContext(SQLiteParser.Recursive__selectContext,0) 

4926 

4927 

4928 def CLOSE_PAR(self): 

4929 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

4930 

4931 def ALL_(self): 

4932 return self.getToken(SQLiteParser.ALL_, 0) 

4933 

4934 def getRuleIndex(self): 

4935 return SQLiteParser.RULE_recursive_cte 

4936 

4937 def enterRule(self, listener:ParseTreeListener): 

4938 if hasattr( listener, "enterRecursive_cte" ): 

4939 listener.enterRecursive_cte(self) 

4940 

4941 def exitRule(self, listener:ParseTreeListener): 

4942 if hasattr( listener, "exitRecursive_cte" ): 

4943 listener.exitRecursive_cte(self) 

4944 

4945 

4946 

4947 

4948 def recursive_cte(self): 

4949 

4950 localctx = SQLiteParser.Recursive_cteContext(self, self._ctx, self.state) 

4951 self.enterRule(localctx, 52, self.RULE_recursive_cte) 

4952 self._la = 0 # Token type 

4953 try: 

4954 self.enterOuterAlt(localctx, 1) 

4955 self.state = 784 

4956 self.cte_table_name() 

4957 self.state = 785 

4958 self.match(SQLiteParser.AS_) 

4959 self.state = 786 

4960 self.match(SQLiteParser.OPEN_PAR) 

4961 self.state = 787 

4962 self.initial_select() 

4963 self.state = 788 

4964 self.match(SQLiteParser.UNION_) 

4965 self.state = 790 

4966 self._errHandler.sync(self) 

4967 _la = self._input.LA(1) 

4968 if _la==SQLiteParser.ALL_: 

4969 self.state = 789 

4970 self.match(SQLiteParser.ALL_) 

4971 

4972 

4973 self.state = 792 

4974 self.recursive__select() 

4975 self.state = 793 

4976 self.match(SQLiteParser.CLOSE_PAR) 

4977 except RecognitionException as re: 

4978 localctx.exception = re 

4979 self._errHandler.reportError(self, re) 

4980 self._errHandler.recover(self, re) 

4981 finally: 

4982 self.exitRule() 

4983 return localctx 

4984 

4985 

4986 class Common_table_expressionContext(ParserRuleContext): 

4987 

4988 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

4989 super().__init__(parent, invokingState) 

4990 self.parser = parser 

4991 

4992 def table_name(self): 

4993 return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0) 

4994 

4995 

4996 def AS_(self): 

4997 return self.getToken(SQLiteParser.AS_, 0) 

4998 

4999 def OPEN_PAR(self, i:int=None): 

5000 if i is None: 

5001 return self.getTokens(SQLiteParser.OPEN_PAR) 

5002 else: 

5003 return self.getToken(SQLiteParser.OPEN_PAR, i) 

5004 

5005 def select_stmt(self): 

5006 return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0) 

5007 

5008 

5009 def CLOSE_PAR(self, i:int=None): 

5010 if i is None: 

5011 return self.getTokens(SQLiteParser.CLOSE_PAR) 

5012 else: 

5013 return self.getToken(SQLiteParser.CLOSE_PAR, i) 

5014 

5015 def column_name(self, i:int=None): 

5016 if i is None: 

5017 return self.getTypedRuleContexts(SQLiteParser.Column_nameContext) 

5018 else: 

5019 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i) 

5020 

5021 

5022 def COMMA(self, i:int=None): 

5023 if i is None: 

5024 return self.getTokens(SQLiteParser.COMMA) 

5025 else: 

5026 return self.getToken(SQLiteParser.COMMA, i) 

5027 

5028 def getRuleIndex(self): 

5029 return SQLiteParser.RULE_common_table_expression 

5030 

5031 def enterRule(self, listener:ParseTreeListener): 

5032 if hasattr( listener, "enterCommon_table_expression" ): 

5033 listener.enterCommon_table_expression(self) 

5034 

5035 def exitRule(self, listener:ParseTreeListener): 

5036 if hasattr( listener, "exitCommon_table_expression" ): 

5037 listener.exitCommon_table_expression(self) 

5038 

5039 

5040 

5041 

5042 def common_table_expression(self): 

5043 

5044 localctx = SQLiteParser.Common_table_expressionContext(self, self._ctx, self.state) 

5045 self.enterRule(localctx, 54, self.RULE_common_table_expression) 

5046 self._la = 0 # Token type 

5047 try: 

5048 self.enterOuterAlt(localctx, 1) 

5049 self.state = 795 

5050 self.table_name() 

5051 self.state = 807 

5052 self._errHandler.sync(self) 

5053 _la = self._input.LA(1) 

5054 if _la==SQLiteParser.OPEN_PAR: 

5055 self.state = 796 

5056 self.match(SQLiteParser.OPEN_PAR) 

5057 self.state = 797 

5058 self.column_name() 

5059 self.state = 802 

5060 self._errHandler.sync(self) 

5061 _la = self._input.LA(1) 

5062 while _la==SQLiteParser.COMMA: 

5063 self.state = 798 

5064 self.match(SQLiteParser.COMMA) 

5065 self.state = 799 

5066 self.column_name() 

5067 self.state = 804 

5068 self._errHandler.sync(self) 

5069 _la = self._input.LA(1) 

5070 

5071 self.state = 805 

5072 self.match(SQLiteParser.CLOSE_PAR) 

5073 

5074 

5075 self.state = 809 

5076 self.match(SQLiteParser.AS_) 

5077 self.state = 810 

5078 self.match(SQLiteParser.OPEN_PAR) 

5079 self.state = 811 

5080 self.select_stmt() 

5081 self.state = 812 

5082 self.match(SQLiteParser.CLOSE_PAR) 

5083 except RecognitionException as re: 

5084 localctx.exception = re 

5085 self._errHandler.reportError(self, re) 

5086 self._errHandler.recover(self, re) 

5087 finally: 

5088 self.exitRule() 

5089 return localctx 

5090 

5091 

5092 class Delete_stmtContext(ParserRuleContext): 

5093 

5094 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

5095 super().__init__(parent, invokingState) 

5096 self.parser = parser 

5097 

5098 def DELETE_(self): 

5099 return self.getToken(SQLiteParser.DELETE_, 0) 

5100 

5101 def FROM_(self): 

5102 return self.getToken(SQLiteParser.FROM_, 0) 

5103 

5104 def qualified_table_name(self): 

5105 return self.getTypedRuleContext(SQLiteParser.Qualified_table_nameContext,0) 

5106 

5107 

5108 def with_clause(self): 

5109 return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0) 

5110 

5111 

5112 def WHERE_(self): 

5113 return self.getToken(SQLiteParser.WHERE_, 0) 

5114 

5115 def expr(self): 

5116 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

5117 

5118 

5119 def getRuleIndex(self): 

5120 return SQLiteParser.RULE_delete_stmt 

5121 

5122 def enterRule(self, listener:ParseTreeListener): 

5123 if hasattr( listener, "enterDelete_stmt" ): 

5124 listener.enterDelete_stmt(self) 

5125 

5126 def exitRule(self, listener:ParseTreeListener): 

5127 if hasattr( listener, "exitDelete_stmt" ): 

5128 listener.exitDelete_stmt(self) 

5129 

5130 

5131 

5132 

5133 def delete_stmt(self): 

5134 

5135 localctx = SQLiteParser.Delete_stmtContext(self, self._ctx, self.state) 

5136 self.enterRule(localctx, 56, self.RULE_delete_stmt) 

5137 self._la = 0 # Token type 

5138 try: 

5139 self.enterOuterAlt(localctx, 1) 

5140 self.state = 815 

5141 self._errHandler.sync(self) 

5142 _la = self._input.LA(1) 

5143 if _la==SQLiteParser.WITH_: 

5144 self.state = 814 

5145 self.with_clause() 

5146 

5147 

5148 self.state = 817 

5149 self.match(SQLiteParser.DELETE_) 

5150 self.state = 818 

5151 self.match(SQLiteParser.FROM_) 

5152 self.state = 819 

5153 self.qualified_table_name() 

5154 self.state = 822 

5155 self._errHandler.sync(self) 

5156 _la = self._input.LA(1) 

5157 if _la==SQLiteParser.WHERE_: 

5158 self.state = 820 

5159 self.match(SQLiteParser.WHERE_) 

5160 self.state = 821 

5161 self.expr(0) 

5162 

5163 

5164 except RecognitionException as re: 

5165 localctx.exception = re 

5166 self._errHandler.reportError(self, re) 

5167 self._errHandler.recover(self, re) 

5168 finally: 

5169 self.exitRule() 

5170 return localctx 

5171 

5172 

5173 class Delete_stmt_limitedContext(ParserRuleContext): 

5174 

5175 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

5176 super().__init__(parent, invokingState) 

5177 self.parser = parser 

5178 

5179 def DELETE_(self): 

5180 return self.getToken(SQLiteParser.DELETE_, 0) 

5181 

5182 def FROM_(self): 

5183 return self.getToken(SQLiteParser.FROM_, 0) 

5184 

5185 def qualified_table_name(self): 

5186 return self.getTypedRuleContext(SQLiteParser.Qualified_table_nameContext,0) 

5187 

5188 

5189 def with_clause(self): 

5190 return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0) 

5191 

5192 

5193 def WHERE_(self): 

5194 return self.getToken(SQLiteParser.WHERE_, 0) 

5195 

5196 def expr(self): 

5197 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

5198 

5199 

5200 def limit_stmt(self): 

5201 return self.getTypedRuleContext(SQLiteParser.Limit_stmtContext,0) 

5202 

5203 

5204 def order_by_stmt(self): 

5205 return self.getTypedRuleContext(SQLiteParser.Order_by_stmtContext,0) 

5206 

5207 

5208 def getRuleIndex(self): 

5209 return SQLiteParser.RULE_delete_stmt_limited 

5210 

5211 def enterRule(self, listener:ParseTreeListener): 

5212 if hasattr( listener, "enterDelete_stmt_limited" ): 

5213 listener.enterDelete_stmt_limited(self) 

5214 

5215 def exitRule(self, listener:ParseTreeListener): 

5216 if hasattr( listener, "exitDelete_stmt_limited" ): 

5217 listener.exitDelete_stmt_limited(self) 

5218 

5219 

5220 

5221 

5222 def delete_stmt_limited(self): 

5223 

5224 localctx = SQLiteParser.Delete_stmt_limitedContext(self, self._ctx, self.state) 

5225 self.enterRule(localctx, 58, self.RULE_delete_stmt_limited) 

5226 self._la = 0 # Token type 

5227 try: 

5228 self.enterOuterAlt(localctx, 1) 

5229 self.state = 825 

5230 self._errHandler.sync(self) 

5231 _la = self._input.LA(1) 

5232 if _la==SQLiteParser.WITH_: 

5233 self.state = 824 

5234 self.with_clause() 

5235 

5236 

5237 self.state = 827 

5238 self.match(SQLiteParser.DELETE_) 

5239 self.state = 828 

5240 self.match(SQLiteParser.FROM_) 

5241 self.state = 829 

5242 self.qualified_table_name() 

5243 self.state = 832 

5244 self._errHandler.sync(self) 

5245 _la = self._input.LA(1) 

5246 if _la==SQLiteParser.WHERE_: 

5247 self.state = 830 

5248 self.match(SQLiteParser.WHERE_) 

5249 self.state = 831 

5250 self.expr(0) 

5251 

5252 

5253 self.state = 838 

5254 self._errHandler.sync(self) 

5255 _la = self._input.LA(1) 

5256 if _la==SQLiteParser.LIMIT_ or _la==SQLiteParser.ORDER_: 

5257 self.state = 835 

5258 self._errHandler.sync(self) 

5259 _la = self._input.LA(1) 

5260 if _la==SQLiteParser.ORDER_: 

5261 self.state = 834 

5262 self.order_by_stmt() 

5263 

5264 

5265 self.state = 837 

5266 self.limit_stmt() 

5267 

5268 

5269 except RecognitionException as re: 

5270 localctx.exception = re 

5271 self._errHandler.reportError(self, re) 

5272 self._errHandler.recover(self, re) 

5273 finally: 

5274 self.exitRule() 

5275 return localctx 

5276 

5277 

5278 class Detach_stmtContext(ParserRuleContext): 

5279 

5280 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

5281 super().__init__(parent, invokingState) 

5282 self.parser = parser 

5283 

5284 def DETACH_(self): 

5285 return self.getToken(SQLiteParser.DETACH_, 0) 

5286 

5287 def schema_name(self): 

5288 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

5289 

5290 

5291 def DATABASE_(self): 

5292 return self.getToken(SQLiteParser.DATABASE_, 0) 

5293 

5294 def getRuleIndex(self): 

5295 return SQLiteParser.RULE_detach_stmt 

5296 

5297 def enterRule(self, listener:ParseTreeListener): 

5298 if hasattr( listener, "enterDetach_stmt" ): 

5299 listener.enterDetach_stmt(self) 

5300 

5301 def exitRule(self, listener:ParseTreeListener): 

5302 if hasattr( listener, "exitDetach_stmt" ): 

5303 listener.exitDetach_stmt(self) 

5304 

5305 

5306 

5307 

5308 def detach_stmt(self): 

5309 

5310 localctx = SQLiteParser.Detach_stmtContext(self, self._ctx, self.state) 

5311 self.enterRule(localctx, 60, self.RULE_detach_stmt) 

5312 try: 

5313 self.enterOuterAlt(localctx, 1) 

5314 self.state = 840 

5315 self.match(SQLiteParser.DETACH_) 

5316 self.state = 842 

5317 self._errHandler.sync(self) 

5318 la_ = self._interp.adaptivePredict(self._input,101,self._ctx) 

5319 if la_ == 1: 

5320 self.state = 841 

5321 self.match(SQLiteParser.DATABASE_) 

5322 

5323 

5324 self.state = 844 

5325 self.schema_name() 

5326 except RecognitionException as re: 

5327 localctx.exception = re 

5328 self._errHandler.reportError(self, re) 

5329 self._errHandler.recover(self, re) 

5330 finally: 

5331 self.exitRule() 

5332 return localctx 

5333 

5334 

5335 class Drop_stmtContext(ParserRuleContext): 

5336 

5337 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

5338 super().__init__(parent, invokingState) 

5339 self.parser = parser 

5340 self.object = None # Token 

5341 

5342 def DROP_(self): 

5343 return self.getToken(SQLiteParser.DROP_, 0) 

5344 

5345 def any_name(self): 

5346 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

5347 

5348 

5349 def INDEX_(self): 

5350 return self.getToken(SQLiteParser.INDEX_, 0) 

5351 

5352 def TABLE_(self): 

5353 return self.getToken(SQLiteParser.TABLE_, 0) 

5354 

5355 def TRIGGER_(self): 

5356 return self.getToken(SQLiteParser.TRIGGER_, 0) 

5357 

5358 def VIEW_(self): 

5359 return self.getToken(SQLiteParser.VIEW_, 0) 

5360 

5361 def IF_(self): 

5362 return self.getToken(SQLiteParser.IF_, 0) 

5363 

5364 def EXISTS_(self): 

5365 return self.getToken(SQLiteParser.EXISTS_, 0) 

5366 

5367 def schema_name(self): 

5368 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

5369 

5370 

5371 def DOT(self): 

5372 return self.getToken(SQLiteParser.DOT, 0) 

5373 

5374 def getRuleIndex(self): 

5375 return SQLiteParser.RULE_drop_stmt 

5376 

5377 def enterRule(self, listener:ParseTreeListener): 

5378 if hasattr( listener, "enterDrop_stmt" ): 

5379 listener.enterDrop_stmt(self) 

5380 

5381 def exitRule(self, listener:ParseTreeListener): 

5382 if hasattr( listener, "exitDrop_stmt" ): 

5383 listener.exitDrop_stmt(self) 

5384 

5385 

5386 

5387 

5388 def drop_stmt(self): 

5389 

5390 localctx = SQLiteParser.Drop_stmtContext(self, self._ctx, self.state) 

5391 self.enterRule(localctx, 62, self.RULE_drop_stmt) 

5392 self._la = 0 # Token type 

5393 try: 

5394 self.enterOuterAlt(localctx, 1) 

5395 self.state = 846 

5396 self.match(SQLiteParser.DROP_) 

5397 self.state = 847 

5398 localctx.object = self._input.LT(1) 

5399 _la = self._input.LA(1) 

5400 if not(((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (SQLiteParser.INDEX_ - 84)) | (1 << (SQLiteParser.TABLE_ - 84)) | (1 << (SQLiteParser.TRIGGER_ - 84)) | (1 << (SQLiteParser.VIEW_ - 84)))) != 0)): 

5401 localctx.object = self._errHandler.recoverInline(self) 

5402 else: 

5403 self._errHandler.reportMatch(self) 

5404 self.consume() 

5405 self.state = 850 

5406 self._errHandler.sync(self) 

5407 la_ = self._interp.adaptivePredict(self._input,102,self._ctx) 

5408 if la_ == 1: 

5409 self.state = 848 

5410 self.match(SQLiteParser.IF_) 

5411 self.state = 849 

5412 self.match(SQLiteParser.EXISTS_) 

5413 

5414 

5415 self.state = 855 

5416 self._errHandler.sync(self) 

5417 la_ = self._interp.adaptivePredict(self._input,103,self._ctx) 

5418 if la_ == 1: 

5419 self.state = 852 

5420 self.schema_name() 

5421 self.state = 853 

5422 self.match(SQLiteParser.DOT) 

5423 

5424 

5425 self.state = 857 

5426 self.any_name() 

5427 except RecognitionException as re: 

5428 localctx.exception = re 

5429 self._errHandler.reportError(self, re) 

5430 self._errHandler.recover(self, re) 

5431 finally: 

5432 self.exitRule() 

5433 return localctx 

5434 

5435 

5436 class ExprContext(ParserRuleContext): 

5437 

5438 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

5439 super().__init__(parent, invokingState) 

5440 self.parser = parser 

5441 

5442 def literal_value(self): 

5443 return self.getTypedRuleContext(SQLiteParser.Literal_valueContext,0) 

5444 

5445 

5446 def BIND_PARAMETER(self): 

5447 return self.getToken(SQLiteParser.BIND_PARAMETER, 0) 

5448 

5449 def column_name(self): 

5450 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,0) 

5451 

5452 

5453 def table_name(self): 

5454 return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0) 

5455 

5456 

5457 def DOT(self, i:int=None): 

5458 if i is None: 

5459 return self.getTokens(SQLiteParser.DOT) 

5460 else: 

5461 return self.getToken(SQLiteParser.DOT, i) 

5462 

5463 def schema_name(self): 

5464 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

5465 

5466 

5467 def unary_operator(self): 

5468 return self.getTypedRuleContext(SQLiteParser.Unary_operatorContext,0) 

5469 

5470 

5471 def expr(self, i:int=None): 

5472 if i is None: 

5473 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

5474 else: 

5475 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

5476 

5477 

5478 def function_name(self): 

5479 return self.getTypedRuleContext(SQLiteParser.Function_nameContext,0) 

5480 

5481 

5482 def OPEN_PAR(self): 

5483 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

5484 

5485 def CLOSE_PAR(self): 

5486 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

5487 

5488 def STAR(self): 

5489 return self.getToken(SQLiteParser.STAR, 0) 

5490 

5491 def filter_clause(self): 

5492 return self.getTypedRuleContext(SQLiteParser.Filter_clauseContext,0) 

5493 

5494 

5495 def over_clause(self): 

5496 return self.getTypedRuleContext(SQLiteParser.Over_clauseContext,0) 

5497 

5498 

5499 def DISTINCT_(self): 

5500 return self.getToken(SQLiteParser.DISTINCT_, 0) 

5501 

5502 def COMMA(self, i:int=None): 

5503 if i is None: 

5504 return self.getTokens(SQLiteParser.COMMA) 

5505 else: 

5506 return self.getToken(SQLiteParser.COMMA, i) 

5507 

5508 def CAST_(self): 

5509 return self.getToken(SQLiteParser.CAST_, 0) 

5510 

5511 def AS_(self): 

5512 return self.getToken(SQLiteParser.AS_, 0) 

5513 

5514 def type_name(self): 

5515 return self.getTypedRuleContext(SQLiteParser.Type_nameContext,0) 

5516 

5517 

5518 def select_stmt(self): 

5519 return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0) 

5520 

5521 

5522 def EXISTS_(self): 

5523 return self.getToken(SQLiteParser.EXISTS_, 0) 

5524 

5525 def NOT_(self): 

5526 return self.getToken(SQLiteParser.NOT_, 0) 

5527 

5528 def CASE_(self): 

5529 return self.getToken(SQLiteParser.CASE_, 0) 

5530 

5531 def END_(self): 

5532 return self.getToken(SQLiteParser.END_, 0) 

5533 

5534 def WHEN_(self, i:int=None): 

5535 if i is None: 

5536 return self.getTokens(SQLiteParser.WHEN_) 

5537 else: 

5538 return self.getToken(SQLiteParser.WHEN_, i) 

5539 

5540 def THEN_(self, i:int=None): 

5541 if i is None: 

5542 return self.getTokens(SQLiteParser.THEN_) 

5543 else: 

5544 return self.getToken(SQLiteParser.THEN_, i) 

5545 

5546 def ELSE_(self): 

5547 return self.getToken(SQLiteParser.ELSE_, 0) 

5548 

5549 def raise_function(self): 

5550 return self.getTypedRuleContext(SQLiteParser.Raise_functionContext,0) 

5551 

5552 

5553 def PIPE2(self): 

5554 return self.getToken(SQLiteParser.PIPE2, 0) 

5555 

5556 def DIV(self): 

5557 return self.getToken(SQLiteParser.DIV, 0) 

5558 

5559 def MOD(self): 

5560 return self.getToken(SQLiteParser.MOD, 0) 

5561 

5562 def PLUS(self): 

5563 return self.getToken(SQLiteParser.PLUS, 0) 

5564 

5565 def MINUS(self): 

5566 return self.getToken(SQLiteParser.MINUS, 0) 

5567 

5568 def LT2(self): 

5569 return self.getToken(SQLiteParser.LT2, 0) 

5570 

5571 def GT2(self): 

5572 return self.getToken(SQLiteParser.GT2, 0) 

5573 

5574 def AMP(self): 

5575 return self.getToken(SQLiteParser.AMP, 0) 

5576 

5577 def PIPE(self): 

5578 return self.getToken(SQLiteParser.PIPE, 0) 

5579 

5580 def LT(self): 

5581 return self.getToken(SQLiteParser.LT, 0) 

5582 

5583 def LT_EQ(self): 

5584 return self.getToken(SQLiteParser.LT_EQ, 0) 

5585 

5586 def GT(self): 

5587 return self.getToken(SQLiteParser.GT, 0) 

5588 

5589 def GT_EQ(self): 

5590 return self.getToken(SQLiteParser.GT_EQ, 0) 

5591 

5592 def ASSIGN(self): 

5593 return self.getToken(SQLiteParser.ASSIGN, 0) 

5594 

5595 def EQ(self): 

5596 return self.getToken(SQLiteParser.EQ, 0) 

5597 

5598 def NOT_EQ1(self): 

5599 return self.getToken(SQLiteParser.NOT_EQ1, 0) 

5600 

5601 def NOT_EQ2(self): 

5602 return self.getToken(SQLiteParser.NOT_EQ2, 0) 

5603 

5604 def IS_(self): 

5605 return self.getToken(SQLiteParser.IS_, 0) 

5606 

5607 def IN_(self): 

5608 return self.getToken(SQLiteParser.IN_, 0) 

5609 

5610 def LIKE_(self): 

5611 return self.getToken(SQLiteParser.LIKE_, 0) 

5612 

5613 def GLOB_(self): 

5614 return self.getToken(SQLiteParser.GLOB_, 0) 

5615 

5616 def MATCH_(self): 

5617 return self.getToken(SQLiteParser.MATCH_, 0) 

5618 

5619 def REGEXP_(self): 

5620 return self.getToken(SQLiteParser.REGEXP_, 0) 

5621 

5622 def AND_(self): 

5623 return self.getToken(SQLiteParser.AND_, 0) 

5624 

5625 def OR_(self): 

5626 return self.getToken(SQLiteParser.OR_, 0) 

5627 

5628 def BETWEEN_(self): 

5629 return self.getToken(SQLiteParser.BETWEEN_, 0) 

5630 

5631 def COLLATE_(self): 

5632 return self.getToken(SQLiteParser.COLLATE_, 0) 

5633 

5634 def collation_name(self): 

5635 return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0) 

5636 

5637 

5638 def ESCAPE_(self): 

5639 return self.getToken(SQLiteParser.ESCAPE_, 0) 

5640 

5641 def ISNULL_(self): 

5642 return self.getToken(SQLiteParser.ISNULL_, 0) 

5643 

5644 def NOTNULL_(self): 

5645 return self.getToken(SQLiteParser.NOTNULL_, 0) 

5646 

5647 def NULL_(self): 

5648 return self.getToken(SQLiteParser.NULL_, 0) 

5649 

5650 def table_function_name(self): 

5651 return self.getTypedRuleContext(SQLiteParser.Table_function_nameContext,0) 

5652 

5653 

5654 def getRuleIndex(self): 

5655 return SQLiteParser.RULE_expr 

5656 

5657 def enterRule(self, listener:ParseTreeListener): 

5658 if hasattr( listener, "enterExpr" ): 

5659 listener.enterExpr(self) 

5660 

5661 def exitRule(self, listener:ParseTreeListener): 

5662 if hasattr( listener, "exitExpr" ): 

5663 listener.exitExpr(self) 

5664 

5665 

5666 

5667 def expr(self, _p:int=0): 

5668 _parentctx = self._ctx 

5669 _parentState = self.state 

5670 localctx = SQLiteParser.ExprContext(self, self._ctx, _parentState) 

5671 _prevctx = localctx 

5672 _startState = 64 

5673 self.enterRecursionRule(localctx, 64, self.RULE_expr, _p) 

5674 self._la = 0 # Token type 

5675 try: 

5676 self.enterOuterAlt(localctx, 1) 

5677 self.state = 947 

5678 self._errHandler.sync(self) 

5679 la_ = self._interp.adaptivePredict(self._input,117,self._ctx) 

5680 if la_ == 1: 

5681 self.state = 860 

5682 self.literal_value() 

5683 pass 

5684 

5685 elif la_ == 2: 

5686 self.state = 861 

5687 self.match(SQLiteParser.BIND_PARAMETER) 

5688 pass 

5689 

5690 elif la_ == 3: 

5691 self.state = 870 

5692 self._errHandler.sync(self) 

5693 la_ = self._interp.adaptivePredict(self._input,105,self._ctx) 

5694 if la_ == 1: 

5695 self.state = 865 

5696 self._errHandler.sync(self) 

5697 la_ = self._interp.adaptivePredict(self._input,104,self._ctx) 

5698 if la_ == 1: 

5699 self.state = 862 

5700 self.schema_name() 

5701 self.state = 863 

5702 self.match(SQLiteParser.DOT) 

5703 

5704 

5705 self.state = 867 

5706 self.table_name() 

5707 self.state = 868 

5708 self.match(SQLiteParser.DOT) 

5709 

5710 

5711 self.state = 872 

5712 self.column_name() 

5713 pass 

5714 

5715 elif la_ == 4: 

5716 self.state = 873 

5717 self.unary_operator() 

5718 self.state = 874 

5719 self.expr(21) 

5720 pass 

5721 

5722 elif la_ == 5: 

5723 self.state = 876 

5724 self.function_name() 

5725 self.state = 877 

5726 self.match(SQLiteParser.OPEN_PAR) 

5727 self.state = 890 

5728 self._errHandler.sync(self) 

5729 token = self._input.LA(1) 

5730 if token in [SQLiteParser.OPEN_PAR, SQLiteParser.PLUS, SQLiteParser.MINUS, SQLiteParser.TILDE, SQLiteParser.ABORT_, SQLiteParser.ACTION_, SQLiteParser.ADD_, SQLiteParser.AFTER_, SQLiteParser.ALL_, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.AND_, SQLiteParser.AS_, SQLiteParser.ASC_, SQLiteParser.ATTACH_, SQLiteParser.AUTOINCREMENT_, SQLiteParser.BEFORE_, SQLiteParser.BEGIN_, SQLiteParser.BETWEEN_, SQLiteParser.BY_, SQLiteParser.CASCADE_, SQLiteParser.CASE_, SQLiteParser.CAST_, SQLiteParser.CHECK_, SQLiteParser.COLLATE_, SQLiteParser.COLUMN_, SQLiteParser.COMMIT_, SQLiteParser.CONFLICT_, SQLiteParser.CONSTRAINT_, SQLiteParser.CREATE_, SQLiteParser.CROSS_, SQLiteParser.CURRENT_DATE_, SQLiteParser.CURRENT_TIME_, SQLiteParser.CURRENT_TIMESTAMP_, SQLiteParser.DATABASE_, SQLiteParser.DEFAULT_, SQLiteParser.DEFERRABLE_, SQLiteParser.DEFERRED_, SQLiteParser.DELETE_, SQLiteParser.DESC_, SQLiteParser.DETACH_, SQLiteParser.DISTINCT_, SQLiteParser.DROP_, SQLiteParser.EACH_, SQLiteParser.ELSE_, SQLiteParser.END_, SQLiteParser.ESCAPE_, SQLiteParser.EXCEPT_, SQLiteParser.EXCLUSIVE_, SQLiteParser.EXISTS_, SQLiteParser.EXPLAIN_, SQLiteParser.FAIL_, SQLiteParser.FOR_, SQLiteParser.FOREIGN_, SQLiteParser.FROM_, SQLiteParser.FULL_, SQLiteParser.GLOB_, SQLiteParser.GROUP_, SQLiteParser.HAVING_, SQLiteParser.IF_, SQLiteParser.IGNORE_, SQLiteParser.IMMEDIATE_, SQLiteParser.IN_, SQLiteParser.INDEX_, SQLiteParser.INDEXED_, SQLiteParser.INITIALLY_, SQLiteParser.INNER_, SQLiteParser.INSERT_, SQLiteParser.INSTEAD_, SQLiteParser.INTERSECT_, SQLiteParser.INTO_, SQLiteParser.IS_, SQLiteParser.ISNULL_, SQLiteParser.JOIN_, SQLiteParser.KEY_, SQLiteParser.LEFT_, SQLiteParser.LIKE_, SQLiteParser.LIMIT_, SQLiteParser.MATCH_, SQLiteParser.NATURAL_, SQLiteParser.NO_, SQLiteParser.NOT_, SQLiteParser.NOTNULL_, SQLiteParser.NULL_, SQLiteParser.OF_, SQLiteParser.OFFSET_, SQLiteParser.ON_, SQLiteParser.OR_, SQLiteParser.ORDER_, SQLiteParser.OUTER_, SQLiteParser.PLAN_, SQLiteParser.PRAGMA_, SQLiteParser.PRIMARY_, SQLiteParser.QUERY_, SQLiteParser.RAISE_, SQLiteParser.RECURSIVE_, SQLiteParser.REFERENCES_, SQLiteParser.REGEXP_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.RENAME_, SQLiteParser.REPLACE_, SQLiteParser.RESTRICT_, SQLiteParser.RIGHT_, SQLiteParser.ROLLBACK_, SQLiteParser.ROW_, SQLiteParser.ROWS_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.SET_, SQLiteParser.TABLE_, SQLiteParser.TEMP_, SQLiteParser.TEMPORARY_, SQLiteParser.THEN_, SQLiteParser.TO_, SQLiteParser.TRANSACTION_, SQLiteParser.TRIGGER_, SQLiteParser.UNION_, SQLiteParser.UNIQUE_, SQLiteParser.UPDATE_, SQLiteParser.USING_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.VIEW_, SQLiteParser.VIRTUAL_, SQLiteParser.WHEN_, SQLiteParser.WHERE_, SQLiteParser.WITH_, SQLiteParser.WITHOUT_, SQLiteParser.FIRST_VALUE_, SQLiteParser.OVER_, SQLiteParser.PARTITION_, SQLiteParser.RANGE_, SQLiteParser.PRECEDING_, SQLiteParser.UNBOUNDED_, SQLiteParser.CURRENT_, SQLiteParser.FOLLOWING_, SQLiteParser.CUME_DIST_, SQLiteParser.DENSE_RANK_, SQLiteParser.LAG_, SQLiteParser.LAST_VALUE_, SQLiteParser.LEAD_, SQLiteParser.NTH_VALUE_, SQLiteParser.NTILE_, SQLiteParser.PERCENT_RANK_, SQLiteParser.RANK_, SQLiteParser.ROW_NUMBER_, SQLiteParser.GENERATED_, SQLiteParser.ALWAYS_, SQLiteParser.STORED_, SQLiteParser.TRUE_, SQLiteParser.FALSE_, SQLiteParser.WINDOW_, SQLiteParser.NULLS_, SQLiteParser.FIRST_, SQLiteParser.LAST_, SQLiteParser.FILTER_, SQLiteParser.GROUPS_, SQLiteParser.EXCLUDE_, SQLiteParser.IDENTIFIER, SQLiteParser.NUMERIC_LITERAL, SQLiteParser.BIND_PARAMETER, SQLiteParser.STRING_LITERAL, SQLiteParser.BLOB_LITERAL]: 

5731 self.state = 879 

5732 self._errHandler.sync(self) 

5733 la_ = self._interp.adaptivePredict(self._input,106,self._ctx) 

5734 if la_ == 1: 

5735 self.state = 878 

5736 self.match(SQLiteParser.DISTINCT_) 

5737 

5738 

5739 self.state = 881 

5740 self.expr(0) 

5741 self.state = 886 

5742 self._errHandler.sync(self) 

5743 _la = self._input.LA(1) 

5744 while _la==SQLiteParser.COMMA: 

5745 self.state = 882 

5746 self.match(SQLiteParser.COMMA) 

5747 self.state = 883 

5748 self.expr(0) 

5749 self.state = 888 

5750 self._errHandler.sync(self) 

5751 _la = self._input.LA(1) 

5752 

5753 pass 

5754 elif token in [SQLiteParser.STAR]: 

5755 self.state = 889 

5756 self.match(SQLiteParser.STAR) 

5757 pass 

5758 elif token in [SQLiteParser.CLOSE_PAR]: 

5759 pass 

5760 else: 

5761 pass 

5762 self.state = 892 

5763 self.match(SQLiteParser.CLOSE_PAR) 

5764 self.state = 894 

5765 self._errHandler.sync(self) 

5766 la_ = self._interp.adaptivePredict(self._input,109,self._ctx) 

5767 if la_ == 1: 

5768 self.state = 893 

5769 self.filter_clause() 

5770 

5771 

5772 self.state = 897 

5773 self._errHandler.sync(self) 

5774 la_ = self._interp.adaptivePredict(self._input,110,self._ctx) 

5775 if la_ == 1: 

5776 self.state = 896 

5777 self.over_clause() 

5778 

5779 

5780 pass 

5781 

5782 elif la_ == 6: 

5783 self.state = 899 

5784 self.match(SQLiteParser.OPEN_PAR) 

5785 self.state = 900 

5786 self.expr(0) 

5787 self.state = 905 

5788 self._errHandler.sync(self) 

5789 _la = self._input.LA(1) 

5790 while _la==SQLiteParser.COMMA: 

5791 self.state = 901 

5792 self.match(SQLiteParser.COMMA) 

5793 self.state = 902 

5794 self.expr(0) 

5795 self.state = 907 

5796 self._errHandler.sync(self) 

5797 _la = self._input.LA(1) 

5798 

5799 self.state = 908 

5800 self.match(SQLiteParser.CLOSE_PAR) 

5801 pass 

5802 

5803 elif la_ == 7: 

5804 self.state = 910 

5805 self.match(SQLiteParser.CAST_) 

5806 self.state = 911 

5807 self.match(SQLiteParser.OPEN_PAR) 

5808 self.state = 912 

5809 self.expr(0) 

5810 self.state = 913 

5811 self.match(SQLiteParser.AS_) 

5812 self.state = 914 

5813 self.type_name() 

5814 self.state = 915 

5815 self.match(SQLiteParser.CLOSE_PAR) 

5816 pass 

5817 

5818 elif la_ == 8: 

5819 self.state = 921 

5820 self._errHandler.sync(self) 

5821 _la = self._input.LA(1) 

5822 if _la==SQLiteParser.EXISTS_ or _la==SQLiteParser.NOT_: 

5823 self.state = 918 

5824 self._errHandler.sync(self) 

5825 _la = self._input.LA(1) 

5826 if _la==SQLiteParser.NOT_: 

5827 self.state = 917 

5828 self.match(SQLiteParser.NOT_) 

5829 

5830 

5831 self.state = 920 

5832 self.match(SQLiteParser.EXISTS_) 

5833 

5834 

5835 self.state = 923 

5836 self.match(SQLiteParser.OPEN_PAR) 

5837 self.state = 924 

5838 self.select_stmt() 

5839 self.state = 925 

5840 self.match(SQLiteParser.CLOSE_PAR) 

5841 pass 

5842 

5843 elif la_ == 9: 

5844 self.state = 927 

5845 self.match(SQLiteParser.CASE_) 

5846 self.state = 929 

5847 self._errHandler.sync(self) 

5848 la_ = self._interp.adaptivePredict(self._input,114,self._ctx) 

5849 if la_ == 1: 

5850 self.state = 928 

5851 self.expr(0) 

5852 

5853 

5854 self.state = 936 

5855 self._errHandler.sync(self) 

5856 _la = self._input.LA(1) 

5857 while True: 

5858 self.state = 931 

5859 self.match(SQLiteParser.WHEN_) 

5860 self.state = 932 

5861 self.expr(0) 

5862 self.state = 933 

5863 self.match(SQLiteParser.THEN_) 

5864 self.state = 934 

5865 self.expr(0) 

5866 self.state = 938 

5867 self._errHandler.sync(self) 

5868 _la = self._input.LA(1) 

5869 if not (_la==SQLiteParser.WHEN_): 

5870 break 

5871 

5872 self.state = 942 

5873 self._errHandler.sync(self) 

5874 _la = self._input.LA(1) 

5875 if _la==SQLiteParser.ELSE_: 

5876 self.state = 940 

5877 self.match(SQLiteParser.ELSE_) 

5878 self.state = 941 

5879 self.expr(0) 

5880 

5881 

5882 self.state = 944 

5883 self.match(SQLiteParser.END_) 

5884 pass 

5885 

5886 elif la_ == 10: 

5887 self.state = 946 

5888 self.raise_function() 

5889 pass 

5890 

5891 

5892 self._ctx.stop = self._input.LT(-1) 

5893 self.state = 1068 

5894 self._errHandler.sync(self) 

5895 _alt = self._interp.adaptivePredict(self._input,133,self._ctx) 

5896 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: 

5897 if _alt==1: 

5898 if self._parseListeners is not None: 

5899 self.triggerExitRuleEvent() 

5900 _prevctx = localctx 

5901 self.state = 1066 

5902 self._errHandler.sync(self) 

5903 la_ = self._interp.adaptivePredict(self._input,132,self._ctx) 

5904 if la_ == 1: 

5905 localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState) 

5906 self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) 

5907 self.state = 949 

5908 if not self.precpred(self._ctx, 20): 

5909 from antlr4.error.Errors import FailedPredicateException 

5910 raise FailedPredicateException(self, "self.precpred(self._ctx, 20)") 

5911 self.state = 950 

5912 self.match(SQLiteParser.PIPE2) 

5913 self.state = 951 

5914 self.expr(21) 

5915 pass 

5916 

5917 elif la_ == 2: 

5918 localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState) 

5919 self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) 

5920 self.state = 952 

5921 if not self.precpred(self._ctx, 19): 

5922 from antlr4.error.Errors import FailedPredicateException 

5923 raise FailedPredicateException(self, "self.precpred(self._ctx, 19)") 

5924 self.state = 953 

5925 _la = self._input.LA(1) 

5926 if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.STAR) | (1 << SQLiteParser.DIV) | (1 << SQLiteParser.MOD))) != 0)): 

5927 self._errHandler.recoverInline(self) 

5928 else: 

5929 self._errHandler.reportMatch(self) 

5930 self.consume() 

5931 self.state = 954 

5932 self.expr(20) 

5933 pass 

5934 

5935 elif la_ == 3: 

5936 localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState) 

5937 self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) 

5938 self.state = 955 

5939 if not self.precpred(self._ctx, 18): 

5940 from antlr4.error.Errors import FailedPredicateException 

5941 raise FailedPredicateException(self, "self.precpred(self._ctx, 18)") 

5942 self.state = 956 

5943 _la = self._input.LA(1) 

5944 if not(_la==SQLiteParser.PLUS or _la==SQLiteParser.MINUS): 

5945 self._errHandler.recoverInline(self) 

5946 else: 

5947 self._errHandler.reportMatch(self) 

5948 self.consume() 

5949 self.state = 957 

5950 self.expr(19) 

5951 pass 

5952 

5953 elif la_ == 4: 

5954 localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState) 

5955 self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) 

5956 self.state = 958 

5957 if not self.precpred(self._ctx, 17): 

5958 from antlr4.error.Errors import FailedPredicateException 

5959 raise FailedPredicateException(self, "self.precpred(self._ctx, 17)") 

5960 self.state = 959 

5961 _la = self._input.LA(1) 

5962 if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.LT2) | (1 << SQLiteParser.GT2) | (1 << SQLiteParser.AMP) | (1 << SQLiteParser.PIPE))) != 0)): 

5963 self._errHandler.recoverInline(self) 

5964 else: 

5965 self._errHandler.reportMatch(self) 

5966 self.consume() 

5967 self.state = 960 

5968 self.expr(18) 

5969 pass 

5970 

5971 elif la_ == 5: 

5972 localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState) 

5973 self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) 

5974 self.state = 961 

5975 if not self.precpred(self._ctx, 16): 

5976 from antlr4.error.Errors import FailedPredicateException 

5977 raise FailedPredicateException(self, "self.precpred(self._ctx, 16)") 

5978 self.state = 962 

5979 _la = self._input.LA(1) 

5980 if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.LT) | (1 << SQLiteParser.LT_EQ) | (1 << SQLiteParser.GT) | (1 << SQLiteParser.GT_EQ))) != 0)): 

5981 self._errHandler.recoverInline(self) 

5982 else: 

5983 self._errHandler.reportMatch(self) 

5984 self.consume() 

5985 self.state = 963 

5986 self.expr(17) 

5987 pass 

5988 

5989 elif la_ == 6: 

5990 localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState) 

5991 self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) 

5992 self.state = 964 

5993 if not self.precpred(self._ctx, 15): 

5994 from antlr4.error.Errors import FailedPredicateException 

5995 raise FailedPredicateException(self, "self.precpred(self._ctx, 15)") 

5996 self.state = 977 

5997 self._errHandler.sync(self) 

5998 la_ = self._interp.adaptivePredict(self._input,118,self._ctx) 

5999 if la_ == 1: 

6000 self.state = 965 

6001 self.match(SQLiteParser.ASSIGN) 

6002 pass 

6003 

6004 elif la_ == 2: 

6005 self.state = 966 

6006 self.match(SQLiteParser.EQ) 

6007 pass 

6008 

6009 elif la_ == 3: 

6010 self.state = 967 

6011 self.match(SQLiteParser.NOT_EQ1) 

6012 pass 

6013 

6014 elif la_ == 4: 

6015 self.state = 968 

6016 self.match(SQLiteParser.NOT_EQ2) 

6017 pass 

6018 

6019 elif la_ == 5: 

6020 self.state = 969 

6021 self.match(SQLiteParser.IS_) 

6022 pass 

6023 

6024 elif la_ == 6: 

6025 self.state = 970 

6026 self.match(SQLiteParser.IS_) 

6027 self.state = 971 

6028 self.match(SQLiteParser.NOT_) 

6029 pass 

6030 

6031 elif la_ == 7: 

6032 self.state = 972 

6033 self.match(SQLiteParser.IN_) 

6034 pass 

6035 

6036 elif la_ == 8: 

6037 self.state = 973 

6038 self.match(SQLiteParser.LIKE_) 

6039 pass 

6040 

6041 elif la_ == 9: 

6042 self.state = 974 

6043 self.match(SQLiteParser.GLOB_) 

6044 pass 

6045 

6046 elif la_ == 10: 

6047 self.state = 975 

6048 self.match(SQLiteParser.MATCH_) 

6049 pass 

6050 

6051 elif la_ == 11: 

6052 self.state = 976 

6053 self.match(SQLiteParser.REGEXP_) 

6054 pass 

6055 

6056 

6057 self.state = 979 

6058 self.expr(16) 

6059 pass 

6060 

6061 elif la_ == 7: 

6062 localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState) 

6063 self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) 

6064 self.state = 980 

6065 if not self.precpred(self._ctx, 14): 

6066 from antlr4.error.Errors import FailedPredicateException 

6067 raise FailedPredicateException(self, "self.precpred(self._ctx, 14)") 

6068 self.state = 981 

6069 self.match(SQLiteParser.AND_) 

6070 self.state = 982 

6071 self.expr(15) 

6072 pass 

6073 

6074 elif la_ == 8: 

6075 localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState) 

6076 self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) 

6077 self.state = 983 

6078 if not self.precpred(self._ctx, 13): 

6079 from antlr4.error.Errors import FailedPredicateException 

6080 raise FailedPredicateException(self, "self.precpred(self._ctx, 13)") 

6081 self.state = 984 

6082 self.match(SQLiteParser.OR_) 

6083 self.state = 985 

6084 self.expr(14) 

6085 pass 

6086 

6087 elif la_ == 9: 

6088 localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState) 

6089 self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) 

6090 self.state = 986 

6091 if not self.precpred(self._ctx, 6): 

6092 from antlr4.error.Errors import FailedPredicateException 

6093 raise FailedPredicateException(self, "self.precpred(self._ctx, 6)") 

6094 self.state = 987 

6095 self.match(SQLiteParser.IS_) 

6096 self.state = 989 

6097 self._errHandler.sync(self) 

6098 la_ = self._interp.adaptivePredict(self._input,119,self._ctx) 

6099 if la_ == 1: 

6100 self.state = 988 

6101 self.match(SQLiteParser.NOT_) 

6102 

6103 

6104 self.state = 991 

6105 self.expr(7) 

6106 pass 

6107 

6108 elif la_ == 10: 

6109 localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState) 

6110 self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) 

6111 self.state = 992 

6112 if not self.precpred(self._ctx, 5): 

6113 from antlr4.error.Errors import FailedPredicateException 

6114 raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") 

6115 self.state = 994 

6116 self._errHandler.sync(self) 

6117 _la = self._input.LA(1) 

6118 if _la==SQLiteParser.NOT_: 

6119 self.state = 993 

6120 self.match(SQLiteParser.NOT_) 

6121 

6122 

6123 self.state = 996 

6124 self.match(SQLiteParser.BETWEEN_) 

6125 self.state = 997 

6126 self.expr(0) 

6127 self.state = 998 

6128 self.match(SQLiteParser.AND_) 

6129 self.state = 999 

6130 self.expr(6) 

6131 pass 

6132 

6133 elif la_ == 11: 

6134 localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState) 

6135 self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) 

6136 self.state = 1001 

6137 if not self.precpred(self._ctx, 9): 

6138 from antlr4.error.Errors import FailedPredicateException 

6139 raise FailedPredicateException(self, "self.precpred(self._ctx, 9)") 

6140 self.state = 1002 

6141 self.match(SQLiteParser.COLLATE_) 

6142 self.state = 1003 

6143 self.collation_name() 

6144 pass 

6145 

6146 elif la_ == 12: 

6147 localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState) 

6148 self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) 

6149 self.state = 1004 

6150 if not self.precpred(self._ctx, 8): 

6151 from antlr4.error.Errors import FailedPredicateException 

6152 raise FailedPredicateException(self, "self.precpred(self._ctx, 8)") 

6153 self.state = 1006 

6154 self._errHandler.sync(self) 

6155 _la = self._input.LA(1) 

6156 if _la==SQLiteParser.NOT_: 

6157 self.state = 1005 

6158 self.match(SQLiteParser.NOT_) 

6159 

6160 

6161 self.state = 1008 

6162 _la = self._input.LA(1) 

6163 if not(((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & ((1 << (SQLiteParser.GLOB_ - 77)) | (1 << (SQLiteParser.LIKE_ - 77)) | (1 << (SQLiteParser.MATCH_ - 77)) | (1 << (SQLiteParser.REGEXP_ - 77)))) != 0)): 

6164 self._errHandler.recoverInline(self) 

6165 else: 

6166 self._errHandler.reportMatch(self) 

6167 self.consume() 

6168 self.state = 1009 

6169 self.expr(0) 

6170 self.state = 1012 

6171 self._errHandler.sync(self) 

6172 la_ = self._interp.adaptivePredict(self._input,122,self._ctx) 

6173 if la_ == 1: 

6174 self.state = 1010 

6175 self.match(SQLiteParser.ESCAPE_) 

6176 self.state = 1011 

6177 self.expr(0) 

6178 

6179 

6180 pass 

6181 

6182 elif la_ == 13: 

6183 localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState) 

6184 self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) 

6185 self.state = 1014 

6186 if not self.precpred(self._ctx, 7): 

6187 from antlr4.error.Errors import FailedPredicateException 

6188 raise FailedPredicateException(self, "self.precpred(self._ctx, 7)") 

6189 self.state = 1019 

6190 self._errHandler.sync(self) 

6191 token = self._input.LA(1) 

6192 if token in [SQLiteParser.ISNULL_]: 

6193 self.state = 1015 

6194 self.match(SQLiteParser.ISNULL_) 

6195 pass 

6196 elif token in [SQLiteParser.NOTNULL_]: 

6197 self.state = 1016 

6198 self.match(SQLiteParser.NOTNULL_) 

6199 pass 

6200 elif token in [SQLiteParser.NOT_]: 

6201 self.state = 1017 

6202 self.match(SQLiteParser.NOT_) 

6203 self.state = 1018 

6204 self.match(SQLiteParser.NULL_) 

6205 pass 

6206 else: 

6207 raise NoViableAltException(self) 

6208 

6209 pass 

6210 

6211 elif la_ == 14: 

6212 localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState) 

6213 self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) 

6214 self.state = 1021 

6215 if not self.precpred(self._ctx, 4): 

6216 from antlr4.error.Errors import FailedPredicateException 

6217 raise FailedPredicateException(self, "self.precpred(self._ctx, 4)") 

6218 self.state = 1023 

6219 self._errHandler.sync(self) 

6220 _la = self._input.LA(1) 

6221 if _la==SQLiteParser.NOT_: 

6222 self.state = 1022 

6223 self.match(SQLiteParser.NOT_) 

6224 

6225 

6226 self.state = 1025 

6227 self.match(SQLiteParser.IN_) 

6228 self.state = 1064 

6229 self._errHandler.sync(self) 

6230 la_ = self._interp.adaptivePredict(self._input,131,self._ctx) 

6231 if la_ == 1: 

6232 self.state = 1026 

6233 self.match(SQLiteParser.OPEN_PAR) 

6234 self.state = 1036 

6235 self._errHandler.sync(self) 

6236 la_ = self._interp.adaptivePredict(self._input,126,self._ctx) 

6237 if la_ == 1: 

6238 self.state = 1027 

6239 self.select_stmt() 

6240 

6241 elif la_ == 2: 

6242 self.state = 1028 

6243 self.expr(0) 

6244 self.state = 1033 

6245 self._errHandler.sync(self) 

6246 _la = self._input.LA(1) 

6247 while _la==SQLiteParser.COMMA: 

6248 self.state = 1029 

6249 self.match(SQLiteParser.COMMA) 

6250 self.state = 1030 

6251 self.expr(0) 

6252 self.state = 1035 

6253 self._errHandler.sync(self) 

6254 _la = self._input.LA(1) 

6255 

6256 

6257 

6258 self.state = 1038 

6259 self.match(SQLiteParser.CLOSE_PAR) 

6260 pass 

6261 

6262 elif la_ == 2: 

6263 self.state = 1042 

6264 self._errHandler.sync(self) 

6265 la_ = self._interp.adaptivePredict(self._input,127,self._ctx) 

6266 if la_ == 1: 

6267 self.state = 1039 

6268 self.schema_name() 

6269 self.state = 1040 

6270 self.match(SQLiteParser.DOT) 

6271 

6272 

6273 self.state = 1044 

6274 self.table_name() 

6275 pass 

6276 

6277 elif la_ == 3: 

6278 self.state = 1048 

6279 self._errHandler.sync(self) 

6280 la_ = self._interp.adaptivePredict(self._input,128,self._ctx) 

6281 if la_ == 1: 

6282 self.state = 1045 

6283 self.schema_name() 

6284 self.state = 1046 

6285 self.match(SQLiteParser.DOT) 

6286 

6287 

6288 self.state = 1050 

6289 self.table_function_name() 

6290 self.state = 1051 

6291 self.match(SQLiteParser.OPEN_PAR) 

6292 self.state = 1060 

6293 self._errHandler.sync(self) 

6294 _la = self._input.LA(1) 

6295 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.OPEN_PAR) | (1 << SQLiteParser.PLUS) | (1 << SQLiteParser.MINUS) | (1 << SQLiteParser.TILDE) | (1 << SQLiteParser.ABORT_) | (1 << SQLiteParser.ACTION_) | (1 << SQLiteParser.ADD_) | (1 << SQLiteParser.AFTER_) | (1 << SQLiteParser.ALL_) | (1 << SQLiteParser.ALTER_) | (1 << SQLiteParser.ANALYZE_) | (1 << SQLiteParser.AND_) | (1 << SQLiteParser.AS_) | (1 << SQLiteParser.ASC_) | (1 << SQLiteParser.ATTACH_) | (1 << SQLiteParser.AUTOINCREMENT_) | (1 << SQLiteParser.BEFORE_) | (1 << SQLiteParser.BEGIN_) | (1 << SQLiteParser.BETWEEN_) | (1 << SQLiteParser.BY_) | (1 << SQLiteParser.CASCADE_) | (1 << SQLiteParser.CASE_) | (1 << SQLiteParser.CAST_) | (1 << SQLiteParser.CHECK_) | (1 << SQLiteParser.COLLATE_) | (1 << SQLiteParser.COLUMN_) | (1 << SQLiteParser.COMMIT_) | (1 << SQLiteParser.CONFLICT_) | (1 << SQLiteParser.CONSTRAINT_) | (1 << SQLiteParser.CREATE_) | (1 << SQLiteParser.CROSS_) | (1 << SQLiteParser.CURRENT_DATE_) | (1 << SQLiteParser.CURRENT_TIME_) | (1 << SQLiteParser.CURRENT_TIMESTAMP_) | (1 << SQLiteParser.DATABASE_) | (1 << SQLiteParser.DEFAULT_) | (1 << SQLiteParser.DEFERRABLE_) | (1 << SQLiteParser.DEFERRED_) | (1 << SQLiteParser.DELETE_) | (1 << SQLiteParser.DESC_) | (1 << SQLiteParser.DETACH_) | (1 << SQLiteParser.DISTINCT_) | (1 << SQLiteParser.DROP_))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SQLiteParser.EACH_ - 64)) | (1 << (SQLiteParser.ELSE_ - 64)) | (1 << (SQLiteParser.END_ - 64)) | (1 << (SQLiteParser.ESCAPE_ - 64)) | (1 << (SQLiteParser.EXCEPT_ - 64)) | (1 << (SQLiteParser.EXCLUSIVE_ - 64)) | (1 << (SQLiteParser.EXISTS_ - 64)) | (1 << (SQLiteParser.EXPLAIN_ - 64)) | (1 << (SQLiteParser.FAIL_ - 64)) | (1 << (SQLiteParser.FOR_ - 64)) | (1 << (SQLiteParser.FOREIGN_ - 64)) | (1 << (SQLiteParser.FROM_ - 64)) | (1 << (SQLiteParser.FULL_ - 64)) | (1 << (SQLiteParser.GLOB_ - 64)) | (1 << (SQLiteParser.GROUP_ - 64)) | (1 << (SQLiteParser.HAVING_ - 64)) | (1 << (SQLiteParser.IF_ - 64)) | (1 << (SQLiteParser.IGNORE_ - 64)) | (1 << (SQLiteParser.IMMEDIATE_ - 64)) | (1 << (SQLiteParser.IN_ - 64)) | (1 << (SQLiteParser.INDEX_ - 64)) | (1 << (SQLiteParser.INDEXED_ - 64)) | (1 << (SQLiteParser.INITIALLY_ - 64)) | (1 << (SQLiteParser.INNER_ - 64)) | (1 << (SQLiteParser.INSERT_ - 64)) | (1 << (SQLiteParser.INSTEAD_ - 64)) | (1 << (SQLiteParser.INTERSECT_ - 64)) | (1 << (SQLiteParser.INTO_ - 64)) | (1 << (SQLiteParser.IS_ - 64)) | (1 << (SQLiteParser.ISNULL_ - 64)) | (1 << (SQLiteParser.JOIN_ - 64)) | (1 << (SQLiteParser.KEY_ - 64)) | (1 << (SQLiteParser.LEFT_ - 64)) | (1 << (SQLiteParser.LIKE_ - 64)) | (1 << (SQLiteParser.LIMIT_ - 64)) | (1 << (SQLiteParser.MATCH_ - 64)) | (1 << (SQLiteParser.NATURAL_ - 64)) | (1 << (SQLiteParser.NO_ - 64)) | (1 << (SQLiteParser.NOT_ - 64)) | (1 << (SQLiteParser.NOTNULL_ - 64)) | (1 << (SQLiteParser.NULL_ - 64)) | (1 << (SQLiteParser.OF_ - 64)) | (1 << (SQLiteParser.OFFSET_ - 64)) | (1 << (SQLiteParser.ON_ - 64)) | (1 << (SQLiteParser.OR_ - 64)) | (1 << (SQLiteParser.ORDER_ - 64)) | (1 << (SQLiteParser.OUTER_ - 64)) | (1 << (SQLiteParser.PLAN_ - 64)) | (1 << (SQLiteParser.PRAGMA_ - 64)) | (1 << (SQLiteParser.PRIMARY_ - 64)) | (1 << (SQLiteParser.QUERY_ - 64)) | (1 << (SQLiteParser.RAISE_ - 64)) | (1 << (SQLiteParser.RECURSIVE_ - 64)) | (1 << (SQLiteParser.REFERENCES_ - 64)) | (1 << (SQLiteParser.REGEXP_ - 64)) | (1 << (SQLiteParser.REINDEX_ - 64)) | (1 << (SQLiteParser.RELEASE_ - 64)) | (1 << (SQLiteParser.RENAME_ - 64)) | (1 << (SQLiteParser.REPLACE_ - 64)) | (1 << (SQLiteParser.RESTRICT_ - 64)) | (1 << (SQLiteParser.RIGHT_ - 64)) | (1 << (SQLiteParser.ROLLBACK_ - 64)) | (1 << (SQLiteParser.ROW_ - 64)) | (1 << (SQLiteParser.ROWS_ - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SQLiteParser.SAVEPOINT_ - 128)) | (1 << (SQLiteParser.SELECT_ - 128)) | (1 << (SQLiteParser.SET_ - 128)) | (1 << (SQLiteParser.TABLE_ - 128)) | (1 << (SQLiteParser.TEMP_ - 128)) | (1 << (SQLiteParser.TEMPORARY_ - 128)) | (1 << (SQLiteParser.THEN_ - 128)) | (1 << (SQLiteParser.TO_ - 128)) | (1 << (SQLiteParser.TRANSACTION_ - 128)) | (1 << (SQLiteParser.TRIGGER_ - 128)) | (1 << (SQLiteParser.UNION_ - 128)) | (1 << (SQLiteParser.UNIQUE_ - 128)) | (1 << (SQLiteParser.UPDATE_ - 128)) | (1 << (SQLiteParser.USING_ - 128)) | (1 << (SQLiteParser.VACUUM_ - 128)) | (1 << (SQLiteParser.VALUES_ - 128)) | (1 << (SQLiteParser.VIEW_ - 128)) | (1 << (SQLiteParser.VIRTUAL_ - 128)) | (1 << (SQLiteParser.WHEN_ - 128)) | (1 << (SQLiteParser.WHERE_ - 128)) | (1 << (SQLiteParser.WITH_ - 128)) | (1 << (SQLiteParser.WITHOUT_ - 128)) | (1 << (SQLiteParser.FIRST_VALUE_ - 128)) | (1 << (SQLiteParser.OVER_ - 128)) | (1 << (SQLiteParser.PARTITION_ - 128)) | (1 << (SQLiteParser.RANGE_ - 128)) | (1 << (SQLiteParser.PRECEDING_ - 128)) | (1 << (SQLiteParser.UNBOUNDED_ - 128)) | (1 << (SQLiteParser.CURRENT_ - 128)) | (1 << (SQLiteParser.FOLLOWING_ - 128)) | (1 << (SQLiteParser.CUME_DIST_ - 128)) | (1 << (SQLiteParser.DENSE_RANK_ - 128)) | (1 << (SQLiteParser.LAG_ - 128)) | (1 << (SQLiteParser.LAST_VALUE_ - 128)) | (1 << (SQLiteParser.LEAD_ - 128)) | (1 << (SQLiteParser.NTH_VALUE_ - 128)) | (1 << (SQLiteParser.NTILE_ - 128)) | (1 << (SQLiteParser.PERCENT_RANK_ - 128)) | (1 << (SQLiteParser.RANK_ - 128)) | (1 << (SQLiteParser.ROW_NUMBER_ - 128)) | (1 << (SQLiteParser.GENERATED_ - 128)) | (1 << (SQLiteParser.ALWAYS_ - 128)) | (1 << (SQLiteParser.STORED_ - 128)) | (1 << (SQLiteParser.TRUE_ - 128)) | (1 << (SQLiteParser.FALSE_ - 128)) | (1 << (SQLiteParser.WINDOW_ - 128)) | (1 << (SQLiteParser.NULLS_ - 128)) | (1 << (SQLiteParser.FIRST_ - 128)) | (1 << (SQLiteParser.LAST_ - 128)) | (1 << (SQLiteParser.FILTER_ - 128)) | (1 << (SQLiteParser.GROUPS_ - 128)) | (1 << (SQLiteParser.EXCLUDE_ - 128)) | (1 << (SQLiteParser.IDENTIFIER - 128)) | (1 << (SQLiteParser.NUMERIC_LITERAL - 128)) | (1 << (SQLiteParser.BIND_PARAMETER - 128)) | (1 << (SQLiteParser.STRING_LITERAL - 128)) | (1 << (SQLiteParser.BLOB_LITERAL - 128)))) != 0): 

6296 self.state = 1052 

6297 self.expr(0) 

6298 self.state = 1057 

6299 self._errHandler.sync(self) 

6300 _la = self._input.LA(1) 

6301 while _la==SQLiteParser.COMMA: 

6302 self.state = 1053 

6303 self.match(SQLiteParser.COMMA) 

6304 self.state = 1054 

6305 self.expr(0) 

6306 self.state = 1059 

6307 self._errHandler.sync(self) 

6308 _la = self._input.LA(1) 

6309 

6310 

6311 

6312 self.state = 1062 

6313 self.match(SQLiteParser.CLOSE_PAR) 

6314 pass 

6315 

6316 

6317 pass 

6318 

6319 

6320 self.state = 1070 

6321 self._errHandler.sync(self) 

6322 _alt = self._interp.adaptivePredict(self._input,133,self._ctx) 

6323 

6324 except RecognitionException as re: 

6325 localctx.exception = re 

6326 self._errHandler.reportError(self, re) 

6327 self._errHandler.recover(self, re) 

6328 finally: 

6329 self.unrollRecursionContexts(_parentctx) 

6330 return localctx 

6331 

6332 

6333 class Raise_functionContext(ParserRuleContext): 

6334 

6335 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

6336 super().__init__(parent, invokingState) 

6337 self.parser = parser 

6338 

6339 def RAISE_(self): 

6340 return self.getToken(SQLiteParser.RAISE_, 0) 

6341 

6342 def OPEN_PAR(self): 

6343 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

6344 

6345 def CLOSE_PAR(self): 

6346 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

6347 

6348 def IGNORE_(self): 

6349 return self.getToken(SQLiteParser.IGNORE_, 0) 

6350 

6351 def COMMA(self): 

6352 return self.getToken(SQLiteParser.COMMA, 0) 

6353 

6354 def error_message(self): 

6355 return self.getTypedRuleContext(SQLiteParser.Error_messageContext,0) 

6356 

6357 

6358 def ROLLBACK_(self): 

6359 return self.getToken(SQLiteParser.ROLLBACK_, 0) 

6360 

6361 def ABORT_(self): 

6362 return self.getToken(SQLiteParser.ABORT_, 0) 

6363 

6364 def FAIL_(self): 

6365 return self.getToken(SQLiteParser.FAIL_, 0) 

6366 

6367 def getRuleIndex(self): 

6368 return SQLiteParser.RULE_raise_function 

6369 

6370 def enterRule(self, listener:ParseTreeListener): 

6371 if hasattr( listener, "enterRaise_function" ): 

6372 listener.enterRaise_function(self) 

6373 

6374 def exitRule(self, listener:ParseTreeListener): 

6375 if hasattr( listener, "exitRaise_function" ): 

6376 listener.exitRaise_function(self) 

6377 

6378 

6379 

6380 

6381 def raise_function(self): 

6382 

6383 localctx = SQLiteParser.Raise_functionContext(self, self._ctx, self.state) 

6384 self.enterRule(localctx, 66, self.RULE_raise_function) 

6385 self._la = 0 # Token type 

6386 try: 

6387 self.enterOuterAlt(localctx, 1) 

6388 self.state = 1071 

6389 self.match(SQLiteParser.RAISE_) 

6390 self.state = 1072 

6391 self.match(SQLiteParser.OPEN_PAR) 

6392 self.state = 1077 

6393 self._errHandler.sync(self) 

6394 token = self._input.LA(1) 

6395 if token in [SQLiteParser.IGNORE_]: 

6396 self.state = 1073 

6397 self.match(SQLiteParser.IGNORE_) 

6398 pass 

6399 elif token in [SQLiteParser.ABORT_, SQLiteParser.FAIL_, SQLiteParser.ROLLBACK_]: 

6400 self.state = 1074 

6401 _la = self._input.LA(1) 

6402 if not(_la==SQLiteParser.ABORT_ or _la==SQLiteParser.FAIL_ or _la==SQLiteParser.ROLLBACK_): 

6403 self._errHandler.recoverInline(self) 

6404 else: 

6405 self._errHandler.reportMatch(self) 

6406 self.consume() 

6407 self.state = 1075 

6408 self.match(SQLiteParser.COMMA) 

6409 self.state = 1076 

6410 self.error_message() 

6411 pass 

6412 else: 

6413 raise NoViableAltException(self) 

6414 

6415 self.state = 1079 

6416 self.match(SQLiteParser.CLOSE_PAR) 

6417 except RecognitionException as re: 

6418 localctx.exception = re 

6419 self._errHandler.reportError(self, re) 

6420 self._errHandler.recover(self, re) 

6421 finally: 

6422 self.exitRule() 

6423 return localctx 

6424 

6425 

6426 class Literal_valueContext(ParserRuleContext): 

6427 

6428 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

6429 super().__init__(parent, invokingState) 

6430 self.parser = parser 

6431 

6432 def NUMERIC_LITERAL(self): 

6433 return self.getToken(SQLiteParser.NUMERIC_LITERAL, 0) 

6434 

6435 def STRING_LITERAL(self): 

6436 return self.getToken(SQLiteParser.STRING_LITERAL, 0) 

6437 

6438 def BLOB_LITERAL(self): 

6439 return self.getToken(SQLiteParser.BLOB_LITERAL, 0) 

6440 

6441 def NULL_(self): 

6442 return self.getToken(SQLiteParser.NULL_, 0) 

6443 

6444 def TRUE_(self): 

6445 return self.getToken(SQLiteParser.TRUE_, 0) 

6446 

6447 def FALSE_(self): 

6448 return self.getToken(SQLiteParser.FALSE_, 0) 

6449 

6450 def CURRENT_TIME_(self): 

6451 return self.getToken(SQLiteParser.CURRENT_TIME_, 0) 

6452 

6453 def CURRENT_DATE_(self): 

6454 return self.getToken(SQLiteParser.CURRENT_DATE_, 0) 

6455 

6456 def CURRENT_TIMESTAMP_(self): 

6457 return self.getToken(SQLiteParser.CURRENT_TIMESTAMP_, 0) 

6458 

6459 def getRuleIndex(self): 

6460 return SQLiteParser.RULE_literal_value 

6461 

6462 def enterRule(self, listener:ParseTreeListener): 

6463 if hasattr( listener, "enterLiteral_value" ): 

6464 listener.enterLiteral_value(self) 

6465 

6466 def exitRule(self, listener:ParseTreeListener): 

6467 if hasattr( listener, "exitLiteral_value" ): 

6468 listener.exitLiteral_value(self) 

6469 

6470 

6471 

6472 

6473 def literal_value(self): 

6474 

6475 localctx = SQLiteParser.Literal_valueContext(self, self._ctx, self.state) 

6476 self.enterRule(localctx, 68, self.RULE_literal_value) 

6477 self._la = 0 # Token type 

6478 try: 

6479 self.enterOuterAlt(localctx, 1) 

6480 self.state = 1081 

6481 _la = self._input.LA(1) 

6482 if not(((((_la - 52)) & ~0x3f) == 0 and ((1 << (_la - 52)) & ((1 << (SQLiteParser.CURRENT_DATE_ - 52)) | (1 << (SQLiteParser.CURRENT_TIME_ - 52)) | (1 << (SQLiteParser.CURRENT_TIMESTAMP_ - 52)) | (1 << (SQLiteParser.NULL_ - 52)))) != 0) or ((((_la - 171)) & ~0x3f) == 0 and ((1 << (_la - 171)) & ((1 << (SQLiteParser.TRUE_ - 171)) | (1 << (SQLiteParser.FALSE_ - 171)) | (1 << (SQLiteParser.NUMERIC_LITERAL - 171)) | (1 << (SQLiteParser.STRING_LITERAL - 171)) | (1 << (SQLiteParser.BLOB_LITERAL - 171)))) != 0)): 

6483 self._errHandler.recoverInline(self) 

6484 else: 

6485 self._errHandler.reportMatch(self) 

6486 self.consume() 

6487 except RecognitionException as re: 

6488 localctx.exception = re 

6489 self._errHandler.reportError(self, re) 

6490 self._errHandler.recover(self, re) 

6491 finally: 

6492 self.exitRule() 

6493 return localctx 

6494 

6495 

6496 class Insert_stmtContext(ParserRuleContext): 

6497 

6498 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

6499 super().__init__(parent, invokingState) 

6500 self.parser = parser 

6501 

6502 def INTO_(self): 

6503 return self.getToken(SQLiteParser.INTO_, 0) 

6504 

6505 def table_name(self): 

6506 return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0) 

6507 

6508 

6509 def INSERT_(self): 

6510 return self.getToken(SQLiteParser.INSERT_, 0) 

6511 

6512 def REPLACE_(self): 

6513 return self.getToken(SQLiteParser.REPLACE_, 0) 

6514 

6515 def OR_(self): 

6516 return self.getToken(SQLiteParser.OR_, 0) 

6517 

6518 def with_clause(self): 

6519 return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0) 

6520 

6521 

6522 def ROLLBACK_(self): 

6523 return self.getToken(SQLiteParser.ROLLBACK_, 0) 

6524 

6525 def ABORT_(self): 

6526 return self.getToken(SQLiteParser.ABORT_, 0) 

6527 

6528 def FAIL_(self): 

6529 return self.getToken(SQLiteParser.FAIL_, 0) 

6530 

6531 def IGNORE_(self): 

6532 return self.getToken(SQLiteParser.IGNORE_, 0) 

6533 

6534 def schema_name(self): 

6535 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

6536 

6537 

6538 def DOT(self): 

6539 return self.getToken(SQLiteParser.DOT, 0) 

6540 

6541 def AS_(self): 

6542 return self.getToken(SQLiteParser.AS_, 0) 

6543 

6544 def table_alias(self): 

6545 return self.getTypedRuleContext(SQLiteParser.Table_aliasContext,0) 

6546 

6547 

6548 def OPEN_PAR(self, i:int=None): 

6549 if i is None: 

6550 return self.getTokens(SQLiteParser.OPEN_PAR) 

6551 else: 

6552 return self.getToken(SQLiteParser.OPEN_PAR, i) 

6553 

6554 def column_name(self, i:int=None): 

6555 if i is None: 

6556 return self.getTypedRuleContexts(SQLiteParser.Column_nameContext) 

6557 else: 

6558 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i) 

6559 

6560 

6561 def CLOSE_PAR(self, i:int=None): 

6562 if i is None: 

6563 return self.getTokens(SQLiteParser.CLOSE_PAR) 

6564 else: 

6565 return self.getToken(SQLiteParser.CLOSE_PAR, i) 

6566 

6567 def VALUES_(self): 

6568 return self.getToken(SQLiteParser.VALUES_, 0) 

6569 

6570 def expr(self, i:int=None): 

6571 if i is None: 

6572 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

6573 else: 

6574 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

6575 

6576 

6577 def select_stmt(self): 

6578 return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0) 

6579 

6580 

6581 def upsert_clause(self): 

6582 return self.getTypedRuleContext(SQLiteParser.Upsert_clauseContext,0) 

6583 

6584 

6585 def COMMA(self, i:int=None): 

6586 if i is None: 

6587 return self.getTokens(SQLiteParser.COMMA) 

6588 else: 

6589 return self.getToken(SQLiteParser.COMMA, i) 

6590 

6591 def DEFAULT_(self): 

6592 return self.getToken(SQLiteParser.DEFAULT_, 0) 

6593 

6594 def getRuleIndex(self): 

6595 return SQLiteParser.RULE_insert_stmt 

6596 

6597 def enterRule(self, listener:ParseTreeListener): 

6598 if hasattr( listener, "enterInsert_stmt" ): 

6599 listener.enterInsert_stmt(self) 

6600 

6601 def exitRule(self, listener:ParseTreeListener): 

6602 if hasattr( listener, "exitInsert_stmt" ): 

6603 listener.exitInsert_stmt(self) 

6604 

6605 

6606 

6607 

6608 def insert_stmt(self): 

6609 

6610 localctx = SQLiteParser.Insert_stmtContext(self, self._ctx, self.state) 

6611 self.enterRule(localctx, 70, self.RULE_insert_stmt) 

6612 self._la = 0 # Token type 

6613 try: 

6614 self.state = 1153 

6615 self._errHandler.sync(self) 

6616 token = self._input.LA(1) 

6617 if token in [SQLiteParser.INSERT_, SQLiteParser.REPLACE_, SQLiteParser.WITH_]: 

6618 self.enterOuterAlt(localctx, 1) 

6619 self.state = 1084 

6620 self._errHandler.sync(self) 

6621 _la = self._input.LA(1) 

6622 if _la==SQLiteParser.WITH_: 

6623 self.state = 1083 

6624 self.with_clause() 

6625 

6626 

6627 self.state = 1091 

6628 self._errHandler.sync(self) 

6629 la_ = self._interp.adaptivePredict(self._input,136,self._ctx) 

6630 if la_ == 1: 

6631 self.state = 1086 

6632 self.match(SQLiteParser.INSERT_) 

6633 pass 

6634 

6635 elif la_ == 2: 

6636 self.state = 1087 

6637 self.match(SQLiteParser.REPLACE_) 

6638 pass 

6639 

6640 elif la_ == 3: 

6641 self.state = 1088 

6642 self.match(SQLiteParser.INSERT_) 

6643 self.state = 1089 

6644 self.match(SQLiteParser.OR_) 

6645 self.state = 1090 

6646 _la = self._input.LA(1) 

6647 if not(_la==SQLiteParser.ABORT_ or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (SQLiteParser.FAIL_ - 72)) | (1 << (SQLiteParser.IGNORE_ - 72)) | (1 << (SQLiteParser.REPLACE_ - 72)) | (1 << (SQLiteParser.ROLLBACK_ - 72)))) != 0)): 

6648 self._errHandler.recoverInline(self) 

6649 else: 

6650 self._errHandler.reportMatch(self) 

6651 self.consume() 

6652 pass 

6653 

6654 

6655 self.state = 1093 

6656 self.match(SQLiteParser.INTO_) 

6657 self.state = 1097 

6658 self._errHandler.sync(self) 

6659 la_ = self._interp.adaptivePredict(self._input,137,self._ctx) 

6660 if la_ == 1: 

6661 self.state = 1094 

6662 self.schema_name() 

6663 self.state = 1095 

6664 self.match(SQLiteParser.DOT) 

6665 

6666 

6667 self.state = 1099 

6668 self.table_name() 

6669 self.state = 1102 

6670 self._errHandler.sync(self) 

6671 _la = self._input.LA(1) 

6672 if _la==SQLiteParser.AS_: 

6673 self.state = 1100 

6674 self.match(SQLiteParser.AS_) 

6675 self.state = 1101 

6676 self.table_alias() 

6677 

6678 

6679 self.state = 1115 

6680 self._errHandler.sync(self) 

6681 _la = self._input.LA(1) 

6682 if _la==SQLiteParser.OPEN_PAR: 

6683 self.state = 1104 

6684 self.match(SQLiteParser.OPEN_PAR) 

6685 self.state = 1105 

6686 self.column_name() 

6687 self.state = 1110 

6688 self._errHandler.sync(self) 

6689 _la = self._input.LA(1) 

6690 while _la==SQLiteParser.COMMA: 

6691 self.state = 1106 

6692 self.match(SQLiteParser.COMMA) 

6693 self.state = 1107 

6694 self.column_name() 

6695 self.state = 1112 

6696 self._errHandler.sync(self) 

6697 _la = self._input.LA(1) 

6698 

6699 self.state = 1113 

6700 self.match(SQLiteParser.CLOSE_PAR) 

6701 

6702 

6703 self.state = 1146 

6704 self._errHandler.sync(self) 

6705 la_ = self._interp.adaptivePredict(self._input,144,self._ctx) 

6706 if la_ == 1: 

6707 self.state = 1117 

6708 self.match(SQLiteParser.VALUES_) 

6709 self.state = 1118 

6710 self.match(SQLiteParser.OPEN_PAR) 

6711 self.state = 1119 

6712 self.expr(0) 

6713 self.state = 1124 

6714 self._errHandler.sync(self) 

6715 _la = self._input.LA(1) 

6716 while _la==SQLiteParser.COMMA: 

6717 self.state = 1120 

6718 self.match(SQLiteParser.COMMA) 

6719 self.state = 1121 

6720 self.expr(0) 

6721 self.state = 1126 

6722 self._errHandler.sync(self) 

6723 _la = self._input.LA(1) 

6724 

6725 self.state = 1127 

6726 self.match(SQLiteParser.CLOSE_PAR) 

6727 self.state = 1142 

6728 self._errHandler.sync(self) 

6729 _la = self._input.LA(1) 

6730 while _la==SQLiteParser.COMMA: 

6731 self.state = 1128 

6732 self.match(SQLiteParser.COMMA) 

6733 self.state = 1129 

6734 self.match(SQLiteParser.OPEN_PAR) 

6735 self.state = 1130 

6736 self.expr(0) 

6737 self.state = 1135 

6738 self._errHandler.sync(self) 

6739 _la = self._input.LA(1) 

6740 while _la==SQLiteParser.COMMA: 

6741 self.state = 1131 

6742 self.match(SQLiteParser.COMMA) 

6743 self.state = 1132 

6744 self.expr(0) 

6745 self.state = 1137 

6746 self._errHandler.sync(self) 

6747 _la = self._input.LA(1) 

6748 

6749 self.state = 1138 

6750 self.match(SQLiteParser.CLOSE_PAR) 

6751 self.state = 1144 

6752 self._errHandler.sync(self) 

6753 _la = self._input.LA(1) 

6754 

6755 pass 

6756 

6757 elif la_ == 2: 

6758 self.state = 1145 

6759 self.select_stmt() 

6760 pass 

6761 

6762 

6763 self.state = 1149 

6764 self._errHandler.sync(self) 

6765 _la = self._input.LA(1) 

6766 if _la==SQLiteParser.ON_: 

6767 self.state = 1148 

6768 self.upsert_clause() 

6769 

6770 

6771 pass 

6772 elif token in [SQLiteParser.DEFAULT_]: 

6773 self.enterOuterAlt(localctx, 2) 

6774 self.state = 1151 

6775 self.match(SQLiteParser.DEFAULT_) 

6776 self.state = 1152 

6777 self.match(SQLiteParser.VALUES_) 

6778 pass 

6779 else: 

6780 raise NoViableAltException(self) 

6781 

6782 except RecognitionException as re: 

6783 localctx.exception = re 

6784 self._errHandler.reportError(self, re) 

6785 self._errHandler.recover(self, re) 

6786 finally: 

6787 self.exitRule() 

6788 return localctx 

6789 

6790 

6791 class Upsert_clauseContext(ParserRuleContext): 

6792 

6793 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

6794 super().__init__(parent, invokingState) 

6795 self.parser = parser 

6796 

6797 def ON_(self): 

6798 return self.getToken(SQLiteParser.ON_, 0) 

6799 

6800 def CONFLICT_(self): 

6801 return self.getToken(SQLiteParser.CONFLICT_, 0) 

6802 

6803 def DO_(self): 

6804 return self.getToken(SQLiteParser.DO_, 0) 

6805 

6806 def NOTHING_(self): 

6807 return self.getToken(SQLiteParser.NOTHING_, 0) 

6808 

6809 def UPDATE_(self): 

6810 return self.getToken(SQLiteParser.UPDATE_, 0) 

6811 

6812 def SET_(self): 

6813 return self.getToken(SQLiteParser.SET_, 0) 

6814 

6815 def OPEN_PAR(self): 

6816 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

6817 

6818 def indexed_column(self, i:int=None): 

6819 if i is None: 

6820 return self.getTypedRuleContexts(SQLiteParser.Indexed_columnContext) 

6821 else: 

6822 return self.getTypedRuleContext(SQLiteParser.Indexed_columnContext,i) 

6823 

6824 

6825 def CLOSE_PAR(self): 

6826 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

6827 

6828 def EQ(self, i:int=None): 

6829 if i is None: 

6830 return self.getTokens(SQLiteParser.EQ) 

6831 else: 

6832 return self.getToken(SQLiteParser.EQ, i) 

6833 

6834 def expr(self, i:int=None): 

6835 if i is None: 

6836 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

6837 else: 

6838 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

6839 

6840 

6841 def COMMA(self, i:int=None): 

6842 if i is None: 

6843 return self.getTokens(SQLiteParser.COMMA) 

6844 else: 

6845 return self.getToken(SQLiteParser.COMMA, i) 

6846 

6847 def WHERE_(self, i:int=None): 

6848 if i is None: 

6849 return self.getTokens(SQLiteParser.WHERE_) 

6850 else: 

6851 return self.getToken(SQLiteParser.WHERE_, i) 

6852 

6853 def column_name(self, i:int=None): 

6854 if i is None: 

6855 return self.getTypedRuleContexts(SQLiteParser.Column_nameContext) 

6856 else: 

6857 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i) 

6858 

6859 

6860 def column_name_list(self, i:int=None): 

6861 if i is None: 

6862 return self.getTypedRuleContexts(SQLiteParser.Column_name_listContext) 

6863 else: 

6864 return self.getTypedRuleContext(SQLiteParser.Column_name_listContext,i) 

6865 

6866 

6867 def getRuleIndex(self): 

6868 return SQLiteParser.RULE_upsert_clause 

6869 

6870 def enterRule(self, listener:ParseTreeListener): 

6871 if hasattr( listener, "enterUpsert_clause" ): 

6872 listener.enterUpsert_clause(self) 

6873 

6874 def exitRule(self, listener:ParseTreeListener): 

6875 if hasattr( listener, "exitUpsert_clause" ): 

6876 listener.exitUpsert_clause(self) 

6877 

6878 

6879 

6880 

6881 def upsert_clause(self): 

6882 

6883 localctx = SQLiteParser.Upsert_clauseContext(self, self._ctx, self.state) 

6884 self.enterRule(localctx, 72, self.RULE_upsert_clause) 

6885 self._la = 0 # Token type 

6886 try: 

6887 self.enterOuterAlt(localctx, 1) 

6888 self.state = 1155 

6889 self.match(SQLiteParser.ON_) 

6890 self.state = 1156 

6891 self.match(SQLiteParser.CONFLICT_) 

6892 self.state = 1171 

6893 self._errHandler.sync(self) 

6894 _la = self._input.LA(1) 

6895 if _la==SQLiteParser.OPEN_PAR: 

6896 self.state = 1157 

6897 self.match(SQLiteParser.OPEN_PAR) 

6898 self.state = 1158 

6899 self.indexed_column() 

6900 self.state = 1163 

6901 self._errHandler.sync(self) 

6902 _la = self._input.LA(1) 

6903 while _la==SQLiteParser.COMMA: 

6904 self.state = 1159 

6905 self.match(SQLiteParser.COMMA) 

6906 self.state = 1160 

6907 self.indexed_column() 

6908 self.state = 1165 

6909 self._errHandler.sync(self) 

6910 _la = self._input.LA(1) 

6911 

6912 self.state = 1166 

6913 self.match(SQLiteParser.CLOSE_PAR) 

6914 self.state = 1169 

6915 self._errHandler.sync(self) 

6916 _la = self._input.LA(1) 

6917 if _la==SQLiteParser.WHERE_: 

6918 self.state = 1167 

6919 self.match(SQLiteParser.WHERE_) 

6920 self.state = 1168 

6921 self.expr(0) 

6922 

6923 

6924 

6925 

6926 self.state = 1173 

6927 self.match(SQLiteParser.DO_) 

6928 self.state = 1200 

6929 self._errHandler.sync(self) 

6930 token = self._input.LA(1) 

6931 if token in [SQLiteParser.NOTHING_]: 

6932 self.state = 1174 

6933 self.match(SQLiteParser.NOTHING_) 

6934 pass 

6935 elif token in [SQLiteParser.UPDATE_]: 

6936 self.state = 1175 

6937 self.match(SQLiteParser.UPDATE_) 

6938 self.state = 1176 

6939 self.match(SQLiteParser.SET_) 

6940 

6941 self.state = 1179 

6942 self._errHandler.sync(self) 

6943 la_ = self._interp.adaptivePredict(self._input,150,self._ctx) 

6944 if la_ == 1: 

6945 self.state = 1177 

6946 self.column_name() 

6947 pass 

6948 

6949 elif la_ == 2: 

6950 self.state = 1178 

6951 self.column_name_list() 

6952 pass 

6953 

6954 

6955 self.state = 1181 

6956 self.match(SQLiteParser.EQ) 

6957 self.state = 1182 

6958 self.expr(0) 

6959 self.state = 1193 

6960 self._errHandler.sync(self) 

6961 _la = self._input.LA(1) 

6962 while _la==SQLiteParser.COMMA: 

6963 self.state = 1183 

6964 self.match(SQLiteParser.COMMA) 

6965 self.state = 1186 

6966 self._errHandler.sync(self) 

6967 la_ = self._interp.adaptivePredict(self._input,151,self._ctx) 

6968 if la_ == 1: 

6969 self.state = 1184 

6970 self.column_name() 

6971 pass 

6972 

6973 elif la_ == 2: 

6974 self.state = 1185 

6975 self.column_name_list() 

6976 pass 

6977 

6978 

6979 self.state = 1188 

6980 self.match(SQLiteParser.EQ) 

6981 self.state = 1189 

6982 self.expr(0) 

6983 self.state = 1195 

6984 self._errHandler.sync(self) 

6985 _la = self._input.LA(1) 

6986 

6987 self.state = 1198 

6988 self._errHandler.sync(self) 

6989 _la = self._input.LA(1) 

6990 if _la==SQLiteParser.WHERE_: 

6991 self.state = 1196 

6992 self.match(SQLiteParser.WHERE_) 

6993 self.state = 1197 

6994 self.expr(0) 

6995 

6996 

6997 pass 

6998 else: 

6999 raise NoViableAltException(self) 

7000 

7001 except RecognitionException as re: 

7002 localctx.exception = re 

7003 self._errHandler.reportError(self, re) 

7004 self._errHandler.recover(self, re) 

7005 finally: 

7006 self.exitRule() 

7007 return localctx 

7008 

7009 

7010 class Pragma_stmtContext(ParserRuleContext): 

7011 

7012 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

7013 super().__init__(parent, invokingState) 

7014 self.parser = parser 

7015 

7016 def PRAGMA_(self): 

7017 return self.getToken(SQLiteParser.PRAGMA_, 0) 

7018 

7019 def pragma_name(self): 

7020 return self.getTypedRuleContext(SQLiteParser.Pragma_nameContext,0) 

7021 

7022 

7023 def schema_name(self): 

7024 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

7025 

7026 

7027 def DOT(self): 

7028 return self.getToken(SQLiteParser.DOT, 0) 

7029 

7030 def ASSIGN(self): 

7031 return self.getToken(SQLiteParser.ASSIGN, 0) 

7032 

7033 def pragma_value(self): 

7034 return self.getTypedRuleContext(SQLiteParser.Pragma_valueContext,0) 

7035 

7036 

7037 def OPEN_PAR(self): 

7038 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

7039 

7040 def CLOSE_PAR(self): 

7041 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

7042 

7043 def getRuleIndex(self): 

7044 return SQLiteParser.RULE_pragma_stmt 

7045 

7046 def enterRule(self, listener:ParseTreeListener): 

7047 if hasattr( listener, "enterPragma_stmt" ): 

7048 listener.enterPragma_stmt(self) 

7049 

7050 def exitRule(self, listener:ParseTreeListener): 

7051 if hasattr( listener, "exitPragma_stmt" ): 

7052 listener.exitPragma_stmt(self) 

7053 

7054 

7055 

7056 

7057 def pragma_stmt(self): 

7058 

7059 localctx = SQLiteParser.Pragma_stmtContext(self, self._ctx, self.state) 

7060 self.enterRule(localctx, 74, self.RULE_pragma_stmt) 

7061 try: 

7062 self.enterOuterAlt(localctx, 1) 

7063 self.state = 1202 

7064 self.match(SQLiteParser.PRAGMA_) 

7065 self.state = 1206 

7066 self._errHandler.sync(self) 

7067 la_ = self._interp.adaptivePredict(self._input,155,self._ctx) 

7068 if la_ == 1: 

7069 self.state = 1203 

7070 self.schema_name() 

7071 self.state = 1204 

7072 self.match(SQLiteParser.DOT) 

7073 

7074 

7075 self.state = 1208 

7076 self.pragma_name() 

7077 self.state = 1215 

7078 self._errHandler.sync(self) 

7079 token = self._input.LA(1) 

7080 if token in [SQLiteParser.ASSIGN]: 

7081 self.state = 1209 

7082 self.match(SQLiteParser.ASSIGN) 

7083 self.state = 1210 

7084 self.pragma_value() 

7085 pass 

7086 elif token in [SQLiteParser.OPEN_PAR]: 

7087 self.state = 1211 

7088 self.match(SQLiteParser.OPEN_PAR) 

7089 self.state = 1212 

7090 self.pragma_value() 

7091 self.state = 1213 

7092 self.match(SQLiteParser.CLOSE_PAR) 

7093 pass 

7094 elif token in [SQLiteParser.EOF, SQLiteParser.SCOL, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.ATTACH_, SQLiteParser.BEGIN_, SQLiteParser.COMMIT_, SQLiteParser.CREATE_, SQLiteParser.DEFAULT_, SQLiteParser.DELETE_, SQLiteParser.DETACH_, SQLiteParser.DROP_, SQLiteParser.END_, SQLiteParser.EXPLAIN_, SQLiteParser.INSERT_, SQLiteParser.PRAGMA_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.REPLACE_, SQLiteParser.ROLLBACK_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.UPDATE_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.WITH_]: 

7095 pass 

7096 else: 

7097 pass 

7098 except RecognitionException as re: 

7099 localctx.exception = re 

7100 self._errHandler.reportError(self, re) 

7101 self._errHandler.recover(self, re) 

7102 finally: 

7103 self.exitRule() 

7104 return localctx 

7105 

7106 

7107 class Pragma_valueContext(ParserRuleContext): 

7108 

7109 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

7110 super().__init__(parent, invokingState) 

7111 self.parser = parser 

7112 

7113 def signed_number(self): 

7114 return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,0) 

7115 

7116 

7117 def name(self): 

7118 return self.getTypedRuleContext(SQLiteParser.NameContext,0) 

7119 

7120 

7121 def STRING_LITERAL(self): 

7122 return self.getToken(SQLiteParser.STRING_LITERAL, 0) 

7123 

7124 def getRuleIndex(self): 

7125 return SQLiteParser.RULE_pragma_value 

7126 

7127 def enterRule(self, listener:ParseTreeListener): 

7128 if hasattr( listener, "enterPragma_value" ): 

7129 listener.enterPragma_value(self) 

7130 

7131 def exitRule(self, listener:ParseTreeListener): 

7132 if hasattr( listener, "exitPragma_value" ): 

7133 listener.exitPragma_value(self) 

7134 

7135 

7136 

7137 

7138 def pragma_value(self): 

7139 

7140 localctx = SQLiteParser.Pragma_valueContext(self, self._ctx, self.state) 

7141 self.enterRule(localctx, 76, self.RULE_pragma_value) 

7142 try: 

7143 self.state = 1220 

7144 self._errHandler.sync(self) 

7145 la_ = self._interp.adaptivePredict(self._input,157,self._ctx) 

7146 if la_ == 1: 

7147 self.enterOuterAlt(localctx, 1) 

7148 self.state = 1217 

7149 self.signed_number() 

7150 pass 

7151 

7152 elif la_ == 2: 

7153 self.enterOuterAlt(localctx, 2) 

7154 self.state = 1218 

7155 self.name() 

7156 pass 

7157 

7158 elif la_ == 3: 

7159 self.enterOuterAlt(localctx, 3) 

7160 self.state = 1219 

7161 self.match(SQLiteParser.STRING_LITERAL) 

7162 pass 

7163 

7164 

7165 except RecognitionException as re: 

7166 localctx.exception = re 

7167 self._errHandler.reportError(self, re) 

7168 self._errHandler.recover(self, re) 

7169 finally: 

7170 self.exitRule() 

7171 return localctx 

7172 

7173 

7174 class Reindex_stmtContext(ParserRuleContext): 

7175 

7176 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

7177 super().__init__(parent, invokingState) 

7178 self.parser = parser 

7179 

7180 def REINDEX_(self): 

7181 return self.getToken(SQLiteParser.REINDEX_, 0) 

7182 

7183 def collation_name(self): 

7184 return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0) 

7185 

7186 

7187 def table_name(self): 

7188 return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0) 

7189 

7190 

7191 def index_name(self): 

7192 return self.getTypedRuleContext(SQLiteParser.Index_nameContext,0) 

7193 

7194 

7195 def schema_name(self): 

7196 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

7197 

7198 

7199 def DOT(self): 

7200 return self.getToken(SQLiteParser.DOT, 0) 

7201 

7202 def getRuleIndex(self): 

7203 return SQLiteParser.RULE_reindex_stmt 

7204 

7205 def enterRule(self, listener:ParseTreeListener): 

7206 if hasattr( listener, "enterReindex_stmt" ): 

7207 listener.enterReindex_stmt(self) 

7208 

7209 def exitRule(self, listener:ParseTreeListener): 

7210 if hasattr( listener, "exitReindex_stmt" ): 

7211 listener.exitReindex_stmt(self) 

7212 

7213 

7214 

7215 

7216 def reindex_stmt(self): 

7217 

7218 localctx = SQLiteParser.Reindex_stmtContext(self, self._ctx, self.state) 

7219 self.enterRule(localctx, 78, self.RULE_reindex_stmt) 

7220 try: 

7221 self.enterOuterAlt(localctx, 1) 

7222 self.state = 1222 

7223 self.match(SQLiteParser.REINDEX_) 

7224 self.state = 1233 

7225 self._errHandler.sync(self) 

7226 la_ = self._interp.adaptivePredict(self._input,160,self._ctx) 

7227 if la_ == 1: 

7228 self.state = 1223 

7229 self.collation_name() 

7230 

7231 elif la_ == 2: 

7232 self.state = 1227 

7233 self._errHandler.sync(self) 

7234 la_ = self._interp.adaptivePredict(self._input,158,self._ctx) 

7235 if la_ == 1: 

7236 self.state = 1224 

7237 self.schema_name() 

7238 self.state = 1225 

7239 self.match(SQLiteParser.DOT) 

7240 

7241 

7242 self.state = 1231 

7243 self._errHandler.sync(self) 

7244 la_ = self._interp.adaptivePredict(self._input,159,self._ctx) 

7245 if la_ == 1: 

7246 self.state = 1229 

7247 self.table_name() 

7248 pass 

7249 

7250 elif la_ == 2: 

7251 self.state = 1230 

7252 self.index_name() 

7253 pass 

7254 

7255 

7256 

7257 

7258 except RecognitionException as re: 

7259 localctx.exception = re 

7260 self._errHandler.reportError(self, re) 

7261 self._errHandler.recover(self, re) 

7262 finally: 

7263 self.exitRule() 

7264 return localctx 

7265 

7266 

7267 class Select_stmtContext(ParserRuleContext): 

7268 

7269 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

7270 super().__init__(parent, invokingState) 

7271 self.parser = parser 

7272 

7273 def select_core(self, i:int=None): 

7274 if i is None: 

7275 return self.getTypedRuleContexts(SQLiteParser.Select_coreContext) 

7276 else: 

7277 return self.getTypedRuleContext(SQLiteParser.Select_coreContext,i) 

7278 

7279 

7280 def common_table_stmt(self): 

7281 return self.getTypedRuleContext(SQLiteParser.Common_table_stmtContext,0) 

7282 

7283 

7284 def compound_operator(self, i:int=None): 

7285 if i is None: 

7286 return self.getTypedRuleContexts(SQLiteParser.Compound_operatorContext) 

7287 else: 

7288 return self.getTypedRuleContext(SQLiteParser.Compound_operatorContext,i) 

7289 

7290 

7291 def order_by_stmt(self): 

7292 return self.getTypedRuleContext(SQLiteParser.Order_by_stmtContext,0) 

7293 

7294 

7295 def limit_stmt(self): 

7296 return self.getTypedRuleContext(SQLiteParser.Limit_stmtContext,0) 

7297 

7298 

7299 def getRuleIndex(self): 

7300 return SQLiteParser.RULE_select_stmt 

7301 

7302 def enterRule(self, listener:ParseTreeListener): 

7303 if hasattr( listener, "enterSelect_stmt" ): 

7304 listener.enterSelect_stmt(self) 

7305 

7306 def exitRule(self, listener:ParseTreeListener): 

7307 if hasattr( listener, "exitSelect_stmt" ): 

7308 listener.exitSelect_stmt(self) 

7309 

7310 

7311 

7312 

7313 def select_stmt(self): 

7314 

7315 localctx = SQLiteParser.Select_stmtContext(self, self._ctx, self.state) 

7316 self.enterRule(localctx, 80, self.RULE_select_stmt) 

7317 self._la = 0 # Token type 

7318 try: 

7319 self.enterOuterAlt(localctx, 1) 

7320 self.state = 1236 

7321 self._errHandler.sync(self) 

7322 _la = self._input.LA(1) 

7323 if _la==SQLiteParser.WITH_: 

7324 self.state = 1235 

7325 self.common_table_stmt() 

7326 

7327 

7328 self.state = 1238 

7329 self.select_core() 

7330 self.state = 1244 

7331 self._errHandler.sync(self) 

7332 _alt = self._interp.adaptivePredict(self._input,162,self._ctx) 

7333 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: 

7334 if _alt==1: 

7335 self.state = 1239 

7336 self.compound_operator() 

7337 self.state = 1240 

7338 self.select_core() 

7339 self.state = 1246 

7340 self._errHandler.sync(self) 

7341 _alt = self._interp.adaptivePredict(self._input,162,self._ctx) 

7342 

7343 self.state = 1248 

7344 self._errHandler.sync(self) 

7345 _la = self._input.LA(1) 

7346 if _la==SQLiteParser.ORDER_: 

7347 self.state = 1247 

7348 self.order_by_stmt() 

7349 

7350 

7351 self.state = 1251 

7352 self._errHandler.sync(self) 

7353 _la = self._input.LA(1) 

7354 if _la==SQLiteParser.LIMIT_: 

7355 self.state = 1250 

7356 self.limit_stmt() 

7357 

7358 

7359 except RecognitionException as re: 

7360 localctx.exception = re 

7361 self._errHandler.reportError(self, re) 

7362 self._errHandler.recover(self, re) 

7363 finally: 

7364 self.exitRule() 

7365 return localctx 

7366 

7367 

7368 class Join_clauseContext(ParserRuleContext): 

7369 

7370 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

7371 super().__init__(parent, invokingState) 

7372 self.parser = parser 

7373 

7374 def table_or_subquery(self, i:int=None): 

7375 if i is None: 

7376 return self.getTypedRuleContexts(SQLiteParser.Table_or_subqueryContext) 

7377 else: 

7378 return self.getTypedRuleContext(SQLiteParser.Table_or_subqueryContext,i) 

7379 

7380 

7381 def join_operator(self, i:int=None): 

7382 if i is None: 

7383 return self.getTypedRuleContexts(SQLiteParser.Join_operatorContext) 

7384 else: 

7385 return self.getTypedRuleContext(SQLiteParser.Join_operatorContext,i) 

7386 

7387 

7388 def join_constraint(self, i:int=None): 

7389 if i is None: 

7390 return self.getTypedRuleContexts(SQLiteParser.Join_constraintContext) 

7391 else: 

7392 return self.getTypedRuleContext(SQLiteParser.Join_constraintContext,i) 

7393 

7394 

7395 def getRuleIndex(self): 

7396 return SQLiteParser.RULE_join_clause 

7397 

7398 def enterRule(self, listener:ParseTreeListener): 

7399 if hasattr( listener, "enterJoin_clause" ): 

7400 listener.enterJoin_clause(self) 

7401 

7402 def exitRule(self, listener:ParseTreeListener): 

7403 if hasattr( listener, "exitJoin_clause" ): 

7404 listener.exitJoin_clause(self) 

7405 

7406 

7407 

7408 

7409 def join_clause(self): 

7410 

7411 localctx = SQLiteParser.Join_clauseContext(self, self._ctx, self.state) 

7412 self.enterRule(localctx, 82, self.RULE_join_clause) 

7413 self._la = 0 # Token type 

7414 try: 

7415 self.enterOuterAlt(localctx, 1) 

7416 self.state = 1253 

7417 self.table_or_subquery() 

7418 self.state = 1261 

7419 self._errHandler.sync(self) 

7420 _la = self._input.LA(1) 

7421 while _la==SQLiteParser.COMMA or _la==SQLiteParser.CROSS_ or ((((_la - 87)) & ~0x3f) == 0 and ((1 << (_la - 87)) & ((1 << (SQLiteParser.INNER_ - 87)) | (1 << (SQLiteParser.JOIN_ - 87)) | (1 << (SQLiteParser.LEFT_ - 87)) | (1 << (SQLiteParser.NATURAL_ - 87)))) != 0): 

7422 self.state = 1254 

7423 self.join_operator() 

7424 self.state = 1255 

7425 self.table_or_subquery() 

7426 self.state = 1257 

7427 self._errHandler.sync(self) 

7428 la_ = self._interp.adaptivePredict(self._input,165,self._ctx) 

7429 if la_ == 1: 

7430 self.state = 1256 

7431 self.join_constraint() 

7432 

7433 

7434 self.state = 1263 

7435 self._errHandler.sync(self) 

7436 _la = self._input.LA(1) 

7437 

7438 except RecognitionException as re: 

7439 localctx.exception = re 

7440 self._errHandler.reportError(self, re) 

7441 self._errHandler.recover(self, re) 

7442 finally: 

7443 self.exitRule() 

7444 return localctx 

7445 

7446 

7447 class Select_coreContext(ParserRuleContext): 

7448 

7449 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

7450 super().__init__(parent, invokingState) 

7451 self.parser = parser 

7452 

7453 def SELECT_(self): 

7454 return self.getToken(SQLiteParser.SELECT_, 0) 

7455 

7456 def result_column(self, i:int=None): 

7457 if i is None: 

7458 return self.getTypedRuleContexts(SQLiteParser.Result_columnContext) 

7459 else: 

7460 return self.getTypedRuleContext(SQLiteParser.Result_columnContext,i) 

7461 

7462 

7463 def COMMA(self, i:int=None): 

7464 if i is None: 

7465 return self.getTokens(SQLiteParser.COMMA) 

7466 else: 

7467 return self.getToken(SQLiteParser.COMMA, i) 

7468 

7469 def FROM_(self): 

7470 return self.getToken(SQLiteParser.FROM_, 0) 

7471 

7472 def WHERE_(self): 

7473 return self.getToken(SQLiteParser.WHERE_, 0) 

7474 

7475 def expr(self, i:int=None): 

7476 if i is None: 

7477 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

7478 else: 

7479 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

7480 

7481 

7482 def GROUP_(self): 

7483 return self.getToken(SQLiteParser.GROUP_, 0) 

7484 

7485 def BY_(self): 

7486 return self.getToken(SQLiteParser.BY_, 0) 

7487 

7488 def WINDOW_(self): 

7489 return self.getToken(SQLiteParser.WINDOW_, 0) 

7490 

7491 def window_name(self, i:int=None): 

7492 if i is None: 

7493 return self.getTypedRuleContexts(SQLiteParser.Window_nameContext) 

7494 else: 

7495 return self.getTypedRuleContext(SQLiteParser.Window_nameContext,i) 

7496 

7497 

7498 def AS_(self, i:int=None): 

7499 if i is None: 

7500 return self.getTokens(SQLiteParser.AS_) 

7501 else: 

7502 return self.getToken(SQLiteParser.AS_, i) 

7503 

7504 def window_defn(self, i:int=None): 

7505 if i is None: 

7506 return self.getTypedRuleContexts(SQLiteParser.Window_defnContext) 

7507 else: 

7508 return self.getTypedRuleContext(SQLiteParser.Window_defnContext,i) 

7509 

7510 

7511 def DISTINCT_(self): 

7512 return self.getToken(SQLiteParser.DISTINCT_, 0) 

7513 

7514 def ALL_(self): 

7515 return self.getToken(SQLiteParser.ALL_, 0) 

7516 

7517 def table_or_subquery(self, i:int=None): 

7518 if i is None: 

7519 return self.getTypedRuleContexts(SQLiteParser.Table_or_subqueryContext) 

7520 else: 

7521 return self.getTypedRuleContext(SQLiteParser.Table_or_subqueryContext,i) 

7522 

7523 

7524 def join_clause(self): 

7525 return self.getTypedRuleContext(SQLiteParser.Join_clauseContext,0) 

7526 

7527 

7528 def HAVING_(self): 

7529 return self.getToken(SQLiteParser.HAVING_, 0) 

7530 

7531 def VALUES_(self): 

7532 return self.getToken(SQLiteParser.VALUES_, 0) 

7533 

7534 def OPEN_PAR(self, i:int=None): 

7535 if i is None: 

7536 return self.getTokens(SQLiteParser.OPEN_PAR) 

7537 else: 

7538 return self.getToken(SQLiteParser.OPEN_PAR, i) 

7539 

7540 def CLOSE_PAR(self, i:int=None): 

7541 if i is None: 

7542 return self.getTokens(SQLiteParser.CLOSE_PAR) 

7543 else: 

7544 return self.getToken(SQLiteParser.CLOSE_PAR, i) 

7545 

7546 def getRuleIndex(self): 

7547 return SQLiteParser.RULE_select_core 

7548 

7549 def enterRule(self, listener:ParseTreeListener): 

7550 if hasattr( listener, "enterSelect_core" ): 

7551 listener.enterSelect_core(self) 

7552 

7553 def exitRule(self, listener:ParseTreeListener): 

7554 if hasattr( listener, "exitSelect_core" ): 

7555 listener.exitSelect_core(self) 

7556 

7557 

7558 

7559 

7560 def select_core(self): 

7561 

7562 localctx = SQLiteParser.Select_coreContext(self, self._ctx, self.state) 

7563 self.enterRule(localctx, 84, self.RULE_select_core) 

7564 self._la = 0 # Token type 

7565 try: 

7566 self.state = 1354 

7567 self._errHandler.sync(self) 

7568 token = self._input.LA(1) 

7569 if token in [SQLiteParser.SELECT_]: 

7570 self.enterOuterAlt(localctx, 1) 

7571 self.state = 1264 

7572 self.match(SQLiteParser.SELECT_) 

7573 self.state = 1266 

7574 self._errHandler.sync(self) 

7575 la_ = self._interp.adaptivePredict(self._input,167,self._ctx) 

7576 if la_ == 1: 

7577 self.state = 1265 

7578 _la = self._input.LA(1) 

7579 if not(_la==SQLiteParser.ALL_ or _la==SQLiteParser.DISTINCT_): 

7580 self._errHandler.recoverInline(self) 

7581 else: 

7582 self._errHandler.reportMatch(self) 

7583 self.consume() 

7584 

7585 

7586 self.state = 1268 

7587 self.result_column() 

7588 self.state = 1273 

7589 self._errHandler.sync(self) 

7590 _la = self._input.LA(1) 

7591 while _la==SQLiteParser.COMMA: 

7592 self.state = 1269 

7593 self.match(SQLiteParser.COMMA) 

7594 self.state = 1270 

7595 self.result_column() 

7596 self.state = 1275 

7597 self._errHandler.sync(self) 

7598 _la = self._input.LA(1) 

7599 

7600 self.state = 1288 

7601 self._errHandler.sync(self) 

7602 _la = self._input.LA(1) 

7603 if _la==SQLiteParser.FROM_: 

7604 self.state = 1276 

7605 self.match(SQLiteParser.FROM_) 

7606 self.state = 1286 

7607 self._errHandler.sync(self) 

7608 la_ = self._interp.adaptivePredict(self._input,170,self._ctx) 

7609 if la_ == 1: 

7610 self.state = 1277 

7611 self.table_or_subquery() 

7612 self.state = 1282 

7613 self._errHandler.sync(self) 

7614 _la = self._input.LA(1) 

7615 while _la==SQLiteParser.COMMA: 

7616 self.state = 1278 

7617 self.match(SQLiteParser.COMMA) 

7618 self.state = 1279 

7619 self.table_or_subquery() 

7620 self.state = 1284 

7621 self._errHandler.sync(self) 

7622 _la = self._input.LA(1) 

7623 

7624 pass 

7625 

7626 elif la_ == 2: 

7627 self.state = 1285 

7628 self.join_clause() 

7629 pass 

7630 

7631 

7632 

7633 

7634 self.state = 1292 

7635 self._errHandler.sync(self) 

7636 _la = self._input.LA(1) 

7637 if _la==SQLiteParser.WHERE_: 

7638 self.state = 1290 

7639 self.match(SQLiteParser.WHERE_) 

7640 self.state = 1291 

7641 self.expr(0) 

7642 

7643 

7644 self.state = 1308 

7645 self._errHandler.sync(self) 

7646 _la = self._input.LA(1) 

7647 if _la==SQLiteParser.GROUP_: 

7648 self.state = 1294 

7649 self.match(SQLiteParser.GROUP_) 

7650 self.state = 1295 

7651 self.match(SQLiteParser.BY_) 

7652 self.state = 1296 

7653 self.expr(0) 

7654 self.state = 1301 

7655 self._errHandler.sync(self) 

7656 _la = self._input.LA(1) 

7657 while _la==SQLiteParser.COMMA: 

7658 self.state = 1297 

7659 self.match(SQLiteParser.COMMA) 

7660 self.state = 1298 

7661 self.expr(0) 

7662 self.state = 1303 

7663 self._errHandler.sync(self) 

7664 _la = self._input.LA(1) 

7665 

7666 self.state = 1306 

7667 self._errHandler.sync(self) 

7668 _la = self._input.LA(1) 

7669 if _la==SQLiteParser.HAVING_: 

7670 self.state = 1304 

7671 self.match(SQLiteParser.HAVING_) 

7672 self.state = 1305 

7673 self.expr(0) 

7674 

7675 

7676 

7677 

7678 self.state = 1324 

7679 self._errHandler.sync(self) 

7680 _la = self._input.LA(1) 

7681 if _la==SQLiteParser.WINDOW_: 

7682 self.state = 1310 

7683 self.match(SQLiteParser.WINDOW_) 

7684 self.state = 1311 

7685 self.window_name() 

7686 self.state = 1312 

7687 self.match(SQLiteParser.AS_) 

7688 self.state = 1313 

7689 self.window_defn() 

7690 self.state = 1321 

7691 self._errHandler.sync(self) 

7692 _la = self._input.LA(1) 

7693 while _la==SQLiteParser.COMMA: 

7694 self.state = 1314 

7695 self.match(SQLiteParser.COMMA) 

7696 self.state = 1315 

7697 self.window_name() 

7698 self.state = 1316 

7699 self.match(SQLiteParser.AS_) 

7700 self.state = 1317 

7701 self.window_defn() 

7702 self.state = 1323 

7703 self._errHandler.sync(self) 

7704 _la = self._input.LA(1) 

7705 

7706 

7707 

7708 pass 

7709 elif token in [SQLiteParser.VALUES_]: 

7710 self.enterOuterAlt(localctx, 2) 

7711 self.state = 1326 

7712 self.match(SQLiteParser.VALUES_) 

7713 self.state = 1327 

7714 self.match(SQLiteParser.OPEN_PAR) 

7715 self.state = 1328 

7716 self.expr(0) 

7717 self.state = 1333 

7718 self._errHandler.sync(self) 

7719 _la = self._input.LA(1) 

7720 while _la==SQLiteParser.COMMA: 

7721 self.state = 1329 

7722 self.match(SQLiteParser.COMMA) 

7723 self.state = 1330 

7724 self.expr(0) 

7725 self.state = 1335 

7726 self._errHandler.sync(self) 

7727 _la = self._input.LA(1) 

7728 

7729 self.state = 1336 

7730 self.match(SQLiteParser.CLOSE_PAR) 

7731 self.state = 1351 

7732 self._errHandler.sync(self) 

7733 _la = self._input.LA(1) 

7734 while _la==SQLiteParser.COMMA: 

7735 self.state = 1337 

7736 self.match(SQLiteParser.COMMA) 

7737 self.state = 1338 

7738 self.match(SQLiteParser.OPEN_PAR) 

7739 self.state = 1339 

7740 self.expr(0) 

7741 self.state = 1344 

7742 self._errHandler.sync(self) 

7743 _la = self._input.LA(1) 

7744 while _la==SQLiteParser.COMMA: 

7745 self.state = 1340 

7746 self.match(SQLiteParser.COMMA) 

7747 self.state = 1341 

7748 self.expr(0) 

7749 self.state = 1346 

7750 self._errHandler.sync(self) 

7751 _la = self._input.LA(1) 

7752 

7753 self.state = 1347 

7754 self.match(SQLiteParser.CLOSE_PAR) 

7755 self.state = 1353 

7756 self._errHandler.sync(self) 

7757 _la = self._input.LA(1) 

7758 

7759 pass 

7760 else: 

7761 raise NoViableAltException(self) 

7762 

7763 except RecognitionException as re: 

7764 localctx.exception = re 

7765 self._errHandler.reportError(self, re) 

7766 self._errHandler.recover(self, re) 

7767 finally: 

7768 self.exitRule() 

7769 return localctx 

7770 

7771 

7772 class Factored_select_stmtContext(ParserRuleContext): 

7773 

7774 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

7775 super().__init__(parent, invokingState) 

7776 self.parser = parser 

7777 

7778 def select_stmt(self): 

7779 return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0) 

7780 

7781 

7782 def getRuleIndex(self): 

7783 return SQLiteParser.RULE_factored_select_stmt 

7784 

7785 def enterRule(self, listener:ParseTreeListener): 

7786 if hasattr( listener, "enterFactored_select_stmt" ): 

7787 listener.enterFactored_select_stmt(self) 

7788 

7789 def exitRule(self, listener:ParseTreeListener): 

7790 if hasattr( listener, "exitFactored_select_stmt" ): 

7791 listener.exitFactored_select_stmt(self) 

7792 

7793 

7794 

7795 

7796 def factored_select_stmt(self): 

7797 

7798 localctx = SQLiteParser.Factored_select_stmtContext(self, self._ctx, self.state) 

7799 self.enterRule(localctx, 86, self.RULE_factored_select_stmt) 

7800 try: 

7801 self.enterOuterAlt(localctx, 1) 

7802 self.state = 1356 

7803 self.select_stmt() 

7804 except RecognitionException as re: 

7805 localctx.exception = re 

7806 self._errHandler.reportError(self, re) 

7807 self._errHandler.recover(self, re) 

7808 finally: 

7809 self.exitRule() 

7810 return localctx 

7811 

7812 

7813 class Simple_select_stmtContext(ParserRuleContext): 

7814 

7815 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

7816 super().__init__(parent, invokingState) 

7817 self.parser = parser 

7818 

7819 def select_core(self): 

7820 return self.getTypedRuleContext(SQLiteParser.Select_coreContext,0) 

7821 

7822 

7823 def common_table_stmt(self): 

7824 return self.getTypedRuleContext(SQLiteParser.Common_table_stmtContext,0) 

7825 

7826 

7827 def order_by_stmt(self): 

7828 return self.getTypedRuleContext(SQLiteParser.Order_by_stmtContext,0) 

7829 

7830 

7831 def limit_stmt(self): 

7832 return self.getTypedRuleContext(SQLiteParser.Limit_stmtContext,0) 

7833 

7834 

7835 def getRuleIndex(self): 

7836 return SQLiteParser.RULE_simple_select_stmt 

7837 

7838 def enterRule(self, listener:ParseTreeListener): 

7839 if hasattr( listener, "enterSimple_select_stmt" ): 

7840 listener.enterSimple_select_stmt(self) 

7841 

7842 def exitRule(self, listener:ParseTreeListener): 

7843 if hasattr( listener, "exitSimple_select_stmt" ): 

7844 listener.exitSimple_select_stmt(self) 

7845 

7846 

7847 

7848 

7849 def simple_select_stmt(self): 

7850 

7851 localctx = SQLiteParser.Simple_select_stmtContext(self, self._ctx, self.state) 

7852 self.enterRule(localctx, 88, self.RULE_simple_select_stmt) 

7853 self._la = 0 # Token type 

7854 try: 

7855 self.enterOuterAlt(localctx, 1) 

7856 self.state = 1359 

7857 self._errHandler.sync(self) 

7858 _la = self._input.LA(1) 

7859 if _la==SQLiteParser.WITH_: 

7860 self.state = 1358 

7861 self.common_table_stmt() 

7862 

7863 

7864 self.state = 1361 

7865 self.select_core() 

7866 self.state = 1363 

7867 self._errHandler.sync(self) 

7868 _la = self._input.LA(1) 

7869 if _la==SQLiteParser.ORDER_: 

7870 self.state = 1362 

7871 self.order_by_stmt() 

7872 

7873 

7874 self.state = 1366 

7875 self._errHandler.sync(self) 

7876 _la = self._input.LA(1) 

7877 if _la==SQLiteParser.LIMIT_: 

7878 self.state = 1365 

7879 self.limit_stmt() 

7880 

7881 

7882 except RecognitionException as re: 

7883 localctx.exception = re 

7884 self._errHandler.reportError(self, re) 

7885 self._errHandler.recover(self, re) 

7886 finally: 

7887 self.exitRule() 

7888 return localctx 

7889 

7890 

7891 class Compound_select_stmtContext(ParserRuleContext): 

7892 

7893 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

7894 super().__init__(parent, invokingState) 

7895 self.parser = parser 

7896 

7897 def select_core(self, i:int=None): 

7898 if i is None: 

7899 return self.getTypedRuleContexts(SQLiteParser.Select_coreContext) 

7900 else: 

7901 return self.getTypedRuleContext(SQLiteParser.Select_coreContext,i) 

7902 

7903 

7904 def common_table_stmt(self): 

7905 return self.getTypedRuleContext(SQLiteParser.Common_table_stmtContext,0) 

7906 

7907 

7908 def order_by_stmt(self): 

7909 return self.getTypedRuleContext(SQLiteParser.Order_by_stmtContext,0) 

7910 

7911 

7912 def limit_stmt(self): 

7913 return self.getTypedRuleContext(SQLiteParser.Limit_stmtContext,0) 

7914 

7915 

7916 def UNION_(self, i:int=None): 

7917 if i is None: 

7918 return self.getTokens(SQLiteParser.UNION_) 

7919 else: 

7920 return self.getToken(SQLiteParser.UNION_, i) 

7921 

7922 def INTERSECT_(self, i:int=None): 

7923 if i is None: 

7924 return self.getTokens(SQLiteParser.INTERSECT_) 

7925 else: 

7926 return self.getToken(SQLiteParser.INTERSECT_, i) 

7927 

7928 def EXCEPT_(self, i:int=None): 

7929 if i is None: 

7930 return self.getTokens(SQLiteParser.EXCEPT_) 

7931 else: 

7932 return self.getToken(SQLiteParser.EXCEPT_, i) 

7933 

7934 def ALL_(self, i:int=None): 

7935 if i is None: 

7936 return self.getTokens(SQLiteParser.ALL_) 

7937 else: 

7938 return self.getToken(SQLiteParser.ALL_, i) 

7939 

7940 def getRuleIndex(self): 

7941 return SQLiteParser.RULE_compound_select_stmt 

7942 

7943 def enterRule(self, listener:ParseTreeListener): 

7944 if hasattr( listener, "enterCompound_select_stmt" ): 

7945 listener.enterCompound_select_stmt(self) 

7946 

7947 def exitRule(self, listener:ParseTreeListener): 

7948 if hasattr( listener, "exitCompound_select_stmt" ): 

7949 listener.exitCompound_select_stmt(self) 

7950 

7951 

7952 

7953 

7954 def compound_select_stmt(self): 

7955 

7956 localctx = SQLiteParser.Compound_select_stmtContext(self, self._ctx, self.state) 

7957 self.enterRule(localctx, 90, self.RULE_compound_select_stmt) 

7958 self._la = 0 # Token type 

7959 try: 

7960 self.enterOuterAlt(localctx, 1) 

7961 self.state = 1369 

7962 self._errHandler.sync(self) 

7963 _la = self._input.LA(1) 

7964 if _la==SQLiteParser.WITH_: 

7965 self.state = 1368 

7966 self.common_table_stmt() 

7967 

7968 

7969 self.state = 1371 

7970 self.select_core() 

7971 self.state = 1381 

7972 self._errHandler.sync(self) 

7973 _la = self._input.LA(1) 

7974 while True: 

7975 self.state = 1378 

7976 self._errHandler.sync(self) 

7977 token = self._input.LA(1) 

7978 if token in [SQLiteParser.UNION_]: 

7979 self.state = 1372 

7980 self.match(SQLiteParser.UNION_) 

7981 self.state = 1374 

7982 self._errHandler.sync(self) 

7983 _la = self._input.LA(1) 

7984 if _la==SQLiteParser.ALL_: 

7985 self.state = 1373 

7986 self.match(SQLiteParser.ALL_) 

7987 

7988 

7989 pass 

7990 elif token in [SQLiteParser.INTERSECT_]: 

7991 self.state = 1376 

7992 self.match(SQLiteParser.INTERSECT_) 

7993 pass 

7994 elif token in [SQLiteParser.EXCEPT_]: 

7995 self.state = 1377 

7996 self.match(SQLiteParser.EXCEPT_) 

7997 pass 

7998 else: 

7999 raise NoViableAltException(self) 

8000 

8001 self.state = 1380 

8002 self.select_core() 

8003 self.state = 1383 

8004 self._errHandler.sync(self) 

8005 _la = self._input.LA(1) 

8006 if not (_la==SQLiteParser.EXCEPT_ or _la==SQLiteParser.INTERSECT_ or _la==SQLiteParser.UNION_): 

8007 break 

8008 

8009 self.state = 1386 

8010 self._errHandler.sync(self) 

8011 _la = self._input.LA(1) 

8012 if _la==SQLiteParser.ORDER_: 

8013 self.state = 1385 

8014 self.order_by_stmt() 

8015 

8016 

8017 self.state = 1389 

8018 self._errHandler.sync(self) 

8019 _la = self._input.LA(1) 

8020 if _la==SQLiteParser.LIMIT_: 

8021 self.state = 1388 

8022 self.limit_stmt() 

8023 

8024 

8025 except RecognitionException as re: 

8026 localctx.exception = re 

8027 self._errHandler.reportError(self, re) 

8028 self._errHandler.recover(self, re) 

8029 finally: 

8030 self.exitRule() 

8031 return localctx 

8032 

8033 

8034 class Table_or_subqueryContext(ParserRuleContext): 

8035 

8036 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

8037 super().__init__(parent, invokingState) 

8038 self.parser = parser 

8039 

8040 def table_name(self): 

8041 return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0) 

8042 

8043 

8044 def schema_name(self): 

8045 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

8046 

8047 

8048 def DOT(self): 

8049 return self.getToken(SQLiteParser.DOT, 0) 

8050 

8051 def table_alias(self): 

8052 return self.getTypedRuleContext(SQLiteParser.Table_aliasContext,0) 

8053 

8054 

8055 def INDEXED_(self): 

8056 return self.getToken(SQLiteParser.INDEXED_, 0) 

8057 

8058 def BY_(self): 

8059 return self.getToken(SQLiteParser.BY_, 0) 

8060 

8061 def index_name(self): 

8062 return self.getTypedRuleContext(SQLiteParser.Index_nameContext,0) 

8063 

8064 

8065 def NOT_(self): 

8066 return self.getToken(SQLiteParser.NOT_, 0) 

8067 

8068 def AS_(self): 

8069 return self.getToken(SQLiteParser.AS_, 0) 

8070 

8071 def table_function_name(self): 

8072 return self.getTypedRuleContext(SQLiteParser.Table_function_nameContext,0) 

8073 

8074 

8075 def OPEN_PAR(self): 

8076 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

8077 

8078 def expr(self, i:int=None): 

8079 if i is None: 

8080 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

8081 else: 

8082 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

8083 

8084 

8085 def CLOSE_PAR(self): 

8086 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

8087 

8088 def COMMA(self, i:int=None): 

8089 if i is None: 

8090 return self.getTokens(SQLiteParser.COMMA) 

8091 else: 

8092 return self.getToken(SQLiteParser.COMMA, i) 

8093 

8094 def table_or_subquery(self, i:int=None): 

8095 if i is None: 

8096 return self.getTypedRuleContexts(SQLiteParser.Table_or_subqueryContext) 

8097 else: 

8098 return self.getTypedRuleContext(SQLiteParser.Table_or_subqueryContext,i) 

8099 

8100 

8101 def join_clause(self): 

8102 return self.getTypedRuleContext(SQLiteParser.Join_clauseContext,0) 

8103 

8104 

8105 def select_stmt(self): 

8106 return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0) 

8107 

8108 

8109 def getRuleIndex(self): 

8110 return SQLiteParser.RULE_table_or_subquery 

8111 

8112 def enterRule(self, listener:ParseTreeListener): 

8113 if hasattr( listener, "enterTable_or_subquery" ): 

8114 listener.enterTable_or_subquery(self) 

8115 

8116 def exitRule(self, listener:ParseTreeListener): 

8117 if hasattr( listener, "exitTable_or_subquery" ): 

8118 listener.exitTable_or_subquery(self) 

8119 

8120 

8121 

8122 

8123 def table_or_subquery(self): 

8124 

8125 localctx = SQLiteParser.Table_or_subqueryContext(self, self._ctx, self.state) 

8126 self.enterRule(localctx, 92, self.RULE_table_or_subquery) 

8127 self._la = 0 # Token type 

8128 try: 

8129 self.state = 1455 

8130 self._errHandler.sync(self) 

8131 la_ = self._interp.adaptivePredict(self._input,203,self._ctx) 

8132 if la_ == 1: 

8133 self.enterOuterAlt(localctx, 1) 

8134 self.state = 1394 

8135 self._errHandler.sync(self) 

8136 la_ = self._interp.adaptivePredict(self._input,191,self._ctx) 

8137 if la_ == 1: 

8138 self.state = 1391 

8139 self.schema_name() 

8140 self.state = 1392 

8141 self.match(SQLiteParser.DOT) 

8142 

8143 

8144 self.state = 1396 

8145 self.table_name() 

8146 self.state = 1401 

8147 self._errHandler.sync(self) 

8148 la_ = self._interp.adaptivePredict(self._input,193,self._ctx) 

8149 if la_ == 1: 

8150 self.state = 1398 

8151 self._errHandler.sync(self) 

8152 la_ = self._interp.adaptivePredict(self._input,192,self._ctx) 

8153 if la_ == 1: 

8154 self.state = 1397 

8155 self.match(SQLiteParser.AS_) 

8156 

8157 

8158 self.state = 1400 

8159 self.table_alias() 

8160 

8161 

8162 self.state = 1408 

8163 self._errHandler.sync(self) 

8164 token = self._input.LA(1) 

8165 if token in [SQLiteParser.INDEXED_]: 

8166 self.state = 1403 

8167 self.match(SQLiteParser.INDEXED_) 

8168 self.state = 1404 

8169 self.match(SQLiteParser.BY_) 

8170 self.state = 1405 

8171 self.index_name() 

8172 pass 

8173 elif token in [SQLiteParser.NOT_]: 

8174 self.state = 1406 

8175 self.match(SQLiteParser.NOT_) 

8176 self.state = 1407 

8177 self.match(SQLiteParser.INDEXED_) 

8178 pass 

8179 elif token in [SQLiteParser.EOF, SQLiteParser.SCOL, SQLiteParser.CLOSE_PAR, SQLiteParser.COMMA, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.ATTACH_, SQLiteParser.BEGIN_, SQLiteParser.COMMIT_, SQLiteParser.CREATE_, SQLiteParser.CROSS_, SQLiteParser.DEFAULT_, SQLiteParser.DELETE_, SQLiteParser.DETACH_, SQLiteParser.DROP_, SQLiteParser.END_, SQLiteParser.EXCEPT_, SQLiteParser.EXPLAIN_, SQLiteParser.GROUP_, SQLiteParser.INNER_, SQLiteParser.INSERT_, SQLiteParser.INTERSECT_, SQLiteParser.JOIN_, SQLiteParser.LEFT_, SQLiteParser.LIMIT_, SQLiteParser.NATURAL_, SQLiteParser.ON_, SQLiteParser.ORDER_, SQLiteParser.PRAGMA_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.REPLACE_, SQLiteParser.ROLLBACK_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.UNION_, SQLiteParser.UPDATE_, SQLiteParser.USING_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.WHERE_, SQLiteParser.WITH_, SQLiteParser.WINDOW_]: 

8180 pass 

8181 else: 

8182 pass 

8183 pass 

8184 

8185 elif la_ == 2: 

8186 self.enterOuterAlt(localctx, 2) 

8187 self.state = 1413 

8188 self._errHandler.sync(self) 

8189 la_ = self._interp.adaptivePredict(self._input,195,self._ctx) 

8190 if la_ == 1: 

8191 self.state = 1410 

8192 self.schema_name() 

8193 self.state = 1411 

8194 self.match(SQLiteParser.DOT) 

8195 

8196 

8197 self.state = 1415 

8198 self.table_function_name() 

8199 self.state = 1416 

8200 self.match(SQLiteParser.OPEN_PAR) 

8201 self.state = 1417 

8202 self.expr(0) 

8203 self.state = 1422 

8204 self._errHandler.sync(self) 

8205 _la = self._input.LA(1) 

8206 while _la==SQLiteParser.COMMA: 

8207 self.state = 1418 

8208 self.match(SQLiteParser.COMMA) 

8209 self.state = 1419 

8210 self.expr(0) 

8211 self.state = 1424 

8212 self._errHandler.sync(self) 

8213 _la = self._input.LA(1) 

8214 

8215 self.state = 1425 

8216 self.match(SQLiteParser.CLOSE_PAR) 

8217 self.state = 1430 

8218 self._errHandler.sync(self) 

8219 la_ = self._interp.adaptivePredict(self._input,198,self._ctx) 

8220 if la_ == 1: 

8221 self.state = 1427 

8222 self._errHandler.sync(self) 

8223 la_ = self._interp.adaptivePredict(self._input,197,self._ctx) 

8224 if la_ == 1: 

8225 self.state = 1426 

8226 self.match(SQLiteParser.AS_) 

8227 

8228 

8229 self.state = 1429 

8230 self.table_alias() 

8231 

8232 

8233 pass 

8234 

8235 elif la_ == 3: 

8236 self.enterOuterAlt(localctx, 3) 

8237 self.state = 1432 

8238 self.match(SQLiteParser.OPEN_PAR) 

8239 self.state = 1442 

8240 self._errHandler.sync(self) 

8241 la_ = self._interp.adaptivePredict(self._input,200,self._ctx) 

8242 if la_ == 1: 

8243 self.state = 1433 

8244 self.table_or_subquery() 

8245 self.state = 1438 

8246 self._errHandler.sync(self) 

8247 _la = self._input.LA(1) 

8248 while _la==SQLiteParser.COMMA: 

8249 self.state = 1434 

8250 self.match(SQLiteParser.COMMA) 

8251 self.state = 1435 

8252 self.table_or_subquery() 

8253 self.state = 1440 

8254 self._errHandler.sync(self) 

8255 _la = self._input.LA(1) 

8256 

8257 pass 

8258 

8259 elif la_ == 2: 

8260 self.state = 1441 

8261 self.join_clause() 

8262 pass 

8263 

8264 

8265 self.state = 1444 

8266 self.match(SQLiteParser.CLOSE_PAR) 

8267 pass 

8268 

8269 elif la_ == 4: 

8270 self.enterOuterAlt(localctx, 4) 

8271 self.state = 1446 

8272 self.match(SQLiteParser.OPEN_PAR) 

8273 self.state = 1447 

8274 self.select_stmt() 

8275 self.state = 1448 

8276 self.match(SQLiteParser.CLOSE_PAR) 

8277 self.state = 1453 

8278 self._errHandler.sync(self) 

8279 la_ = self._interp.adaptivePredict(self._input,202,self._ctx) 

8280 if la_ == 1: 

8281 self.state = 1450 

8282 self._errHandler.sync(self) 

8283 la_ = self._interp.adaptivePredict(self._input,201,self._ctx) 

8284 if la_ == 1: 

8285 self.state = 1449 

8286 self.match(SQLiteParser.AS_) 

8287 

8288 

8289 self.state = 1452 

8290 self.table_alias() 

8291 

8292 

8293 pass 

8294 

8295 

8296 except RecognitionException as re: 

8297 localctx.exception = re 

8298 self._errHandler.reportError(self, re) 

8299 self._errHandler.recover(self, re) 

8300 finally: 

8301 self.exitRule() 

8302 return localctx 

8303 

8304 

8305 class Result_columnContext(ParserRuleContext): 

8306 

8307 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

8308 super().__init__(parent, invokingState) 

8309 self.parser = parser 

8310 

8311 def STAR(self): 

8312 return self.getToken(SQLiteParser.STAR, 0) 

8313 

8314 def table_name(self): 

8315 return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0) 

8316 

8317 

8318 def DOT(self): 

8319 return self.getToken(SQLiteParser.DOT, 0) 

8320 

8321 def expr(self): 

8322 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

8323 

8324 

8325 def column_alias(self): 

8326 return self.getTypedRuleContext(SQLiteParser.Column_aliasContext,0) 

8327 

8328 

8329 def AS_(self): 

8330 return self.getToken(SQLiteParser.AS_, 0) 

8331 

8332 def getRuleIndex(self): 

8333 return SQLiteParser.RULE_result_column 

8334 

8335 def enterRule(self, listener:ParseTreeListener): 

8336 if hasattr( listener, "enterResult_column" ): 

8337 listener.enterResult_column(self) 

8338 

8339 def exitRule(self, listener:ParseTreeListener): 

8340 if hasattr( listener, "exitResult_column" ): 

8341 listener.exitResult_column(self) 

8342 

8343 

8344 

8345 

8346 def result_column(self): 

8347 

8348 localctx = SQLiteParser.Result_columnContext(self, self._ctx, self.state) 

8349 self.enterRule(localctx, 94, self.RULE_result_column) 

8350 self._la = 0 # Token type 

8351 try: 

8352 self.state = 1469 

8353 self._errHandler.sync(self) 

8354 la_ = self._interp.adaptivePredict(self._input,206,self._ctx) 

8355 if la_ == 1: 

8356 self.enterOuterAlt(localctx, 1) 

8357 self.state = 1457 

8358 self.match(SQLiteParser.STAR) 

8359 pass 

8360 

8361 elif la_ == 2: 

8362 self.enterOuterAlt(localctx, 2) 

8363 self.state = 1458 

8364 self.table_name() 

8365 self.state = 1459 

8366 self.match(SQLiteParser.DOT) 

8367 self.state = 1460 

8368 self.match(SQLiteParser.STAR) 

8369 pass 

8370 

8371 elif la_ == 3: 

8372 self.enterOuterAlt(localctx, 3) 

8373 self.state = 1462 

8374 self.expr(0) 

8375 self.state = 1467 

8376 self._errHandler.sync(self) 

8377 _la = self._input.LA(1) 

8378 if _la==SQLiteParser.AS_ or _la==SQLiteParser.IDENTIFIER or _la==SQLiteParser.STRING_LITERAL: 

8379 self.state = 1464 

8380 self._errHandler.sync(self) 

8381 _la = self._input.LA(1) 

8382 if _la==SQLiteParser.AS_: 

8383 self.state = 1463 

8384 self.match(SQLiteParser.AS_) 

8385 

8386 

8387 self.state = 1466 

8388 self.column_alias() 

8389 

8390 

8391 pass 

8392 

8393 

8394 except RecognitionException as re: 

8395 localctx.exception = re 

8396 self._errHandler.reportError(self, re) 

8397 self._errHandler.recover(self, re) 

8398 finally: 

8399 self.exitRule() 

8400 return localctx 

8401 

8402 

8403 class Join_operatorContext(ParserRuleContext): 

8404 

8405 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

8406 super().__init__(parent, invokingState) 

8407 self.parser = parser 

8408 

8409 def COMMA(self): 

8410 return self.getToken(SQLiteParser.COMMA, 0) 

8411 

8412 def JOIN_(self): 

8413 return self.getToken(SQLiteParser.JOIN_, 0) 

8414 

8415 def NATURAL_(self): 

8416 return self.getToken(SQLiteParser.NATURAL_, 0) 

8417 

8418 def LEFT_(self): 

8419 return self.getToken(SQLiteParser.LEFT_, 0) 

8420 

8421 def INNER_(self): 

8422 return self.getToken(SQLiteParser.INNER_, 0) 

8423 

8424 def CROSS_(self): 

8425 return self.getToken(SQLiteParser.CROSS_, 0) 

8426 

8427 def OUTER_(self): 

8428 return self.getToken(SQLiteParser.OUTER_, 0) 

8429 

8430 def getRuleIndex(self): 

8431 return SQLiteParser.RULE_join_operator 

8432 

8433 def enterRule(self, listener:ParseTreeListener): 

8434 if hasattr( listener, "enterJoin_operator" ): 

8435 listener.enterJoin_operator(self) 

8436 

8437 def exitRule(self, listener:ParseTreeListener): 

8438 if hasattr( listener, "exitJoin_operator" ): 

8439 listener.exitJoin_operator(self) 

8440 

8441 

8442 

8443 

8444 def join_operator(self): 

8445 

8446 localctx = SQLiteParser.Join_operatorContext(self, self._ctx, self.state) 

8447 self.enterRule(localctx, 96, self.RULE_join_operator) 

8448 self._la = 0 # Token type 

8449 try: 

8450 self.state = 1484 

8451 self._errHandler.sync(self) 

8452 token = self._input.LA(1) 

8453 if token in [SQLiteParser.COMMA]: 

8454 self.enterOuterAlt(localctx, 1) 

8455 self.state = 1471 

8456 self.match(SQLiteParser.COMMA) 

8457 pass 

8458 elif token in [SQLiteParser.CROSS_, SQLiteParser.INNER_, SQLiteParser.JOIN_, SQLiteParser.LEFT_, SQLiteParser.NATURAL_]: 

8459 self.enterOuterAlt(localctx, 2) 

8460 self.state = 1473 

8461 self._errHandler.sync(self) 

8462 _la = self._input.LA(1) 

8463 if _la==SQLiteParser.NATURAL_: 

8464 self.state = 1472 

8465 self.match(SQLiteParser.NATURAL_) 

8466 

8467 

8468 self.state = 1481 

8469 self._errHandler.sync(self) 

8470 token = self._input.LA(1) 

8471 if token in [SQLiteParser.LEFT_]: 

8472 self.state = 1475 

8473 self.match(SQLiteParser.LEFT_) 

8474 self.state = 1477 

8475 self._errHandler.sync(self) 

8476 _la = self._input.LA(1) 

8477 if _la==SQLiteParser.OUTER_: 

8478 self.state = 1476 

8479 self.match(SQLiteParser.OUTER_) 

8480 

8481 

8482 pass 

8483 elif token in [SQLiteParser.INNER_]: 

8484 self.state = 1479 

8485 self.match(SQLiteParser.INNER_) 

8486 pass 

8487 elif token in [SQLiteParser.CROSS_]: 

8488 self.state = 1480 

8489 self.match(SQLiteParser.CROSS_) 

8490 pass 

8491 elif token in [SQLiteParser.JOIN_]: 

8492 pass 

8493 else: 

8494 pass 

8495 self.state = 1483 

8496 self.match(SQLiteParser.JOIN_) 

8497 pass 

8498 else: 

8499 raise NoViableAltException(self) 

8500 

8501 except RecognitionException as re: 

8502 localctx.exception = re 

8503 self._errHandler.reportError(self, re) 

8504 self._errHandler.recover(self, re) 

8505 finally: 

8506 self.exitRule() 

8507 return localctx 

8508 

8509 

8510 class Join_constraintContext(ParserRuleContext): 

8511 

8512 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

8513 super().__init__(parent, invokingState) 

8514 self.parser = parser 

8515 

8516 def ON_(self): 

8517 return self.getToken(SQLiteParser.ON_, 0) 

8518 

8519 def expr(self): 

8520 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

8521 

8522 

8523 def USING_(self): 

8524 return self.getToken(SQLiteParser.USING_, 0) 

8525 

8526 def OPEN_PAR(self): 

8527 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

8528 

8529 def column_name(self, i:int=None): 

8530 if i is None: 

8531 return self.getTypedRuleContexts(SQLiteParser.Column_nameContext) 

8532 else: 

8533 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i) 

8534 

8535 

8536 def CLOSE_PAR(self): 

8537 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

8538 

8539 def COMMA(self, i:int=None): 

8540 if i is None: 

8541 return self.getTokens(SQLiteParser.COMMA) 

8542 else: 

8543 return self.getToken(SQLiteParser.COMMA, i) 

8544 

8545 def getRuleIndex(self): 

8546 return SQLiteParser.RULE_join_constraint 

8547 

8548 def enterRule(self, listener:ParseTreeListener): 

8549 if hasattr( listener, "enterJoin_constraint" ): 

8550 listener.enterJoin_constraint(self) 

8551 

8552 def exitRule(self, listener:ParseTreeListener): 

8553 if hasattr( listener, "exitJoin_constraint" ): 

8554 listener.exitJoin_constraint(self) 

8555 

8556 

8557 

8558 

8559 def join_constraint(self): 

8560 

8561 localctx = SQLiteParser.Join_constraintContext(self, self._ctx, self.state) 

8562 self.enterRule(localctx, 98, self.RULE_join_constraint) 

8563 self._la = 0 # Token type 

8564 try: 

8565 self.state = 1500 

8566 self._errHandler.sync(self) 

8567 token = self._input.LA(1) 

8568 if token in [SQLiteParser.ON_]: 

8569 self.enterOuterAlt(localctx, 1) 

8570 self.state = 1486 

8571 self.match(SQLiteParser.ON_) 

8572 self.state = 1487 

8573 self.expr(0) 

8574 pass 

8575 elif token in [SQLiteParser.USING_]: 

8576 self.enterOuterAlt(localctx, 2) 

8577 self.state = 1488 

8578 self.match(SQLiteParser.USING_) 

8579 self.state = 1489 

8580 self.match(SQLiteParser.OPEN_PAR) 

8581 self.state = 1490 

8582 self.column_name() 

8583 self.state = 1495 

8584 self._errHandler.sync(self) 

8585 _la = self._input.LA(1) 

8586 while _la==SQLiteParser.COMMA: 

8587 self.state = 1491 

8588 self.match(SQLiteParser.COMMA) 

8589 self.state = 1492 

8590 self.column_name() 

8591 self.state = 1497 

8592 self._errHandler.sync(self) 

8593 _la = self._input.LA(1) 

8594 

8595 self.state = 1498 

8596 self.match(SQLiteParser.CLOSE_PAR) 

8597 pass 

8598 else: 

8599 raise NoViableAltException(self) 

8600 

8601 except RecognitionException as re: 

8602 localctx.exception = re 

8603 self._errHandler.reportError(self, re) 

8604 self._errHandler.recover(self, re) 

8605 finally: 

8606 self.exitRule() 

8607 return localctx 

8608 

8609 

8610 class Compound_operatorContext(ParserRuleContext): 

8611 

8612 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

8613 super().__init__(parent, invokingState) 

8614 self.parser = parser 

8615 

8616 def UNION_(self): 

8617 return self.getToken(SQLiteParser.UNION_, 0) 

8618 

8619 def ALL_(self): 

8620 return self.getToken(SQLiteParser.ALL_, 0) 

8621 

8622 def INTERSECT_(self): 

8623 return self.getToken(SQLiteParser.INTERSECT_, 0) 

8624 

8625 def EXCEPT_(self): 

8626 return self.getToken(SQLiteParser.EXCEPT_, 0) 

8627 

8628 def getRuleIndex(self): 

8629 return SQLiteParser.RULE_compound_operator 

8630 

8631 def enterRule(self, listener:ParseTreeListener): 

8632 if hasattr( listener, "enterCompound_operator" ): 

8633 listener.enterCompound_operator(self) 

8634 

8635 def exitRule(self, listener:ParseTreeListener): 

8636 if hasattr( listener, "exitCompound_operator" ): 

8637 listener.exitCompound_operator(self) 

8638 

8639 

8640 

8641 

8642 def compound_operator(self): 

8643 

8644 localctx = SQLiteParser.Compound_operatorContext(self, self._ctx, self.state) 

8645 self.enterRule(localctx, 100, self.RULE_compound_operator) 

8646 self._la = 0 # Token type 

8647 try: 

8648 self.state = 1508 

8649 self._errHandler.sync(self) 

8650 token = self._input.LA(1) 

8651 if token in [SQLiteParser.UNION_]: 

8652 self.enterOuterAlt(localctx, 1) 

8653 self.state = 1502 

8654 self.match(SQLiteParser.UNION_) 

8655 self.state = 1504 

8656 self._errHandler.sync(self) 

8657 _la = self._input.LA(1) 

8658 if _la==SQLiteParser.ALL_: 

8659 self.state = 1503 

8660 self.match(SQLiteParser.ALL_) 

8661 

8662 

8663 pass 

8664 elif token in [SQLiteParser.INTERSECT_]: 

8665 self.enterOuterAlt(localctx, 2) 

8666 self.state = 1506 

8667 self.match(SQLiteParser.INTERSECT_) 

8668 pass 

8669 elif token in [SQLiteParser.EXCEPT_]: 

8670 self.enterOuterAlt(localctx, 3) 

8671 self.state = 1507 

8672 self.match(SQLiteParser.EXCEPT_) 

8673 pass 

8674 else: 

8675 raise NoViableAltException(self) 

8676 

8677 except RecognitionException as re: 

8678 localctx.exception = re 

8679 self._errHandler.reportError(self, re) 

8680 self._errHandler.recover(self, re) 

8681 finally: 

8682 self.exitRule() 

8683 return localctx 

8684 

8685 

8686 class Update_stmtContext(ParserRuleContext): 

8687 

8688 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

8689 super().__init__(parent, invokingState) 

8690 self.parser = parser 

8691 

8692 def UPDATE_(self): 

8693 return self.getToken(SQLiteParser.UPDATE_, 0) 

8694 

8695 def qualified_table_name(self): 

8696 return self.getTypedRuleContext(SQLiteParser.Qualified_table_nameContext,0) 

8697 

8698 

8699 def SET_(self): 

8700 return self.getToken(SQLiteParser.SET_, 0) 

8701 

8702 def ASSIGN(self, i:int=None): 

8703 if i is None: 

8704 return self.getTokens(SQLiteParser.ASSIGN) 

8705 else: 

8706 return self.getToken(SQLiteParser.ASSIGN, i) 

8707 

8708 def expr(self, i:int=None): 

8709 if i is None: 

8710 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

8711 else: 

8712 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

8713 

8714 

8715 def column_name(self, i:int=None): 

8716 if i is None: 

8717 return self.getTypedRuleContexts(SQLiteParser.Column_nameContext) 

8718 else: 

8719 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i) 

8720 

8721 

8722 def column_name_list(self, i:int=None): 

8723 if i is None: 

8724 return self.getTypedRuleContexts(SQLiteParser.Column_name_listContext) 

8725 else: 

8726 return self.getTypedRuleContext(SQLiteParser.Column_name_listContext,i) 

8727 

8728 

8729 def with_clause(self): 

8730 return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0) 

8731 

8732 

8733 def OR_(self): 

8734 return self.getToken(SQLiteParser.OR_, 0) 

8735 

8736 def COMMA(self, i:int=None): 

8737 if i is None: 

8738 return self.getTokens(SQLiteParser.COMMA) 

8739 else: 

8740 return self.getToken(SQLiteParser.COMMA, i) 

8741 

8742 def WHERE_(self): 

8743 return self.getToken(SQLiteParser.WHERE_, 0) 

8744 

8745 def ROLLBACK_(self): 

8746 return self.getToken(SQLiteParser.ROLLBACK_, 0) 

8747 

8748 def ABORT_(self): 

8749 return self.getToken(SQLiteParser.ABORT_, 0) 

8750 

8751 def REPLACE_(self): 

8752 return self.getToken(SQLiteParser.REPLACE_, 0) 

8753 

8754 def FAIL_(self): 

8755 return self.getToken(SQLiteParser.FAIL_, 0) 

8756 

8757 def IGNORE_(self): 

8758 return self.getToken(SQLiteParser.IGNORE_, 0) 

8759 

8760 def getRuleIndex(self): 

8761 return SQLiteParser.RULE_update_stmt 

8762 

8763 def enterRule(self, listener:ParseTreeListener): 

8764 if hasattr( listener, "enterUpdate_stmt" ): 

8765 listener.enterUpdate_stmt(self) 

8766 

8767 def exitRule(self, listener:ParseTreeListener): 

8768 if hasattr( listener, "exitUpdate_stmt" ): 

8769 listener.exitUpdate_stmt(self) 

8770 

8771 

8772 

8773 

8774 def update_stmt(self): 

8775 

8776 localctx = SQLiteParser.Update_stmtContext(self, self._ctx, self.state) 

8777 self.enterRule(localctx, 102, self.RULE_update_stmt) 

8778 self._la = 0 # Token type 

8779 try: 

8780 self.enterOuterAlt(localctx, 1) 

8781 self.state = 1511 

8782 self._errHandler.sync(self) 

8783 _la = self._input.LA(1) 

8784 if _la==SQLiteParser.WITH_: 

8785 self.state = 1510 

8786 self.with_clause() 

8787 

8788 

8789 self.state = 1513 

8790 self.match(SQLiteParser.UPDATE_) 

8791 self.state = 1516 

8792 self._errHandler.sync(self) 

8793 la_ = self._interp.adaptivePredict(self._input,216,self._ctx) 

8794 if la_ == 1: 

8795 self.state = 1514 

8796 self.match(SQLiteParser.OR_) 

8797 self.state = 1515 

8798 _la = self._input.LA(1) 

8799 if not(_la==SQLiteParser.ABORT_ or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (SQLiteParser.FAIL_ - 72)) | (1 << (SQLiteParser.IGNORE_ - 72)) | (1 << (SQLiteParser.REPLACE_ - 72)) | (1 << (SQLiteParser.ROLLBACK_ - 72)))) != 0)): 

8800 self._errHandler.recoverInline(self) 

8801 else: 

8802 self._errHandler.reportMatch(self) 

8803 self.consume() 

8804 

8805 

8806 self.state = 1518 

8807 self.qualified_table_name() 

8808 self.state = 1519 

8809 self.match(SQLiteParser.SET_) 

8810 self.state = 1522 

8811 self._errHandler.sync(self) 

8812 la_ = self._interp.adaptivePredict(self._input,217,self._ctx) 

8813 if la_ == 1: 

8814 self.state = 1520 

8815 self.column_name() 

8816 pass 

8817 

8818 elif la_ == 2: 

8819 self.state = 1521 

8820 self.column_name_list() 

8821 pass 

8822 

8823 

8824 self.state = 1524 

8825 self.match(SQLiteParser.ASSIGN) 

8826 self.state = 1525 

8827 self.expr(0) 

8828 self.state = 1536 

8829 self._errHandler.sync(self) 

8830 _la = self._input.LA(1) 

8831 while _la==SQLiteParser.COMMA: 

8832 self.state = 1526 

8833 self.match(SQLiteParser.COMMA) 

8834 self.state = 1529 

8835 self._errHandler.sync(self) 

8836 la_ = self._interp.adaptivePredict(self._input,218,self._ctx) 

8837 if la_ == 1: 

8838 self.state = 1527 

8839 self.column_name() 

8840 pass 

8841 

8842 elif la_ == 2: 

8843 self.state = 1528 

8844 self.column_name_list() 

8845 pass 

8846 

8847 

8848 self.state = 1531 

8849 self.match(SQLiteParser.ASSIGN) 

8850 self.state = 1532 

8851 self.expr(0) 

8852 self.state = 1538 

8853 self._errHandler.sync(self) 

8854 _la = self._input.LA(1) 

8855 

8856 self.state = 1541 

8857 self._errHandler.sync(self) 

8858 _la = self._input.LA(1) 

8859 if _la==SQLiteParser.WHERE_: 

8860 self.state = 1539 

8861 self.match(SQLiteParser.WHERE_) 

8862 self.state = 1540 

8863 self.expr(0) 

8864 

8865 

8866 except RecognitionException as re: 

8867 localctx.exception = re 

8868 self._errHandler.reportError(self, re) 

8869 self._errHandler.recover(self, re) 

8870 finally: 

8871 self.exitRule() 

8872 return localctx 

8873 

8874 

8875 class Column_name_listContext(ParserRuleContext): 

8876 

8877 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

8878 super().__init__(parent, invokingState) 

8879 self.parser = parser 

8880 

8881 def OPEN_PAR(self): 

8882 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

8883 

8884 def column_name(self, i:int=None): 

8885 if i is None: 

8886 return self.getTypedRuleContexts(SQLiteParser.Column_nameContext) 

8887 else: 

8888 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i) 

8889 

8890 

8891 def CLOSE_PAR(self): 

8892 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

8893 

8894 def COMMA(self, i:int=None): 

8895 if i is None: 

8896 return self.getTokens(SQLiteParser.COMMA) 

8897 else: 

8898 return self.getToken(SQLiteParser.COMMA, i) 

8899 

8900 def getRuleIndex(self): 

8901 return SQLiteParser.RULE_column_name_list 

8902 

8903 def enterRule(self, listener:ParseTreeListener): 

8904 if hasattr( listener, "enterColumn_name_list" ): 

8905 listener.enterColumn_name_list(self) 

8906 

8907 def exitRule(self, listener:ParseTreeListener): 

8908 if hasattr( listener, "exitColumn_name_list" ): 

8909 listener.exitColumn_name_list(self) 

8910 

8911 

8912 

8913 

8914 def column_name_list(self): 

8915 

8916 localctx = SQLiteParser.Column_name_listContext(self, self._ctx, self.state) 

8917 self.enterRule(localctx, 104, self.RULE_column_name_list) 

8918 self._la = 0 # Token type 

8919 try: 

8920 self.enterOuterAlt(localctx, 1) 

8921 self.state = 1543 

8922 self.match(SQLiteParser.OPEN_PAR) 

8923 self.state = 1544 

8924 self.column_name() 

8925 self.state = 1549 

8926 self._errHandler.sync(self) 

8927 _la = self._input.LA(1) 

8928 while _la==SQLiteParser.COMMA: 

8929 self.state = 1545 

8930 self.match(SQLiteParser.COMMA) 

8931 self.state = 1546 

8932 self.column_name() 

8933 self.state = 1551 

8934 self._errHandler.sync(self) 

8935 _la = self._input.LA(1) 

8936 

8937 self.state = 1552 

8938 self.match(SQLiteParser.CLOSE_PAR) 

8939 except RecognitionException as re: 

8940 localctx.exception = re 

8941 self._errHandler.reportError(self, re) 

8942 self._errHandler.recover(self, re) 

8943 finally: 

8944 self.exitRule() 

8945 return localctx 

8946 

8947 

8948 class Update_stmt_limitedContext(ParserRuleContext): 

8949 

8950 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

8951 super().__init__(parent, invokingState) 

8952 self.parser = parser 

8953 

8954 def UPDATE_(self): 

8955 return self.getToken(SQLiteParser.UPDATE_, 0) 

8956 

8957 def qualified_table_name(self): 

8958 return self.getTypedRuleContext(SQLiteParser.Qualified_table_nameContext,0) 

8959 

8960 

8961 def SET_(self): 

8962 return self.getToken(SQLiteParser.SET_, 0) 

8963 

8964 def ASSIGN(self, i:int=None): 

8965 if i is None: 

8966 return self.getTokens(SQLiteParser.ASSIGN) 

8967 else: 

8968 return self.getToken(SQLiteParser.ASSIGN, i) 

8969 

8970 def expr(self, i:int=None): 

8971 if i is None: 

8972 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

8973 else: 

8974 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

8975 

8976 

8977 def column_name(self, i:int=None): 

8978 if i is None: 

8979 return self.getTypedRuleContexts(SQLiteParser.Column_nameContext) 

8980 else: 

8981 return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i) 

8982 

8983 

8984 def column_name_list(self, i:int=None): 

8985 if i is None: 

8986 return self.getTypedRuleContexts(SQLiteParser.Column_name_listContext) 

8987 else: 

8988 return self.getTypedRuleContext(SQLiteParser.Column_name_listContext,i) 

8989 

8990 

8991 def with_clause(self): 

8992 return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0) 

8993 

8994 

8995 def OR_(self): 

8996 return self.getToken(SQLiteParser.OR_, 0) 

8997 

8998 def COMMA(self, i:int=None): 

8999 if i is None: 

9000 return self.getTokens(SQLiteParser.COMMA) 

9001 else: 

9002 return self.getToken(SQLiteParser.COMMA, i) 

9003 

9004 def WHERE_(self): 

9005 return self.getToken(SQLiteParser.WHERE_, 0) 

9006 

9007 def limit_stmt(self): 

9008 return self.getTypedRuleContext(SQLiteParser.Limit_stmtContext,0) 

9009 

9010 

9011 def ROLLBACK_(self): 

9012 return self.getToken(SQLiteParser.ROLLBACK_, 0) 

9013 

9014 def ABORT_(self): 

9015 return self.getToken(SQLiteParser.ABORT_, 0) 

9016 

9017 def REPLACE_(self): 

9018 return self.getToken(SQLiteParser.REPLACE_, 0) 

9019 

9020 def FAIL_(self): 

9021 return self.getToken(SQLiteParser.FAIL_, 0) 

9022 

9023 def IGNORE_(self): 

9024 return self.getToken(SQLiteParser.IGNORE_, 0) 

9025 

9026 def order_by_stmt(self): 

9027 return self.getTypedRuleContext(SQLiteParser.Order_by_stmtContext,0) 

9028 

9029 

9030 def getRuleIndex(self): 

9031 return SQLiteParser.RULE_update_stmt_limited 

9032 

9033 def enterRule(self, listener:ParseTreeListener): 

9034 if hasattr( listener, "enterUpdate_stmt_limited" ): 

9035 listener.enterUpdate_stmt_limited(self) 

9036 

9037 def exitRule(self, listener:ParseTreeListener): 

9038 if hasattr( listener, "exitUpdate_stmt_limited" ): 

9039 listener.exitUpdate_stmt_limited(self) 

9040 

9041 

9042 

9043 

9044 def update_stmt_limited(self): 

9045 

9046 localctx = SQLiteParser.Update_stmt_limitedContext(self, self._ctx, self.state) 

9047 self.enterRule(localctx, 106, self.RULE_update_stmt_limited) 

9048 self._la = 0 # Token type 

9049 try: 

9050 self.enterOuterAlt(localctx, 1) 

9051 self.state = 1555 

9052 self._errHandler.sync(self) 

9053 _la = self._input.LA(1) 

9054 if _la==SQLiteParser.WITH_: 

9055 self.state = 1554 

9056 self.with_clause() 

9057 

9058 

9059 self.state = 1557 

9060 self.match(SQLiteParser.UPDATE_) 

9061 self.state = 1560 

9062 self._errHandler.sync(self) 

9063 la_ = self._interp.adaptivePredict(self._input,223,self._ctx) 

9064 if la_ == 1: 

9065 self.state = 1558 

9066 self.match(SQLiteParser.OR_) 

9067 self.state = 1559 

9068 _la = self._input.LA(1) 

9069 if not(_la==SQLiteParser.ABORT_ or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (SQLiteParser.FAIL_ - 72)) | (1 << (SQLiteParser.IGNORE_ - 72)) | (1 << (SQLiteParser.REPLACE_ - 72)) | (1 << (SQLiteParser.ROLLBACK_ - 72)))) != 0)): 

9070 self._errHandler.recoverInline(self) 

9071 else: 

9072 self._errHandler.reportMatch(self) 

9073 self.consume() 

9074 

9075 

9076 self.state = 1562 

9077 self.qualified_table_name() 

9078 self.state = 1563 

9079 self.match(SQLiteParser.SET_) 

9080 self.state = 1566 

9081 self._errHandler.sync(self) 

9082 la_ = self._interp.adaptivePredict(self._input,224,self._ctx) 

9083 if la_ == 1: 

9084 self.state = 1564 

9085 self.column_name() 

9086 pass 

9087 

9088 elif la_ == 2: 

9089 self.state = 1565 

9090 self.column_name_list() 

9091 pass 

9092 

9093 

9094 self.state = 1568 

9095 self.match(SQLiteParser.ASSIGN) 

9096 self.state = 1569 

9097 self.expr(0) 

9098 self.state = 1580 

9099 self._errHandler.sync(self) 

9100 _la = self._input.LA(1) 

9101 while _la==SQLiteParser.COMMA: 

9102 self.state = 1570 

9103 self.match(SQLiteParser.COMMA) 

9104 self.state = 1573 

9105 self._errHandler.sync(self) 

9106 la_ = self._interp.adaptivePredict(self._input,225,self._ctx) 

9107 if la_ == 1: 

9108 self.state = 1571 

9109 self.column_name() 

9110 pass 

9111 

9112 elif la_ == 2: 

9113 self.state = 1572 

9114 self.column_name_list() 

9115 pass 

9116 

9117 

9118 self.state = 1575 

9119 self.match(SQLiteParser.ASSIGN) 

9120 self.state = 1576 

9121 self.expr(0) 

9122 self.state = 1582 

9123 self._errHandler.sync(self) 

9124 _la = self._input.LA(1) 

9125 

9126 self.state = 1585 

9127 self._errHandler.sync(self) 

9128 _la = self._input.LA(1) 

9129 if _la==SQLiteParser.WHERE_: 

9130 self.state = 1583 

9131 self.match(SQLiteParser.WHERE_) 

9132 self.state = 1584 

9133 self.expr(0) 

9134 

9135 

9136 self.state = 1591 

9137 self._errHandler.sync(self) 

9138 _la = self._input.LA(1) 

9139 if _la==SQLiteParser.LIMIT_ or _la==SQLiteParser.ORDER_: 

9140 self.state = 1588 

9141 self._errHandler.sync(self) 

9142 _la = self._input.LA(1) 

9143 if _la==SQLiteParser.ORDER_: 

9144 self.state = 1587 

9145 self.order_by_stmt() 

9146 

9147 

9148 self.state = 1590 

9149 self.limit_stmt() 

9150 

9151 

9152 except RecognitionException as re: 

9153 localctx.exception = re 

9154 self._errHandler.reportError(self, re) 

9155 self._errHandler.recover(self, re) 

9156 finally: 

9157 self.exitRule() 

9158 return localctx 

9159 

9160 

9161 class Qualified_table_nameContext(ParserRuleContext): 

9162 

9163 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

9164 super().__init__(parent, invokingState) 

9165 self.parser = parser 

9166 

9167 def table_name(self): 

9168 return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0) 

9169 

9170 

9171 def schema_name(self): 

9172 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

9173 

9174 

9175 def DOT(self): 

9176 return self.getToken(SQLiteParser.DOT, 0) 

9177 

9178 def AS_(self): 

9179 return self.getToken(SQLiteParser.AS_, 0) 

9180 

9181 def alias(self): 

9182 return self.getTypedRuleContext(SQLiteParser.AliasContext,0) 

9183 

9184 

9185 def INDEXED_(self): 

9186 return self.getToken(SQLiteParser.INDEXED_, 0) 

9187 

9188 def BY_(self): 

9189 return self.getToken(SQLiteParser.BY_, 0) 

9190 

9191 def index_name(self): 

9192 return self.getTypedRuleContext(SQLiteParser.Index_nameContext,0) 

9193 

9194 

9195 def NOT_(self): 

9196 return self.getToken(SQLiteParser.NOT_, 0) 

9197 

9198 def getRuleIndex(self): 

9199 return SQLiteParser.RULE_qualified_table_name 

9200 

9201 def enterRule(self, listener:ParseTreeListener): 

9202 if hasattr( listener, "enterQualified_table_name" ): 

9203 listener.enterQualified_table_name(self) 

9204 

9205 def exitRule(self, listener:ParseTreeListener): 

9206 if hasattr( listener, "exitQualified_table_name" ): 

9207 listener.exitQualified_table_name(self) 

9208 

9209 

9210 

9211 

9212 def qualified_table_name(self): 

9213 

9214 localctx = SQLiteParser.Qualified_table_nameContext(self, self._ctx, self.state) 

9215 self.enterRule(localctx, 108, self.RULE_qualified_table_name) 

9216 self._la = 0 # Token type 

9217 try: 

9218 self.enterOuterAlt(localctx, 1) 

9219 self.state = 1596 

9220 self._errHandler.sync(self) 

9221 la_ = self._interp.adaptivePredict(self._input,230,self._ctx) 

9222 if la_ == 1: 

9223 self.state = 1593 

9224 self.schema_name() 

9225 self.state = 1594 

9226 self.match(SQLiteParser.DOT) 

9227 

9228 

9229 self.state = 1598 

9230 self.table_name() 

9231 self.state = 1601 

9232 self._errHandler.sync(self) 

9233 _la = self._input.LA(1) 

9234 if _la==SQLiteParser.AS_: 

9235 self.state = 1599 

9236 self.match(SQLiteParser.AS_) 

9237 self.state = 1600 

9238 self.alias() 

9239 

9240 

9241 self.state = 1608 

9242 self._errHandler.sync(self) 

9243 token = self._input.LA(1) 

9244 if token in [SQLiteParser.INDEXED_]: 

9245 self.state = 1603 

9246 self.match(SQLiteParser.INDEXED_) 

9247 self.state = 1604 

9248 self.match(SQLiteParser.BY_) 

9249 self.state = 1605 

9250 self.index_name() 

9251 pass 

9252 elif token in [SQLiteParser.NOT_]: 

9253 self.state = 1606 

9254 self.match(SQLiteParser.NOT_) 

9255 self.state = 1607 

9256 self.match(SQLiteParser.INDEXED_) 

9257 pass 

9258 elif token in [SQLiteParser.EOF, SQLiteParser.SCOL, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.ATTACH_, SQLiteParser.BEGIN_, SQLiteParser.COMMIT_, SQLiteParser.CREATE_, SQLiteParser.DEFAULT_, SQLiteParser.DELETE_, SQLiteParser.DETACH_, SQLiteParser.DROP_, SQLiteParser.END_, SQLiteParser.EXPLAIN_, SQLiteParser.INSERT_, SQLiteParser.LIMIT_, SQLiteParser.ORDER_, SQLiteParser.PRAGMA_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.REPLACE_, SQLiteParser.ROLLBACK_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.SET_, SQLiteParser.UPDATE_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.WHERE_, SQLiteParser.WITH_]: 

9259 pass 

9260 else: 

9261 pass 

9262 except RecognitionException as re: 

9263 localctx.exception = re 

9264 self._errHandler.reportError(self, re) 

9265 self._errHandler.recover(self, re) 

9266 finally: 

9267 self.exitRule() 

9268 return localctx 

9269 

9270 

9271 class Vacuum_stmtContext(ParserRuleContext): 

9272 

9273 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

9274 super().__init__(parent, invokingState) 

9275 self.parser = parser 

9276 

9277 def VACUUM_(self): 

9278 return self.getToken(SQLiteParser.VACUUM_, 0) 

9279 

9280 def schema_name(self): 

9281 return self.getTypedRuleContext(SQLiteParser.Schema_nameContext,0) 

9282 

9283 

9284 def INTO_(self): 

9285 return self.getToken(SQLiteParser.INTO_, 0) 

9286 

9287 def filename(self): 

9288 return self.getTypedRuleContext(SQLiteParser.FilenameContext,0) 

9289 

9290 

9291 def getRuleIndex(self): 

9292 return SQLiteParser.RULE_vacuum_stmt 

9293 

9294 def enterRule(self, listener:ParseTreeListener): 

9295 if hasattr( listener, "enterVacuum_stmt" ): 

9296 listener.enterVacuum_stmt(self) 

9297 

9298 def exitRule(self, listener:ParseTreeListener): 

9299 if hasattr( listener, "exitVacuum_stmt" ): 

9300 listener.exitVacuum_stmt(self) 

9301 

9302 

9303 

9304 

9305 def vacuum_stmt(self): 

9306 

9307 localctx = SQLiteParser.Vacuum_stmtContext(self, self._ctx, self.state) 

9308 self.enterRule(localctx, 110, self.RULE_vacuum_stmt) 

9309 self._la = 0 # Token type 

9310 try: 

9311 self.enterOuterAlt(localctx, 1) 

9312 self.state = 1610 

9313 self.match(SQLiteParser.VACUUM_) 

9314 self.state = 1612 

9315 self._errHandler.sync(self) 

9316 la_ = self._interp.adaptivePredict(self._input,233,self._ctx) 

9317 if la_ == 1: 

9318 self.state = 1611 

9319 self.schema_name() 

9320 

9321 

9322 self.state = 1616 

9323 self._errHandler.sync(self) 

9324 _la = self._input.LA(1) 

9325 if _la==SQLiteParser.INTO_: 

9326 self.state = 1614 

9327 self.match(SQLiteParser.INTO_) 

9328 self.state = 1615 

9329 self.filename() 

9330 

9331 

9332 except RecognitionException as re: 

9333 localctx.exception = re 

9334 self._errHandler.reportError(self, re) 

9335 self._errHandler.recover(self, re) 

9336 finally: 

9337 self.exitRule() 

9338 return localctx 

9339 

9340 

9341 class Filter_clauseContext(ParserRuleContext): 

9342 

9343 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

9344 super().__init__(parent, invokingState) 

9345 self.parser = parser 

9346 

9347 def FILTER_(self): 

9348 return self.getToken(SQLiteParser.FILTER_, 0) 

9349 

9350 def OPEN_PAR(self): 

9351 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

9352 

9353 def WHERE_(self): 

9354 return self.getToken(SQLiteParser.WHERE_, 0) 

9355 

9356 def expr(self): 

9357 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

9358 

9359 

9360 def CLOSE_PAR(self): 

9361 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

9362 

9363 def getRuleIndex(self): 

9364 return SQLiteParser.RULE_filter_clause 

9365 

9366 def enterRule(self, listener:ParseTreeListener): 

9367 if hasattr( listener, "enterFilter_clause" ): 

9368 listener.enterFilter_clause(self) 

9369 

9370 def exitRule(self, listener:ParseTreeListener): 

9371 if hasattr( listener, "exitFilter_clause" ): 

9372 listener.exitFilter_clause(self) 

9373 

9374 

9375 

9376 

9377 def filter_clause(self): 

9378 

9379 localctx = SQLiteParser.Filter_clauseContext(self, self._ctx, self.state) 

9380 self.enterRule(localctx, 112, self.RULE_filter_clause) 

9381 try: 

9382 self.enterOuterAlt(localctx, 1) 

9383 self.state = 1618 

9384 self.match(SQLiteParser.FILTER_) 

9385 self.state = 1619 

9386 self.match(SQLiteParser.OPEN_PAR) 

9387 self.state = 1620 

9388 self.match(SQLiteParser.WHERE_) 

9389 self.state = 1621 

9390 self.expr(0) 

9391 self.state = 1622 

9392 self.match(SQLiteParser.CLOSE_PAR) 

9393 except RecognitionException as re: 

9394 localctx.exception = re 

9395 self._errHandler.reportError(self, re) 

9396 self._errHandler.recover(self, re) 

9397 finally: 

9398 self.exitRule() 

9399 return localctx 

9400 

9401 

9402 class Window_defnContext(ParserRuleContext): 

9403 

9404 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

9405 super().__init__(parent, invokingState) 

9406 self.parser = parser 

9407 

9408 def OPEN_PAR(self): 

9409 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

9410 

9411 def CLOSE_PAR(self): 

9412 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

9413 

9414 def ORDER_(self): 

9415 return self.getToken(SQLiteParser.ORDER_, 0) 

9416 

9417 def BY_(self, i:int=None): 

9418 if i is None: 

9419 return self.getTokens(SQLiteParser.BY_) 

9420 else: 

9421 return self.getToken(SQLiteParser.BY_, i) 

9422 

9423 def ordering_term(self, i:int=None): 

9424 if i is None: 

9425 return self.getTypedRuleContexts(SQLiteParser.Ordering_termContext) 

9426 else: 

9427 return self.getTypedRuleContext(SQLiteParser.Ordering_termContext,i) 

9428 

9429 

9430 def base_window_name(self): 

9431 return self.getTypedRuleContext(SQLiteParser.Base_window_nameContext,0) 

9432 

9433 

9434 def PARTITION_(self): 

9435 return self.getToken(SQLiteParser.PARTITION_, 0) 

9436 

9437 def expr(self, i:int=None): 

9438 if i is None: 

9439 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

9440 else: 

9441 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

9442 

9443 

9444 def frame_spec(self): 

9445 return self.getTypedRuleContext(SQLiteParser.Frame_specContext,0) 

9446 

9447 

9448 def COMMA(self, i:int=None): 

9449 if i is None: 

9450 return self.getTokens(SQLiteParser.COMMA) 

9451 else: 

9452 return self.getToken(SQLiteParser.COMMA, i) 

9453 

9454 def getRuleIndex(self): 

9455 return SQLiteParser.RULE_window_defn 

9456 

9457 def enterRule(self, listener:ParseTreeListener): 

9458 if hasattr( listener, "enterWindow_defn" ): 

9459 listener.enterWindow_defn(self) 

9460 

9461 def exitRule(self, listener:ParseTreeListener): 

9462 if hasattr( listener, "exitWindow_defn" ): 

9463 listener.exitWindow_defn(self) 

9464 

9465 

9466 

9467 

9468 def window_defn(self): 

9469 

9470 localctx = SQLiteParser.Window_defnContext(self, self._ctx, self.state) 

9471 self.enterRule(localctx, 114, self.RULE_window_defn) 

9472 self._la = 0 # Token type 

9473 try: 

9474 self.enterOuterAlt(localctx, 1) 

9475 self.state = 1624 

9476 self.match(SQLiteParser.OPEN_PAR) 

9477 self.state = 1626 

9478 self._errHandler.sync(self) 

9479 la_ = self._interp.adaptivePredict(self._input,235,self._ctx) 

9480 if la_ == 1: 

9481 self.state = 1625 

9482 self.base_window_name() 

9483 

9484 

9485 self.state = 1638 

9486 self._errHandler.sync(self) 

9487 _la = self._input.LA(1) 

9488 if _la==SQLiteParser.PARTITION_: 

9489 self.state = 1628 

9490 self.match(SQLiteParser.PARTITION_) 

9491 self.state = 1629 

9492 self.match(SQLiteParser.BY_) 

9493 self.state = 1630 

9494 self.expr(0) 

9495 self.state = 1635 

9496 self._errHandler.sync(self) 

9497 _la = self._input.LA(1) 

9498 while _la==SQLiteParser.COMMA: 

9499 self.state = 1631 

9500 self.match(SQLiteParser.COMMA) 

9501 self.state = 1632 

9502 self.expr(0) 

9503 self.state = 1637 

9504 self._errHandler.sync(self) 

9505 _la = self._input.LA(1) 

9506 

9507 

9508 

9509 self.state = 1640 

9510 self.match(SQLiteParser.ORDER_) 

9511 self.state = 1641 

9512 self.match(SQLiteParser.BY_) 

9513 self.state = 1642 

9514 self.ordering_term() 

9515 self.state = 1647 

9516 self._errHandler.sync(self) 

9517 _la = self._input.LA(1) 

9518 while _la==SQLiteParser.COMMA: 

9519 self.state = 1643 

9520 self.match(SQLiteParser.COMMA) 

9521 self.state = 1644 

9522 self.ordering_term() 

9523 self.state = 1649 

9524 self._errHandler.sync(self) 

9525 _la = self._input.LA(1) 

9526 

9527 self.state = 1651 

9528 self._errHandler.sync(self) 

9529 _la = self._input.LA(1) 

9530 if ((((_la - 127)) & ~0x3f) == 0 and ((1 << (_la - 127)) & ((1 << (SQLiteParser.ROWS_ - 127)) | (1 << (SQLiteParser.RANGE_ - 127)) | (1 << (SQLiteParser.GROUPS_ - 127)))) != 0): 

9531 self.state = 1650 

9532 self.frame_spec() 

9533 

9534 

9535 self.state = 1653 

9536 self.match(SQLiteParser.CLOSE_PAR) 

9537 except RecognitionException as re: 

9538 localctx.exception = re 

9539 self._errHandler.reportError(self, re) 

9540 self._errHandler.recover(self, re) 

9541 finally: 

9542 self.exitRule() 

9543 return localctx 

9544 

9545 

9546 class Over_clauseContext(ParserRuleContext): 

9547 

9548 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

9549 super().__init__(parent, invokingState) 

9550 self.parser = parser 

9551 

9552 def OVER_(self): 

9553 return self.getToken(SQLiteParser.OVER_, 0) 

9554 

9555 def window_name(self): 

9556 return self.getTypedRuleContext(SQLiteParser.Window_nameContext,0) 

9557 

9558 

9559 def OPEN_PAR(self): 

9560 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

9561 

9562 def CLOSE_PAR(self): 

9563 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

9564 

9565 def base_window_name(self): 

9566 return self.getTypedRuleContext(SQLiteParser.Base_window_nameContext,0) 

9567 

9568 

9569 def PARTITION_(self): 

9570 return self.getToken(SQLiteParser.PARTITION_, 0) 

9571 

9572 def BY_(self, i:int=None): 

9573 if i is None: 

9574 return self.getTokens(SQLiteParser.BY_) 

9575 else: 

9576 return self.getToken(SQLiteParser.BY_, i) 

9577 

9578 def expr(self, i:int=None): 

9579 if i is None: 

9580 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

9581 else: 

9582 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

9583 

9584 

9585 def ORDER_(self): 

9586 return self.getToken(SQLiteParser.ORDER_, 0) 

9587 

9588 def ordering_term(self, i:int=None): 

9589 if i is None: 

9590 return self.getTypedRuleContexts(SQLiteParser.Ordering_termContext) 

9591 else: 

9592 return self.getTypedRuleContext(SQLiteParser.Ordering_termContext,i) 

9593 

9594 

9595 def frame_spec(self): 

9596 return self.getTypedRuleContext(SQLiteParser.Frame_specContext,0) 

9597 

9598 

9599 def COMMA(self, i:int=None): 

9600 if i is None: 

9601 return self.getTokens(SQLiteParser.COMMA) 

9602 else: 

9603 return self.getToken(SQLiteParser.COMMA, i) 

9604 

9605 def getRuleIndex(self): 

9606 return SQLiteParser.RULE_over_clause 

9607 

9608 def enterRule(self, listener:ParseTreeListener): 

9609 if hasattr( listener, "enterOver_clause" ): 

9610 listener.enterOver_clause(self) 

9611 

9612 def exitRule(self, listener:ParseTreeListener): 

9613 if hasattr( listener, "exitOver_clause" ): 

9614 listener.exitOver_clause(self) 

9615 

9616 

9617 

9618 

9619 def over_clause(self): 

9620 

9621 localctx = SQLiteParser.Over_clauseContext(self, self._ctx, self.state) 

9622 self.enterRule(localctx, 116, self.RULE_over_clause) 

9623 self._la = 0 # Token type 

9624 try: 

9625 self.enterOuterAlt(localctx, 1) 

9626 self.state = 1655 

9627 self.match(SQLiteParser.OVER_) 

9628 self.state = 1689 

9629 self._errHandler.sync(self) 

9630 la_ = self._interp.adaptivePredict(self._input,246,self._ctx) 

9631 if la_ == 1: 

9632 self.state = 1656 

9633 self.window_name() 

9634 pass 

9635 

9636 elif la_ == 2: 

9637 self.state = 1657 

9638 self.match(SQLiteParser.OPEN_PAR) 

9639 self.state = 1659 

9640 self._errHandler.sync(self) 

9641 la_ = self._interp.adaptivePredict(self._input,240,self._ctx) 

9642 if la_ == 1: 

9643 self.state = 1658 

9644 self.base_window_name() 

9645 

9646 

9647 self.state = 1671 

9648 self._errHandler.sync(self) 

9649 _la = self._input.LA(1) 

9650 if _la==SQLiteParser.PARTITION_: 

9651 self.state = 1661 

9652 self.match(SQLiteParser.PARTITION_) 

9653 self.state = 1662 

9654 self.match(SQLiteParser.BY_) 

9655 self.state = 1663 

9656 self.expr(0) 

9657 self.state = 1668 

9658 self._errHandler.sync(self) 

9659 _la = self._input.LA(1) 

9660 while _la==SQLiteParser.COMMA: 

9661 self.state = 1664 

9662 self.match(SQLiteParser.COMMA) 

9663 self.state = 1665 

9664 self.expr(0) 

9665 self.state = 1670 

9666 self._errHandler.sync(self) 

9667 _la = self._input.LA(1) 

9668 

9669 

9670 

9671 self.state = 1683 

9672 self._errHandler.sync(self) 

9673 _la = self._input.LA(1) 

9674 if _la==SQLiteParser.ORDER_: 

9675 self.state = 1673 

9676 self.match(SQLiteParser.ORDER_) 

9677 self.state = 1674 

9678 self.match(SQLiteParser.BY_) 

9679 self.state = 1675 

9680 self.ordering_term() 

9681 self.state = 1680 

9682 self._errHandler.sync(self) 

9683 _la = self._input.LA(1) 

9684 while _la==SQLiteParser.COMMA: 

9685 self.state = 1676 

9686 self.match(SQLiteParser.COMMA) 

9687 self.state = 1677 

9688 self.ordering_term() 

9689 self.state = 1682 

9690 self._errHandler.sync(self) 

9691 _la = self._input.LA(1) 

9692 

9693 

9694 

9695 self.state = 1686 

9696 self._errHandler.sync(self) 

9697 _la = self._input.LA(1) 

9698 if ((((_la - 127)) & ~0x3f) == 0 and ((1 << (_la - 127)) & ((1 << (SQLiteParser.ROWS_ - 127)) | (1 << (SQLiteParser.RANGE_ - 127)) | (1 << (SQLiteParser.GROUPS_ - 127)))) != 0): 

9699 self.state = 1685 

9700 self.frame_spec() 

9701 

9702 

9703 self.state = 1688 

9704 self.match(SQLiteParser.CLOSE_PAR) 

9705 pass 

9706 

9707 

9708 except RecognitionException as re: 

9709 localctx.exception = re 

9710 self._errHandler.reportError(self, re) 

9711 self._errHandler.recover(self, re) 

9712 finally: 

9713 self.exitRule() 

9714 return localctx 

9715 

9716 

9717 class Frame_specContext(ParserRuleContext): 

9718 

9719 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

9720 super().__init__(parent, invokingState) 

9721 self.parser = parser 

9722 

9723 def frame_clause(self): 

9724 return self.getTypedRuleContext(SQLiteParser.Frame_clauseContext,0) 

9725 

9726 

9727 def EXCLUDE_(self): 

9728 return self.getToken(SQLiteParser.EXCLUDE_, 0) 

9729 

9730 def CURRENT_(self): 

9731 return self.getToken(SQLiteParser.CURRENT_, 0) 

9732 

9733 def ROW_(self): 

9734 return self.getToken(SQLiteParser.ROW_, 0) 

9735 

9736 def GROUP_(self): 

9737 return self.getToken(SQLiteParser.GROUP_, 0) 

9738 

9739 def TIES_(self): 

9740 return self.getToken(SQLiteParser.TIES_, 0) 

9741 

9742 def NO_(self): 

9743 return self.getToken(SQLiteParser.NO_, 0) 

9744 

9745 def OTHERS_(self): 

9746 return self.getToken(SQLiteParser.OTHERS_, 0) 

9747 

9748 def getRuleIndex(self): 

9749 return SQLiteParser.RULE_frame_spec 

9750 

9751 def enterRule(self, listener:ParseTreeListener): 

9752 if hasattr( listener, "enterFrame_spec" ): 

9753 listener.enterFrame_spec(self) 

9754 

9755 def exitRule(self, listener:ParseTreeListener): 

9756 if hasattr( listener, "exitFrame_spec" ): 

9757 listener.exitFrame_spec(self) 

9758 

9759 

9760 

9761 

9762 def frame_spec(self): 

9763 

9764 localctx = SQLiteParser.Frame_specContext(self, self._ctx, self.state) 

9765 self.enterRule(localctx, 118, self.RULE_frame_spec) 

9766 try: 

9767 self.enterOuterAlt(localctx, 1) 

9768 self.state = 1691 

9769 self.frame_clause() 

9770 self.state = 1699 

9771 self._errHandler.sync(self) 

9772 token = self._input.LA(1) 

9773 if token in [SQLiteParser.EXCLUDE_]: 

9774 self.state = 1692 

9775 self.match(SQLiteParser.EXCLUDE_) 

9776 

9777 self.state = 1693 

9778 self.match(SQLiteParser.NO_) 

9779 self.state = 1694 

9780 self.match(SQLiteParser.OTHERS_) 

9781 pass 

9782 elif token in [SQLiteParser.CURRENT_]: 

9783 self.state = 1695 

9784 self.match(SQLiteParser.CURRENT_) 

9785 self.state = 1696 

9786 self.match(SQLiteParser.ROW_) 

9787 pass 

9788 elif token in [SQLiteParser.GROUP_]: 

9789 self.state = 1697 

9790 self.match(SQLiteParser.GROUP_) 

9791 pass 

9792 elif token in [SQLiteParser.TIES_]: 

9793 self.state = 1698 

9794 self.match(SQLiteParser.TIES_) 

9795 pass 

9796 elif token in [SQLiteParser.CLOSE_PAR]: 

9797 pass 

9798 else: 

9799 pass 

9800 except RecognitionException as re: 

9801 localctx.exception = re 

9802 self._errHandler.reportError(self, re) 

9803 self._errHandler.recover(self, re) 

9804 finally: 

9805 self.exitRule() 

9806 return localctx 

9807 

9808 

9809 class Frame_clauseContext(ParserRuleContext): 

9810 

9811 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

9812 super().__init__(parent, invokingState) 

9813 self.parser = parser 

9814 

9815 def RANGE_(self): 

9816 return self.getToken(SQLiteParser.RANGE_, 0) 

9817 

9818 def ROWS_(self): 

9819 return self.getToken(SQLiteParser.ROWS_, 0) 

9820 

9821 def GROUPS_(self): 

9822 return self.getToken(SQLiteParser.GROUPS_, 0) 

9823 

9824 def frame_single(self): 

9825 return self.getTypedRuleContext(SQLiteParser.Frame_singleContext,0) 

9826 

9827 

9828 def BETWEEN_(self): 

9829 return self.getToken(SQLiteParser.BETWEEN_, 0) 

9830 

9831 def frame_left(self): 

9832 return self.getTypedRuleContext(SQLiteParser.Frame_leftContext,0) 

9833 

9834 

9835 def AND_(self): 

9836 return self.getToken(SQLiteParser.AND_, 0) 

9837 

9838 def frame_right(self): 

9839 return self.getTypedRuleContext(SQLiteParser.Frame_rightContext,0) 

9840 

9841 

9842 def getRuleIndex(self): 

9843 return SQLiteParser.RULE_frame_clause 

9844 

9845 def enterRule(self, listener:ParseTreeListener): 

9846 if hasattr( listener, "enterFrame_clause" ): 

9847 listener.enterFrame_clause(self) 

9848 

9849 def exitRule(self, listener:ParseTreeListener): 

9850 if hasattr( listener, "exitFrame_clause" ): 

9851 listener.exitFrame_clause(self) 

9852 

9853 

9854 

9855 

9856 def frame_clause(self): 

9857 

9858 localctx = SQLiteParser.Frame_clauseContext(self, self._ctx, self.state) 

9859 self.enterRule(localctx, 120, self.RULE_frame_clause) 

9860 self._la = 0 # Token type 

9861 try: 

9862 self.enterOuterAlt(localctx, 1) 

9863 self.state = 1701 

9864 _la = self._input.LA(1) 

9865 if not(((((_la - 127)) & ~0x3f) == 0 and ((1 << (_la - 127)) & ((1 << (SQLiteParser.ROWS_ - 127)) | (1 << (SQLiteParser.RANGE_ - 127)) | (1 << (SQLiteParser.GROUPS_ - 127)))) != 0)): 

9866 self._errHandler.recoverInline(self) 

9867 else: 

9868 self._errHandler.reportMatch(self) 

9869 self.consume() 

9870 self.state = 1708 

9871 self._errHandler.sync(self) 

9872 la_ = self._interp.adaptivePredict(self._input,248,self._ctx) 

9873 if la_ == 1: 

9874 self.state = 1702 

9875 self.frame_single() 

9876 pass 

9877 

9878 elif la_ == 2: 

9879 self.state = 1703 

9880 self.match(SQLiteParser.BETWEEN_) 

9881 self.state = 1704 

9882 self.frame_left() 

9883 self.state = 1705 

9884 self.match(SQLiteParser.AND_) 

9885 self.state = 1706 

9886 self.frame_right() 

9887 pass 

9888 

9889 

9890 except RecognitionException as re: 

9891 localctx.exception = re 

9892 self._errHandler.reportError(self, re) 

9893 self._errHandler.recover(self, re) 

9894 finally: 

9895 self.exitRule() 

9896 return localctx 

9897 

9898 

9899 class Simple_function_invocationContext(ParserRuleContext): 

9900 

9901 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

9902 super().__init__(parent, invokingState) 

9903 self.parser = parser 

9904 

9905 def simple_func(self): 

9906 return self.getTypedRuleContext(SQLiteParser.Simple_funcContext,0) 

9907 

9908 

9909 def OPEN_PAR(self): 

9910 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

9911 

9912 def CLOSE_PAR(self): 

9913 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

9914 

9915 def expr(self, i:int=None): 

9916 if i is None: 

9917 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

9918 else: 

9919 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

9920 

9921 

9922 def STAR(self): 

9923 return self.getToken(SQLiteParser.STAR, 0) 

9924 

9925 def COMMA(self, i:int=None): 

9926 if i is None: 

9927 return self.getTokens(SQLiteParser.COMMA) 

9928 else: 

9929 return self.getToken(SQLiteParser.COMMA, i) 

9930 

9931 def getRuleIndex(self): 

9932 return SQLiteParser.RULE_simple_function_invocation 

9933 

9934 def enterRule(self, listener:ParseTreeListener): 

9935 if hasattr( listener, "enterSimple_function_invocation" ): 

9936 listener.enterSimple_function_invocation(self) 

9937 

9938 def exitRule(self, listener:ParseTreeListener): 

9939 if hasattr( listener, "exitSimple_function_invocation" ): 

9940 listener.exitSimple_function_invocation(self) 

9941 

9942 

9943 

9944 

9945 def simple_function_invocation(self): 

9946 

9947 localctx = SQLiteParser.Simple_function_invocationContext(self, self._ctx, self.state) 

9948 self.enterRule(localctx, 122, self.RULE_simple_function_invocation) 

9949 self._la = 0 # Token type 

9950 try: 

9951 self.enterOuterAlt(localctx, 1) 

9952 self.state = 1710 

9953 self.simple_func() 

9954 self.state = 1711 

9955 self.match(SQLiteParser.OPEN_PAR) 

9956 self.state = 1721 

9957 self._errHandler.sync(self) 

9958 token = self._input.LA(1) 

9959 if token in [SQLiteParser.OPEN_PAR, SQLiteParser.PLUS, SQLiteParser.MINUS, SQLiteParser.TILDE, SQLiteParser.ABORT_, SQLiteParser.ACTION_, SQLiteParser.ADD_, SQLiteParser.AFTER_, SQLiteParser.ALL_, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.AND_, SQLiteParser.AS_, SQLiteParser.ASC_, SQLiteParser.ATTACH_, SQLiteParser.AUTOINCREMENT_, SQLiteParser.BEFORE_, SQLiteParser.BEGIN_, SQLiteParser.BETWEEN_, SQLiteParser.BY_, SQLiteParser.CASCADE_, SQLiteParser.CASE_, SQLiteParser.CAST_, SQLiteParser.CHECK_, SQLiteParser.COLLATE_, SQLiteParser.COLUMN_, SQLiteParser.COMMIT_, SQLiteParser.CONFLICT_, SQLiteParser.CONSTRAINT_, SQLiteParser.CREATE_, SQLiteParser.CROSS_, SQLiteParser.CURRENT_DATE_, SQLiteParser.CURRENT_TIME_, SQLiteParser.CURRENT_TIMESTAMP_, SQLiteParser.DATABASE_, SQLiteParser.DEFAULT_, SQLiteParser.DEFERRABLE_, SQLiteParser.DEFERRED_, SQLiteParser.DELETE_, SQLiteParser.DESC_, SQLiteParser.DETACH_, SQLiteParser.DISTINCT_, SQLiteParser.DROP_, SQLiteParser.EACH_, SQLiteParser.ELSE_, SQLiteParser.END_, SQLiteParser.ESCAPE_, SQLiteParser.EXCEPT_, SQLiteParser.EXCLUSIVE_, SQLiteParser.EXISTS_, SQLiteParser.EXPLAIN_, SQLiteParser.FAIL_, SQLiteParser.FOR_, SQLiteParser.FOREIGN_, SQLiteParser.FROM_, SQLiteParser.FULL_, SQLiteParser.GLOB_, SQLiteParser.GROUP_, SQLiteParser.HAVING_, SQLiteParser.IF_, SQLiteParser.IGNORE_, SQLiteParser.IMMEDIATE_, SQLiteParser.IN_, SQLiteParser.INDEX_, SQLiteParser.INDEXED_, SQLiteParser.INITIALLY_, SQLiteParser.INNER_, SQLiteParser.INSERT_, SQLiteParser.INSTEAD_, SQLiteParser.INTERSECT_, SQLiteParser.INTO_, SQLiteParser.IS_, SQLiteParser.ISNULL_, SQLiteParser.JOIN_, SQLiteParser.KEY_, SQLiteParser.LEFT_, SQLiteParser.LIKE_, SQLiteParser.LIMIT_, SQLiteParser.MATCH_, SQLiteParser.NATURAL_, SQLiteParser.NO_, SQLiteParser.NOT_, SQLiteParser.NOTNULL_, SQLiteParser.NULL_, SQLiteParser.OF_, SQLiteParser.OFFSET_, SQLiteParser.ON_, SQLiteParser.OR_, SQLiteParser.ORDER_, SQLiteParser.OUTER_, SQLiteParser.PLAN_, SQLiteParser.PRAGMA_, SQLiteParser.PRIMARY_, SQLiteParser.QUERY_, SQLiteParser.RAISE_, SQLiteParser.RECURSIVE_, SQLiteParser.REFERENCES_, SQLiteParser.REGEXP_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.RENAME_, SQLiteParser.REPLACE_, SQLiteParser.RESTRICT_, SQLiteParser.RIGHT_, SQLiteParser.ROLLBACK_, SQLiteParser.ROW_, SQLiteParser.ROWS_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.SET_, SQLiteParser.TABLE_, SQLiteParser.TEMP_, SQLiteParser.TEMPORARY_, SQLiteParser.THEN_, SQLiteParser.TO_, SQLiteParser.TRANSACTION_, SQLiteParser.TRIGGER_, SQLiteParser.UNION_, SQLiteParser.UNIQUE_, SQLiteParser.UPDATE_, SQLiteParser.USING_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.VIEW_, SQLiteParser.VIRTUAL_, SQLiteParser.WHEN_, SQLiteParser.WHERE_, SQLiteParser.WITH_, SQLiteParser.WITHOUT_, SQLiteParser.FIRST_VALUE_, SQLiteParser.OVER_, SQLiteParser.PARTITION_, SQLiteParser.RANGE_, SQLiteParser.PRECEDING_, SQLiteParser.UNBOUNDED_, SQLiteParser.CURRENT_, SQLiteParser.FOLLOWING_, SQLiteParser.CUME_DIST_, SQLiteParser.DENSE_RANK_, SQLiteParser.LAG_, SQLiteParser.LAST_VALUE_, SQLiteParser.LEAD_, SQLiteParser.NTH_VALUE_, SQLiteParser.NTILE_, SQLiteParser.PERCENT_RANK_, SQLiteParser.RANK_, SQLiteParser.ROW_NUMBER_, SQLiteParser.GENERATED_, SQLiteParser.ALWAYS_, SQLiteParser.STORED_, SQLiteParser.TRUE_, SQLiteParser.FALSE_, SQLiteParser.WINDOW_, SQLiteParser.NULLS_, SQLiteParser.FIRST_, SQLiteParser.LAST_, SQLiteParser.FILTER_, SQLiteParser.GROUPS_, SQLiteParser.EXCLUDE_, SQLiteParser.IDENTIFIER, SQLiteParser.NUMERIC_LITERAL, SQLiteParser.BIND_PARAMETER, SQLiteParser.STRING_LITERAL, SQLiteParser.BLOB_LITERAL]: 

9960 self.state = 1712 

9961 self.expr(0) 

9962 self.state = 1717 

9963 self._errHandler.sync(self) 

9964 _la = self._input.LA(1) 

9965 while _la==SQLiteParser.COMMA: 

9966 self.state = 1713 

9967 self.match(SQLiteParser.COMMA) 

9968 self.state = 1714 

9969 self.expr(0) 

9970 self.state = 1719 

9971 self._errHandler.sync(self) 

9972 _la = self._input.LA(1) 

9973 

9974 pass 

9975 elif token in [SQLiteParser.STAR]: 

9976 self.state = 1720 

9977 self.match(SQLiteParser.STAR) 

9978 pass 

9979 else: 

9980 raise NoViableAltException(self) 

9981 

9982 self.state = 1723 

9983 self.match(SQLiteParser.CLOSE_PAR) 

9984 except RecognitionException as re: 

9985 localctx.exception = re 

9986 self._errHandler.reportError(self, re) 

9987 self._errHandler.recover(self, re) 

9988 finally: 

9989 self.exitRule() 

9990 return localctx 

9991 

9992 

9993 class Aggregate_function_invocationContext(ParserRuleContext): 

9994 

9995 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

9996 super().__init__(parent, invokingState) 

9997 self.parser = parser 

9998 

9999 def aggregate_func(self): 

10000 return self.getTypedRuleContext(SQLiteParser.Aggregate_funcContext,0) 

10001 

10002 

10003 def OPEN_PAR(self): 

10004 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

10005 

10006 def CLOSE_PAR(self): 

10007 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

10008 

10009 def expr(self, i:int=None): 

10010 if i is None: 

10011 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

10012 else: 

10013 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

10014 

10015 

10016 def STAR(self): 

10017 return self.getToken(SQLiteParser.STAR, 0) 

10018 

10019 def filter_clause(self): 

10020 return self.getTypedRuleContext(SQLiteParser.Filter_clauseContext,0) 

10021 

10022 

10023 def DISTINCT_(self): 

10024 return self.getToken(SQLiteParser.DISTINCT_, 0) 

10025 

10026 def COMMA(self, i:int=None): 

10027 if i is None: 

10028 return self.getTokens(SQLiteParser.COMMA) 

10029 else: 

10030 return self.getToken(SQLiteParser.COMMA, i) 

10031 

10032 def getRuleIndex(self): 

10033 return SQLiteParser.RULE_aggregate_function_invocation 

10034 

10035 def enterRule(self, listener:ParseTreeListener): 

10036 if hasattr( listener, "enterAggregate_function_invocation" ): 

10037 listener.enterAggregate_function_invocation(self) 

10038 

10039 def exitRule(self, listener:ParseTreeListener): 

10040 if hasattr( listener, "exitAggregate_function_invocation" ): 

10041 listener.exitAggregate_function_invocation(self) 

10042 

10043 

10044 

10045 

10046 def aggregate_function_invocation(self): 

10047 

10048 localctx = SQLiteParser.Aggregate_function_invocationContext(self, self._ctx, self.state) 

10049 self.enterRule(localctx, 124, self.RULE_aggregate_function_invocation) 

10050 self._la = 0 # Token type 

10051 try: 

10052 self.enterOuterAlt(localctx, 1) 

10053 self.state = 1725 

10054 self.aggregate_func() 

10055 self.state = 1726 

10056 self.match(SQLiteParser.OPEN_PAR) 

10057 self.state = 1739 

10058 self._errHandler.sync(self) 

10059 token = self._input.LA(1) 

10060 if token in [SQLiteParser.OPEN_PAR, SQLiteParser.PLUS, SQLiteParser.MINUS, SQLiteParser.TILDE, SQLiteParser.ABORT_, SQLiteParser.ACTION_, SQLiteParser.ADD_, SQLiteParser.AFTER_, SQLiteParser.ALL_, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.AND_, SQLiteParser.AS_, SQLiteParser.ASC_, SQLiteParser.ATTACH_, SQLiteParser.AUTOINCREMENT_, SQLiteParser.BEFORE_, SQLiteParser.BEGIN_, SQLiteParser.BETWEEN_, SQLiteParser.BY_, SQLiteParser.CASCADE_, SQLiteParser.CASE_, SQLiteParser.CAST_, SQLiteParser.CHECK_, SQLiteParser.COLLATE_, SQLiteParser.COLUMN_, SQLiteParser.COMMIT_, SQLiteParser.CONFLICT_, SQLiteParser.CONSTRAINT_, SQLiteParser.CREATE_, SQLiteParser.CROSS_, SQLiteParser.CURRENT_DATE_, SQLiteParser.CURRENT_TIME_, SQLiteParser.CURRENT_TIMESTAMP_, SQLiteParser.DATABASE_, SQLiteParser.DEFAULT_, SQLiteParser.DEFERRABLE_, SQLiteParser.DEFERRED_, SQLiteParser.DELETE_, SQLiteParser.DESC_, SQLiteParser.DETACH_, SQLiteParser.DISTINCT_, SQLiteParser.DROP_, SQLiteParser.EACH_, SQLiteParser.ELSE_, SQLiteParser.END_, SQLiteParser.ESCAPE_, SQLiteParser.EXCEPT_, SQLiteParser.EXCLUSIVE_, SQLiteParser.EXISTS_, SQLiteParser.EXPLAIN_, SQLiteParser.FAIL_, SQLiteParser.FOR_, SQLiteParser.FOREIGN_, SQLiteParser.FROM_, SQLiteParser.FULL_, SQLiteParser.GLOB_, SQLiteParser.GROUP_, SQLiteParser.HAVING_, SQLiteParser.IF_, SQLiteParser.IGNORE_, SQLiteParser.IMMEDIATE_, SQLiteParser.IN_, SQLiteParser.INDEX_, SQLiteParser.INDEXED_, SQLiteParser.INITIALLY_, SQLiteParser.INNER_, SQLiteParser.INSERT_, SQLiteParser.INSTEAD_, SQLiteParser.INTERSECT_, SQLiteParser.INTO_, SQLiteParser.IS_, SQLiteParser.ISNULL_, SQLiteParser.JOIN_, SQLiteParser.KEY_, SQLiteParser.LEFT_, SQLiteParser.LIKE_, SQLiteParser.LIMIT_, SQLiteParser.MATCH_, SQLiteParser.NATURAL_, SQLiteParser.NO_, SQLiteParser.NOT_, SQLiteParser.NOTNULL_, SQLiteParser.NULL_, SQLiteParser.OF_, SQLiteParser.OFFSET_, SQLiteParser.ON_, SQLiteParser.OR_, SQLiteParser.ORDER_, SQLiteParser.OUTER_, SQLiteParser.PLAN_, SQLiteParser.PRAGMA_, SQLiteParser.PRIMARY_, SQLiteParser.QUERY_, SQLiteParser.RAISE_, SQLiteParser.RECURSIVE_, SQLiteParser.REFERENCES_, SQLiteParser.REGEXP_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.RENAME_, SQLiteParser.REPLACE_, SQLiteParser.RESTRICT_, SQLiteParser.RIGHT_, SQLiteParser.ROLLBACK_, SQLiteParser.ROW_, SQLiteParser.ROWS_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.SET_, SQLiteParser.TABLE_, SQLiteParser.TEMP_, SQLiteParser.TEMPORARY_, SQLiteParser.THEN_, SQLiteParser.TO_, SQLiteParser.TRANSACTION_, SQLiteParser.TRIGGER_, SQLiteParser.UNION_, SQLiteParser.UNIQUE_, SQLiteParser.UPDATE_, SQLiteParser.USING_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.VIEW_, SQLiteParser.VIRTUAL_, SQLiteParser.WHEN_, SQLiteParser.WHERE_, SQLiteParser.WITH_, SQLiteParser.WITHOUT_, SQLiteParser.FIRST_VALUE_, SQLiteParser.OVER_, SQLiteParser.PARTITION_, SQLiteParser.RANGE_, SQLiteParser.PRECEDING_, SQLiteParser.UNBOUNDED_, SQLiteParser.CURRENT_, SQLiteParser.FOLLOWING_, SQLiteParser.CUME_DIST_, SQLiteParser.DENSE_RANK_, SQLiteParser.LAG_, SQLiteParser.LAST_VALUE_, SQLiteParser.LEAD_, SQLiteParser.NTH_VALUE_, SQLiteParser.NTILE_, SQLiteParser.PERCENT_RANK_, SQLiteParser.RANK_, SQLiteParser.ROW_NUMBER_, SQLiteParser.GENERATED_, SQLiteParser.ALWAYS_, SQLiteParser.STORED_, SQLiteParser.TRUE_, SQLiteParser.FALSE_, SQLiteParser.WINDOW_, SQLiteParser.NULLS_, SQLiteParser.FIRST_, SQLiteParser.LAST_, SQLiteParser.FILTER_, SQLiteParser.GROUPS_, SQLiteParser.EXCLUDE_, SQLiteParser.IDENTIFIER, SQLiteParser.NUMERIC_LITERAL, SQLiteParser.BIND_PARAMETER, SQLiteParser.STRING_LITERAL, SQLiteParser.BLOB_LITERAL]: 

10061 self.state = 1728 

10062 self._errHandler.sync(self) 

10063 la_ = self._interp.adaptivePredict(self._input,251,self._ctx) 

10064 if la_ == 1: 

10065 self.state = 1727 

10066 self.match(SQLiteParser.DISTINCT_) 

10067 

10068 

10069 self.state = 1730 

10070 self.expr(0) 

10071 self.state = 1735 

10072 self._errHandler.sync(self) 

10073 _la = self._input.LA(1) 

10074 while _la==SQLiteParser.COMMA: 

10075 self.state = 1731 

10076 self.match(SQLiteParser.COMMA) 

10077 self.state = 1732 

10078 self.expr(0) 

10079 self.state = 1737 

10080 self._errHandler.sync(self) 

10081 _la = self._input.LA(1) 

10082 

10083 pass 

10084 elif token in [SQLiteParser.STAR]: 

10085 self.state = 1738 

10086 self.match(SQLiteParser.STAR) 

10087 pass 

10088 elif token in [SQLiteParser.CLOSE_PAR]: 

10089 pass 

10090 else: 

10091 pass 

10092 self.state = 1741 

10093 self.match(SQLiteParser.CLOSE_PAR) 

10094 self.state = 1743 

10095 self._errHandler.sync(self) 

10096 _la = self._input.LA(1) 

10097 if _la==SQLiteParser.FILTER_: 

10098 self.state = 1742 

10099 self.filter_clause() 

10100 

10101 

10102 except RecognitionException as re: 

10103 localctx.exception = re 

10104 self._errHandler.reportError(self, re) 

10105 self._errHandler.recover(self, re) 

10106 finally: 

10107 self.exitRule() 

10108 return localctx 

10109 

10110 

10111 class Window_function_invocationContext(ParserRuleContext): 

10112 

10113 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

10114 super().__init__(parent, invokingState) 

10115 self.parser = parser 

10116 

10117 def window_function(self): 

10118 return self.getTypedRuleContext(SQLiteParser.Window_functionContext,0) 

10119 

10120 

10121 def OPEN_PAR(self): 

10122 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

10123 

10124 def CLOSE_PAR(self): 

10125 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

10126 

10127 def OVER_(self): 

10128 return self.getToken(SQLiteParser.OVER_, 0) 

10129 

10130 def window_defn(self): 

10131 return self.getTypedRuleContext(SQLiteParser.Window_defnContext,0) 

10132 

10133 

10134 def window_name(self): 

10135 return self.getTypedRuleContext(SQLiteParser.Window_nameContext,0) 

10136 

10137 

10138 def expr(self, i:int=None): 

10139 if i is None: 

10140 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

10141 else: 

10142 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

10143 

10144 

10145 def STAR(self): 

10146 return self.getToken(SQLiteParser.STAR, 0) 

10147 

10148 def filter_clause(self): 

10149 return self.getTypedRuleContext(SQLiteParser.Filter_clauseContext,0) 

10150 

10151 

10152 def COMMA(self, i:int=None): 

10153 if i is None: 

10154 return self.getTokens(SQLiteParser.COMMA) 

10155 else: 

10156 return self.getToken(SQLiteParser.COMMA, i) 

10157 

10158 def getRuleIndex(self): 

10159 return SQLiteParser.RULE_window_function_invocation 

10160 

10161 def enterRule(self, listener:ParseTreeListener): 

10162 if hasattr( listener, "enterWindow_function_invocation" ): 

10163 listener.enterWindow_function_invocation(self) 

10164 

10165 def exitRule(self, listener:ParseTreeListener): 

10166 if hasattr( listener, "exitWindow_function_invocation" ): 

10167 listener.exitWindow_function_invocation(self) 

10168 

10169 

10170 

10171 

10172 def window_function_invocation(self): 

10173 

10174 localctx = SQLiteParser.Window_function_invocationContext(self, self._ctx, self.state) 

10175 self.enterRule(localctx, 126, self.RULE_window_function_invocation) 

10176 self._la = 0 # Token type 

10177 try: 

10178 self.enterOuterAlt(localctx, 1) 

10179 self.state = 1745 

10180 self.window_function() 

10181 self.state = 1746 

10182 self.match(SQLiteParser.OPEN_PAR) 

10183 self.state = 1756 

10184 self._errHandler.sync(self) 

10185 token = self._input.LA(1) 

10186 if token in [SQLiteParser.OPEN_PAR, SQLiteParser.PLUS, SQLiteParser.MINUS, SQLiteParser.TILDE, SQLiteParser.ABORT_, SQLiteParser.ACTION_, SQLiteParser.ADD_, SQLiteParser.AFTER_, SQLiteParser.ALL_, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.AND_, SQLiteParser.AS_, SQLiteParser.ASC_, SQLiteParser.ATTACH_, SQLiteParser.AUTOINCREMENT_, SQLiteParser.BEFORE_, SQLiteParser.BEGIN_, SQLiteParser.BETWEEN_, SQLiteParser.BY_, SQLiteParser.CASCADE_, SQLiteParser.CASE_, SQLiteParser.CAST_, SQLiteParser.CHECK_, SQLiteParser.COLLATE_, SQLiteParser.COLUMN_, SQLiteParser.COMMIT_, SQLiteParser.CONFLICT_, SQLiteParser.CONSTRAINT_, SQLiteParser.CREATE_, SQLiteParser.CROSS_, SQLiteParser.CURRENT_DATE_, SQLiteParser.CURRENT_TIME_, SQLiteParser.CURRENT_TIMESTAMP_, SQLiteParser.DATABASE_, SQLiteParser.DEFAULT_, SQLiteParser.DEFERRABLE_, SQLiteParser.DEFERRED_, SQLiteParser.DELETE_, SQLiteParser.DESC_, SQLiteParser.DETACH_, SQLiteParser.DISTINCT_, SQLiteParser.DROP_, SQLiteParser.EACH_, SQLiteParser.ELSE_, SQLiteParser.END_, SQLiteParser.ESCAPE_, SQLiteParser.EXCEPT_, SQLiteParser.EXCLUSIVE_, SQLiteParser.EXISTS_, SQLiteParser.EXPLAIN_, SQLiteParser.FAIL_, SQLiteParser.FOR_, SQLiteParser.FOREIGN_, SQLiteParser.FROM_, SQLiteParser.FULL_, SQLiteParser.GLOB_, SQLiteParser.GROUP_, SQLiteParser.HAVING_, SQLiteParser.IF_, SQLiteParser.IGNORE_, SQLiteParser.IMMEDIATE_, SQLiteParser.IN_, SQLiteParser.INDEX_, SQLiteParser.INDEXED_, SQLiteParser.INITIALLY_, SQLiteParser.INNER_, SQLiteParser.INSERT_, SQLiteParser.INSTEAD_, SQLiteParser.INTERSECT_, SQLiteParser.INTO_, SQLiteParser.IS_, SQLiteParser.ISNULL_, SQLiteParser.JOIN_, SQLiteParser.KEY_, SQLiteParser.LEFT_, SQLiteParser.LIKE_, SQLiteParser.LIMIT_, SQLiteParser.MATCH_, SQLiteParser.NATURAL_, SQLiteParser.NO_, SQLiteParser.NOT_, SQLiteParser.NOTNULL_, SQLiteParser.NULL_, SQLiteParser.OF_, SQLiteParser.OFFSET_, SQLiteParser.ON_, SQLiteParser.OR_, SQLiteParser.ORDER_, SQLiteParser.OUTER_, SQLiteParser.PLAN_, SQLiteParser.PRAGMA_, SQLiteParser.PRIMARY_, SQLiteParser.QUERY_, SQLiteParser.RAISE_, SQLiteParser.RECURSIVE_, SQLiteParser.REFERENCES_, SQLiteParser.REGEXP_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.RENAME_, SQLiteParser.REPLACE_, SQLiteParser.RESTRICT_, SQLiteParser.RIGHT_, SQLiteParser.ROLLBACK_, SQLiteParser.ROW_, SQLiteParser.ROWS_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.SET_, SQLiteParser.TABLE_, SQLiteParser.TEMP_, SQLiteParser.TEMPORARY_, SQLiteParser.THEN_, SQLiteParser.TO_, SQLiteParser.TRANSACTION_, SQLiteParser.TRIGGER_, SQLiteParser.UNION_, SQLiteParser.UNIQUE_, SQLiteParser.UPDATE_, SQLiteParser.USING_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.VIEW_, SQLiteParser.VIRTUAL_, SQLiteParser.WHEN_, SQLiteParser.WHERE_, SQLiteParser.WITH_, SQLiteParser.WITHOUT_, SQLiteParser.FIRST_VALUE_, SQLiteParser.OVER_, SQLiteParser.PARTITION_, SQLiteParser.RANGE_, SQLiteParser.PRECEDING_, SQLiteParser.UNBOUNDED_, SQLiteParser.CURRENT_, SQLiteParser.FOLLOWING_, SQLiteParser.CUME_DIST_, SQLiteParser.DENSE_RANK_, SQLiteParser.LAG_, SQLiteParser.LAST_VALUE_, SQLiteParser.LEAD_, SQLiteParser.NTH_VALUE_, SQLiteParser.NTILE_, SQLiteParser.PERCENT_RANK_, SQLiteParser.RANK_, SQLiteParser.ROW_NUMBER_, SQLiteParser.GENERATED_, SQLiteParser.ALWAYS_, SQLiteParser.STORED_, SQLiteParser.TRUE_, SQLiteParser.FALSE_, SQLiteParser.WINDOW_, SQLiteParser.NULLS_, SQLiteParser.FIRST_, SQLiteParser.LAST_, SQLiteParser.FILTER_, SQLiteParser.GROUPS_, SQLiteParser.EXCLUDE_, SQLiteParser.IDENTIFIER, SQLiteParser.NUMERIC_LITERAL, SQLiteParser.BIND_PARAMETER, SQLiteParser.STRING_LITERAL, SQLiteParser.BLOB_LITERAL]: 

10187 self.state = 1747 

10188 self.expr(0) 

10189 self.state = 1752 

10190 self._errHandler.sync(self) 

10191 _la = self._input.LA(1) 

10192 while _la==SQLiteParser.COMMA: 

10193 self.state = 1748 

10194 self.match(SQLiteParser.COMMA) 

10195 self.state = 1749 

10196 self.expr(0) 

10197 self.state = 1754 

10198 self._errHandler.sync(self) 

10199 _la = self._input.LA(1) 

10200 

10201 pass 

10202 elif token in [SQLiteParser.STAR]: 

10203 self.state = 1755 

10204 self.match(SQLiteParser.STAR) 

10205 pass 

10206 elif token in [SQLiteParser.CLOSE_PAR]: 

10207 pass 

10208 else: 

10209 pass 

10210 self.state = 1758 

10211 self.match(SQLiteParser.CLOSE_PAR) 

10212 self.state = 1760 

10213 self._errHandler.sync(self) 

10214 _la = self._input.LA(1) 

10215 if _la==SQLiteParser.FILTER_: 

10216 self.state = 1759 

10217 self.filter_clause() 

10218 

10219 

10220 self.state = 1762 

10221 self.match(SQLiteParser.OVER_) 

10222 self.state = 1765 

10223 self._errHandler.sync(self) 

10224 la_ = self._interp.adaptivePredict(self._input,258,self._ctx) 

10225 if la_ == 1: 

10226 self.state = 1763 

10227 self.window_defn() 

10228 pass 

10229 

10230 elif la_ == 2: 

10231 self.state = 1764 

10232 self.window_name() 

10233 pass 

10234 

10235 

10236 except RecognitionException as re: 

10237 localctx.exception = re 

10238 self._errHandler.reportError(self, re) 

10239 self._errHandler.recover(self, re) 

10240 finally: 

10241 self.exitRule() 

10242 return localctx 

10243 

10244 

10245 class Common_table_stmtContext(ParserRuleContext): 

10246 

10247 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

10248 super().__init__(parent, invokingState) 

10249 self.parser = parser 

10250 

10251 def WITH_(self): 

10252 return self.getToken(SQLiteParser.WITH_, 0) 

10253 

10254 def common_table_expression(self, i:int=None): 

10255 if i is None: 

10256 return self.getTypedRuleContexts(SQLiteParser.Common_table_expressionContext) 

10257 else: 

10258 return self.getTypedRuleContext(SQLiteParser.Common_table_expressionContext,i) 

10259 

10260 

10261 def RECURSIVE_(self): 

10262 return self.getToken(SQLiteParser.RECURSIVE_, 0) 

10263 

10264 def COMMA(self, i:int=None): 

10265 if i is None: 

10266 return self.getTokens(SQLiteParser.COMMA) 

10267 else: 

10268 return self.getToken(SQLiteParser.COMMA, i) 

10269 

10270 def getRuleIndex(self): 

10271 return SQLiteParser.RULE_common_table_stmt 

10272 

10273 def enterRule(self, listener:ParseTreeListener): 

10274 if hasattr( listener, "enterCommon_table_stmt" ): 

10275 listener.enterCommon_table_stmt(self) 

10276 

10277 def exitRule(self, listener:ParseTreeListener): 

10278 if hasattr( listener, "exitCommon_table_stmt" ): 

10279 listener.exitCommon_table_stmt(self) 

10280 

10281 

10282 

10283 

10284 def common_table_stmt(self): 

10285 

10286 localctx = SQLiteParser.Common_table_stmtContext(self, self._ctx, self.state) 

10287 self.enterRule(localctx, 128, self.RULE_common_table_stmt) 

10288 self._la = 0 # Token type 

10289 try: 

10290 self.enterOuterAlt(localctx, 1) 

10291 self.state = 1767 

10292 self.match(SQLiteParser.WITH_) 

10293 self.state = 1769 

10294 self._errHandler.sync(self) 

10295 la_ = self._interp.adaptivePredict(self._input,259,self._ctx) 

10296 if la_ == 1: 

10297 self.state = 1768 

10298 self.match(SQLiteParser.RECURSIVE_) 

10299 

10300 

10301 self.state = 1771 

10302 self.common_table_expression() 

10303 self.state = 1776 

10304 self._errHandler.sync(self) 

10305 _la = self._input.LA(1) 

10306 while _la==SQLiteParser.COMMA: 

10307 self.state = 1772 

10308 self.match(SQLiteParser.COMMA) 

10309 self.state = 1773 

10310 self.common_table_expression() 

10311 self.state = 1778 

10312 self._errHandler.sync(self) 

10313 _la = self._input.LA(1) 

10314 

10315 except RecognitionException as re: 

10316 localctx.exception = re 

10317 self._errHandler.reportError(self, re) 

10318 self._errHandler.recover(self, re) 

10319 finally: 

10320 self.exitRule() 

10321 return localctx 

10322 

10323 

10324 class Order_by_stmtContext(ParserRuleContext): 

10325 

10326 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

10327 super().__init__(parent, invokingState) 

10328 self.parser = parser 

10329 

10330 def ORDER_(self): 

10331 return self.getToken(SQLiteParser.ORDER_, 0) 

10332 

10333 def BY_(self): 

10334 return self.getToken(SQLiteParser.BY_, 0) 

10335 

10336 def ordering_term(self, i:int=None): 

10337 if i is None: 

10338 return self.getTypedRuleContexts(SQLiteParser.Ordering_termContext) 

10339 else: 

10340 return self.getTypedRuleContext(SQLiteParser.Ordering_termContext,i) 

10341 

10342 

10343 def COMMA(self, i:int=None): 

10344 if i is None: 

10345 return self.getTokens(SQLiteParser.COMMA) 

10346 else: 

10347 return self.getToken(SQLiteParser.COMMA, i) 

10348 

10349 def getRuleIndex(self): 

10350 return SQLiteParser.RULE_order_by_stmt 

10351 

10352 def enterRule(self, listener:ParseTreeListener): 

10353 if hasattr( listener, "enterOrder_by_stmt" ): 

10354 listener.enterOrder_by_stmt(self) 

10355 

10356 def exitRule(self, listener:ParseTreeListener): 

10357 if hasattr( listener, "exitOrder_by_stmt" ): 

10358 listener.exitOrder_by_stmt(self) 

10359 

10360 

10361 

10362 

10363 def order_by_stmt(self): 

10364 

10365 localctx = SQLiteParser.Order_by_stmtContext(self, self._ctx, self.state) 

10366 self.enterRule(localctx, 130, self.RULE_order_by_stmt) 

10367 self._la = 0 # Token type 

10368 try: 

10369 self.enterOuterAlt(localctx, 1) 

10370 self.state = 1779 

10371 self.match(SQLiteParser.ORDER_) 

10372 self.state = 1780 

10373 self.match(SQLiteParser.BY_) 

10374 self.state = 1781 

10375 self.ordering_term() 

10376 self.state = 1786 

10377 self._errHandler.sync(self) 

10378 _la = self._input.LA(1) 

10379 while _la==SQLiteParser.COMMA: 

10380 self.state = 1782 

10381 self.match(SQLiteParser.COMMA) 

10382 self.state = 1783 

10383 self.ordering_term() 

10384 self.state = 1788 

10385 self._errHandler.sync(self) 

10386 _la = self._input.LA(1) 

10387 

10388 except RecognitionException as re: 

10389 localctx.exception = re 

10390 self._errHandler.reportError(self, re) 

10391 self._errHandler.recover(self, re) 

10392 finally: 

10393 self.exitRule() 

10394 return localctx 

10395 

10396 

10397 class Limit_stmtContext(ParserRuleContext): 

10398 

10399 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

10400 super().__init__(parent, invokingState) 

10401 self.parser = parser 

10402 

10403 def LIMIT_(self): 

10404 return self.getToken(SQLiteParser.LIMIT_, 0) 

10405 

10406 def expr(self, i:int=None): 

10407 if i is None: 

10408 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

10409 else: 

10410 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

10411 

10412 

10413 def OFFSET_(self): 

10414 return self.getToken(SQLiteParser.OFFSET_, 0) 

10415 

10416 def COMMA(self): 

10417 return self.getToken(SQLiteParser.COMMA, 0) 

10418 

10419 def getRuleIndex(self): 

10420 return SQLiteParser.RULE_limit_stmt 

10421 

10422 def enterRule(self, listener:ParseTreeListener): 

10423 if hasattr( listener, "enterLimit_stmt" ): 

10424 listener.enterLimit_stmt(self) 

10425 

10426 def exitRule(self, listener:ParseTreeListener): 

10427 if hasattr( listener, "exitLimit_stmt" ): 

10428 listener.exitLimit_stmt(self) 

10429 

10430 

10431 

10432 

10433 def limit_stmt(self): 

10434 

10435 localctx = SQLiteParser.Limit_stmtContext(self, self._ctx, self.state) 

10436 self.enterRule(localctx, 132, self.RULE_limit_stmt) 

10437 self._la = 0 # Token type 

10438 try: 

10439 self.enterOuterAlt(localctx, 1) 

10440 self.state = 1789 

10441 self.match(SQLiteParser.LIMIT_) 

10442 self.state = 1790 

10443 self.expr(0) 

10444 self.state = 1793 

10445 self._errHandler.sync(self) 

10446 _la = self._input.LA(1) 

10447 if _la==SQLiteParser.COMMA or _la==SQLiteParser.OFFSET_: 

10448 self.state = 1791 

10449 _la = self._input.LA(1) 

10450 if not(_la==SQLiteParser.COMMA or _la==SQLiteParser.OFFSET_): 

10451 self._errHandler.recoverInline(self) 

10452 else: 

10453 self._errHandler.reportMatch(self) 

10454 self.consume() 

10455 self.state = 1792 

10456 self.expr(0) 

10457 

10458 

10459 except RecognitionException as re: 

10460 localctx.exception = re 

10461 self._errHandler.reportError(self, re) 

10462 self._errHandler.recover(self, re) 

10463 finally: 

10464 self.exitRule() 

10465 return localctx 

10466 

10467 

10468 class Ordering_termContext(ParserRuleContext): 

10469 

10470 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

10471 super().__init__(parent, invokingState) 

10472 self.parser = parser 

10473 

10474 def expr(self): 

10475 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

10476 

10477 

10478 def COLLATE_(self): 

10479 return self.getToken(SQLiteParser.COLLATE_, 0) 

10480 

10481 def collation_name(self): 

10482 return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0) 

10483 

10484 

10485 def asc_desc(self): 

10486 return self.getTypedRuleContext(SQLiteParser.Asc_descContext,0) 

10487 

10488 

10489 def NULLS_(self): 

10490 return self.getToken(SQLiteParser.NULLS_, 0) 

10491 

10492 def FIRST_(self): 

10493 return self.getToken(SQLiteParser.FIRST_, 0) 

10494 

10495 def LAST_(self): 

10496 return self.getToken(SQLiteParser.LAST_, 0) 

10497 

10498 def getRuleIndex(self): 

10499 return SQLiteParser.RULE_ordering_term 

10500 

10501 def enterRule(self, listener:ParseTreeListener): 

10502 if hasattr( listener, "enterOrdering_term" ): 

10503 listener.enterOrdering_term(self) 

10504 

10505 def exitRule(self, listener:ParseTreeListener): 

10506 if hasattr( listener, "exitOrdering_term" ): 

10507 listener.exitOrdering_term(self) 

10508 

10509 

10510 

10511 

10512 def ordering_term(self): 

10513 

10514 localctx = SQLiteParser.Ordering_termContext(self, self._ctx, self.state) 

10515 self.enterRule(localctx, 134, self.RULE_ordering_term) 

10516 self._la = 0 # Token type 

10517 try: 

10518 self.enterOuterAlt(localctx, 1) 

10519 self.state = 1795 

10520 self.expr(0) 

10521 self.state = 1798 

10522 self._errHandler.sync(self) 

10523 _la = self._input.LA(1) 

10524 if _la==SQLiteParser.COLLATE_: 

10525 self.state = 1796 

10526 self.match(SQLiteParser.COLLATE_) 

10527 self.state = 1797 

10528 self.collation_name() 

10529 

10530 

10531 self.state = 1801 

10532 self._errHandler.sync(self) 

10533 _la = self._input.LA(1) 

10534 if _la==SQLiteParser.ASC_ or _la==SQLiteParser.DESC_: 

10535 self.state = 1800 

10536 self.asc_desc() 

10537 

10538 

10539 self.state = 1805 

10540 self._errHandler.sync(self) 

10541 _la = self._input.LA(1) 

10542 if _la==SQLiteParser.NULLS_: 

10543 self.state = 1803 

10544 self.match(SQLiteParser.NULLS_) 

10545 self.state = 1804 

10546 _la = self._input.LA(1) 

10547 if not(_la==SQLiteParser.FIRST_ or _la==SQLiteParser.LAST_): 

10548 self._errHandler.recoverInline(self) 

10549 else: 

10550 self._errHandler.reportMatch(self) 

10551 self.consume() 

10552 

10553 

10554 except RecognitionException as re: 

10555 localctx.exception = re 

10556 self._errHandler.reportError(self, re) 

10557 self._errHandler.recover(self, re) 

10558 finally: 

10559 self.exitRule() 

10560 return localctx 

10561 

10562 

10563 class Asc_descContext(ParserRuleContext): 

10564 

10565 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

10566 super().__init__(parent, invokingState) 

10567 self.parser = parser 

10568 

10569 def ASC_(self): 

10570 return self.getToken(SQLiteParser.ASC_, 0) 

10571 

10572 def DESC_(self): 

10573 return self.getToken(SQLiteParser.DESC_, 0) 

10574 

10575 def getRuleIndex(self): 

10576 return SQLiteParser.RULE_asc_desc 

10577 

10578 def enterRule(self, listener:ParseTreeListener): 

10579 if hasattr( listener, "enterAsc_desc" ): 

10580 listener.enterAsc_desc(self) 

10581 

10582 def exitRule(self, listener:ParseTreeListener): 

10583 if hasattr( listener, "exitAsc_desc" ): 

10584 listener.exitAsc_desc(self) 

10585 

10586 

10587 

10588 

10589 def asc_desc(self): 

10590 

10591 localctx = SQLiteParser.Asc_descContext(self, self._ctx, self.state) 

10592 self.enterRule(localctx, 136, self.RULE_asc_desc) 

10593 self._la = 0 # Token type 

10594 try: 

10595 self.enterOuterAlt(localctx, 1) 

10596 self.state = 1807 

10597 _la = self._input.LA(1) 

10598 if not(_la==SQLiteParser.ASC_ or _la==SQLiteParser.DESC_): 

10599 self._errHandler.recoverInline(self) 

10600 else: 

10601 self._errHandler.reportMatch(self) 

10602 self.consume() 

10603 except RecognitionException as re: 

10604 localctx.exception = re 

10605 self._errHandler.reportError(self, re) 

10606 self._errHandler.recover(self, re) 

10607 finally: 

10608 self.exitRule() 

10609 return localctx 

10610 

10611 

10612 class Frame_leftContext(ParserRuleContext): 

10613 

10614 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

10615 super().__init__(parent, invokingState) 

10616 self.parser = parser 

10617 

10618 def expr(self): 

10619 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

10620 

10621 

10622 def PRECEDING_(self): 

10623 return self.getToken(SQLiteParser.PRECEDING_, 0) 

10624 

10625 def FOLLOWING_(self): 

10626 return self.getToken(SQLiteParser.FOLLOWING_, 0) 

10627 

10628 def CURRENT_(self): 

10629 return self.getToken(SQLiteParser.CURRENT_, 0) 

10630 

10631 def ROW_(self): 

10632 return self.getToken(SQLiteParser.ROW_, 0) 

10633 

10634 def UNBOUNDED_(self): 

10635 return self.getToken(SQLiteParser.UNBOUNDED_, 0) 

10636 

10637 def getRuleIndex(self): 

10638 return SQLiteParser.RULE_frame_left 

10639 

10640 def enterRule(self, listener:ParseTreeListener): 

10641 if hasattr( listener, "enterFrame_left" ): 

10642 listener.enterFrame_left(self) 

10643 

10644 def exitRule(self, listener:ParseTreeListener): 

10645 if hasattr( listener, "exitFrame_left" ): 

10646 listener.exitFrame_left(self) 

10647 

10648 

10649 

10650 

10651 def frame_left(self): 

10652 

10653 localctx = SQLiteParser.Frame_leftContext(self, self._ctx, self.state) 

10654 self.enterRule(localctx, 138, self.RULE_frame_left) 

10655 try: 

10656 self.state = 1819 

10657 self._errHandler.sync(self) 

10658 la_ = self._interp.adaptivePredict(self._input,266,self._ctx) 

10659 if la_ == 1: 

10660 self.enterOuterAlt(localctx, 1) 

10661 self.state = 1809 

10662 self.expr(0) 

10663 self.state = 1810 

10664 self.match(SQLiteParser.PRECEDING_) 

10665 pass 

10666 

10667 elif la_ == 2: 

10668 self.enterOuterAlt(localctx, 2) 

10669 self.state = 1812 

10670 self.expr(0) 

10671 self.state = 1813 

10672 self.match(SQLiteParser.FOLLOWING_) 

10673 pass 

10674 

10675 elif la_ == 3: 

10676 self.enterOuterAlt(localctx, 3) 

10677 self.state = 1815 

10678 self.match(SQLiteParser.CURRENT_) 

10679 self.state = 1816 

10680 self.match(SQLiteParser.ROW_) 

10681 pass 

10682 

10683 elif la_ == 4: 

10684 self.enterOuterAlt(localctx, 4) 

10685 self.state = 1817 

10686 self.match(SQLiteParser.UNBOUNDED_) 

10687 self.state = 1818 

10688 self.match(SQLiteParser.PRECEDING_) 

10689 pass 

10690 

10691 

10692 except RecognitionException as re: 

10693 localctx.exception = re 

10694 self._errHandler.reportError(self, re) 

10695 self._errHandler.recover(self, re) 

10696 finally: 

10697 self.exitRule() 

10698 return localctx 

10699 

10700 

10701 class Frame_rightContext(ParserRuleContext): 

10702 

10703 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

10704 super().__init__(parent, invokingState) 

10705 self.parser = parser 

10706 

10707 def expr(self): 

10708 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

10709 

10710 

10711 def PRECEDING_(self): 

10712 return self.getToken(SQLiteParser.PRECEDING_, 0) 

10713 

10714 def FOLLOWING_(self): 

10715 return self.getToken(SQLiteParser.FOLLOWING_, 0) 

10716 

10717 def CURRENT_(self): 

10718 return self.getToken(SQLiteParser.CURRENT_, 0) 

10719 

10720 def ROW_(self): 

10721 return self.getToken(SQLiteParser.ROW_, 0) 

10722 

10723 def UNBOUNDED_(self): 

10724 return self.getToken(SQLiteParser.UNBOUNDED_, 0) 

10725 

10726 def getRuleIndex(self): 

10727 return SQLiteParser.RULE_frame_right 

10728 

10729 def enterRule(self, listener:ParseTreeListener): 

10730 if hasattr( listener, "enterFrame_right" ): 

10731 listener.enterFrame_right(self) 

10732 

10733 def exitRule(self, listener:ParseTreeListener): 

10734 if hasattr( listener, "exitFrame_right" ): 

10735 listener.exitFrame_right(self) 

10736 

10737 

10738 

10739 

10740 def frame_right(self): 

10741 

10742 localctx = SQLiteParser.Frame_rightContext(self, self._ctx, self.state) 

10743 self.enterRule(localctx, 140, self.RULE_frame_right) 

10744 try: 

10745 self.state = 1831 

10746 self._errHandler.sync(self) 

10747 la_ = self._interp.adaptivePredict(self._input,267,self._ctx) 

10748 if la_ == 1: 

10749 self.enterOuterAlt(localctx, 1) 

10750 self.state = 1821 

10751 self.expr(0) 

10752 self.state = 1822 

10753 self.match(SQLiteParser.PRECEDING_) 

10754 pass 

10755 

10756 elif la_ == 2: 

10757 self.enterOuterAlt(localctx, 2) 

10758 self.state = 1824 

10759 self.expr(0) 

10760 self.state = 1825 

10761 self.match(SQLiteParser.FOLLOWING_) 

10762 pass 

10763 

10764 elif la_ == 3: 

10765 self.enterOuterAlt(localctx, 3) 

10766 self.state = 1827 

10767 self.match(SQLiteParser.CURRENT_) 

10768 self.state = 1828 

10769 self.match(SQLiteParser.ROW_) 

10770 pass 

10771 

10772 elif la_ == 4: 

10773 self.enterOuterAlt(localctx, 4) 

10774 self.state = 1829 

10775 self.match(SQLiteParser.UNBOUNDED_) 

10776 self.state = 1830 

10777 self.match(SQLiteParser.FOLLOWING_) 

10778 pass 

10779 

10780 

10781 except RecognitionException as re: 

10782 localctx.exception = re 

10783 self._errHandler.reportError(self, re) 

10784 self._errHandler.recover(self, re) 

10785 finally: 

10786 self.exitRule() 

10787 return localctx 

10788 

10789 

10790 class Frame_singleContext(ParserRuleContext): 

10791 

10792 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

10793 super().__init__(parent, invokingState) 

10794 self.parser = parser 

10795 

10796 def expr(self): 

10797 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

10798 

10799 

10800 def PRECEDING_(self): 

10801 return self.getToken(SQLiteParser.PRECEDING_, 0) 

10802 

10803 def UNBOUNDED_(self): 

10804 return self.getToken(SQLiteParser.UNBOUNDED_, 0) 

10805 

10806 def CURRENT_(self): 

10807 return self.getToken(SQLiteParser.CURRENT_, 0) 

10808 

10809 def ROW_(self): 

10810 return self.getToken(SQLiteParser.ROW_, 0) 

10811 

10812 def getRuleIndex(self): 

10813 return SQLiteParser.RULE_frame_single 

10814 

10815 def enterRule(self, listener:ParseTreeListener): 

10816 if hasattr( listener, "enterFrame_single" ): 

10817 listener.enterFrame_single(self) 

10818 

10819 def exitRule(self, listener:ParseTreeListener): 

10820 if hasattr( listener, "exitFrame_single" ): 

10821 listener.exitFrame_single(self) 

10822 

10823 

10824 

10825 

10826 def frame_single(self): 

10827 

10828 localctx = SQLiteParser.Frame_singleContext(self, self._ctx, self.state) 

10829 self.enterRule(localctx, 142, self.RULE_frame_single) 

10830 try: 

10831 self.state = 1840 

10832 self._errHandler.sync(self) 

10833 la_ = self._interp.adaptivePredict(self._input,268,self._ctx) 

10834 if la_ == 1: 

10835 self.enterOuterAlt(localctx, 1) 

10836 self.state = 1833 

10837 self.expr(0) 

10838 self.state = 1834 

10839 self.match(SQLiteParser.PRECEDING_) 

10840 pass 

10841 

10842 elif la_ == 2: 

10843 self.enterOuterAlt(localctx, 2) 

10844 self.state = 1836 

10845 self.match(SQLiteParser.UNBOUNDED_) 

10846 self.state = 1837 

10847 self.match(SQLiteParser.PRECEDING_) 

10848 pass 

10849 

10850 elif la_ == 3: 

10851 self.enterOuterAlt(localctx, 3) 

10852 self.state = 1838 

10853 self.match(SQLiteParser.CURRENT_) 

10854 self.state = 1839 

10855 self.match(SQLiteParser.ROW_) 

10856 pass 

10857 

10858 

10859 except RecognitionException as re: 

10860 localctx.exception = re 

10861 self._errHandler.reportError(self, re) 

10862 self._errHandler.recover(self, re) 

10863 finally: 

10864 self.exitRule() 

10865 return localctx 

10866 

10867 

10868 class Window_functionContext(ParserRuleContext): 

10869 

10870 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

10871 super().__init__(parent, invokingState) 

10872 self.parser = parser 

10873 

10874 def OPEN_PAR(self, i:int=None): 

10875 if i is None: 

10876 return self.getTokens(SQLiteParser.OPEN_PAR) 

10877 else: 

10878 return self.getToken(SQLiteParser.OPEN_PAR, i) 

10879 

10880 def expr(self): 

10881 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

10882 

10883 

10884 def CLOSE_PAR(self, i:int=None): 

10885 if i is None: 

10886 return self.getTokens(SQLiteParser.CLOSE_PAR) 

10887 else: 

10888 return self.getToken(SQLiteParser.CLOSE_PAR, i) 

10889 

10890 def OVER_(self): 

10891 return self.getToken(SQLiteParser.OVER_, 0) 

10892 

10893 def order_by_expr_asc_desc(self): 

10894 return self.getTypedRuleContext(SQLiteParser.Order_by_expr_asc_descContext,0) 

10895 

10896 

10897 def FIRST_VALUE_(self): 

10898 return self.getToken(SQLiteParser.FIRST_VALUE_, 0) 

10899 

10900 def LAST_VALUE_(self): 

10901 return self.getToken(SQLiteParser.LAST_VALUE_, 0) 

10902 

10903 def partition_by(self): 

10904 return self.getTypedRuleContext(SQLiteParser.Partition_byContext,0) 

10905 

10906 

10907 def frame_clause(self): 

10908 return self.getTypedRuleContext(SQLiteParser.Frame_clauseContext,0) 

10909 

10910 

10911 def CUME_DIST_(self): 

10912 return self.getToken(SQLiteParser.CUME_DIST_, 0) 

10913 

10914 def PERCENT_RANK_(self): 

10915 return self.getToken(SQLiteParser.PERCENT_RANK_, 0) 

10916 

10917 def order_by_expr(self): 

10918 return self.getTypedRuleContext(SQLiteParser.Order_by_exprContext,0) 

10919 

10920 

10921 def DENSE_RANK_(self): 

10922 return self.getToken(SQLiteParser.DENSE_RANK_, 0) 

10923 

10924 def RANK_(self): 

10925 return self.getToken(SQLiteParser.RANK_, 0) 

10926 

10927 def ROW_NUMBER_(self): 

10928 return self.getToken(SQLiteParser.ROW_NUMBER_, 0) 

10929 

10930 def LAG_(self): 

10931 return self.getToken(SQLiteParser.LAG_, 0) 

10932 

10933 def LEAD_(self): 

10934 return self.getToken(SQLiteParser.LEAD_, 0) 

10935 

10936 def of_OF_fset(self): 

10937 return self.getTypedRuleContext(SQLiteParser.Of_OF_fsetContext,0) 

10938 

10939 

10940 def default_DEFAULT__value(self): 

10941 return self.getTypedRuleContext(SQLiteParser.Default_DEFAULT__valueContext,0) 

10942 

10943 

10944 def NTH_VALUE_(self): 

10945 return self.getToken(SQLiteParser.NTH_VALUE_, 0) 

10946 

10947 def COMMA(self): 

10948 return self.getToken(SQLiteParser.COMMA, 0) 

10949 

10950 def signed_number(self): 

10951 return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,0) 

10952 

10953 

10954 def NTILE_(self): 

10955 return self.getToken(SQLiteParser.NTILE_, 0) 

10956 

10957 def getRuleIndex(self): 

10958 return SQLiteParser.RULE_window_function 

10959 

10960 def enterRule(self, listener:ParseTreeListener): 

10961 if hasattr( listener, "enterWindow_function" ): 

10962 listener.enterWindow_function(self) 

10963 

10964 def exitRule(self, listener:ParseTreeListener): 

10965 if hasattr( listener, "exitWindow_function" ): 

10966 listener.exitWindow_function(self) 

10967 

10968 

10969 

10970 

10971 def window_function(self): 

10972 

10973 localctx = SQLiteParser.Window_functionContext(self, self._ctx, self.state) 

10974 self.enterRule(localctx, 144, self.RULE_window_function) 

10975 self._la = 0 # Token type 

10976 try: 

10977 self.state = 1927 

10978 self._errHandler.sync(self) 

10979 token = self._input.LA(1) 

10980 if token in [SQLiteParser.FIRST_VALUE_, SQLiteParser.LAST_VALUE_]: 

10981 self.enterOuterAlt(localctx, 1) 

10982 self.state = 1842 

10983 _la = self._input.LA(1) 

10984 if not(_la==SQLiteParser.FIRST_VALUE_ or _la==SQLiteParser.LAST_VALUE_): 

10985 self._errHandler.recoverInline(self) 

10986 else: 

10987 self._errHandler.reportMatch(self) 

10988 self.consume() 

10989 self.state = 1843 

10990 self.match(SQLiteParser.OPEN_PAR) 

10991 self.state = 1844 

10992 self.expr(0) 

10993 self.state = 1845 

10994 self.match(SQLiteParser.CLOSE_PAR) 

10995 self.state = 1846 

10996 self.match(SQLiteParser.OVER_) 

10997 self.state = 1847 

10998 self.match(SQLiteParser.OPEN_PAR) 

10999 self.state = 1849 

11000 self._errHandler.sync(self) 

11001 _la = self._input.LA(1) 

11002 if _la==SQLiteParser.PARTITION_: 

11003 self.state = 1848 

11004 self.partition_by() 

11005 

11006 

11007 self.state = 1851 

11008 self.order_by_expr_asc_desc() 

11009 self.state = 1853 

11010 self._errHandler.sync(self) 

11011 _la = self._input.LA(1) 

11012 if ((((_la - 127)) & ~0x3f) == 0 and ((1 << (_la - 127)) & ((1 << (SQLiteParser.ROWS_ - 127)) | (1 << (SQLiteParser.RANGE_ - 127)) | (1 << (SQLiteParser.GROUPS_ - 127)))) != 0): 

11013 self.state = 1852 

11014 self.frame_clause() 

11015 

11016 

11017 self.state = 1855 

11018 self.match(SQLiteParser.CLOSE_PAR) 

11019 pass 

11020 elif token in [SQLiteParser.CUME_DIST_, SQLiteParser.PERCENT_RANK_]: 

11021 self.enterOuterAlt(localctx, 2) 

11022 self.state = 1857 

11023 _la = self._input.LA(1) 

11024 if not(_la==SQLiteParser.CUME_DIST_ or _la==SQLiteParser.PERCENT_RANK_): 

11025 self._errHandler.recoverInline(self) 

11026 else: 

11027 self._errHandler.reportMatch(self) 

11028 self.consume() 

11029 self.state = 1858 

11030 self.match(SQLiteParser.OPEN_PAR) 

11031 self.state = 1859 

11032 self.match(SQLiteParser.CLOSE_PAR) 

11033 self.state = 1860 

11034 self.match(SQLiteParser.OVER_) 

11035 self.state = 1861 

11036 self.match(SQLiteParser.OPEN_PAR) 

11037 self.state = 1863 

11038 self._errHandler.sync(self) 

11039 _la = self._input.LA(1) 

11040 if _la==SQLiteParser.PARTITION_: 

11041 self.state = 1862 

11042 self.partition_by() 

11043 

11044 

11045 self.state = 1866 

11046 self._errHandler.sync(self) 

11047 _la = self._input.LA(1) 

11048 if _la==SQLiteParser.ORDER_: 

11049 self.state = 1865 

11050 self.order_by_expr() 

11051 

11052 

11053 self.state = 1868 

11054 self.match(SQLiteParser.CLOSE_PAR) 

11055 pass 

11056 elif token in [SQLiteParser.DENSE_RANK_, SQLiteParser.RANK_, SQLiteParser.ROW_NUMBER_]: 

11057 self.enterOuterAlt(localctx, 3) 

11058 self.state = 1869 

11059 _la = self._input.LA(1) 

11060 if not(((((_la - 159)) & ~0x3f) == 0 and ((1 << (_la - 159)) & ((1 << (SQLiteParser.DENSE_RANK_ - 159)) | (1 << (SQLiteParser.RANK_ - 159)) | (1 << (SQLiteParser.ROW_NUMBER_ - 159)))) != 0)): 

11061 self._errHandler.recoverInline(self) 

11062 else: 

11063 self._errHandler.reportMatch(self) 

11064 self.consume() 

11065 self.state = 1870 

11066 self.match(SQLiteParser.OPEN_PAR) 

11067 self.state = 1871 

11068 self.match(SQLiteParser.CLOSE_PAR) 

11069 self.state = 1872 

11070 self.match(SQLiteParser.OVER_) 

11071 self.state = 1873 

11072 self.match(SQLiteParser.OPEN_PAR) 

11073 self.state = 1875 

11074 self._errHandler.sync(self) 

11075 _la = self._input.LA(1) 

11076 if _la==SQLiteParser.PARTITION_: 

11077 self.state = 1874 

11078 self.partition_by() 

11079 

11080 

11081 self.state = 1877 

11082 self.order_by_expr_asc_desc() 

11083 self.state = 1878 

11084 self.match(SQLiteParser.CLOSE_PAR) 

11085 pass 

11086 elif token in [SQLiteParser.LAG_, SQLiteParser.LEAD_]: 

11087 self.enterOuterAlt(localctx, 4) 

11088 self.state = 1880 

11089 _la = self._input.LA(1) 

11090 if not(_la==SQLiteParser.LAG_ or _la==SQLiteParser.LEAD_): 

11091 self._errHandler.recoverInline(self) 

11092 else: 

11093 self._errHandler.reportMatch(self) 

11094 self.consume() 

11095 self.state = 1881 

11096 self.match(SQLiteParser.OPEN_PAR) 

11097 self.state = 1882 

11098 self.expr(0) 

11099 self.state = 1884 

11100 self._errHandler.sync(self) 

11101 la_ = self._interp.adaptivePredict(self._input,274,self._ctx) 

11102 if la_ == 1: 

11103 self.state = 1883 

11104 self.of_OF_fset() 

11105 

11106 

11107 self.state = 1887 

11108 self._errHandler.sync(self) 

11109 _la = self._input.LA(1) 

11110 if _la==SQLiteParser.COMMA: 

11111 self.state = 1886 

11112 self.default_DEFAULT__value() 

11113 

11114 

11115 self.state = 1889 

11116 self.match(SQLiteParser.CLOSE_PAR) 

11117 self.state = 1890 

11118 self.match(SQLiteParser.OVER_) 

11119 self.state = 1891 

11120 self.match(SQLiteParser.OPEN_PAR) 

11121 self.state = 1893 

11122 self._errHandler.sync(self) 

11123 _la = self._input.LA(1) 

11124 if _la==SQLiteParser.PARTITION_: 

11125 self.state = 1892 

11126 self.partition_by() 

11127 

11128 

11129 self.state = 1895 

11130 self.order_by_expr_asc_desc() 

11131 self.state = 1896 

11132 self.match(SQLiteParser.CLOSE_PAR) 

11133 pass 

11134 elif token in [SQLiteParser.NTH_VALUE_]: 

11135 self.enterOuterAlt(localctx, 5) 

11136 self.state = 1898 

11137 self.match(SQLiteParser.NTH_VALUE_) 

11138 self.state = 1899 

11139 self.match(SQLiteParser.OPEN_PAR) 

11140 self.state = 1900 

11141 self.expr(0) 

11142 self.state = 1901 

11143 self.match(SQLiteParser.COMMA) 

11144 self.state = 1902 

11145 self.signed_number() 

11146 self.state = 1903 

11147 self.match(SQLiteParser.CLOSE_PAR) 

11148 self.state = 1904 

11149 self.match(SQLiteParser.OVER_) 

11150 self.state = 1905 

11151 self.match(SQLiteParser.OPEN_PAR) 

11152 self.state = 1907 

11153 self._errHandler.sync(self) 

11154 _la = self._input.LA(1) 

11155 if _la==SQLiteParser.PARTITION_: 

11156 self.state = 1906 

11157 self.partition_by() 

11158 

11159 

11160 self.state = 1909 

11161 self.order_by_expr_asc_desc() 

11162 self.state = 1911 

11163 self._errHandler.sync(self) 

11164 _la = self._input.LA(1) 

11165 if ((((_la - 127)) & ~0x3f) == 0 and ((1 << (_la - 127)) & ((1 << (SQLiteParser.ROWS_ - 127)) | (1 << (SQLiteParser.RANGE_ - 127)) | (1 << (SQLiteParser.GROUPS_ - 127)))) != 0): 

11166 self.state = 1910 

11167 self.frame_clause() 

11168 

11169 

11170 self.state = 1913 

11171 self.match(SQLiteParser.CLOSE_PAR) 

11172 pass 

11173 elif token in [SQLiteParser.NTILE_]: 

11174 self.enterOuterAlt(localctx, 6) 

11175 self.state = 1915 

11176 self.match(SQLiteParser.NTILE_) 

11177 self.state = 1916 

11178 self.match(SQLiteParser.OPEN_PAR) 

11179 self.state = 1917 

11180 self.expr(0) 

11181 self.state = 1918 

11182 self.match(SQLiteParser.CLOSE_PAR) 

11183 self.state = 1919 

11184 self.match(SQLiteParser.OVER_) 

11185 self.state = 1920 

11186 self.match(SQLiteParser.OPEN_PAR) 

11187 self.state = 1922 

11188 self._errHandler.sync(self) 

11189 _la = self._input.LA(1) 

11190 if _la==SQLiteParser.PARTITION_: 

11191 self.state = 1921 

11192 self.partition_by() 

11193 

11194 

11195 self.state = 1924 

11196 self.order_by_expr_asc_desc() 

11197 self.state = 1925 

11198 self.match(SQLiteParser.CLOSE_PAR) 

11199 pass 

11200 else: 

11201 raise NoViableAltException(self) 

11202 

11203 except RecognitionException as re: 

11204 localctx.exception = re 

11205 self._errHandler.reportError(self, re) 

11206 self._errHandler.recover(self, re) 

11207 finally: 

11208 self.exitRule() 

11209 return localctx 

11210 

11211 

11212 class Of_OF_fsetContext(ParserRuleContext): 

11213 

11214 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

11215 super().__init__(parent, invokingState) 

11216 self.parser = parser 

11217 

11218 def COMMA(self): 

11219 return self.getToken(SQLiteParser.COMMA, 0) 

11220 

11221 def signed_number(self): 

11222 return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,0) 

11223 

11224 

11225 def getRuleIndex(self): 

11226 return SQLiteParser.RULE_of_OF_fset 

11227 

11228 def enterRule(self, listener:ParseTreeListener): 

11229 if hasattr( listener, "enterOf_OF_fset" ): 

11230 listener.enterOf_OF_fset(self) 

11231 

11232 def exitRule(self, listener:ParseTreeListener): 

11233 if hasattr( listener, "exitOf_OF_fset" ): 

11234 listener.exitOf_OF_fset(self) 

11235 

11236 

11237 

11238 

11239 def of_OF_fset(self): 

11240 

11241 localctx = SQLiteParser.Of_OF_fsetContext(self, self._ctx, self.state) 

11242 self.enterRule(localctx, 146, self.RULE_of_OF_fset) 

11243 try: 

11244 self.enterOuterAlt(localctx, 1) 

11245 self.state = 1929 

11246 self.match(SQLiteParser.COMMA) 

11247 self.state = 1930 

11248 self.signed_number() 

11249 except RecognitionException as re: 

11250 localctx.exception = re 

11251 self._errHandler.reportError(self, re) 

11252 self._errHandler.recover(self, re) 

11253 finally: 

11254 self.exitRule() 

11255 return localctx 

11256 

11257 

11258 class Default_DEFAULT__valueContext(ParserRuleContext): 

11259 

11260 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

11261 super().__init__(parent, invokingState) 

11262 self.parser = parser 

11263 

11264 def COMMA(self): 

11265 return self.getToken(SQLiteParser.COMMA, 0) 

11266 

11267 def signed_number(self): 

11268 return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,0) 

11269 

11270 

11271 def getRuleIndex(self): 

11272 return SQLiteParser.RULE_default_DEFAULT__value 

11273 

11274 def enterRule(self, listener:ParseTreeListener): 

11275 if hasattr( listener, "enterDefault_DEFAULT__value" ): 

11276 listener.enterDefault_DEFAULT__value(self) 

11277 

11278 def exitRule(self, listener:ParseTreeListener): 

11279 if hasattr( listener, "exitDefault_DEFAULT__value" ): 

11280 listener.exitDefault_DEFAULT__value(self) 

11281 

11282 

11283 

11284 

11285 def default_DEFAULT__value(self): 

11286 

11287 localctx = SQLiteParser.Default_DEFAULT__valueContext(self, self._ctx, self.state) 

11288 self.enterRule(localctx, 148, self.RULE_default_DEFAULT__value) 

11289 try: 

11290 self.enterOuterAlt(localctx, 1) 

11291 self.state = 1932 

11292 self.match(SQLiteParser.COMMA) 

11293 self.state = 1933 

11294 self.signed_number() 

11295 except RecognitionException as re: 

11296 localctx.exception = re 

11297 self._errHandler.reportError(self, re) 

11298 self._errHandler.recover(self, re) 

11299 finally: 

11300 self.exitRule() 

11301 return localctx 

11302 

11303 

11304 class Partition_byContext(ParserRuleContext): 

11305 

11306 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

11307 super().__init__(parent, invokingState) 

11308 self.parser = parser 

11309 

11310 def PARTITION_(self): 

11311 return self.getToken(SQLiteParser.PARTITION_, 0) 

11312 

11313 def BY_(self): 

11314 return self.getToken(SQLiteParser.BY_, 0) 

11315 

11316 def expr(self, i:int=None): 

11317 if i is None: 

11318 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

11319 else: 

11320 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

11321 

11322 

11323 def getRuleIndex(self): 

11324 return SQLiteParser.RULE_partition_by 

11325 

11326 def enterRule(self, listener:ParseTreeListener): 

11327 if hasattr( listener, "enterPartition_by" ): 

11328 listener.enterPartition_by(self) 

11329 

11330 def exitRule(self, listener:ParseTreeListener): 

11331 if hasattr( listener, "exitPartition_by" ): 

11332 listener.exitPartition_by(self) 

11333 

11334 

11335 

11336 

11337 def partition_by(self): 

11338 

11339 localctx = SQLiteParser.Partition_byContext(self, self._ctx, self.state) 

11340 self.enterRule(localctx, 150, self.RULE_partition_by) 

11341 try: 

11342 self.enterOuterAlt(localctx, 1) 

11343 self.state = 1935 

11344 self.match(SQLiteParser.PARTITION_) 

11345 self.state = 1936 

11346 self.match(SQLiteParser.BY_) 

11347 self.state = 1938 

11348 self._errHandler.sync(self) 

11349 _alt = 1 

11350 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: 

11351 if _alt == 1: 

11352 self.state = 1937 

11353 self.expr(0) 

11354 

11355 else: 

11356 raise NoViableAltException(self) 

11357 self.state = 1940 

11358 self._errHandler.sync(self) 

11359 _alt = self._interp.adaptivePredict(self._input,281,self._ctx) 

11360 

11361 except RecognitionException as re: 

11362 localctx.exception = re 

11363 self._errHandler.reportError(self, re) 

11364 self._errHandler.recover(self, re) 

11365 finally: 

11366 self.exitRule() 

11367 return localctx 

11368 

11369 

11370 class Order_by_exprContext(ParserRuleContext): 

11371 

11372 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

11373 super().__init__(parent, invokingState) 

11374 self.parser = parser 

11375 

11376 def ORDER_(self): 

11377 return self.getToken(SQLiteParser.ORDER_, 0) 

11378 

11379 def BY_(self): 

11380 return self.getToken(SQLiteParser.BY_, 0) 

11381 

11382 def expr(self, i:int=None): 

11383 if i is None: 

11384 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

11385 else: 

11386 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

11387 

11388 

11389 def getRuleIndex(self): 

11390 return SQLiteParser.RULE_order_by_expr 

11391 

11392 def enterRule(self, listener:ParseTreeListener): 

11393 if hasattr( listener, "enterOrder_by_expr" ): 

11394 listener.enterOrder_by_expr(self) 

11395 

11396 def exitRule(self, listener:ParseTreeListener): 

11397 if hasattr( listener, "exitOrder_by_expr" ): 

11398 listener.exitOrder_by_expr(self) 

11399 

11400 

11401 

11402 

11403 def order_by_expr(self): 

11404 

11405 localctx = SQLiteParser.Order_by_exprContext(self, self._ctx, self.state) 

11406 self.enterRule(localctx, 152, self.RULE_order_by_expr) 

11407 self._la = 0 # Token type 

11408 try: 

11409 self.enterOuterAlt(localctx, 1) 

11410 self.state = 1942 

11411 self.match(SQLiteParser.ORDER_) 

11412 self.state = 1943 

11413 self.match(SQLiteParser.BY_) 

11414 self.state = 1945 

11415 self._errHandler.sync(self) 

11416 _la = self._input.LA(1) 

11417 while True: 

11418 self.state = 1944 

11419 self.expr(0) 

11420 self.state = 1947 

11421 self._errHandler.sync(self) 

11422 _la = self._input.LA(1) 

11423 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.OPEN_PAR) | (1 << SQLiteParser.PLUS) | (1 << SQLiteParser.MINUS) | (1 << SQLiteParser.TILDE) | (1 << SQLiteParser.ABORT_) | (1 << SQLiteParser.ACTION_) | (1 << SQLiteParser.ADD_) | (1 << SQLiteParser.AFTER_) | (1 << SQLiteParser.ALL_) | (1 << SQLiteParser.ALTER_) | (1 << SQLiteParser.ANALYZE_) | (1 << SQLiteParser.AND_) | (1 << SQLiteParser.AS_) | (1 << SQLiteParser.ASC_) | (1 << SQLiteParser.ATTACH_) | (1 << SQLiteParser.AUTOINCREMENT_) | (1 << SQLiteParser.BEFORE_) | (1 << SQLiteParser.BEGIN_) | (1 << SQLiteParser.BETWEEN_) | (1 << SQLiteParser.BY_) | (1 << SQLiteParser.CASCADE_) | (1 << SQLiteParser.CASE_) | (1 << SQLiteParser.CAST_) | (1 << SQLiteParser.CHECK_) | (1 << SQLiteParser.COLLATE_) | (1 << SQLiteParser.COLUMN_) | (1 << SQLiteParser.COMMIT_) | (1 << SQLiteParser.CONFLICT_) | (1 << SQLiteParser.CONSTRAINT_) | (1 << SQLiteParser.CREATE_) | (1 << SQLiteParser.CROSS_) | (1 << SQLiteParser.CURRENT_DATE_) | (1 << SQLiteParser.CURRENT_TIME_) | (1 << SQLiteParser.CURRENT_TIMESTAMP_) | (1 << SQLiteParser.DATABASE_) | (1 << SQLiteParser.DEFAULT_) | (1 << SQLiteParser.DEFERRABLE_) | (1 << SQLiteParser.DEFERRED_) | (1 << SQLiteParser.DELETE_) | (1 << SQLiteParser.DESC_) | (1 << SQLiteParser.DETACH_) | (1 << SQLiteParser.DISTINCT_) | (1 << SQLiteParser.DROP_))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SQLiteParser.EACH_ - 64)) | (1 << (SQLiteParser.ELSE_ - 64)) | (1 << (SQLiteParser.END_ - 64)) | (1 << (SQLiteParser.ESCAPE_ - 64)) | (1 << (SQLiteParser.EXCEPT_ - 64)) | (1 << (SQLiteParser.EXCLUSIVE_ - 64)) | (1 << (SQLiteParser.EXISTS_ - 64)) | (1 << (SQLiteParser.EXPLAIN_ - 64)) | (1 << (SQLiteParser.FAIL_ - 64)) | (1 << (SQLiteParser.FOR_ - 64)) | (1 << (SQLiteParser.FOREIGN_ - 64)) | (1 << (SQLiteParser.FROM_ - 64)) | (1 << (SQLiteParser.FULL_ - 64)) | (1 << (SQLiteParser.GLOB_ - 64)) | (1 << (SQLiteParser.GROUP_ - 64)) | (1 << (SQLiteParser.HAVING_ - 64)) | (1 << (SQLiteParser.IF_ - 64)) | (1 << (SQLiteParser.IGNORE_ - 64)) | (1 << (SQLiteParser.IMMEDIATE_ - 64)) | (1 << (SQLiteParser.IN_ - 64)) | (1 << (SQLiteParser.INDEX_ - 64)) | (1 << (SQLiteParser.INDEXED_ - 64)) | (1 << (SQLiteParser.INITIALLY_ - 64)) | (1 << (SQLiteParser.INNER_ - 64)) | (1 << (SQLiteParser.INSERT_ - 64)) | (1 << (SQLiteParser.INSTEAD_ - 64)) | (1 << (SQLiteParser.INTERSECT_ - 64)) | (1 << (SQLiteParser.INTO_ - 64)) | (1 << (SQLiteParser.IS_ - 64)) | (1 << (SQLiteParser.ISNULL_ - 64)) | (1 << (SQLiteParser.JOIN_ - 64)) | (1 << (SQLiteParser.KEY_ - 64)) | (1 << (SQLiteParser.LEFT_ - 64)) | (1 << (SQLiteParser.LIKE_ - 64)) | (1 << (SQLiteParser.LIMIT_ - 64)) | (1 << (SQLiteParser.MATCH_ - 64)) | (1 << (SQLiteParser.NATURAL_ - 64)) | (1 << (SQLiteParser.NO_ - 64)) | (1 << (SQLiteParser.NOT_ - 64)) | (1 << (SQLiteParser.NOTNULL_ - 64)) | (1 << (SQLiteParser.NULL_ - 64)) | (1 << (SQLiteParser.OF_ - 64)) | (1 << (SQLiteParser.OFFSET_ - 64)) | (1 << (SQLiteParser.ON_ - 64)) | (1 << (SQLiteParser.OR_ - 64)) | (1 << (SQLiteParser.ORDER_ - 64)) | (1 << (SQLiteParser.OUTER_ - 64)) | (1 << (SQLiteParser.PLAN_ - 64)) | (1 << (SQLiteParser.PRAGMA_ - 64)) | (1 << (SQLiteParser.PRIMARY_ - 64)) | (1 << (SQLiteParser.QUERY_ - 64)) | (1 << (SQLiteParser.RAISE_ - 64)) | (1 << (SQLiteParser.RECURSIVE_ - 64)) | (1 << (SQLiteParser.REFERENCES_ - 64)) | (1 << (SQLiteParser.REGEXP_ - 64)) | (1 << (SQLiteParser.REINDEX_ - 64)) | (1 << (SQLiteParser.RELEASE_ - 64)) | (1 << (SQLiteParser.RENAME_ - 64)) | (1 << (SQLiteParser.REPLACE_ - 64)) | (1 << (SQLiteParser.RESTRICT_ - 64)) | (1 << (SQLiteParser.RIGHT_ - 64)) | (1 << (SQLiteParser.ROLLBACK_ - 64)) | (1 << (SQLiteParser.ROW_ - 64)) | (1 << (SQLiteParser.ROWS_ - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SQLiteParser.SAVEPOINT_ - 128)) | (1 << (SQLiteParser.SELECT_ - 128)) | (1 << (SQLiteParser.SET_ - 128)) | (1 << (SQLiteParser.TABLE_ - 128)) | (1 << (SQLiteParser.TEMP_ - 128)) | (1 << (SQLiteParser.TEMPORARY_ - 128)) | (1 << (SQLiteParser.THEN_ - 128)) | (1 << (SQLiteParser.TO_ - 128)) | (1 << (SQLiteParser.TRANSACTION_ - 128)) | (1 << (SQLiteParser.TRIGGER_ - 128)) | (1 << (SQLiteParser.UNION_ - 128)) | (1 << (SQLiteParser.UNIQUE_ - 128)) | (1 << (SQLiteParser.UPDATE_ - 128)) | (1 << (SQLiteParser.USING_ - 128)) | (1 << (SQLiteParser.VACUUM_ - 128)) | (1 << (SQLiteParser.VALUES_ - 128)) | (1 << (SQLiteParser.VIEW_ - 128)) | (1 << (SQLiteParser.VIRTUAL_ - 128)) | (1 << (SQLiteParser.WHEN_ - 128)) | (1 << (SQLiteParser.WHERE_ - 128)) | (1 << (SQLiteParser.WITH_ - 128)) | (1 << (SQLiteParser.WITHOUT_ - 128)) | (1 << (SQLiteParser.FIRST_VALUE_ - 128)) | (1 << (SQLiteParser.OVER_ - 128)) | (1 << (SQLiteParser.PARTITION_ - 128)) | (1 << (SQLiteParser.RANGE_ - 128)) | (1 << (SQLiteParser.PRECEDING_ - 128)) | (1 << (SQLiteParser.UNBOUNDED_ - 128)) | (1 << (SQLiteParser.CURRENT_ - 128)) | (1 << (SQLiteParser.FOLLOWING_ - 128)) | (1 << (SQLiteParser.CUME_DIST_ - 128)) | (1 << (SQLiteParser.DENSE_RANK_ - 128)) | (1 << (SQLiteParser.LAG_ - 128)) | (1 << (SQLiteParser.LAST_VALUE_ - 128)) | (1 << (SQLiteParser.LEAD_ - 128)) | (1 << (SQLiteParser.NTH_VALUE_ - 128)) | (1 << (SQLiteParser.NTILE_ - 128)) | (1 << (SQLiteParser.PERCENT_RANK_ - 128)) | (1 << (SQLiteParser.RANK_ - 128)) | (1 << (SQLiteParser.ROW_NUMBER_ - 128)) | (1 << (SQLiteParser.GENERATED_ - 128)) | (1 << (SQLiteParser.ALWAYS_ - 128)) | (1 << (SQLiteParser.STORED_ - 128)) | (1 << (SQLiteParser.TRUE_ - 128)) | (1 << (SQLiteParser.FALSE_ - 128)) | (1 << (SQLiteParser.WINDOW_ - 128)) | (1 << (SQLiteParser.NULLS_ - 128)) | (1 << (SQLiteParser.FIRST_ - 128)) | (1 << (SQLiteParser.LAST_ - 128)) | (1 << (SQLiteParser.FILTER_ - 128)) | (1 << (SQLiteParser.GROUPS_ - 128)) | (1 << (SQLiteParser.EXCLUDE_ - 128)) | (1 << (SQLiteParser.IDENTIFIER - 128)) | (1 << (SQLiteParser.NUMERIC_LITERAL - 128)) | (1 << (SQLiteParser.BIND_PARAMETER - 128)) | (1 << (SQLiteParser.STRING_LITERAL - 128)) | (1 << (SQLiteParser.BLOB_LITERAL - 128)))) != 0)): 

11424 break 

11425 

11426 except RecognitionException as re: 

11427 localctx.exception = re 

11428 self._errHandler.reportError(self, re) 

11429 self._errHandler.recover(self, re) 

11430 finally: 

11431 self.exitRule() 

11432 return localctx 

11433 

11434 

11435 class Order_by_expr_asc_descContext(ParserRuleContext): 

11436 

11437 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

11438 super().__init__(parent, invokingState) 

11439 self.parser = parser 

11440 

11441 def ORDER_(self): 

11442 return self.getToken(SQLiteParser.ORDER_, 0) 

11443 

11444 def BY_(self): 

11445 return self.getToken(SQLiteParser.BY_, 0) 

11446 

11447 def order_by_expr_asc_desc(self): 

11448 return self.getTypedRuleContext(SQLiteParser.Order_by_expr_asc_descContext,0) 

11449 

11450 

11451 def getRuleIndex(self): 

11452 return SQLiteParser.RULE_order_by_expr_asc_desc 

11453 

11454 def enterRule(self, listener:ParseTreeListener): 

11455 if hasattr( listener, "enterOrder_by_expr_asc_desc" ): 

11456 listener.enterOrder_by_expr_asc_desc(self) 

11457 

11458 def exitRule(self, listener:ParseTreeListener): 

11459 if hasattr( listener, "exitOrder_by_expr_asc_desc" ): 

11460 listener.exitOrder_by_expr_asc_desc(self) 

11461 

11462 

11463 

11464 

11465 def order_by_expr_asc_desc(self): 

11466 

11467 localctx = SQLiteParser.Order_by_expr_asc_descContext(self, self._ctx, self.state) 

11468 self.enterRule(localctx, 154, self.RULE_order_by_expr_asc_desc) 

11469 try: 

11470 self.enterOuterAlt(localctx, 1) 

11471 self.state = 1949 

11472 self.match(SQLiteParser.ORDER_) 

11473 self.state = 1950 

11474 self.match(SQLiteParser.BY_) 

11475 self.state = 1951 

11476 self.order_by_expr_asc_desc() 

11477 except RecognitionException as re: 

11478 localctx.exception = re 

11479 self._errHandler.reportError(self, re) 

11480 self._errHandler.recover(self, re) 

11481 finally: 

11482 self.exitRule() 

11483 return localctx 

11484 

11485 

11486 class Expr_asc_descContext(ParserRuleContext): 

11487 

11488 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

11489 super().__init__(parent, invokingState) 

11490 self.parser = parser 

11491 

11492 def expr(self, i:int=None): 

11493 if i is None: 

11494 return self.getTypedRuleContexts(SQLiteParser.ExprContext) 

11495 else: 

11496 return self.getTypedRuleContext(SQLiteParser.ExprContext,i) 

11497 

11498 

11499 def asc_desc(self, i:int=None): 

11500 if i is None: 

11501 return self.getTypedRuleContexts(SQLiteParser.Asc_descContext) 

11502 else: 

11503 return self.getTypedRuleContext(SQLiteParser.Asc_descContext,i) 

11504 

11505 

11506 def COMMA(self, i:int=None): 

11507 if i is None: 

11508 return self.getTokens(SQLiteParser.COMMA) 

11509 else: 

11510 return self.getToken(SQLiteParser.COMMA, i) 

11511 

11512 def getRuleIndex(self): 

11513 return SQLiteParser.RULE_expr_asc_desc 

11514 

11515 def enterRule(self, listener:ParseTreeListener): 

11516 if hasattr( listener, "enterExpr_asc_desc" ): 

11517 listener.enterExpr_asc_desc(self) 

11518 

11519 def exitRule(self, listener:ParseTreeListener): 

11520 if hasattr( listener, "exitExpr_asc_desc" ): 

11521 listener.exitExpr_asc_desc(self) 

11522 

11523 

11524 

11525 

11526 def expr_asc_desc(self): 

11527 

11528 localctx = SQLiteParser.Expr_asc_descContext(self, self._ctx, self.state) 

11529 self.enterRule(localctx, 156, self.RULE_expr_asc_desc) 

11530 self._la = 0 # Token type 

11531 try: 

11532 self.enterOuterAlt(localctx, 1) 

11533 self.state = 1953 

11534 self.expr(0) 

11535 self.state = 1955 

11536 self._errHandler.sync(self) 

11537 _la = self._input.LA(1) 

11538 if _la==SQLiteParser.ASC_ or _la==SQLiteParser.DESC_: 

11539 self.state = 1954 

11540 self.asc_desc() 

11541 

11542 

11543 self.state = 1964 

11544 self._errHandler.sync(self) 

11545 _la = self._input.LA(1) 

11546 while _la==SQLiteParser.COMMA: 

11547 self.state = 1957 

11548 self.match(SQLiteParser.COMMA) 

11549 self.state = 1958 

11550 self.expr(0) 

11551 self.state = 1960 

11552 self._errHandler.sync(self) 

11553 _la = self._input.LA(1) 

11554 if _la==SQLiteParser.ASC_ or _la==SQLiteParser.DESC_: 

11555 self.state = 1959 

11556 self.asc_desc() 

11557 

11558 

11559 self.state = 1966 

11560 self._errHandler.sync(self) 

11561 _la = self._input.LA(1) 

11562 

11563 except RecognitionException as re: 

11564 localctx.exception = re 

11565 self._errHandler.reportError(self, re) 

11566 self._errHandler.recover(self, re) 

11567 finally: 

11568 self.exitRule() 

11569 return localctx 

11570 

11571 

11572 class Initial_selectContext(ParserRuleContext): 

11573 

11574 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

11575 super().__init__(parent, invokingState) 

11576 self.parser = parser 

11577 

11578 def select_stmt(self): 

11579 return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0) 

11580 

11581 

11582 def getRuleIndex(self): 

11583 return SQLiteParser.RULE_initial_select 

11584 

11585 def enterRule(self, listener:ParseTreeListener): 

11586 if hasattr( listener, "enterInitial_select" ): 

11587 listener.enterInitial_select(self) 

11588 

11589 def exitRule(self, listener:ParseTreeListener): 

11590 if hasattr( listener, "exitInitial_select" ): 

11591 listener.exitInitial_select(self) 

11592 

11593 

11594 

11595 

11596 def initial_select(self): 

11597 

11598 localctx = SQLiteParser.Initial_selectContext(self, self._ctx, self.state) 

11599 self.enterRule(localctx, 158, self.RULE_initial_select) 

11600 try: 

11601 self.enterOuterAlt(localctx, 1) 

11602 self.state = 1967 

11603 self.select_stmt() 

11604 except RecognitionException as re: 

11605 localctx.exception = re 

11606 self._errHandler.reportError(self, re) 

11607 self._errHandler.recover(self, re) 

11608 finally: 

11609 self.exitRule() 

11610 return localctx 

11611 

11612 

11613 class Recursive__selectContext(ParserRuleContext): 

11614 

11615 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

11616 super().__init__(parent, invokingState) 

11617 self.parser = parser 

11618 

11619 def select_stmt(self): 

11620 return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0) 

11621 

11622 

11623 def getRuleIndex(self): 

11624 return SQLiteParser.RULE_recursive__select 

11625 

11626 def enterRule(self, listener:ParseTreeListener): 

11627 if hasattr( listener, "enterRecursive__select" ): 

11628 listener.enterRecursive__select(self) 

11629 

11630 def exitRule(self, listener:ParseTreeListener): 

11631 if hasattr( listener, "exitRecursive__select" ): 

11632 listener.exitRecursive__select(self) 

11633 

11634 

11635 

11636 

11637 def recursive__select(self): 

11638 

11639 localctx = SQLiteParser.Recursive__selectContext(self, self._ctx, self.state) 

11640 self.enterRule(localctx, 160, self.RULE_recursive__select) 

11641 try: 

11642 self.enterOuterAlt(localctx, 1) 

11643 self.state = 1969 

11644 self.select_stmt() 

11645 except RecognitionException as re: 

11646 localctx.exception = re 

11647 self._errHandler.reportError(self, re) 

11648 self._errHandler.recover(self, re) 

11649 finally: 

11650 self.exitRule() 

11651 return localctx 

11652 

11653 

11654 class Unary_operatorContext(ParserRuleContext): 

11655 

11656 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

11657 super().__init__(parent, invokingState) 

11658 self.parser = parser 

11659 

11660 def MINUS(self): 

11661 return self.getToken(SQLiteParser.MINUS, 0) 

11662 

11663 def PLUS(self): 

11664 return self.getToken(SQLiteParser.PLUS, 0) 

11665 

11666 def TILDE(self): 

11667 return self.getToken(SQLiteParser.TILDE, 0) 

11668 

11669 def NOT_(self): 

11670 return self.getToken(SQLiteParser.NOT_, 0) 

11671 

11672 def getRuleIndex(self): 

11673 return SQLiteParser.RULE_unary_operator 

11674 

11675 def enterRule(self, listener:ParseTreeListener): 

11676 if hasattr( listener, "enterUnary_operator" ): 

11677 listener.enterUnary_operator(self) 

11678 

11679 def exitRule(self, listener:ParseTreeListener): 

11680 if hasattr( listener, "exitUnary_operator" ): 

11681 listener.exitUnary_operator(self) 

11682 

11683 

11684 

11685 

11686 def unary_operator(self): 

11687 

11688 localctx = SQLiteParser.Unary_operatorContext(self, self._ctx, self.state) 

11689 self.enterRule(localctx, 162, self.RULE_unary_operator) 

11690 self._la = 0 # Token type 

11691 try: 

11692 self.enterOuterAlt(localctx, 1) 

11693 self.state = 1971 

11694 _la = self._input.LA(1) 

11695 if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.PLUS) | (1 << SQLiteParser.MINUS) | (1 << SQLiteParser.TILDE))) != 0) or _la==SQLiteParser.NOT_): 

11696 self._errHandler.recoverInline(self) 

11697 else: 

11698 self._errHandler.reportMatch(self) 

11699 self.consume() 

11700 except RecognitionException as re: 

11701 localctx.exception = re 

11702 self._errHandler.reportError(self, re) 

11703 self._errHandler.recover(self, re) 

11704 finally: 

11705 self.exitRule() 

11706 return localctx 

11707 

11708 

11709 class Error_messageContext(ParserRuleContext): 

11710 

11711 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

11712 super().__init__(parent, invokingState) 

11713 self.parser = parser 

11714 

11715 def STRING_LITERAL(self): 

11716 return self.getToken(SQLiteParser.STRING_LITERAL, 0) 

11717 

11718 def getRuleIndex(self): 

11719 return SQLiteParser.RULE_error_message 

11720 

11721 def enterRule(self, listener:ParseTreeListener): 

11722 if hasattr( listener, "enterError_message" ): 

11723 listener.enterError_message(self) 

11724 

11725 def exitRule(self, listener:ParseTreeListener): 

11726 if hasattr( listener, "exitError_message" ): 

11727 listener.exitError_message(self) 

11728 

11729 

11730 

11731 

11732 def error_message(self): 

11733 

11734 localctx = SQLiteParser.Error_messageContext(self, self._ctx, self.state) 

11735 self.enterRule(localctx, 164, self.RULE_error_message) 

11736 try: 

11737 self.enterOuterAlt(localctx, 1) 

11738 self.state = 1973 

11739 self.match(SQLiteParser.STRING_LITERAL) 

11740 except RecognitionException as re: 

11741 localctx.exception = re 

11742 self._errHandler.reportError(self, re) 

11743 self._errHandler.recover(self, re) 

11744 finally: 

11745 self.exitRule() 

11746 return localctx 

11747 

11748 

11749 class Module_argumentContext(ParserRuleContext): 

11750 

11751 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

11752 super().__init__(parent, invokingState) 

11753 self.parser = parser 

11754 

11755 def expr(self): 

11756 return self.getTypedRuleContext(SQLiteParser.ExprContext,0) 

11757 

11758 

11759 def column_def(self): 

11760 return self.getTypedRuleContext(SQLiteParser.Column_defContext,0) 

11761 

11762 

11763 def getRuleIndex(self): 

11764 return SQLiteParser.RULE_module_argument 

11765 

11766 def enterRule(self, listener:ParseTreeListener): 

11767 if hasattr( listener, "enterModule_argument" ): 

11768 listener.enterModule_argument(self) 

11769 

11770 def exitRule(self, listener:ParseTreeListener): 

11771 if hasattr( listener, "exitModule_argument" ): 

11772 listener.exitModule_argument(self) 

11773 

11774 

11775 

11776 

11777 def module_argument(self): 

11778 

11779 localctx = SQLiteParser.Module_argumentContext(self, self._ctx, self.state) 

11780 self.enterRule(localctx, 166, self.RULE_module_argument) 

11781 try: 

11782 self.state = 1977 

11783 self._errHandler.sync(self) 

11784 la_ = self._interp.adaptivePredict(self._input,286,self._ctx) 

11785 if la_ == 1: 

11786 self.enterOuterAlt(localctx, 1) 

11787 self.state = 1975 

11788 self.expr(0) 

11789 pass 

11790 

11791 elif la_ == 2: 

11792 self.enterOuterAlt(localctx, 2) 

11793 self.state = 1976 

11794 self.column_def() 

11795 pass 

11796 

11797 

11798 except RecognitionException as re: 

11799 localctx.exception = re 

11800 self._errHandler.reportError(self, re) 

11801 self._errHandler.recover(self, re) 

11802 finally: 

11803 self.exitRule() 

11804 return localctx 

11805 

11806 

11807 class Column_aliasContext(ParserRuleContext): 

11808 

11809 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

11810 super().__init__(parent, invokingState) 

11811 self.parser = parser 

11812 

11813 def IDENTIFIER(self): 

11814 return self.getToken(SQLiteParser.IDENTIFIER, 0) 

11815 

11816 def STRING_LITERAL(self): 

11817 return self.getToken(SQLiteParser.STRING_LITERAL, 0) 

11818 

11819 def getRuleIndex(self): 

11820 return SQLiteParser.RULE_column_alias 

11821 

11822 def enterRule(self, listener:ParseTreeListener): 

11823 if hasattr( listener, "enterColumn_alias" ): 

11824 listener.enterColumn_alias(self) 

11825 

11826 def exitRule(self, listener:ParseTreeListener): 

11827 if hasattr( listener, "exitColumn_alias" ): 

11828 listener.exitColumn_alias(self) 

11829 

11830 

11831 

11832 

11833 def column_alias(self): 

11834 

11835 localctx = SQLiteParser.Column_aliasContext(self, self._ctx, self.state) 

11836 self.enterRule(localctx, 168, self.RULE_column_alias) 

11837 self._la = 0 # Token type 

11838 try: 

11839 self.enterOuterAlt(localctx, 1) 

11840 self.state = 1979 

11841 _la = self._input.LA(1) 

11842 if not(_la==SQLiteParser.IDENTIFIER or _la==SQLiteParser.STRING_LITERAL): 

11843 self._errHandler.recoverInline(self) 

11844 else: 

11845 self._errHandler.reportMatch(self) 

11846 self.consume() 

11847 except RecognitionException as re: 

11848 localctx.exception = re 

11849 self._errHandler.reportError(self, re) 

11850 self._errHandler.recover(self, re) 

11851 finally: 

11852 self.exitRule() 

11853 return localctx 

11854 

11855 

11856 class KeywordContext(ParserRuleContext): 

11857 

11858 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

11859 super().__init__(parent, invokingState) 

11860 self.parser = parser 

11861 

11862 def ABORT_(self): 

11863 return self.getToken(SQLiteParser.ABORT_, 0) 

11864 

11865 def ACTION_(self): 

11866 return self.getToken(SQLiteParser.ACTION_, 0) 

11867 

11868 def ADD_(self): 

11869 return self.getToken(SQLiteParser.ADD_, 0) 

11870 

11871 def AFTER_(self): 

11872 return self.getToken(SQLiteParser.AFTER_, 0) 

11873 

11874 def ALL_(self): 

11875 return self.getToken(SQLiteParser.ALL_, 0) 

11876 

11877 def ALTER_(self): 

11878 return self.getToken(SQLiteParser.ALTER_, 0) 

11879 

11880 def ANALYZE_(self): 

11881 return self.getToken(SQLiteParser.ANALYZE_, 0) 

11882 

11883 def AND_(self): 

11884 return self.getToken(SQLiteParser.AND_, 0) 

11885 

11886 def AS_(self): 

11887 return self.getToken(SQLiteParser.AS_, 0) 

11888 

11889 def ASC_(self): 

11890 return self.getToken(SQLiteParser.ASC_, 0) 

11891 

11892 def ATTACH_(self): 

11893 return self.getToken(SQLiteParser.ATTACH_, 0) 

11894 

11895 def AUTOINCREMENT_(self): 

11896 return self.getToken(SQLiteParser.AUTOINCREMENT_, 0) 

11897 

11898 def BEFORE_(self): 

11899 return self.getToken(SQLiteParser.BEFORE_, 0) 

11900 

11901 def BEGIN_(self): 

11902 return self.getToken(SQLiteParser.BEGIN_, 0) 

11903 

11904 def BETWEEN_(self): 

11905 return self.getToken(SQLiteParser.BETWEEN_, 0) 

11906 

11907 def BY_(self): 

11908 return self.getToken(SQLiteParser.BY_, 0) 

11909 

11910 def CASCADE_(self): 

11911 return self.getToken(SQLiteParser.CASCADE_, 0) 

11912 

11913 def CASE_(self): 

11914 return self.getToken(SQLiteParser.CASE_, 0) 

11915 

11916 def CAST_(self): 

11917 return self.getToken(SQLiteParser.CAST_, 0) 

11918 

11919 def CHECK_(self): 

11920 return self.getToken(SQLiteParser.CHECK_, 0) 

11921 

11922 def COLLATE_(self): 

11923 return self.getToken(SQLiteParser.COLLATE_, 0) 

11924 

11925 def COLUMN_(self): 

11926 return self.getToken(SQLiteParser.COLUMN_, 0) 

11927 

11928 def COMMIT_(self): 

11929 return self.getToken(SQLiteParser.COMMIT_, 0) 

11930 

11931 def CONFLICT_(self): 

11932 return self.getToken(SQLiteParser.CONFLICT_, 0) 

11933 

11934 def CONSTRAINT_(self): 

11935 return self.getToken(SQLiteParser.CONSTRAINT_, 0) 

11936 

11937 def CREATE_(self): 

11938 return self.getToken(SQLiteParser.CREATE_, 0) 

11939 

11940 def CROSS_(self): 

11941 return self.getToken(SQLiteParser.CROSS_, 0) 

11942 

11943 def CURRENT_DATE_(self): 

11944 return self.getToken(SQLiteParser.CURRENT_DATE_, 0) 

11945 

11946 def CURRENT_TIME_(self): 

11947 return self.getToken(SQLiteParser.CURRENT_TIME_, 0) 

11948 

11949 def CURRENT_TIMESTAMP_(self): 

11950 return self.getToken(SQLiteParser.CURRENT_TIMESTAMP_, 0) 

11951 

11952 def DATABASE_(self): 

11953 return self.getToken(SQLiteParser.DATABASE_, 0) 

11954 

11955 def DEFAULT_(self): 

11956 return self.getToken(SQLiteParser.DEFAULT_, 0) 

11957 

11958 def DEFERRABLE_(self): 

11959 return self.getToken(SQLiteParser.DEFERRABLE_, 0) 

11960 

11961 def DEFERRED_(self): 

11962 return self.getToken(SQLiteParser.DEFERRED_, 0) 

11963 

11964 def DELETE_(self): 

11965 return self.getToken(SQLiteParser.DELETE_, 0) 

11966 

11967 def DESC_(self): 

11968 return self.getToken(SQLiteParser.DESC_, 0) 

11969 

11970 def DETACH_(self): 

11971 return self.getToken(SQLiteParser.DETACH_, 0) 

11972 

11973 def DISTINCT_(self): 

11974 return self.getToken(SQLiteParser.DISTINCT_, 0) 

11975 

11976 def DROP_(self): 

11977 return self.getToken(SQLiteParser.DROP_, 0) 

11978 

11979 def EACH_(self): 

11980 return self.getToken(SQLiteParser.EACH_, 0) 

11981 

11982 def ELSE_(self): 

11983 return self.getToken(SQLiteParser.ELSE_, 0) 

11984 

11985 def END_(self): 

11986 return self.getToken(SQLiteParser.END_, 0) 

11987 

11988 def ESCAPE_(self): 

11989 return self.getToken(SQLiteParser.ESCAPE_, 0) 

11990 

11991 def EXCEPT_(self): 

11992 return self.getToken(SQLiteParser.EXCEPT_, 0) 

11993 

11994 def EXCLUSIVE_(self): 

11995 return self.getToken(SQLiteParser.EXCLUSIVE_, 0) 

11996 

11997 def EXISTS_(self): 

11998 return self.getToken(SQLiteParser.EXISTS_, 0) 

11999 

12000 def EXPLAIN_(self): 

12001 return self.getToken(SQLiteParser.EXPLAIN_, 0) 

12002 

12003 def FAIL_(self): 

12004 return self.getToken(SQLiteParser.FAIL_, 0) 

12005 

12006 def FOR_(self): 

12007 return self.getToken(SQLiteParser.FOR_, 0) 

12008 

12009 def FOREIGN_(self): 

12010 return self.getToken(SQLiteParser.FOREIGN_, 0) 

12011 

12012 def FROM_(self): 

12013 return self.getToken(SQLiteParser.FROM_, 0) 

12014 

12015 def FULL_(self): 

12016 return self.getToken(SQLiteParser.FULL_, 0) 

12017 

12018 def GLOB_(self): 

12019 return self.getToken(SQLiteParser.GLOB_, 0) 

12020 

12021 def GROUP_(self): 

12022 return self.getToken(SQLiteParser.GROUP_, 0) 

12023 

12024 def HAVING_(self): 

12025 return self.getToken(SQLiteParser.HAVING_, 0) 

12026 

12027 def IF_(self): 

12028 return self.getToken(SQLiteParser.IF_, 0) 

12029 

12030 def IGNORE_(self): 

12031 return self.getToken(SQLiteParser.IGNORE_, 0) 

12032 

12033 def IMMEDIATE_(self): 

12034 return self.getToken(SQLiteParser.IMMEDIATE_, 0) 

12035 

12036 def IN_(self): 

12037 return self.getToken(SQLiteParser.IN_, 0) 

12038 

12039 def INDEX_(self): 

12040 return self.getToken(SQLiteParser.INDEX_, 0) 

12041 

12042 def INDEXED_(self): 

12043 return self.getToken(SQLiteParser.INDEXED_, 0) 

12044 

12045 def INITIALLY_(self): 

12046 return self.getToken(SQLiteParser.INITIALLY_, 0) 

12047 

12048 def INNER_(self): 

12049 return self.getToken(SQLiteParser.INNER_, 0) 

12050 

12051 def INSERT_(self): 

12052 return self.getToken(SQLiteParser.INSERT_, 0) 

12053 

12054 def INSTEAD_(self): 

12055 return self.getToken(SQLiteParser.INSTEAD_, 0) 

12056 

12057 def INTERSECT_(self): 

12058 return self.getToken(SQLiteParser.INTERSECT_, 0) 

12059 

12060 def INTO_(self): 

12061 return self.getToken(SQLiteParser.INTO_, 0) 

12062 

12063 def IS_(self): 

12064 return self.getToken(SQLiteParser.IS_, 0) 

12065 

12066 def ISNULL_(self): 

12067 return self.getToken(SQLiteParser.ISNULL_, 0) 

12068 

12069 def JOIN_(self): 

12070 return self.getToken(SQLiteParser.JOIN_, 0) 

12071 

12072 def KEY_(self): 

12073 return self.getToken(SQLiteParser.KEY_, 0) 

12074 

12075 def LEFT_(self): 

12076 return self.getToken(SQLiteParser.LEFT_, 0) 

12077 

12078 def LIKE_(self): 

12079 return self.getToken(SQLiteParser.LIKE_, 0) 

12080 

12081 def LIMIT_(self): 

12082 return self.getToken(SQLiteParser.LIMIT_, 0) 

12083 

12084 def MATCH_(self): 

12085 return self.getToken(SQLiteParser.MATCH_, 0) 

12086 

12087 def NATURAL_(self): 

12088 return self.getToken(SQLiteParser.NATURAL_, 0) 

12089 

12090 def NO_(self): 

12091 return self.getToken(SQLiteParser.NO_, 0) 

12092 

12093 def NOT_(self): 

12094 return self.getToken(SQLiteParser.NOT_, 0) 

12095 

12096 def NOTNULL_(self): 

12097 return self.getToken(SQLiteParser.NOTNULL_, 0) 

12098 

12099 def NULL_(self): 

12100 return self.getToken(SQLiteParser.NULL_, 0) 

12101 

12102 def OF_(self): 

12103 return self.getToken(SQLiteParser.OF_, 0) 

12104 

12105 def OFFSET_(self): 

12106 return self.getToken(SQLiteParser.OFFSET_, 0) 

12107 

12108 def ON_(self): 

12109 return self.getToken(SQLiteParser.ON_, 0) 

12110 

12111 def OR_(self): 

12112 return self.getToken(SQLiteParser.OR_, 0) 

12113 

12114 def ORDER_(self): 

12115 return self.getToken(SQLiteParser.ORDER_, 0) 

12116 

12117 def OUTER_(self): 

12118 return self.getToken(SQLiteParser.OUTER_, 0) 

12119 

12120 def PLAN_(self): 

12121 return self.getToken(SQLiteParser.PLAN_, 0) 

12122 

12123 def PRAGMA_(self): 

12124 return self.getToken(SQLiteParser.PRAGMA_, 0) 

12125 

12126 def PRIMARY_(self): 

12127 return self.getToken(SQLiteParser.PRIMARY_, 0) 

12128 

12129 def QUERY_(self): 

12130 return self.getToken(SQLiteParser.QUERY_, 0) 

12131 

12132 def RAISE_(self): 

12133 return self.getToken(SQLiteParser.RAISE_, 0) 

12134 

12135 def RECURSIVE_(self): 

12136 return self.getToken(SQLiteParser.RECURSIVE_, 0) 

12137 

12138 def REFERENCES_(self): 

12139 return self.getToken(SQLiteParser.REFERENCES_, 0) 

12140 

12141 def REGEXP_(self): 

12142 return self.getToken(SQLiteParser.REGEXP_, 0) 

12143 

12144 def REINDEX_(self): 

12145 return self.getToken(SQLiteParser.REINDEX_, 0) 

12146 

12147 def RELEASE_(self): 

12148 return self.getToken(SQLiteParser.RELEASE_, 0) 

12149 

12150 def RENAME_(self): 

12151 return self.getToken(SQLiteParser.RENAME_, 0) 

12152 

12153 def REPLACE_(self): 

12154 return self.getToken(SQLiteParser.REPLACE_, 0) 

12155 

12156 def RESTRICT_(self): 

12157 return self.getToken(SQLiteParser.RESTRICT_, 0) 

12158 

12159 def RIGHT_(self): 

12160 return self.getToken(SQLiteParser.RIGHT_, 0) 

12161 

12162 def ROLLBACK_(self): 

12163 return self.getToken(SQLiteParser.ROLLBACK_, 0) 

12164 

12165 def ROW_(self): 

12166 return self.getToken(SQLiteParser.ROW_, 0) 

12167 

12168 def ROWS_(self): 

12169 return self.getToken(SQLiteParser.ROWS_, 0) 

12170 

12171 def SAVEPOINT_(self): 

12172 return self.getToken(SQLiteParser.SAVEPOINT_, 0) 

12173 

12174 def SELECT_(self): 

12175 return self.getToken(SQLiteParser.SELECT_, 0) 

12176 

12177 def SET_(self): 

12178 return self.getToken(SQLiteParser.SET_, 0) 

12179 

12180 def TABLE_(self): 

12181 return self.getToken(SQLiteParser.TABLE_, 0) 

12182 

12183 def TEMP_(self): 

12184 return self.getToken(SQLiteParser.TEMP_, 0) 

12185 

12186 def TEMPORARY_(self): 

12187 return self.getToken(SQLiteParser.TEMPORARY_, 0) 

12188 

12189 def THEN_(self): 

12190 return self.getToken(SQLiteParser.THEN_, 0) 

12191 

12192 def TO_(self): 

12193 return self.getToken(SQLiteParser.TO_, 0) 

12194 

12195 def TRANSACTION_(self): 

12196 return self.getToken(SQLiteParser.TRANSACTION_, 0) 

12197 

12198 def TRIGGER_(self): 

12199 return self.getToken(SQLiteParser.TRIGGER_, 0) 

12200 

12201 def UNION_(self): 

12202 return self.getToken(SQLiteParser.UNION_, 0) 

12203 

12204 def UNIQUE_(self): 

12205 return self.getToken(SQLiteParser.UNIQUE_, 0) 

12206 

12207 def UPDATE_(self): 

12208 return self.getToken(SQLiteParser.UPDATE_, 0) 

12209 

12210 def USING_(self): 

12211 return self.getToken(SQLiteParser.USING_, 0) 

12212 

12213 def VACUUM_(self): 

12214 return self.getToken(SQLiteParser.VACUUM_, 0) 

12215 

12216 def VALUES_(self): 

12217 return self.getToken(SQLiteParser.VALUES_, 0) 

12218 

12219 def VIEW_(self): 

12220 return self.getToken(SQLiteParser.VIEW_, 0) 

12221 

12222 def VIRTUAL_(self): 

12223 return self.getToken(SQLiteParser.VIRTUAL_, 0) 

12224 

12225 def WHEN_(self): 

12226 return self.getToken(SQLiteParser.WHEN_, 0) 

12227 

12228 def WHERE_(self): 

12229 return self.getToken(SQLiteParser.WHERE_, 0) 

12230 

12231 def WITH_(self): 

12232 return self.getToken(SQLiteParser.WITH_, 0) 

12233 

12234 def WITHOUT_(self): 

12235 return self.getToken(SQLiteParser.WITHOUT_, 0) 

12236 

12237 def FIRST_VALUE_(self): 

12238 return self.getToken(SQLiteParser.FIRST_VALUE_, 0) 

12239 

12240 def OVER_(self): 

12241 return self.getToken(SQLiteParser.OVER_, 0) 

12242 

12243 def PARTITION_(self): 

12244 return self.getToken(SQLiteParser.PARTITION_, 0) 

12245 

12246 def RANGE_(self): 

12247 return self.getToken(SQLiteParser.RANGE_, 0) 

12248 

12249 def PRECEDING_(self): 

12250 return self.getToken(SQLiteParser.PRECEDING_, 0) 

12251 

12252 def UNBOUNDED_(self): 

12253 return self.getToken(SQLiteParser.UNBOUNDED_, 0) 

12254 

12255 def CURRENT_(self): 

12256 return self.getToken(SQLiteParser.CURRENT_, 0) 

12257 

12258 def FOLLOWING_(self): 

12259 return self.getToken(SQLiteParser.FOLLOWING_, 0) 

12260 

12261 def CUME_DIST_(self): 

12262 return self.getToken(SQLiteParser.CUME_DIST_, 0) 

12263 

12264 def DENSE_RANK_(self): 

12265 return self.getToken(SQLiteParser.DENSE_RANK_, 0) 

12266 

12267 def LAG_(self): 

12268 return self.getToken(SQLiteParser.LAG_, 0) 

12269 

12270 def LAST_VALUE_(self): 

12271 return self.getToken(SQLiteParser.LAST_VALUE_, 0) 

12272 

12273 def LEAD_(self): 

12274 return self.getToken(SQLiteParser.LEAD_, 0) 

12275 

12276 def NTH_VALUE_(self): 

12277 return self.getToken(SQLiteParser.NTH_VALUE_, 0) 

12278 

12279 def NTILE_(self): 

12280 return self.getToken(SQLiteParser.NTILE_, 0) 

12281 

12282 def PERCENT_RANK_(self): 

12283 return self.getToken(SQLiteParser.PERCENT_RANK_, 0) 

12284 

12285 def RANK_(self): 

12286 return self.getToken(SQLiteParser.RANK_, 0) 

12287 

12288 def ROW_NUMBER_(self): 

12289 return self.getToken(SQLiteParser.ROW_NUMBER_, 0) 

12290 

12291 def GENERATED_(self): 

12292 return self.getToken(SQLiteParser.GENERATED_, 0) 

12293 

12294 def ALWAYS_(self): 

12295 return self.getToken(SQLiteParser.ALWAYS_, 0) 

12296 

12297 def STORED_(self): 

12298 return self.getToken(SQLiteParser.STORED_, 0) 

12299 

12300 def TRUE_(self): 

12301 return self.getToken(SQLiteParser.TRUE_, 0) 

12302 

12303 def FALSE_(self): 

12304 return self.getToken(SQLiteParser.FALSE_, 0) 

12305 

12306 def WINDOW_(self): 

12307 return self.getToken(SQLiteParser.WINDOW_, 0) 

12308 

12309 def NULLS_(self): 

12310 return self.getToken(SQLiteParser.NULLS_, 0) 

12311 

12312 def FIRST_(self): 

12313 return self.getToken(SQLiteParser.FIRST_, 0) 

12314 

12315 def LAST_(self): 

12316 return self.getToken(SQLiteParser.LAST_, 0) 

12317 

12318 def FILTER_(self): 

12319 return self.getToken(SQLiteParser.FILTER_, 0) 

12320 

12321 def GROUPS_(self): 

12322 return self.getToken(SQLiteParser.GROUPS_, 0) 

12323 

12324 def EXCLUDE_(self): 

12325 return self.getToken(SQLiteParser.EXCLUDE_, 0) 

12326 

12327 def getRuleIndex(self): 

12328 return SQLiteParser.RULE_keyword 

12329 

12330 def enterRule(self, listener:ParseTreeListener): 

12331 if hasattr( listener, "enterKeyword" ): 

12332 listener.enterKeyword(self) 

12333 

12334 def exitRule(self, listener:ParseTreeListener): 

12335 if hasattr( listener, "exitKeyword" ): 

12336 listener.exitKeyword(self) 

12337 

12338 

12339 

12340 

12341 def keyword(self): 

12342 

12343 localctx = SQLiteParser.KeywordContext(self, self._ctx, self.state) 

12344 self.enterRule(localctx, 170, self.RULE_keyword) 

12345 self._la = 0 # Token type 

12346 try: 

12347 self.enterOuterAlt(localctx, 1) 

12348 self.state = 1981 

12349 _la = self._input.LA(1) 

12350 if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.ABORT_) | (1 << SQLiteParser.ACTION_) | (1 << SQLiteParser.ADD_) | (1 << SQLiteParser.AFTER_) | (1 << SQLiteParser.ALL_) | (1 << SQLiteParser.ALTER_) | (1 << SQLiteParser.ANALYZE_) | (1 << SQLiteParser.AND_) | (1 << SQLiteParser.AS_) | (1 << SQLiteParser.ASC_) | (1 << SQLiteParser.ATTACH_) | (1 << SQLiteParser.AUTOINCREMENT_) | (1 << SQLiteParser.BEFORE_) | (1 << SQLiteParser.BEGIN_) | (1 << SQLiteParser.BETWEEN_) | (1 << SQLiteParser.BY_) | (1 << SQLiteParser.CASCADE_) | (1 << SQLiteParser.CASE_) | (1 << SQLiteParser.CAST_) | (1 << SQLiteParser.CHECK_) | (1 << SQLiteParser.COLLATE_) | (1 << SQLiteParser.COLUMN_) | (1 << SQLiteParser.COMMIT_) | (1 << SQLiteParser.CONFLICT_) | (1 << SQLiteParser.CONSTRAINT_) | (1 << SQLiteParser.CREATE_) | (1 << SQLiteParser.CROSS_) | (1 << SQLiteParser.CURRENT_DATE_) | (1 << SQLiteParser.CURRENT_TIME_) | (1 << SQLiteParser.CURRENT_TIMESTAMP_) | (1 << SQLiteParser.DATABASE_) | (1 << SQLiteParser.DEFAULT_) | (1 << SQLiteParser.DEFERRABLE_) | (1 << SQLiteParser.DEFERRED_) | (1 << SQLiteParser.DELETE_) | (1 << SQLiteParser.DESC_) | (1 << SQLiteParser.DETACH_) | (1 << SQLiteParser.DISTINCT_) | (1 << SQLiteParser.DROP_))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (SQLiteParser.EACH_ - 64)) | (1 << (SQLiteParser.ELSE_ - 64)) | (1 << (SQLiteParser.END_ - 64)) | (1 << (SQLiteParser.ESCAPE_ - 64)) | (1 << (SQLiteParser.EXCEPT_ - 64)) | (1 << (SQLiteParser.EXCLUSIVE_ - 64)) | (1 << (SQLiteParser.EXISTS_ - 64)) | (1 << (SQLiteParser.EXPLAIN_ - 64)) | (1 << (SQLiteParser.FAIL_ - 64)) | (1 << (SQLiteParser.FOR_ - 64)) | (1 << (SQLiteParser.FOREIGN_ - 64)) | (1 << (SQLiteParser.FROM_ - 64)) | (1 << (SQLiteParser.FULL_ - 64)) | (1 << (SQLiteParser.GLOB_ - 64)) | (1 << (SQLiteParser.GROUP_ - 64)) | (1 << (SQLiteParser.HAVING_ - 64)) | (1 << (SQLiteParser.IF_ - 64)) | (1 << (SQLiteParser.IGNORE_ - 64)) | (1 << (SQLiteParser.IMMEDIATE_ - 64)) | (1 << (SQLiteParser.IN_ - 64)) | (1 << (SQLiteParser.INDEX_ - 64)) | (1 << (SQLiteParser.INDEXED_ - 64)) | (1 << (SQLiteParser.INITIALLY_ - 64)) | (1 << (SQLiteParser.INNER_ - 64)) | (1 << (SQLiteParser.INSERT_ - 64)) | (1 << (SQLiteParser.INSTEAD_ - 64)) | (1 << (SQLiteParser.INTERSECT_ - 64)) | (1 << (SQLiteParser.INTO_ - 64)) | (1 << (SQLiteParser.IS_ - 64)) | (1 << (SQLiteParser.ISNULL_ - 64)) | (1 << (SQLiteParser.JOIN_ - 64)) | (1 << (SQLiteParser.KEY_ - 64)) | (1 << (SQLiteParser.LEFT_ - 64)) | (1 << (SQLiteParser.LIKE_ - 64)) | (1 << (SQLiteParser.LIMIT_ - 64)) | (1 << (SQLiteParser.MATCH_ - 64)) | (1 << (SQLiteParser.NATURAL_ - 64)) | (1 << (SQLiteParser.NO_ - 64)) | (1 << (SQLiteParser.NOT_ - 64)) | (1 << (SQLiteParser.NOTNULL_ - 64)) | (1 << (SQLiteParser.NULL_ - 64)) | (1 << (SQLiteParser.OF_ - 64)) | (1 << (SQLiteParser.OFFSET_ - 64)) | (1 << (SQLiteParser.ON_ - 64)) | (1 << (SQLiteParser.OR_ - 64)) | (1 << (SQLiteParser.ORDER_ - 64)) | (1 << (SQLiteParser.OUTER_ - 64)) | (1 << (SQLiteParser.PLAN_ - 64)) | (1 << (SQLiteParser.PRAGMA_ - 64)) | (1 << (SQLiteParser.PRIMARY_ - 64)) | (1 << (SQLiteParser.QUERY_ - 64)) | (1 << (SQLiteParser.RAISE_ - 64)) | (1 << (SQLiteParser.RECURSIVE_ - 64)) | (1 << (SQLiteParser.REFERENCES_ - 64)) | (1 << (SQLiteParser.REGEXP_ - 64)) | (1 << (SQLiteParser.REINDEX_ - 64)) | (1 << (SQLiteParser.RELEASE_ - 64)) | (1 << (SQLiteParser.RENAME_ - 64)) | (1 << (SQLiteParser.REPLACE_ - 64)) | (1 << (SQLiteParser.RESTRICT_ - 64)) | (1 << (SQLiteParser.RIGHT_ - 64)) | (1 << (SQLiteParser.ROLLBACK_ - 64)) | (1 << (SQLiteParser.ROW_ - 64)) | (1 << (SQLiteParser.ROWS_ - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (SQLiteParser.SAVEPOINT_ - 128)) | (1 << (SQLiteParser.SELECT_ - 128)) | (1 << (SQLiteParser.SET_ - 128)) | (1 << (SQLiteParser.TABLE_ - 128)) | (1 << (SQLiteParser.TEMP_ - 128)) | (1 << (SQLiteParser.TEMPORARY_ - 128)) | (1 << (SQLiteParser.THEN_ - 128)) | (1 << (SQLiteParser.TO_ - 128)) | (1 << (SQLiteParser.TRANSACTION_ - 128)) | (1 << (SQLiteParser.TRIGGER_ - 128)) | (1 << (SQLiteParser.UNION_ - 128)) | (1 << (SQLiteParser.UNIQUE_ - 128)) | (1 << (SQLiteParser.UPDATE_ - 128)) | (1 << (SQLiteParser.USING_ - 128)) | (1 << (SQLiteParser.VACUUM_ - 128)) | (1 << (SQLiteParser.VALUES_ - 128)) | (1 << (SQLiteParser.VIEW_ - 128)) | (1 << (SQLiteParser.VIRTUAL_ - 128)) | (1 << (SQLiteParser.WHEN_ - 128)) | (1 << (SQLiteParser.WHERE_ - 128)) | (1 << (SQLiteParser.WITH_ - 128)) | (1 << (SQLiteParser.WITHOUT_ - 128)) | (1 << (SQLiteParser.FIRST_VALUE_ - 128)) | (1 << (SQLiteParser.OVER_ - 128)) | (1 << (SQLiteParser.PARTITION_ - 128)) | (1 << (SQLiteParser.RANGE_ - 128)) | (1 << (SQLiteParser.PRECEDING_ - 128)) | (1 << (SQLiteParser.UNBOUNDED_ - 128)) | (1 << (SQLiteParser.CURRENT_ - 128)) | (1 << (SQLiteParser.FOLLOWING_ - 128)) | (1 << (SQLiteParser.CUME_DIST_ - 128)) | (1 << (SQLiteParser.DENSE_RANK_ - 128)) | (1 << (SQLiteParser.LAG_ - 128)) | (1 << (SQLiteParser.LAST_VALUE_ - 128)) | (1 << (SQLiteParser.LEAD_ - 128)) | (1 << (SQLiteParser.NTH_VALUE_ - 128)) | (1 << (SQLiteParser.NTILE_ - 128)) | (1 << (SQLiteParser.PERCENT_RANK_ - 128)) | (1 << (SQLiteParser.RANK_ - 128)) | (1 << (SQLiteParser.ROW_NUMBER_ - 128)) | (1 << (SQLiteParser.GENERATED_ - 128)) | (1 << (SQLiteParser.ALWAYS_ - 128)) | (1 << (SQLiteParser.STORED_ - 128)) | (1 << (SQLiteParser.TRUE_ - 128)) | (1 << (SQLiteParser.FALSE_ - 128)) | (1 << (SQLiteParser.WINDOW_ - 128)) | (1 << (SQLiteParser.NULLS_ - 128)) | (1 << (SQLiteParser.FIRST_ - 128)) | (1 << (SQLiteParser.LAST_ - 128)) | (1 << (SQLiteParser.FILTER_ - 128)) | (1 << (SQLiteParser.GROUPS_ - 128)) | (1 << (SQLiteParser.EXCLUDE_ - 128)))) != 0)): 

12351 self._errHandler.recoverInline(self) 

12352 else: 

12353 self._errHandler.reportMatch(self) 

12354 self.consume() 

12355 except RecognitionException as re: 

12356 localctx.exception = re 

12357 self._errHandler.reportError(self, re) 

12358 self._errHandler.recover(self, re) 

12359 finally: 

12360 self.exitRule() 

12361 return localctx 

12362 

12363 

12364 class NameContext(ParserRuleContext): 

12365 

12366 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12367 super().__init__(parent, invokingState) 

12368 self.parser = parser 

12369 

12370 def any_name(self): 

12371 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12372 

12373 

12374 def getRuleIndex(self): 

12375 return SQLiteParser.RULE_name 

12376 

12377 def enterRule(self, listener:ParseTreeListener): 

12378 if hasattr( listener, "enterName" ): 

12379 listener.enterName(self) 

12380 

12381 def exitRule(self, listener:ParseTreeListener): 

12382 if hasattr( listener, "exitName" ): 

12383 listener.exitName(self) 

12384 

12385 

12386 

12387 

12388 def name(self): 

12389 

12390 localctx = SQLiteParser.NameContext(self, self._ctx, self.state) 

12391 self.enterRule(localctx, 172, self.RULE_name) 

12392 try: 

12393 self.enterOuterAlt(localctx, 1) 

12394 self.state = 1983 

12395 self.any_name() 

12396 except RecognitionException as re: 

12397 localctx.exception = re 

12398 self._errHandler.reportError(self, re) 

12399 self._errHandler.recover(self, re) 

12400 finally: 

12401 self.exitRule() 

12402 return localctx 

12403 

12404 

12405 class Function_nameContext(ParserRuleContext): 

12406 

12407 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12408 super().__init__(parent, invokingState) 

12409 self.parser = parser 

12410 

12411 def any_name(self): 

12412 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12413 

12414 

12415 def getRuleIndex(self): 

12416 return SQLiteParser.RULE_function_name 

12417 

12418 def enterRule(self, listener:ParseTreeListener): 

12419 if hasattr( listener, "enterFunction_name" ): 

12420 listener.enterFunction_name(self) 

12421 

12422 def exitRule(self, listener:ParseTreeListener): 

12423 if hasattr( listener, "exitFunction_name" ): 

12424 listener.exitFunction_name(self) 

12425 

12426 

12427 

12428 

12429 def function_name(self): 

12430 

12431 localctx = SQLiteParser.Function_nameContext(self, self._ctx, self.state) 

12432 self.enterRule(localctx, 174, self.RULE_function_name) 

12433 try: 

12434 self.enterOuterAlt(localctx, 1) 

12435 self.state = 1985 

12436 self.any_name() 

12437 except RecognitionException as re: 

12438 localctx.exception = re 

12439 self._errHandler.reportError(self, re) 

12440 self._errHandler.recover(self, re) 

12441 finally: 

12442 self.exitRule() 

12443 return localctx 

12444 

12445 

12446 class Schema_nameContext(ParserRuleContext): 

12447 

12448 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12449 super().__init__(parent, invokingState) 

12450 self.parser = parser 

12451 

12452 def any_name(self): 

12453 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12454 

12455 

12456 def getRuleIndex(self): 

12457 return SQLiteParser.RULE_schema_name 

12458 

12459 def enterRule(self, listener:ParseTreeListener): 

12460 if hasattr( listener, "enterSchema_name" ): 

12461 listener.enterSchema_name(self) 

12462 

12463 def exitRule(self, listener:ParseTreeListener): 

12464 if hasattr( listener, "exitSchema_name" ): 

12465 listener.exitSchema_name(self) 

12466 

12467 

12468 

12469 

12470 def schema_name(self): 

12471 

12472 localctx = SQLiteParser.Schema_nameContext(self, self._ctx, self.state) 

12473 self.enterRule(localctx, 176, self.RULE_schema_name) 

12474 try: 

12475 self.enterOuterAlt(localctx, 1) 

12476 self.state = 1987 

12477 self.any_name() 

12478 except RecognitionException as re: 

12479 localctx.exception = re 

12480 self._errHandler.reportError(self, re) 

12481 self._errHandler.recover(self, re) 

12482 finally: 

12483 self.exitRule() 

12484 return localctx 

12485 

12486 

12487 class Table_nameContext(ParserRuleContext): 

12488 

12489 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12490 super().__init__(parent, invokingState) 

12491 self.parser = parser 

12492 

12493 def any_name(self): 

12494 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12495 

12496 

12497 def getRuleIndex(self): 

12498 return SQLiteParser.RULE_table_name 

12499 

12500 def enterRule(self, listener:ParseTreeListener): 

12501 if hasattr( listener, "enterTable_name" ): 

12502 listener.enterTable_name(self) 

12503 

12504 def exitRule(self, listener:ParseTreeListener): 

12505 if hasattr( listener, "exitTable_name" ): 

12506 listener.exitTable_name(self) 

12507 

12508 

12509 

12510 

12511 def table_name(self): 

12512 

12513 localctx = SQLiteParser.Table_nameContext(self, self._ctx, self.state) 

12514 self.enterRule(localctx, 178, self.RULE_table_name) 

12515 try: 

12516 self.enterOuterAlt(localctx, 1) 

12517 self.state = 1989 

12518 self.any_name() 

12519 except RecognitionException as re: 

12520 localctx.exception = re 

12521 self._errHandler.reportError(self, re) 

12522 self._errHandler.recover(self, re) 

12523 finally: 

12524 self.exitRule() 

12525 return localctx 

12526 

12527 

12528 class Table_or_index_nameContext(ParserRuleContext): 

12529 

12530 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12531 super().__init__(parent, invokingState) 

12532 self.parser = parser 

12533 

12534 def any_name(self): 

12535 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12536 

12537 

12538 def getRuleIndex(self): 

12539 return SQLiteParser.RULE_table_or_index_name 

12540 

12541 def enterRule(self, listener:ParseTreeListener): 

12542 if hasattr( listener, "enterTable_or_index_name" ): 

12543 listener.enterTable_or_index_name(self) 

12544 

12545 def exitRule(self, listener:ParseTreeListener): 

12546 if hasattr( listener, "exitTable_or_index_name" ): 

12547 listener.exitTable_or_index_name(self) 

12548 

12549 

12550 

12551 

12552 def table_or_index_name(self): 

12553 

12554 localctx = SQLiteParser.Table_or_index_nameContext(self, self._ctx, self.state) 

12555 self.enterRule(localctx, 180, self.RULE_table_or_index_name) 

12556 try: 

12557 self.enterOuterAlt(localctx, 1) 

12558 self.state = 1991 

12559 self.any_name() 

12560 except RecognitionException as re: 

12561 localctx.exception = re 

12562 self._errHandler.reportError(self, re) 

12563 self._errHandler.recover(self, re) 

12564 finally: 

12565 self.exitRule() 

12566 return localctx 

12567 

12568 

12569 class New_table_nameContext(ParserRuleContext): 

12570 

12571 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12572 super().__init__(parent, invokingState) 

12573 self.parser = parser 

12574 

12575 def any_name(self): 

12576 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12577 

12578 

12579 def getRuleIndex(self): 

12580 return SQLiteParser.RULE_new_table_name 

12581 

12582 def enterRule(self, listener:ParseTreeListener): 

12583 if hasattr( listener, "enterNew_table_name" ): 

12584 listener.enterNew_table_name(self) 

12585 

12586 def exitRule(self, listener:ParseTreeListener): 

12587 if hasattr( listener, "exitNew_table_name" ): 

12588 listener.exitNew_table_name(self) 

12589 

12590 

12591 

12592 

12593 def new_table_name(self): 

12594 

12595 localctx = SQLiteParser.New_table_nameContext(self, self._ctx, self.state) 

12596 self.enterRule(localctx, 182, self.RULE_new_table_name) 

12597 try: 

12598 self.enterOuterAlt(localctx, 1) 

12599 self.state = 1993 

12600 self.any_name() 

12601 except RecognitionException as re: 

12602 localctx.exception = re 

12603 self._errHandler.reportError(self, re) 

12604 self._errHandler.recover(self, re) 

12605 finally: 

12606 self.exitRule() 

12607 return localctx 

12608 

12609 

12610 class Column_nameContext(ParserRuleContext): 

12611 

12612 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12613 super().__init__(parent, invokingState) 

12614 self.parser = parser 

12615 

12616 def any_name(self): 

12617 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12618 

12619 

12620 def getRuleIndex(self): 

12621 return SQLiteParser.RULE_column_name 

12622 

12623 def enterRule(self, listener:ParseTreeListener): 

12624 if hasattr( listener, "enterColumn_name" ): 

12625 listener.enterColumn_name(self) 

12626 

12627 def exitRule(self, listener:ParseTreeListener): 

12628 if hasattr( listener, "exitColumn_name" ): 

12629 listener.exitColumn_name(self) 

12630 

12631 

12632 

12633 

12634 def column_name(self): 

12635 

12636 localctx = SQLiteParser.Column_nameContext(self, self._ctx, self.state) 

12637 self.enterRule(localctx, 184, self.RULE_column_name) 

12638 try: 

12639 self.enterOuterAlt(localctx, 1) 

12640 self.state = 1995 

12641 self.any_name() 

12642 except RecognitionException as re: 

12643 localctx.exception = re 

12644 self._errHandler.reportError(self, re) 

12645 self._errHandler.recover(self, re) 

12646 finally: 

12647 self.exitRule() 

12648 return localctx 

12649 

12650 

12651 class Collation_nameContext(ParserRuleContext): 

12652 

12653 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12654 super().__init__(parent, invokingState) 

12655 self.parser = parser 

12656 

12657 def any_name(self): 

12658 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12659 

12660 

12661 def getRuleIndex(self): 

12662 return SQLiteParser.RULE_collation_name 

12663 

12664 def enterRule(self, listener:ParseTreeListener): 

12665 if hasattr( listener, "enterCollation_name" ): 

12666 listener.enterCollation_name(self) 

12667 

12668 def exitRule(self, listener:ParseTreeListener): 

12669 if hasattr( listener, "exitCollation_name" ): 

12670 listener.exitCollation_name(self) 

12671 

12672 

12673 

12674 

12675 def collation_name(self): 

12676 

12677 localctx = SQLiteParser.Collation_nameContext(self, self._ctx, self.state) 

12678 self.enterRule(localctx, 186, self.RULE_collation_name) 

12679 try: 

12680 self.enterOuterAlt(localctx, 1) 

12681 self.state = 1997 

12682 self.any_name() 

12683 except RecognitionException as re: 

12684 localctx.exception = re 

12685 self._errHandler.reportError(self, re) 

12686 self._errHandler.recover(self, re) 

12687 finally: 

12688 self.exitRule() 

12689 return localctx 

12690 

12691 

12692 class Foreign_tableContext(ParserRuleContext): 

12693 

12694 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12695 super().__init__(parent, invokingState) 

12696 self.parser = parser 

12697 

12698 def any_name(self): 

12699 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12700 

12701 

12702 def getRuleIndex(self): 

12703 return SQLiteParser.RULE_foreign_table 

12704 

12705 def enterRule(self, listener:ParseTreeListener): 

12706 if hasattr( listener, "enterForeign_table" ): 

12707 listener.enterForeign_table(self) 

12708 

12709 def exitRule(self, listener:ParseTreeListener): 

12710 if hasattr( listener, "exitForeign_table" ): 

12711 listener.exitForeign_table(self) 

12712 

12713 

12714 

12715 

12716 def foreign_table(self): 

12717 

12718 localctx = SQLiteParser.Foreign_tableContext(self, self._ctx, self.state) 

12719 self.enterRule(localctx, 188, self.RULE_foreign_table) 

12720 try: 

12721 self.enterOuterAlt(localctx, 1) 

12722 self.state = 1999 

12723 self.any_name() 

12724 except RecognitionException as re: 

12725 localctx.exception = re 

12726 self._errHandler.reportError(self, re) 

12727 self._errHandler.recover(self, re) 

12728 finally: 

12729 self.exitRule() 

12730 return localctx 

12731 

12732 

12733 class Index_nameContext(ParserRuleContext): 

12734 

12735 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12736 super().__init__(parent, invokingState) 

12737 self.parser = parser 

12738 

12739 def any_name(self): 

12740 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12741 

12742 

12743 def getRuleIndex(self): 

12744 return SQLiteParser.RULE_index_name 

12745 

12746 def enterRule(self, listener:ParseTreeListener): 

12747 if hasattr( listener, "enterIndex_name" ): 

12748 listener.enterIndex_name(self) 

12749 

12750 def exitRule(self, listener:ParseTreeListener): 

12751 if hasattr( listener, "exitIndex_name" ): 

12752 listener.exitIndex_name(self) 

12753 

12754 

12755 

12756 

12757 def index_name(self): 

12758 

12759 localctx = SQLiteParser.Index_nameContext(self, self._ctx, self.state) 

12760 self.enterRule(localctx, 190, self.RULE_index_name) 

12761 try: 

12762 self.enterOuterAlt(localctx, 1) 

12763 self.state = 2001 

12764 self.any_name() 

12765 except RecognitionException as re: 

12766 localctx.exception = re 

12767 self._errHandler.reportError(self, re) 

12768 self._errHandler.recover(self, re) 

12769 finally: 

12770 self.exitRule() 

12771 return localctx 

12772 

12773 

12774 class Trigger_nameContext(ParserRuleContext): 

12775 

12776 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12777 super().__init__(parent, invokingState) 

12778 self.parser = parser 

12779 

12780 def any_name(self): 

12781 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12782 

12783 

12784 def getRuleIndex(self): 

12785 return SQLiteParser.RULE_trigger_name 

12786 

12787 def enterRule(self, listener:ParseTreeListener): 

12788 if hasattr( listener, "enterTrigger_name" ): 

12789 listener.enterTrigger_name(self) 

12790 

12791 def exitRule(self, listener:ParseTreeListener): 

12792 if hasattr( listener, "exitTrigger_name" ): 

12793 listener.exitTrigger_name(self) 

12794 

12795 

12796 

12797 

12798 def trigger_name(self): 

12799 

12800 localctx = SQLiteParser.Trigger_nameContext(self, self._ctx, self.state) 

12801 self.enterRule(localctx, 192, self.RULE_trigger_name) 

12802 try: 

12803 self.enterOuterAlt(localctx, 1) 

12804 self.state = 2003 

12805 self.any_name() 

12806 except RecognitionException as re: 

12807 localctx.exception = re 

12808 self._errHandler.reportError(self, re) 

12809 self._errHandler.recover(self, re) 

12810 finally: 

12811 self.exitRule() 

12812 return localctx 

12813 

12814 

12815 class View_nameContext(ParserRuleContext): 

12816 

12817 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12818 super().__init__(parent, invokingState) 

12819 self.parser = parser 

12820 

12821 def any_name(self): 

12822 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12823 

12824 

12825 def getRuleIndex(self): 

12826 return SQLiteParser.RULE_view_name 

12827 

12828 def enterRule(self, listener:ParseTreeListener): 

12829 if hasattr( listener, "enterView_name" ): 

12830 listener.enterView_name(self) 

12831 

12832 def exitRule(self, listener:ParseTreeListener): 

12833 if hasattr( listener, "exitView_name" ): 

12834 listener.exitView_name(self) 

12835 

12836 

12837 

12838 

12839 def view_name(self): 

12840 

12841 localctx = SQLiteParser.View_nameContext(self, self._ctx, self.state) 

12842 self.enterRule(localctx, 194, self.RULE_view_name) 

12843 try: 

12844 self.enterOuterAlt(localctx, 1) 

12845 self.state = 2005 

12846 self.any_name() 

12847 except RecognitionException as re: 

12848 localctx.exception = re 

12849 self._errHandler.reportError(self, re) 

12850 self._errHandler.recover(self, re) 

12851 finally: 

12852 self.exitRule() 

12853 return localctx 

12854 

12855 

12856 class Module_nameContext(ParserRuleContext): 

12857 

12858 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12859 super().__init__(parent, invokingState) 

12860 self.parser = parser 

12861 

12862 def any_name(self): 

12863 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12864 

12865 

12866 def getRuleIndex(self): 

12867 return SQLiteParser.RULE_module_name 

12868 

12869 def enterRule(self, listener:ParseTreeListener): 

12870 if hasattr( listener, "enterModule_name" ): 

12871 listener.enterModule_name(self) 

12872 

12873 def exitRule(self, listener:ParseTreeListener): 

12874 if hasattr( listener, "exitModule_name" ): 

12875 listener.exitModule_name(self) 

12876 

12877 

12878 

12879 

12880 def module_name(self): 

12881 

12882 localctx = SQLiteParser.Module_nameContext(self, self._ctx, self.state) 

12883 self.enterRule(localctx, 196, self.RULE_module_name) 

12884 try: 

12885 self.enterOuterAlt(localctx, 1) 

12886 self.state = 2007 

12887 self.any_name() 

12888 except RecognitionException as re: 

12889 localctx.exception = re 

12890 self._errHandler.reportError(self, re) 

12891 self._errHandler.recover(self, re) 

12892 finally: 

12893 self.exitRule() 

12894 return localctx 

12895 

12896 

12897 class Pragma_nameContext(ParserRuleContext): 

12898 

12899 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12900 super().__init__(parent, invokingState) 

12901 self.parser = parser 

12902 

12903 def any_name(self): 

12904 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12905 

12906 

12907 def getRuleIndex(self): 

12908 return SQLiteParser.RULE_pragma_name 

12909 

12910 def enterRule(self, listener:ParseTreeListener): 

12911 if hasattr( listener, "enterPragma_name" ): 

12912 listener.enterPragma_name(self) 

12913 

12914 def exitRule(self, listener:ParseTreeListener): 

12915 if hasattr( listener, "exitPragma_name" ): 

12916 listener.exitPragma_name(self) 

12917 

12918 

12919 

12920 

12921 def pragma_name(self): 

12922 

12923 localctx = SQLiteParser.Pragma_nameContext(self, self._ctx, self.state) 

12924 self.enterRule(localctx, 198, self.RULE_pragma_name) 

12925 try: 

12926 self.enterOuterAlt(localctx, 1) 

12927 self.state = 2009 

12928 self.any_name() 

12929 except RecognitionException as re: 

12930 localctx.exception = re 

12931 self._errHandler.reportError(self, re) 

12932 self._errHandler.recover(self, re) 

12933 finally: 

12934 self.exitRule() 

12935 return localctx 

12936 

12937 

12938 class Savepoint_nameContext(ParserRuleContext): 

12939 

12940 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12941 super().__init__(parent, invokingState) 

12942 self.parser = parser 

12943 

12944 def any_name(self): 

12945 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12946 

12947 

12948 def getRuleIndex(self): 

12949 return SQLiteParser.RULE_savepoint_name 

12950 

12951 def enterRule(self, listener:ParseTreeListener): 

12952 if hasattr( listener, "enterSavepoint_name" ): 

12953 listener.enterSavepoint_name(self) 

12954 

12955 def exitRule(self, listener:ParseTreeListener): 

12956 if hasattr( listener, "exitSavepoint_name" ): 

12957 listener.exitSavepoint_name(self) 

12958 

12959 

12960 

12961 

12962 def savepoint_name(self): 

12963 

12964 localctx = SQLiteParser.Savepoint_nameContext(self, self._ctx, self.state) 

12965 self.enterRule(localctx, 200, self.RULE_savepoint_name) 

12966 try: 

12967 self.enterOuterAlt(localctx, 1) 

12968 self.state = 2011 

12969 self.any_name() 

12970 except RecognitionException as re: 

12971 localctx.exception = re 

12972 self._errHandler.reportError(self, re) 

12973 self._errHandler.recover(self, re) 

12974 finally: 

12975 self.exitRule() 

12976 return localctx 

12977 

12978 

12979 class Table_aliasContext(ParserRuleContext): 

12980 

12981 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

12982 super().__init__(parent, invokingState) 

12983 self.parser = parser 

12984 

12985 def any_name(self): 

12986 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

12987 

12988 

12989 def getRuleIndex(self): 

12990 return SQLiteParser.RULE_table_alias 

12991 

12992 def enterRule(self, listener:ParseTreeListener): 

12993 if hasattr( listener, "enterTable_alias" ): 

12994 listener.enterTable_alias(self) 

12995 

12996 def exitRule(self, listener:ParseTreeListener): 

12997 if hasattr( listener, "exitTable_alias" ): 

12998 listener.exitTable_alias(self) 

12999 

13000 

13001 

13002 

13003 def table_alias(self): 

13004 

13005 localctx = SQLiteParser.Table_aliasContext(self, self._ctx, self.state) 

13006 self.enterRule(localctx, 202, self.RULE_table_alias) 

13007 try: 

13008 self.enterOuterAlt(localctx, 1) 

13009 self.state = 2013 

13010 self.any_name() 

13011 except RecognitionException as re: 

13012 localctx.exception = re 

13013 self._errHandler.reportError(self, re) 

13014 self._errHandler.recover(self, re) 

13015 finally: 

13016 self.exitRule() 

13017 return localctx 

13018 

13019 

13020 class Transaction_nameContext(ParserRuleContext): 

13021 

13022 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

13023 super().__init__(parent, invokingState) 

13024 self.parser = parser 

13025 

13026 def any_name(self): 

13027 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

13028 

13029 

13030 def getRuleIndex(self): 

13031 return SQLiteParser.RULE_transaction_name 

13032 

13033 def enterRule(self, listener:ParseTreeListener): 

13034 if hasattr( listener, "enterTransaction_name" ): 

13035 listener.enterTransaction_name(self) 

13036 

13037 def exitRule(self, listener:ParseTreeListener): 

13038 if hasattr( listener, "exitTransaction_name" ): 

13039 listener.exitTransaction_name(self) 

13040 

13041 

13042 

13043 

13044 def transaction_name(self): 

13045 

13046 localctx = SQLiteParser.Transaction_nameContext(self, self._ctx, self.state) 

13047 self.enterRule(localctx, 204, self.RULE_transaction_name) 

13048 try: 

13049 self.enterOuterAlt(localctx, 1) 

13050 self.state = 2015 

13051 self.any_name() 

13052 except RecognitionException as re: 

13053 localctx.exception = re 

13054 self._errHandler.reportError(self, re) 

13055 self._errHandler.recover(self, re) 

13056 finally: 

13057 self.exitRule() 

13058 return localctx 

13059 

13060 

13061 class Window_nameContext(ParserRuleContext): 

13062 

13063 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

13064 super().__init__(parent, invokingState) 

13065 self.parser = parser 

13066 

13067 def any_name(self): 

13068 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

13069 

13070 

13071 def getRuleIndex(self): 

13072 return SQLiteParser.RULE_window_name 

13073 

13074 def enterRule(self, listener:ParseTreeListener): 

13075 if hasattr( listener, "enterWindow_name" ): 

13076 listener.enterWindow_name(self) 

13077 

13078 def exitRule(self, listener:ParseTreeListener): 

13079 if hasattr( listener, "exitWindow_name" ): 

13080 listener.exitWindow_name(self) 

13081 

13082 

13083 

13084 

13085 def window_name(self): 

13086 

13087 localctx = SQLiteParser.Window_nameContext(self, self._ctx, self.state) 

13088 self.enterRule(localctx, 206, self.RULE_window_name) 

13089 try: 

13090 self.enterOuterAlt(localctx, 1) 

13091 self.state = 2017 

13092 self.any_name() 

13093 except RecognitionException as re: 

13094 localctx.exception = re 

13095 self._errHandler.reportError(self, re) 

13096 self._errHandler.recover(self, re) 

13097 finally: 

13098 self.exitRule() 

13099 return localctx 

13100 

13101 

13102 class AliasContext(ParserRuleContext): 

13103 

13104 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

13105 super().__init__(parent, invokingState) 

13106 self.parser = parser 

13107 

13108 def any_name(self): 

13109 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

13110 

13111 

13112 def getRuleIndex(self): 

13113 return SQLiteParser.RULE_alias 

13114 

13115 def enterRule(self, listener:ParseTreeListener): 

13116 if hasattr( listener, "enterAlias" ): 

13117 listener.enterAlias(self) 

13118 

13119 def exitRule(self, listener:ParseTreeListener): 

13120 if hasattr( listener, "exitAlias" ): 

13121 listener.exitAlias(self) 

13122 

13123 

13124 

13125 

13126 def alias(self): 

13127 

13128 localctx = SQLiteParser.AliasContext(self, self._ctx, self.state) 

13129 self.enterRule(localctx, 208, self.RULE_alias) 

13130 try: 

13131 self.enterOuterAlt(localctx, 1) 

13132 self.state = 2019 

13133 self.any_name() 

13134 except RecognitionException as re: 

13135 localctx.exception = re 

13136 self._errHandler.reportError(self, re) 

13137 self._errHandler.recover(self, re) 

13138 finally: 

13139 self.exitRule() 

13140 return localctx 

13141 

13142 

13143 class FilenameContext(ParserRuleContext): 

13144 

13145 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

13146 super().__init__(parent, invokingState) 

13147 self.parser = parser 

13148 

13149 def any_name(self): 

13150 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

13151 

13152 

13153 def getRuleIndex(self): 

13154 return SQLiteParser.RULE_filename 

13155 

13156 def enterRule(self, listener:ParseTreeListener): 

13157 if hasattr( listener, "enterFilename" ): 

13158 listener.enterFilename(self) 

13159 

13160 def exitRule(self, listener:ParseTreeListener): 

13161 if hasattr( listener, "exitFilename" ): 

13162 listener.exitFilename(self) 

13163 

13164 

13165 

13166 

13167 def filename(self): 

13168 

13169 localctx = SQLiteParser.FilenameContext(self, self._ctx, self.state) 

13170 self.enterRule(localctx, 210, self.RULE_filename) 

13171 try: 

13172 self.enterOuterAlt(localctx, 1) 

13173 self.state = 2021 

13174 self.any_name() 

13175 except RecognitionException as re: 

13176 localctx.exception = re 

13177 self._errHandler.reportError(self, re) 

13178 self._errHandler.recover(self, re) 

13179 finally: 

13180 self.exitRule() 

13181 return localctx 

13182 

13183 

13184 class Base_window_nameContext(ParserRuleContext): 

13185 

13186 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

13187 super().__init__(parent, invokingState) 

13188 self.parser = parser 

13189 

13190 def any_name(self): 

13191 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

13192 

13193 

13194 def getRuleIndex(self): 

13195 return SQLiteParser.RULE_base_window_name 

13196 

13197 def enterRule(self, listener:ParseTreeListener): 

13198 if hasattr( listener, "enterBase_window_name" ): 

13199 listener.enterBase_window_name(self) 

13200 

13201 def exitRule(self, listener:ParseTreeListener): 

13202 if hasattr( listener, "exitBase_window_name" ): 

13203 listener.exitBase_window_name(self) 

13204 

13205 

13206 

13207 

13208 def base_window_name(self): 

13209 

13210 localctx = SQLiteParser.Base_window_nameContext(self, self._ctx, self.state) 

13211 self.enterRule(localctx, 212, self.RULE_base_window_name) 

13212 try: 

13213 self.enterOuterAlt(localctx, 1) 

13214 self.state = 2023 

13215 self.any_name() 

13216 except RecognitionException as re: 

13217 localctx.exception = re 

13218 self._errHandler.reportError(self, re) 

13219 self._errHandler.recover(self, re) 

13220 finally: 

13221 self.exitRule() 

13222 return localctx 

13223 

13224 

13225 class Simple_funcContext(ParserRuleContext): 

13226 

13227 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

13228 super().__init__(parent, invokingState) 

13229 self.parser = parser 

13230 

13231 def any_name(self): 

13232 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

13233 

13234 

13235 def getRuleIndex(self): 

13236 return SQLiteParser.RULE_simple_func 

13237 

13238 def enterRule(self, listener:ParseTreeListener): 

13239 if hasattr( listener, "enterSimple_func" ): 

13240 listener.enterSimple_func(self) 

13241 

13242 def exitRule(self, listener:ParseTreeListener): 

13243 if hasattr( listener, "exitSimple_func" ): 

13244 listener.exitSimple_func(self) 

13245 

13246 

13247 

13248 

13249 def simple_func(self): 

13250 

13251 localctx = SQLiteParser.Simple_funcContext(self, self._ctx, self.state) 

13252 self.enterRule(localctx, 214, self.RULE_simple_func) 

13253 try: 

13254 self.enterOuterAlt(localctx, 1) 

13255 self.state = 2025 

13256 self.any_name() 

13257 except RecognitionException as re: 

13258 localctx.exception = re 

13259 self._errHandler.reportError(self, re) 

13260 self._errHandler.recover(self, re) 

13261 finally: 

13262 self.exitRule() 

13263 return localctx 

13264 

13265 

13266 class Aggregate_funcContext(ParserRuleContext): 

13267 

13268 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

13269 super().__init__(parent, invokingState) 

13270 self.parser = parser 

13271 

13272 def any_name(self): 

13273 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

13274 

13275 

13276 def getRuleIndex(self): 

13277 return SQLiteParser.RULE_aggregate_func 

13278 

13279 def enterRule(self, listener:ParseTreeListener): 

13280 if hasattr( listener, "enterAggregate_func" ): 

13281 listener.enterAggregate_func(self) 

13282 

13283 def exitRule(self, listener:ParseTreeListener): 

13284 if hasattr( listener, "exitAggregate_func" ): 

13285 listener.exitAggregate_func(self) 

13286 

13287 

13288 

13289 

13290 def aggregate_func(self): 

13291 

13292 localctx = SQLiteParser.Aggregate_funcContext(self, self._ctx, self.state) 

13293 self.enterRule(localctx, 216, self.RULE_aggregate_func) 

13294 try: 

13295 self.enterOuterAlt(localctx, 1) 

13296 self.state = 2027 

13297 self.any_name() 

13298 except RecognitionException as re: 

13299 localctx.exception = re 

13300 self._errHandler.reportError(self, re) 

13301 self._errHandler.recover(self, re) 

13302 finally: 

13303 self.exitRule() 

13304 return localctx 

13305 

13306 

13307 class Table_function_nameContext(ParserRuleContext): 

13308 

13309 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

13310 super().__init__(parent, invokingState) 

13311 self.parser = parser 

13312 

13313 def any_name(self): 

13314 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

13315 

13316 

13317 def getRuleIndex(self): 

13318 return SQLiteParser.RULE_table_function_name 

13319 

13320 def enterRule(self, listener:ParseTreeListener): 

13321 if hasattr( listener, "enterTable_function_name" ): 

13322 listener.enterTable_function_name(self) 

13323 

13324 def exitRule(self, listener:ParseTreeListener): 

13325 if hasattr( listener, "exitTable_function_name" ): 

13326 listener.exitTable_function_name(self) 

13327 

13328 

13329 

13330 

13331 def table_function_name(self): 

13332 

13333 localctx = SQLiteParser.Table_function_nameContext(self, self._ctx, self.state) 

13334 self.enterRule(localctx, 218, self.RULE_table_function_name) 

13335 try: 

13336 self.enterOuterAlt(localctx, 1) 

13337 self.state = 2029 

13338 self.any_name() 

13339 except RecognitionException as re: 

13340 localctx.exception = re 

13341 self._errHandler.reportError(self, re) 

13342 self._errHandler.recover(self, re) 

13343 finally: 

13344 self.exitRule() 

13345 return localctx 

13346 

13347 

13348 class Any_nameContext(ParserRuleContext): 

13349 

13350 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): 

13351 super().__init__(parent, invokingState) 

13352 self.parser = parser 

13353 

13354 def IDENTIFIER(self): 

13355 return self.getToken(SQLiteParser.IDENTIFIER, 0) 

13356 

13357 def keyword(self): 

13358 return self.getTypedRuleContext(SQLiteParser.KeywordContext,0) 

13359 

13360 

13361 def STRING_LITERAL(self): 

13362 return self.getToken(SQLiteParser.STRING_LITERAL, 0) 

13363 

13364 def OPEN_PAR(self): 

13365 return self.getToken(SQLiteParser.OPEN_PAR, 0) 

13366 

13367 def any_name(self): 

13368 return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0) 

13369 

13370 

13371 def CLOSE_PAR(self): 

13372 return self.getToken(SQLiteParser.CLOSE_PAR, 0) 

13373 

13374 def getRuleIndex(self): 

13375 return SQLiteParser.RULE_any_name 

13376 

13377 def enterRule(self, listener:ParseTreeListener): 

13378 if hasattr( listener, "enterAny_name" ): 

13379 listener.enterAny_name(self) 

13380 

13381 def exitRule(self, listener:ParseTreeListener): 

13382 if hasattr( listener, "exitAny_name" ): 

13383 listener.exitAny_name(self) 

13384 

13385 

13386 

13387 

13388 def any_name(self): 

13389 

13390 localctx = SQLiteParser.Any_nameContext(self, self._ctx, self.state) 

13391 self.enterRule(localctx, 220, self.RULE_any_name) 

13392 try: 

13393 self.state = 2038 

13394 self._errHandler.sync(self) 

13395 token = self._input.LA(1) 

13396 if token in [SQLiteParser.IDENTIFIER]: 

13397 self.enterOuterAlt(localctx, 1) 

13398 self.state = 2031 

13399 self.match(SQLiteParser.IDENTIFIER) 

13400 pass 

13401 elif token in [SQLiteParser.ABORT_, SQLiteParser.ACTION_, SQLiteParser.ADD_, SQLiteParser.AFTER_, SQLiteParser.ALL_, SQLiteParser.ALTER_, SQLiteParser.ANALYZE_, SQLiteParser.AND_, SQLiteParser.AS_, SQLiteParser.ASC_, SQLiteParser.ATTACH_, SQLiteParser.AUTOINCREMENT_, SQLiteParser.BEFORE_, SQLiteParser.BEGIN_, SQLiteParser.BETWEEN_, SQLiteParser.BY_, SQLiteParser.CASCADE_, SQLiteParser.CASE_, SQLiteParser.CAST_, SQLiteParser.CHECK_, SQLiteParser.COLLATE_, SQLiteParser.COLUMN_, SQLiteParser.COMMIT_, SQLiteParser.CONFLICT_, SQLiteParser.CONSTRAINT_, SQLiteParser.CREATE_, SQLiteParser.CROSS_, SQLiteParser.CURRENT_DATE_, SQLiteParser.CURRENT_TIME_, SQLiteParser.CURRENT_TIMESTAMP_, SQLiteParser.DATABASE_, SQLiteParser.DEFAULT_, SQLiteParser.DEFERRABLE_, SQLiteParser.DEFERRED_, SQLiteParser.DELETE_, SQLiteParser.DESC_, SQLiteParser.DETACH_, SQLiteParser.DISTINCT_, SQLiteParser.DROP_, SQLiteParser.EACH_, SQLiteParser.ELSE_, SQLiteParser.END_, SQLiteParser.ESCAPE_, SQLiteParser.EXCEPT_, SQLiteParser.EXCLUSIVE_, SQLiteParser.EXISTS_, SQLiteParser.EXPLAIN_, SQLiteParser.FAIL_, SQLiteParser.FOR_, SQLiteParser.FOREIGN_, SQLiteParser.FROM_, SQLiteParser.FULL_, SQLiteParser.GLOB_, SQLiteParser.GROUP_, SQLiteParser.HAVING_, SQLiteParser.IF_, SQLiteParser.IGNORE_, SQLiteParser.IMMEDIATE_, SQLiteParser.IN_, SQLiteParser.INDEX_, SQLiteParser.INDEXED_, SQLiteParser.INITIALLY_, SQLiteParser.INNER_, SQLiteParser.INSERT_, SQLiteParser.INSTEAD_, SQLiteParser.INTERSECT_, SQLiteParser.INTO_, SQLiteParser.IS_, SQLiteParser.ISNULL_, SQLiteParser.JOIN_, SQLiteParser.KEY_, SQLiteParser.LEFT_, SQLiteParser.LIKE_, SQLiteParser.LIMIT_, SQLiteParser.MATCH_, SQLiteParser.NATURAL_, SQLiteParser.NO_, SQLiteParser.NOT_, SQLiteParser.NOTNULL_, SQLiteParser.NULL_, SQLiteParser.OF_, SQLiteParser.OFFSET_, SQLiteParser.ON_, SQLiteParser.OR_, SQLiteParser.ORDER_, SQLiteParser.OUTER_, SQLiteParser.PLAN_, SQLiteParser.PRAGMA_, SQLiteParser.PRIMARY_, SQLiteParser.QUERY_, SQLiteParser.RAISE_, SQLiteParser.RECURSIVE_, SQLiteParser.REFERENCES_, SQLiteParser.REGEXP_, SQLiteParser.REINDEX_, SQLiteParser.RELEASE_, SQLiteParser.RENAME_, SQLiteParser.REPLACE_, SQLiteParser.RESTRICT_, SQLiteParser.RIGHT_, SQLiteParser.ROLLBACK_, SQLiteParser.ROW_, SQLiteParser.ROWS_, SQLiteParser.SAVEPOINT_, SQLiteParser.SELECT_, SQLiteParser.SET_, SQLiteParser.TABLE_, SQLiteParser.TEMP_, SQLiteParser.TEMPORARY_, SQLiteParser.THEN_, SQLiteParser.TO_, SQLiteParser.TRANSACTION_, SQLiteParser.TRIGGER_, SQLiteParser.UNION_, SQLiteParser.UNIQUE_, SQLiteParser.UPDATE_, SQLiteParser.USING_, SQLiteParser.VACUUM_, SQLiteParser.VALUES_, SQLiteParser.VIEW_, SQLiteParser.VIRTUAL_, SQLiteParser.WHEN_, SQLiteParser.WHERE_, SQLiteParser.WITH_, SQLiteParser.WITHOUT_, SQLiteParser.FIRST_VALUE_, SQLiteParser.OVER_, SQLiteParser.PARTITION_, SQLiteParser.RANGE_, SQLiteParser.PRECEDING_, SQLiteParser.UNBOUNDED_, SQLiteParser.CURRENT_, SQLiteParser.FOLLOWING_, SQLiteParser.CUME_DIST_, SQLiteParser.DENSE_RANK_, SQLiteParser.LAG_, SQLiteParser.LAST_VALUE_, SQLiteParser.LEAD_, SQLiteParser.NTH_VALUE_, SQLiteParser.NTILE_, SQLiteParser.PERCENT_RANK_, SQLiteParser.RANK_, SQLiteParser.ROW_NUMBER_, SQLiteParser.GENERATED_, SQLiteParser.ALWAYS_, SQLiteParser.STORED_, SQLiteParser.TRUE_, SQLiteParser.FALSE_, SQLiteParser.WINDOW_, SQLiteParser.NULLS_, SQLiteParser.FIRST_, SQLiteParser.LAST_, SQLiteParser.FILTER_, SQLiteParser.GROUPS_, SQLiteParser.EXCLUDE_]: 

13402 self.enterOuterAlt(localctx, 2) 

13403 self.state = 2032 

13404 self.keyword() 

13405 pass 

13406 elif token in [SQLiteParser.STRING_LITERAL]: 

13407 self.enterOuterAlt(localctx, 3) 

13408 self.state = 2033 

13409 self.match(SQLiteParser.STRING_LITERAL) 

13410 pass 

13411 elif token in [SQLiteParser.OPEN_PAR]: 

13412 self.enterOuterAlt(localctx, 4) 

13413 self.state = 2034 

13414 self.match(SQLiteParser.OPEN_PAR) 

13415 self.state = 2035 

13416 self.any_name() 

13417 self.state = 2036 

13418 self.match(SQLiteParser.CLOSE_PAR) 

13419 pass 

13420 else: 

13421 raise NoViableAltException(self) 

13422 

13423 except RecognitionException as re: 

13424 localctx.exception = re 

13425 self._errHandler.reportError(self, re) 

13426 self._errHandler.recover(self, re) 

13427 finally: 

13428 self.exitRule() 

13429 return localctx 

13430 

13431 

13432 

13433 def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int): 

13434 if self._predicates == None: 

13435 self._predicates = dict() 

13436 self._predicates[32] = self.expr_sempred 

13437 pred = self._predicates.get(ruleIndex, None) 

13438 if pred is None: 

13439 raise Exception("No predicate with index:" + str(ruleIndex)) 

13440 else: 

13441 return pred(localctx, predIndex) 

13442 

13443 def expr_sempred(self, localctx:ExprContext, predIndex:int): 

13444 if predIndex == 0: 

13445 return self.precpred(self._ctx, 20) 

13446 

13447 

13448 if predIndex == 1: 

13449 return self.precpred(self._ctx, 19) 

13450 

13451 

13452 if predIndex == 2: 

13453 return self.precpred(self._ctx, 18) 

13454 

13455 

13456 if predIndex == 3: 

13457 return self.precpred(self._ctx, 17) 

13458 

13459 

13460 if predIndex == 4: 

13461 return self.precpred(self._ctx, 16) 

13462 

13463 

13464 if predIndex == 5: 

13465 return self.precpred(self._ctx, 15) 

13466 

13467 

13468 if predIndex == 6: 

13469 return self.precpred(self._ctx, 14) 

13470 

13471 

13472 if predIndex == 7: 

13473 return self.precpred(self._ctx, 13) 

13474 

13475 

13476 if predIndex == 8: 

13477 return self.precpred(self._ctx, 6) 

13478 

13479 

13480 if predIndex == 9: 

13481 return self.precpred(self._ctx, 5) 

13482 

13483 

13484 if predIndex == 10: 

13485 return self.precpred(self._ctx, 9) 

13486 

13487 

13488 if predIndex == 11: 

13489 return self.precpred(self._ctx, 8) 

13490 

13491 

13492 if predIndex == 12: 

13493 return self.precpred(self._ctx, 7) 

13494 

13495 

13496 if predIndex == 13: 

13497 return self.precpred(self._ctx, 4) 

13498 

13499 

13500 

13501 

13502