omlish 0.0.0.dev252__py3-none-any.whl → 0.0.0.dev253__py3-none-any.whl

omlish/sql/parsing/_antlr/MinisqlParser.py

@@ -0,0 +1,3762 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+# Generated from Minisql.g4 by ANTLR 4.13.2
+# encoding: utf-8
+from omlish.antlr._runtime._all import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+	from typing import TextIO
+else:
+	from typing.io import TextIO
+
+def serializedATN():
+    return [
+        4,1,67,419,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,
+        6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,
+        2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,
+        7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,
+        2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,
+        7,33,1,0,1,0,1,0,1,0,1,1,1,1,1,2,1,2,1,2,1,2,5,2,79,8,2,10,2,12,
+        2,82,9,2,3,2,84,8,2,1,2,1,2,1,3,1,3,1,3,1,3,1,3,1,3,1,4,1,4,5,4,
+        96,8,4,10,4,12,4,99,9,4,1,5,1,5,3,5,103,8,5,1,5,1,5,1,6,1,6,3,6,
+        109,8,6,1,6,1,6,1,6,5,6,114,8,6,10,6,12,6,117,9,6,1,6,1,6,1,6,1,
+        6,5,6,123,8,6,10,6,12,6,126,9,6,3,6,128,8,6,1,6,1,6,3,6,132,8,6,
+        1,6,1,6,1,6,3,6,137,8,6,1,6,1,6,3,6,141,8,6,1,6,1,6,1,6,1,6,1,6,
+        5,6,148,8,6,10,6,12,6,151,9,6,3,6,153,8,6,1,7,1,7,1,7,3,7,158,8,
+        7,1,7,3,7,161,8,7,3,7,163,8,7,1,8,1,8,1,9,1,9,1,9,3,9,170,8,9,1,
+        9,1,9,3,9,174,8,9,1,9,1,9,1,9,1,9,1,9,1,9,5,9,182,8,9,10,9,12,9,
+        185,9,9,1,10,1,10,1,10,1,10,1,10,3,10,192,8,10,1,10,1,10,3,10,196,
+        8,10,1,10,1,10,1,10,1,10,1,10,5,10,203,8,10,10,10,12,10,206,9,10,
+        1,10,1,10,1,10,3,10,211,8,10,1,10,1,10,1,10,1,10,1,10,1,10,3,10,
+        219,8,10,1,10,1,10,3,10,223,8,10,1,11,1,11,1,11,1,11,1,11,3,11,230,
+        8,11,1,11,1,11,1,11,1,11,5,11,236,8,11,10,11,12,11,239,9,11,1,12,
+        1,12,1,12,1,12,1,12,5,12,246,8,12,10,12,12,12,249,9,12,3,12,251,
+        8,12,1,12,1,12,3,12,255,8,12,1,12,1,12,1,12,1,12,1,12,3,12,262,8,
+        12,1,12,1,12,5,12,266,8,12,10,12,12,12,269,9,12,1,12,1,12,3,12,273,
+        8,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,3,12,285,
+        8,12,1,13,1,13,1,13,1,13,1,13,1,13,3,13,293,8,13,1,14,1,14,1,14,
+        1,14,1,14,1,15,1,15,1,15,1,15,1,15,1,15,1,15,5,15,307,8,15,10,15,
+        12,15,310,9,15,3,15,312,8,15,1,15,1,15,1,16,1,16,3,16,318,8,16,1,
+        17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,3,17,330,8,17,1,
+        17,1,17,3,17,334,8,17,1,17,1,17,1,17,3,17,339,8,17,1,17,1,17,1,17,
+        1,17,3,17,345,8,17,5,17,347,8,17,10,17,12,17,350,9,17,1,18,1,18,
+        1,18,5,18,355,8,18,10,18,12,18,358,9,18,1,19,1,19,1,19,5,19,363,
+        8,19,10,19,12,19,366,9,19,1,20,1,20,1,20,5,20,371,8,20,10,20,12,
+        20,374,9,20,1,21,1,21,3,21,378,8,21,1,22,1,22,1,23,1,23,1,23,3,23,
+        385,8,23,1,24,1,24,1,25,1,25,1,26,1,26,1,27,1,27,1,28,1,28,1,29,
+        1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,3,29,409,
+        8,29,1,30,1,30,1,31,1,31,1,32,1,32,1,33,1,33,1,33,0,3,18,22,34,34,
+        0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,
+        46,48,50,52,54,56,58,60,62,64,66,0,7,2,0,21,21,46,46,2,0,23,23,27,
+        27,2,0,20,20,28,28,1,0,8,14,2,0,5,5,15,19,1,0,15,16,3,0,40,40,50,
+        50,62,62,455,0,68,1,0,0,0,2,72,1,0,0,0,4,83,1,0,0,0,6,87,1,0,0,0,
+        8,93,1,0,0,0,10,100,1,0,0,0,12,106,1,0,0,0,14,162,1,0,0,0,16,164,
+        1,0,0,0,18,173,1,0,0,0,20,222,1,0,0,0,22,229,1,0,0,0,24,284,1,0,
+        0,0,26,292,1,0,0,0,28,294,1,0,0,0,30,299,1,0,0,0,32,315,1,0,0,0,
+        34,329,1,0,0,0,36,351,1,0,0,0,38,359,1,0,0,0,40,367,1,0,0,0,42,377,
+        1,0,0,0,44,379,1,0,0,0,46,384,1,0,0,0,48,386,1,0,0,0,50,388,1,0,
+        0,0,52,390,1,0,0,0,54,392,1,0,0,0,56,394,1,0,0,0,58,408,1,0,0,0,
+        60,410,1,0,0,0,62,412,1,0,0,0,64,414,1,0,0,0,66,416,1,0,0,0,68,69,
+        3,2,1,0,69,70,5,1,0,0,70,71,5,0,0,1,71,1,1,0,0,0,72,73,3,4,2,0,73,
+        3,1,0,0,0,74,75,5,57,0,0,75,80,3,6,3,0,76,77,5,2,0,0,77,79,3,6,3,
+        0,78,76,1,0,0,0,79,82,1,0,0,0,80,78,1,0,0,0,80,81,1,0,0,0,81,84,
+        1,0,0,0,82,80,1,0,0,0,83,74,1,0,0,0,83,84,1,0,0,0,84,85,1,0,0,0,
+        85,86,3,8,4,0,86,5,1,0,0,0,87,88,3,42,21,0,88,89,5,22,0,0,89,90,
+        5,3,0,0,90,91,3,2,1,0,91,92,5,4,0,0,92,7,1,0,0,0,93,97,3,12,6,0,
+        94,96,3,10,5,0,95,94,1,0,0,0,96,99,1,0,0,0,97,95,1,0,0,0,97,98,1,
+        0,0,0,98,9,1,0,0,0,99,97,1,0,0,0,100,102,5,54,0,0,101,103,3,56,28,
+        0,102,101,1,0,0,0,102,103,1,0,0,0,103,104,1,0,0,0,104,105,3,12,6,
+        0,105,11,1,0,0,0,106,108,5,51,0,0,107,109,3,56,28,0,108,107,1,0,
+        0,0,108,109,1,0,0,0,109,110,1,0,0,0,110,115,3,14,7,0,111,112,5,2,
+        0,0,112,114,3,14,7,0,113,111,1,0,0,0,114,117,1,0,0,0,115,113,1,0,
+        0,0,115,116,1,0,0,0,116,127,1,0,0,0,117,115,1,0,0,0,118,119,5,32,
+        0,0,119,124,3,34,17,0,120,121,5,2,0,0,121,123,3,34,17,0,122,120,
+        1,0,0,0,123,126,1,0,0,0,124,122,1,0,0,0,124,125,1,0,0,0,125,128,
+        1,0,0,0,126,124,1,0,0,0,127,118,1,0,0,0,127,128,1,0,0,0,128,131,
+        1,0,0,0,129,130,5,56,0,0,130,132,3,18,9,0,131,129,1,0,0,0,131,132,
+        1,0,0,0,132,136,1,0,0,0,133,134,5,34,0,0,134,135,5,24,0,0,135,137,
+        3,36,18,0,136,133,1,0,0,0,136,137,1,0,0,0,137,140,1,0,0,0,138,139,
+        5,35,0,0,139,141,3,18,9,0,140,138,1,0,0,0,140,141,1,0,0,0,141,152,
+        1,0,0,0,142,143,5,47,0,0,143,144,5,24,0,0,144,149,3,32,16,0,145,
+        146,5,2,0,0,146,148,3,32,16,0,147,145,1,0,0,0,148,151,1,0,0,0,149,
+        147,1,0,0,0,149,150,1,0,0,0,150,153,1,0,0,0,151,149,1,0,0,0,152,
+        142,1,0,0,0,152,153,1,0,0,0,153,13,1,0,0,0,154,163,5,5,0,0,155,160,
+        3,16,8,0,156,158,5,22,0,0,157,156,1,0,0,0,157,158,1,0,0,0,158,159,
+        1,0,0,0,159,161,3,42,21,0,160,157,1,0,0,0,160,161,1,0,0,0,161,163,
+        1,0,0,0,162,154,1,0,0,0,162,155,1,0,0,0,163,15,1,0,0,0,164,165,3,
+        18,9,0,165,17,1,0,0,0,166,167,6,9,-1,0,167,169,3,22,11,0,168,170,
+        3,20,10,0,169,168,1,0,0,0,169,170,1,0,0,0,170,174,1,0,0,0,171,172,
+        5,43,0,0,172,174,3,18,9,3,173,166,1,0,0,0,173,171,1,0,0,0,174,183,
+        1,0,0,0,175,176,10,2,0,0,176,177,7,0,0,0,177,182,3,18,9,3,178,179,
+        10,1,0,0,179,180,5,6,0,0,180,182,3,42,21,0,181,175,1,0,0,0,181,178,
+        1,0,0,0,182,185,1,0,0,0,183,181,1,0,0,0,183,184,1,0,0,0,184,19,1,
+        0,0,0,185,183,1,0,0,0,186,187,3,60,30,0,187,188,3,22,11,0,188,223,
+        1,0,0,0,189,191,5,38,0,0,190,192,5,43,0,0,191,190,1,0,0,0,191,192,
+        1,0,0,0,192,193,1,0,0,0,193,223,5,44,0,0,194,196,5,43,0,0,195,194,
+        1,0,0,0,195,196,1,0,0,0,196,197,1,0,0,0,197,198,5,36,0,0,198,199,
+        5,3,0,0,199,204,3,16,8,0,200,201,5,2,0,0,201,203,3,16,8,0,202,200,
+        1,0,0,0,203,206,1,0,0,0,204,202,1,0,0,0,204,205,1,0,0,0,205,207,
+        1,0,0,0,206,204,1,0,0,0,207,208,5,4,0,0,208,223,1,0,0,0,209,211,
+        5,43,0,0,210,209,1,0,0,0,210,211,1,0,0,0,211,212,1,0,0,0,212,213,
+        5,36,0,0,213,214,5,3,0,0,214,215,3,2,1,0,215,216,5,4,0,0,216,223,
+        1,0,0,0,217,219,5,43,0,0,218,217,1,0,0,0,218,219,1,0,0,0,219,220,
+        1,0,0,0,220,221,5,41,0,0,221,223,3,16,8,0,222,186,1,0,0,0,222,189,
+        1,0,0,0,222,195,1,0,0,0,222,210,1,0,0,0,222,218,1,0,0,0,223,21,1,
+        0,0,0,224,225,6,11,-1,0,225,230,3,24,12,0,226,227,3,64,32,0,227,
+        228,3,22,11,2,228,230,1,0,0,0,229,224,1,0,0,0,229,226,1,0,0,0,230,
+        237,1,0,0,0,231,232,10,1,0,0,232,233,3,62,31,0,233,234,3,22,11,2,
+        234,236,1,0,0,0,235,231,1,0,0,0,236,239,1,0,0,0,237,235,1,0,0,0,
+        237,238,1,0,0,0,238,23,1,0,0,0,239,237,1,0,0,0,240,241,3,38,19,0,
+        241,250,5,3,0,0,242,247,3,16,8,0,243,244,5,2,0,0,244,246,3,16,8,
+        0,245,243,1,0,0,0,246,249,1,0,0,0,247,245,1,0,0,0,247,248,1,0,0,
+        0,248,251,1,0,0,0,249,247,1,0,0,0,250,242,1,0,0,0,250,251,1,0,0,
+        0,251,252,1,0,0,0,252,254,5,4,0,0,253,255,3,30,15,0,254,253,1,0,
+        0,0,254,255,1,0,0,0,255,285,1,0,0,0,256,257,3,38,19,0,257,258,5,
+        3,0,0,258,259,5,5,0,0,259,261,5,4,0,0,260,262,3,30,15,0,261,260,
+        1,0,0,0,261,262,1,0,0,0,262,285,1,0,0,0,263,267,5,25,0,0,264,266,
+        3,28,14,0,265,264,1,0,0,0,266,269,1,0,0,0,267,265,1,0,0,0,267,268,
+        1,0,0,0,268,272,1,0,0,0,269,267,1,0,0,0,270,271,5,29,0,0,271,273,
+        3,16,8,0,272,270,1,0,0,0,272,273,1,0,0,0,273,274,1,0,0,0,274,285,
+        5,30,0,0,275,276,5,3,0,0,276,277,3,2,1,0,277,278,5,4,0,0,278,285,
+        1,0,0,0,279,280,5,3,0,0,280,281,3,16,8,0,281,282,5,4,0,0,282,285,
+        1,0,0,0,283,285,3,26,13,0,284,240,1,0,0,0,284,256,1,0,0,0,284,263,
+        1,0,0,0,284,275,1,0,0,0,284,279,1,0,0,0,284,283,1,0,0,0,285,25,1,
+        0,0,0,286,293,3,38,19,0,287,293,3,46,23,0,288,293,3,48,24,0,289,
+        293,3,50,25,0,290,293,3,52,26,0,291,293,3,54,27,0,292,286,1,0,0,
+        0,292,287,1,0,0,0,292,288,1,0,0,0,292,289,1,0,0,0,292,290,1,0,0,
+        0,292,291,1,0,0,0,293,27,1,0,0,0,294,295,5,55,0,0,295,296,3,16,8,
+        0,296,297,5,52,0,0,297,298,3,16,8,0,298,29,1,0,0,0,299,300,5,49,
+        0,0,300,311,5,3,0,0,301,302,5,47,0,0,302,303,5,24,0,0,303,308,3,
+        32,16,0,304,305,5,2,0,0,305,307,3,32,16,0,306,304,1,0,0,0,307,310,
+        1,0,0,0,308,306,1,0,0,0,308,309,1,0,0,0,309,312,1,0,0,0,310,308,
+        1,0,0,0,311,301,1,0,0,0,311,312,1,0,0,0,312,313,1,0,0,0,313,314,
+        5,4,0,0,314,31,1,0,0,0,315,317,3,16,8,0,316,318,7,1,0,0,317,316,
+        1,0,0,0,317,318,1,0,0,0,318,33,1,0,0,0,319,320,6,17,-1,0,320,321,
+        5,3,0,0,321,322,3,2,1,0,322,323,5,4,0,0,323,330,1,0,0,0,324,325,
+        5,3,0,0,325,326,3,34,17,0,326,327,5,4,0,0,327,330,1,0,0,0,328,330,
+        3,38,19,0,329,319,1,0,0,0,329,324,1,0,0,0,329,328,1,0,0,0,330,348,
+        1,0,0,0,331,333,10,5,0,0,332,334,5,22,0,0,333,332,1,0,0,0,333,334,
+        1,0,0,0,334,335,1,0,0,0,335,347,3,42,21,0,336,338,10,4,0,0,337,339,
+        3,58,29,0,338,337,1,0,0,0,338,339,1,0,0,0,339,340,1,0,0,0,340,341,
+        5,39,0,0,341,344,3,34,17,0,342,343,5,45,0,0,343,345,3,18,9,0,344,
+        342,1,0,0,0,344,345,1,0,0,0,345,347,1,0,0,0,346,331,1,0,0,0,346,
+        336,1,0,0,0,347,350,1,0,0,0,348,346,1,0,0,0,348,349,1,0,0,0,349,
+        35,1,0,0,0,350,348,1,0,0,0,351,356,3,16,8,0,352,353,5,2,0,0,353,
+        355,3,16,8,0,354,352,1,0,0,0,355,358,1,0,0,0,356,354,1,0,0,0,356,
+        357,1,0,0,0,357,37,1,0,0,0,358,356,1,0,0,0,359,364,3,42,21,0,360,
+        361,5,7,0,0,361,363,3,42,21,0,362,360,1,0,0,0,363,366,1,0,0,0,364,
+        362,1,0,0,0,364,365,1,0,0,0,365,39,1,0,0,0,366,364,1,0,0,0,367,372,
+        3,42,21,0,368,369,5,2,0,0,369,371,3,42,21,0,370,368,1,0,0,0,371,
+        374,1,0,0,0,372,370,1,0,0,0,372,373,1,0,0,0,373,41,1,0,0,0,374,372,
+        1,0,0,0,375,378,3,66,33,0,376,378,3,44,22,0,377,375,1,0,0,0,377,
+        376,1,0,0,0,378,43,1,0,0,0,379,380,5,63,0,0,380,45,1,0,0,0,381,385,
+        5,59,0,0,382,385,5,60,0,0,383,385,5,61,0,0,384,381,1,0,0,0,384,382,
+        1,0,0,0,384,383,1,0,0,0,385,47,1,0,0,0,386,387,5,58,0,0,387,49,1,
+        0,0,0,388,389,5,44,0,0,389,51,1,0,0,0,390,391,5,53,0,0,391,53,1,
+        0,0,0,392,393,5,31,0,0,393,55,1,0,0,0,394,395,7,2,0,0,395,57,1,0,
+        0,0,396,409,5,37,0,0,397,409,5,40,0,0,398,399,5,40,0,0,399,409,5,
+        48,0,0,400,409,5,50,0,0,401,402,5,50,0,0,402,409,5,48,0,0,403,409,
+        5,33,0,0,404,405,5,33,0,0,405,409,5,48,0,0,406,409,5,26,0,0,407,
+        409,5,42,0,0,408,396,1,0,0,0,408,397,1,0,0,0,408,398,1,0,0,0,408,
+        400,1,0,0,0,408,401,1,0,0,0,408,403,1,0,0,0,408,404,1,0,0,0,408,
+        406,1,0,0,0,408,407,1,0,0,0,409,59,1,0,0,0,410,411,7,3,0,0,411,61,
+        1,0,0,0,412,413,7,4,0,0,413,63,1,0,0,0,414,415,7,5,0,0,415,65,1,
+        0,0,0,416,417,7,6,0,0,417,67,1,0,0,0,51,80,83,97,102,108,115,124,
+        127,131,136,140,149,152,157,160,162,169,173,181,183,191,195,204,
+        210,218,222,229,237,247,250,254,261,267,272,284,292,308,311,317,
+        329,333,338,344,346,348,356,364,372,377,384,408
+    ]
+
+class MinisqlParser ( Parser ):
+
+    grammarFileName = "Minisql.g4"
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    sharedContextCache = PredictionContextCache()
+
+    literalNames = [ "<INVALID>", "';'", "','", "'('", "')'", "'*'", "'::'", 
+                     "'.'", "'='", "'!='", "'<>'", "'<'", "'<='", "'>'", 
+                     "'>='", "'+'", "'-'", "'/'", "'%'", "'||'", "'all'", 
+                     "'and'", "'as'", "'asc'", "'by'", "'case'", "'cross'", 
+                     "'desc'", "'distinct'", "'else'", "'end'", "'false'", 
+                     "'from'", "'full'", "'group'", "'having'", "'in'", 
+                     "'inner'", "'is'", "'join'", "'left'", "'like'", "'natural'", 
+                     "'not'", "'null'", "'on'", "'or'", "'order'", "'outer'", 
+                     "'over'", "'right'", "'select'", "'then'", "'true'", 
+                     "'union'", "'when'", "'where'", "'with'" ]
+
+    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                      "ALL", "AND", "AS", "ASC", "BY", "CASE", "CROSS", 
+                      "DESC", "DISTINCT", "ELSE", "END", "FALSE", "FROM", 
+                      "FULL", "GROUP", "HAVING", "IN", "INNER", "IS", "JOIN", 
+                      "LEFT", "LIKE", "NATURAL", "NOT", "NULL", "ON", "OR", 
+                      "ORDER", "OUTER", "OVER", "RIGHT", "SELECT", "THEN", 
+                      "TRUE", "UNION", "WHEN", "WHERE", "WITH", "STRING", 
+                      "INTEGER_VALUE", "DECIMAL_VALUE", "FLOAT_VALUE", "IDENT", 
+                      "QUOTED_IDENT", "COMMENT", "BLOCK_COMMENT", "WS", 
+                      "DELIMITER" ]
+
+    RULE_singleStmt = 0
+    RULE_select = 1
+    RULE_cteSelect = 2
+    RULE_cte = 3
+    RULE_unionSelect = 4
+    RULE_unionItem = 5
+    RULE_primarySelect = 6
+    RULE_selectItem = 7
+    RULE_expr = 8
+    RULE_booleanExpr = 9
+    RULE_predicate = 10
+    RULE_valueExpr = 11
+    RULE_primaryExpr = 12
+    RULE_simpleExpr = 13
+    RULE_caseItem = 14
+    RULE_over = 15
+    RULE_sortItem = 16
+    RULE_relation = 17
+    RULE_groupBy = 18
+    RULE_qualifiedName = 19
+    RULE_identList = 20
+    RULE_ident = 21
+    RULE_quotedIdent = 22
+    RULE_number = 23
+    RULE_string = 24
+    RULE_null = 25
+    RULE_true = 26
+    RULE_false = 27
+    RULE_setQuantifier = 28
+    RULE_joinType = 29
+    RULE_cmpOp = 30
+    RULE_arithOp = 31
+    RULE_unaryOp = 32
+    RULE_unquotedIdent = 33
+
+    ruleNames =  [ "singleStmt", "select", "cteSelect", "cte", "unionSelect", 
+                   "unionItem", "primarySelect", "selectItem", "expr", "booleanExpr", 
+                   "predicate", "valueExpr", "primaryExpr", "simpleExpr", 
+                   "caseItem", "over", "sortItem", "relation", "groupBy", 
+                   "qualifiedName", "identList", "ident", "quotedIdent", 
+                   "number", "string", "null", "true", "false", "setQuantifier", 
+                   "joinType", "cmpOp", "arithOp", "unaryOp", "unquotedIdent" ]
+
+    EOF = Token.EOF
+    T__0=1
+    T__1=2
+    T__2=3
+    T__3=4
+    T__4=5
+    T__5=6
+    T__6=7
+    T__7=8
+    T__8=9
+    T__9=10
+    T__10=11
+    T__11=12
+    T__12=13
+    T__13=14
+    T__14=15
+    T__15=16
+    T__16=17
+    T__17=18
+    T__18=19
+    ALL=20
+    AND=21
+    AS=22
+    ASC=23
+    BY=24
+    CASE=25
+    CROSS=26
+    DESC=27
+    DISTINCT=28
+    ELSE=29
+    END=30
+    FALSE=31
+    FROM=32
+    FULL=33
+    GROUP=34
+    HAVING=35
+    IN=36
+    INNER=37
+    IS=38
+    JOIN=39
+    LEFT=40
+    LIKE=41
+    NATURAL=42
+    NOT=43
+    NULL=44
+    ON=45
+    OR=46
+    ORDER=47
+    OUTER=48
+    OVER=49
+    RIGHT=50
+    SELECT=51
+    THEN=52
+    TRUE=53
+    UNION=54
+    WHEN=55
+    WHERE=56
+    WITH=57
+    STRING=58
+    INTEGER_VALUE=59
+    DECIMAL_VALUE=60
+    FLOAT_VALUE=61
+    IDENT=62
+    QUOTED_IDENT=63
+    COMMENT=64
+    BLOCK_COMMENT=65
+    WS=66
+    DELIMITER=67
+
+    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.13.2")
+        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
+        self._predicates = None
+
+
+
+
+    class SingleStmtContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def select(self):
+            return self.getTypedRuleContext(MinisqlParser.SelectContext,0)
+
+
+        def EOF(self):
+            return self.getToken(MinisqlParser.EOF, 0)
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_singleStmt
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSingleStmt" ):
+                listener.enterSingleStmt(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSingleStmt" ):
+                listener.exitSingleStmt(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSingleStmt" ):
+                return visitor.visitSingleStmt(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def singleStmt(self):
+
+        localctx = MinisqlParser.SingleStmtContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 0, self.RULE_singleStmt)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 68
+            self.select()
+            self.state = 69
+            self.match(MinisqlParser.T__0)
+            self.state = 70
+            self.match(MinisqlParser.EOF)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class SelectContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def cteSelect(self):
+            return self.getTypedRuleContext(MinisqlParser.CteSelectContext,0)
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_select
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSelect" ):
+                listener.enterSelect(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSelect" ):
+                listener.exitSelect(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSelect" ):
+                return visitor.visitSelect(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def select(self):
+
+        localctx = MinisqlParser.SelectContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 2, self.RULE_select)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 72
+            self.cteSelect()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class CteSelectContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def unionSelect(self):
+            return self.getTypedRuleContext(MinisqlParser.UnionSelectContext,0)
+
+
+        def WITH(self):
+            return self.getToken(MinisqlParser.WITH, 0)
+
+        def cte(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.CteContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.CteContext,i)
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_cteSelect
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCteSelect" ):
+                listener.enterCteSelect(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCteSelect" ):
+                listener.exitCteSelect(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitCteSelect" ):
+                return visitor.visitCteSelect(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def cteSelect(self):
+
+        localctx = MinisqlParser.CteSelectContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 4, self.RULE_cteSelect)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 83
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==57:
+                self.state = 74
+                self.match(MinisqlParser.WITH)
+                self.state = 75
+                self.cte()
+                self.state = 80
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==2:
+                    self.state = 76
+                    self.match(MinisqlParser.T__1)
+                    self.state = 77
+                    self.cte()
+                    self.state = 82
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+
+
+            self.state = 85
+            self.unionSelect()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class CteContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def ident(self):
+            return self.getTypedRuleContext(MinisqlParser.IdentContext,0)
+
+
+        def AS(self):
+            return self.getToken(MinisqlParser.AS, 0)
+
+        def select(self):
+            return self.getTypedRuleContext(MinisqlParser.SelectContext,0)
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_cte
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCte" ):
+                listener.enterCte(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCte" ):
+                listener.exitCte(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitCte" ):
+                return visitor.visitCte(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def cte(self):
+
+        localctx = MinisqlParser.CteContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 6, self.RULE_cte)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 87
+            self.ident()
+            self.state = 88
+            self.match(MinisqlParser.AS)
+            self.state = 89
+            self.match(MinisqlParser.T__2)
+            self.state = 90
+            self.select()
+            self.state = 91
+            self.match(MinisqlParser.T__3)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class UnionSelectContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def primarySelect(self):
+            return self.getTypedRuleContext(MinisqlParser.PrimarySelectContext,0)
+
+
+        def unionItem(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.UnionItemContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.UnionItemContext,i)
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_unionSelect
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterUnionSelect" ):
+                listener.enterUnionSelect(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitUnionSelect" ):
+                listener.exitUnionSelect(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitUnionSelect" ):
+                return visitor.visitUnionSelect(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def unionSelect(self):
+
+        localctx = MinisqlParser.UnionSelectContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 8, self.RULE_unionSelect)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 93
+            self.primarySelect()
+            self.state = 97
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==54:
+                self.state = 94
+                self.unionItem()
+                self.state = 99
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class UnionItemContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def UNION(self):
+            return self.getToken(MinisqlParser.UNION, 0)
+
+        def primarySelect(self):
+            return self.getTypedRuleContext(MinisqlParser.PrimarySelectContext,0)
+
+
+        def setQuantifier(self):
+            return self.getTypedRuleContext(MinisqlParser.SetQuantifierContext,0)
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_unionItem
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterUnionItem" ):
+                listener.enterUnionItem(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitUnionItem" ):
+                listener.exitUnionItem(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitUnionItem" ):
+                return visitor.visitUnionItem(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def unionItem(self):
+
+        localctx = MinisqlParser.UnionItemContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 10, self.RULE_unionItem)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 100
+            self.match(MinisqlParser.UNION)
+            self.state = 102
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==20 or _la==28:
+                self.state = 101
+                self.setQuantifier()
+
+
+            self.state = 104
+            self.primarySelect()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class PrimarySelectContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+            self.where = None # BooleanExprContext
+            self.having = None # BooleanExprContext
+
+        def SELECT(self):
+            return self.getToken(MinisqlParser.SELECT, 0)
+
+        def selectItem(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.SelectItemContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.SelectItemContext,i)
+
+
+        def setQuantifier(self):
+            return self.getTypedRuleContext(MinisqlParser.SetQuantifierContext,0)
+
+
+        def FROM(self):
+            return self.getToken(MinisqlParser.FROM, 0)
+
+        def relation(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.RelationContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.RelationContext,i)
+
+
+        def WHERE(self):
+            return self.getToken(MinisqlParser.WHERE, 0)
+
+        def GROUP(self):
+            return self.getToken(MinisqlParser.GROUP, 0)
+
+        def BY(self, i:int=None):
+            if i is None:
+                return self.getTokens(MinisqlParser.BY)
+            else:
+                return self.getToken(MinisqlParser.BY, i)
+
+        def groupBy(self):
+            return self.getTypedRuleContext(MinisqlParser.GroupByContext,0)
+
+
+        def HAVING(self):
+            return self.getToken(MinisqlParser.HAVING, 0)
+
+        def ORDER(self):
+            return self.getToken(MinisqlParser.ORDER, 0)
+
+        def sortItem(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.SortItemContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.SortItemContext,i)
+
+
+        def booleanExpr(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.BooleanExprContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.BooleanExprContext,i)
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_primarySelect
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPrimarySelect" ):
+                listener.enterPrimarySelect(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPrimarySelect" ):
+                listener.exitPrimarySelect(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitPrimarySelect" ):
+                return visitor.visitPrimarySelect(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def primarySelect(self):
+
+        localctx = MinisqlParser.PrimarySelectContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 12, self.RULE_primarySelect)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 106
+            self.match(MinisqlParser.SELECT)
+            self.state = 108
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==20 or _la==28:
+                self.state = 107
+                self.setQuantifier()
+
+
+            self.state = 110
+            self.selectItem()
+            self.state = 115
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==2:
+                self.state = 111
+                self.match(MinisqlParser.T__1)
+                self.state = 112
+                self.selectItem()
+                self.state = 117
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+            self.state = 127
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==32:
+                self.state = 118
+                self.match(MinisqlParser.FROM)
+                self.state = 119
+                self.relation(0)
+                self.state = 124
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==2:
+                    self.state = 120
+                    self.match(MinisqlParser.T__1)
+                    self.state = 121
+                    self.relation(0)
+                    self.state = 126
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+
+
+            self.state = 131
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==56:
+                self.state = 129
+                self.match(MinisqlParser.WHERE)
+                self.state = 130
+                localctx.where = self.booleanExpr(0)
+
+
+            self.state = 136
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==34:
+                self.state = 133
+                self.match(MinisqlParser.GROUP)
+                self.state = 134
+                self.match(MinisqlParser.BY)
+                self.state = 135
+                self.groupBy()
+
+
+            self.state = 140
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==35:
+                self.state = 138
+                self.match(MinisqlParser.HAVING)
+                self.state = 139
+                localctx.having = self.booleanExpr(0)
+
+
+            self.state = 152
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==47:
+                self.state = 142
+                self.match(MinisqlParser.ORDER)
+                self.state = 143
+                self.match(MinisqlParser.BY)
+                self.state = 144
+                self.sortItem()
+                self.state = 149
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==2:
+                    self.state = 145
+                    self.match(MinisqlParser.T__1)
+                    self.state = 146
+                    self.sortItem()
+                    self.state = 151
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class SelectItemContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_selectItem
+
+     
+        def copyFrom(self, ctx:ParserRuleContext):
+            super().copyFrom(ctx)
+
+
+
+    class ExprSelectItemContext(SelectItemContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.SelectItemContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def expr(self):
+            return self.getTypedRuleContext(MinisqlParser.ExprContext,0)
+
+        def ident(self):
+            return self.getTypedRuleContext(MinisqlParser.IdentContext,0)
+
+        def AS(self):
+            return self.getToken(MinisqlParser.AS, 0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterExprSelectItem" ):
+                listener.enterExprSelectItem(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitExprSelectItem" ):
+                listener.exitExprSelectItem(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitExprSelectItem" ):
+                return visitor.visitExprSelectItem(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class AllSelectItemContext(SelectItemContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.SelectItemContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAllSelectItem" ):
+                listener.enterAllSelectItem(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAllSelectItem" ):
+                listener.exitAllSelectItem(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAllSelectItem" ):
+                return visitor.visitAllSelectItem(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def selectItem(self):
+
+        localctx = MinisqlParser.SelectItemContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 14, self.RULE_selectItem)
+        self._la = 0 # Token type
+        try:
+            self.state = 162
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [5]:
+                localctx = MinisqlParser.AllSelectItemContext(self, localctx)
+                self.enterOuterAlt(localctx, 1)
+                self.state = 154
+                self.match(MinisqlParser.T__4)
+                pass
+            elif token in [3, 15, 16, 25, 31, 40, 43, 44, 50, 53, 58, 59, 60, 61, 62, 63]:
+                localctx = MinisqlParser.ExprSelectItemContext(self, localctx)
+                self.enterOuterAlt(localctx, 2)
+                self.state = 155
+                self.expr()
+                self.state = 160
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4610559019004723200) != 0):
+                    self.state = 157
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    if _la==22:
+                        self.state = 156
+                        self.match(MinisqlParser.AS)
+
+
+                    self.state = 159
+                    self.ident()
+
+
+                pass
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ExprContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def booleanExpr(self):
+            return self.getTypedRuleContext(MinisqlParser.BooleanExprContext,0)
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_expr
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterExpr" ):
+                listener.enterExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitExpr" ):
+                listener.exitExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitExpr" ):
+                return visitor.visitExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def expr(self):
+
+        localctx = MinisqlParser.ExprContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 16, self.RULE_expr)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 164
+            self.booleanExpr(0)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class BooleanExprContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_booleanExpr
+
+     
+        def copyFrom(self, ctx:ParserRuleContext):
+            super().copyFrom(ctx)
+
+
+    class UnaryBooleanExprContext(BooleanExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.BooleanExprContext
+            super().__init__(parser)
+            self.op = None # Token
+            self.copyFrom(ctx)
+
+        def booleanExpr(self):
+            return self.getTypedRuleContext(MinisqlParser.BooleanExprContext,0)
+
+        def NOT(self):
+            return self.getToken(MinisqlParser.NOT, 0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterUnaryBooleanExpr" ):
+                listener.enterUnaryBooleanExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitUnaryBooleanExpr" ):
+                listener.exitUnaryBooleanExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitUnaryBooleanExpr" ):
+                return visitor.visitUnaryBooleanExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class PredicatedBooleanExprContext(BooleanExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.BooleanExprContext
+            super().__init__(parser)
+            self._valueExpr = None # ValueExprContext
+            self.copyFrom(ctx)
+
+        def valueExpr(self):
+            return self.getTypedRuleContext(MinisqlParser.ValueExprContext,0)
+
+        def predicate(self):
+            return self.getTypedRuleContext(MinisqlParser.PredicateContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPredicatedBooleanExpr" ):
+                listener.enterPredicatedBooleanExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPredicatedBooleanExpr" ):
+                listener.exitPredicatedBooleanExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitPredicatedBooleanExpr" ):
+                return visitor.visitPredicatedBooleanExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class BinaryBooleanExprContext(BooleanExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.BooleanExprContext
+            super().__init__(parser)
+            self.op = None # Token
+            self.copyFrom(ctx)
+
+        def booleanExpr(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.BooleanExprContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.BooleanExprContext,i)
+
+        def AND(self):
+            return self.getToken(MinisqlParser.AND, 0)
+        def OR(self):
+            return self.getToken(MinisqlParser.OR, 0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterBinaryBooleanExpr" ):
+                listener.enterBinaryBooleanExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitBinaryBooleanExpr" ):
+                listener.exitBinaryBooleanExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitBinaryBooleanExpr" ):
+                return visitor.visitBinaryBooleanExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class CastBooleanExprContext(BooleanExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.BooleanExprContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def booleanExpr(self):
+            return self.getTypedRuleContext(MinisqlParser.BooleanExprContext,0)
+
+        def ident(self):
+            return self.getTypedRuleContext(MinisqlParser.IdentContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCastBooleanExpr" ):
+                listener.enterCastBooleanExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCastBooleanExpr" ):
+                listener.exitCastBooleanExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitCastBooleanExpr" ):
+                return visitor.visitCastBooleanExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def booleanExpr(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = MinisqlParser.BooleanExprContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 18
+        self.enterRecursionRule(localctx, 18, self.RULE_booleanExpr, _p)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 173
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [3, 15, 16, 25, 31, 40, 44, 50, 53, 58, 59, 60, 61, 62, 63]:
+                localctx = MinisqlParser.PredicatedBooleanExprContext(self, localctx)
+                self._ctx = localctx
+                _prevctx = localctx
+
+                self.state = 167
+                localctx._valueExpr = self.valueExpr(0)
+                self.state = 169
+                self._errHandler.sync(self)
+                la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
+                if la_ == 1:
+                    self.state = 168
+                    self.predicate(localctx._valueExpr)
+
+
+                pass
+            elif token in [43]:
+                localctx = MinisqlParser.UnaryBooleanExprContext(self, localctx)
+                self._ctx = localctx
+                _prevctx = localctx
+                self.state = 171
+                localctx.op = self.match(MinisqlParser.NOT)
+                self.state = 172
+                self.booleanExpr(3)
+                pass
+            else:
+                raise NoViableAltException(self)
+
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 183
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,19,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    self.state = 181
+                    self._errHandler.sync(self)
+                    la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
+                    if la_ == 1:
+                        localctx = MinisqlParser.BinaryBooleanExprContext(self, MinisqlParser.BooleanExprContext(self, _parentctx, _parentState))
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_booleanExpr)
+                        self.state = 175
+                        if not self.precpred(self._ctx, 2):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
+                        self.state = 176
+                        localctx.op = self._input.LT(1)
+                        _la = self._input.LA(1)
+                        if not(_la==21 or _la==46):
+                            localctx.op = self._errHandler.recoverInline(self)
+                        else:
+                            self._errHandler.reportMatch(self)
+                            self.consume()
+                        self.state = 177
+                        self.booleanExpr(3)
+                        pass
+
+                    elif la_ == 2:
+                        localctx = MinisqlParser.CastBooleanExprContext(self, MinisqlParser.BooleanExprContext(self, _parentctx, _parentState))
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_booleanExpr)
+                        self.state = 178
+                        if not self.precpred(self._ctx, 1):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                        self.state = 179
+                        self.match(MinisqlParser.T__5)
+                        self.state = 180
+                        self.ident()
+                        pass
+
+             
+                self.state = 185
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,19,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+
+    class PredicateContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, value:ParserRuleContext=None):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+            self.value = None
+            self.value = value
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_predicate
+
+     
+        def copyFrom(self, ctx:ParserRuleContext):
+            super().copyFrom(ctx)
+            self.value = ctx.value
+
+
+
+    class IsNullPredicateContext(PredicateContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.PredicateContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def IS(self):
+            return self.getToken(MinisqlParser.IS, 0)
+        def NULL(self):
+            return self.getToken(MinisqlParser.NULL, 0)
+        def NOT(self):
+            return self.getToken(MinisqlParser.NOT, 0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterIsNullPredicate" ):
+                listener.enterIsNullPredicate(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitIsNullPredicate" ):
+                listener.exitIsNullPredicate(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitIsNullPredicate" ):
+                return visitor.visitIsNullPredicate(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class CmpPredicateContext(PredicateContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.PredicateContext
+            super().__init__(parser)
+            self.right = None # ValueExprContext
+            self.copyFrom(ctx)
+
+        def cmpOp(self):
+            return self.getTypedRuleContext(MinisqlParser.CmpOpContext,0)
+
+        def valueExpr(self):
+            return self.getTypedRuleContext(MinisqlParser.ValueExprContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCmpPredicate" ):
+                listener.enterCmpPredicate(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCmpPredicate" ):
+                listener.exitCmpPredicate(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitCmpPredicate" ):
+                return visitor.visitCmpPredicate(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class LikePredicateContext(PredicateContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.PredicateContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def LIKE(self):
+            return self.getToken(MinisqlParser.LIKE, 0)
+        def expr(self):
+            return self.getTypedRuleContext(MinisqlParser.ExprContext,0)
+
+        def NOT(self):
+            return self.getToken(MinisqlParser.NOT, 0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterLikePredicate" ):
+                listener.enterLikePredicate(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitLikePredicate" ):
+                listener.exitLikePredicate(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitLikePredicate" ):
+                return visitor.visitLikePredicate(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class InSelectPredicateContext(PredicateContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.PredicateContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def IN(self):
+            return self.getToken(MinisqlParser.IN, 0)
+        def select(self):
+            return self.getTypedRuleContext(MinisqlParser.SelectContext,0)
+
+        def NOT(self):
+            return self.getToken(MinisqlParser.NOT, 0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInSelectPredicate" ):
+                listener.enterInSelectPredicate(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInSelectPredicate" ):
+                listener.exitInSelectPredicate(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInSelectPredicate" ):
+                return visitor.visitInSelectPredicate(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class InListPredicateContext(PredicateContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.PredicateContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def IN(self):
+            return self.getToken(MinisqlParser.IN, 0)
+        def expr(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.ExprContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.ExprContext,i)
+
+        def NOT(self):
+            return self.getToken(MinisqlParser.NOT, 0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInListPredicate" ):
+                listener.enterInListPredicate(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInListPredicate" ):
+                listener.exitInListPredicate(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInListPredicate" ):
+                return visitor.visitInListPredicate(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def predicate(self, value:ParserRuleContext):
+
+        localctx = MinisqlParser.PredicateContext(self, self._ctx, self.state, value)
+        self.enterRule(localctx, 20, self.RULE_predicate)
+        self._la = 0 # Token type
+        try:
+            self.state = 222
+            self._errHandler.sync(self)
+            la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
+            if la_ == 1:
+                localctx = MinisqlParser.CmpPredicateContext(self, localctx)
+                self.enterOuterAlt(localctx, 1)
+                self.state = 186
+                self.cmpOp()
+                self.state = 187
+                localctx.right = self.valueExpr(0)
+                pass
+
+            elif la_ == 2:
+                localctx = MinisqlParser.IsNullPredicateContext(self, localctx)
+                self.enterOuterAlt(localctx, 2)
+                self.state = 189
+                self.match(MinisqlParser.IS)
+                self.state = 191
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if _la==43:
+                    self.state = 190
+                    self.match(MinisqlParser.NOT)
+
+
+                self.state = 193
+                self.match(MinisqlParser.NULL)
+                pass
+
+            elif la_ == 3:
+                localctx = MinisqlParser.InListPredicateContext(self, localctx)
+                self.enterOuterAlt(localctx, 3)
+                self.state = 195
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if _la==43:
+                    self.state = 194
+                    self.match(MinisqlParser.NOT)
+
+
+                self.state = 197
+                self.match(MinisqlParser.IN)
+                self.state = 198
+                self.match(MinisqlParser.T__2)
+                self.state = 199
+                self.expr()
+                self.state = 204
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==2:
+                    self.state = 200
+                    self.match(MinisqlParser.T__1)
+                    self.state = 201
+                    self.expr()
+                    self.state = 206
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+                self.state = 207
+                self.match(MinisqlParser.T__3)
+                pass
+
+            elif la_ == 4:
+                localctx = MinisqlParser.InSelectPredicateContext(self, localctx)
+                self.enterOuterAlt(localctx, 4)
+                self.state = 210
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if _la==43:
+                    self.state = 209
+                    self.match(MinisqlParser.NOT)
+
+
+                self.state = 212
+                self.match(MinisqlParser.IN)
+                self.state = 213
+                self.match(MinisqlParser.T__2)
+                self.state = 214
+                self.select()
+                self.state = 215
+                self.match(MinisqlParser.T__3)
+                pass
+
+            elif la_ == 5:
+                localctx = MinisqlParser.LikePredicateContext(self, localctx)
+                self.enterOuterAlt(localctx, 5)
+                self.state = 218
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if _la==43:
+                    self.state = 217
+                    self.match(MinisqlParser.NOT)
+
+
+                self.state = 220
+                self.match(MinisqlParser.LIKE)
+                self.state = 221
+                self.expr()
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ValueExprContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_valueExpr
+
+     
+        def copyFrom(self, ctx:ParserRuleContext):
+            super().copyFrom(ctx)
+
+
+    class ArithValueExprContext(ValueExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.ValueExprContext
+            super().__init__(parser)
+            self.left = None # ValueExprContext
+            self.op = None # ArithOpContext
+            self.right = None # ValueExprContext
+            self.copyFrom(ctx)
+
+        def valueExpr(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.ValueExprContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.ValueExprContext,i)
+
+        def arithOp(self):
+            return self.getTypedRuleContext(MinisqlParser.ArithOpContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterArithValueExpr" ):
+                listener.enterArithValueExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitArithValueExpr" ):
+                listener.exitArithValueExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitArithValueExpr" ):
+                return visitor.visitArithValueExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class UnaryValueExprContext(ValueExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.ValueExprContext
+            super().__init__(parser)
+            self.op = None # UnaryOpContext
+            self.copyFrom(ctx)
+
+        def valueExpr(self):
+            return self.getTypedRuleContext(MinisqlParser.ValueExprContext,0)
+
+        def unaryOp(self):
+            return self.getTypedRuleContext(MinisqlParser.UnaryOpContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterUnaryValueExpr" ):
+                listener.enterUnaryValueExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitUnaryValueExpr" ):
+                listener.exitUnaryValueExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitUnaryValueExpr" ):
+                return visitor.visitUnaryValueExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class PrimaryValueExprContext(ValueExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.ValueExprContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def primaryExpr(self):
+            return self.getTypedRuleContext(MinisqlParser.PrimaryExprContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPrimaryValueExpr" ):
+                listener.enterPrimaryValueExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPrimaryValueExpr" ):
+                listener.exitPrimaryValueExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitPrimaryValueExpr" ):
+                return visitor.visitPrimaryValueExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def valueExpr(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = MinisqlParser.ValueExprContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 22
+        self.enterRecursionRule(localctx, 22, self.RULE_valueExpr, _p)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 229
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [3, 25, 31, 40, 44, 50, 53, 58, 59, 60, 61, 62, 63]:
+                localctx = MinisqlParser.PrimaryValueExprContext(self, localctx)
+                self._ctx = localctx
+                _prevctx = localctx
+
+                self.state = 225
+                self.primaryExpr()
+                pass
+            elif token in [15, 16]:
+                localctx = MinisqlParser.UnaryValueExprContext(self, localctx)
+                self._ctx = localctx
+                _prevctx = localctx
+                self.state = 226
+                localctx.op = self.unaryOp()
+                self.state = 227
+                self.valueExpr(2)
+                pass
+            else:
+                raise NoViableAltException(self)
+
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 237
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,27,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    localctx = MinisqlParser.ArithValueExprContext(self, MinisqlParser.ValueExprContext(self, _parentctx, _parentState))
+                    localctx.left = _prevctx
+                    self.pushNewRecursionContext(localctx, _startState, self.RULE_valueExpr)
+                    self.state = 231
+                    if not self.precpred(self._ctx, 1):
+                        from antlr4.error.Errors import FailedPredicateException
+                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
+                    self.state = 232
+                    localctx.op = self.arithOp()
+                    self.state = 233
+                    localctx.right = self.valueExpr(2) 
+                self.state = 239
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,27,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+
+    class PrimaryExprContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_primaryExpr
+
+     
+        def copyFrom(self, ctx:ParserRuleContext):
+            super().copyFrom(ctx)
+
+
+
+    class SelectExprContext(PrimaryExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.PrimaryExprContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def select(self):
+            return self.getTypedRuleContext(MinisqlParser.SelectContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSelectExpr" ):
+                listener.enterSelectExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSelectExpr" ):
+                listener.exitSelectExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSelectExpr" ):
+                return visitor.visitSelectExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class SimplePrimaryExprContext(PrimaryExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.PrimaryExprContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def simpleExpr(self):
+            return self.getTypedRuleContext(MinisqlParser.SimpleExprContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSimplePrimaryExpr" ):
+                listener.enterSimplePrimaryExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSimplePrimaryExpr" ):
+                listener.exitSimplePrimaryExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSimplePrimaryExpr" ):
+                return visitor.visitSimplePrimaryExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class StarFunctionCallExprContext(PrimaryExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.PrimaryExprContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def qualifiedName(self):
+            return self.getTypedRuleContext(MinisqlParser.QualifiedNameContext,0)
+
+        def over(self):
+            return self.getTypedRuleContext(MinisqlParser.OverContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterStarFunctionCallExpr" ):
+                listener.enterStarFunctionCallExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitStarFunctionCallExpr" ):
+                listener.exitStarFunctionCallExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitStarFunctionCallExpr" ):
+                return visitor.visitStarFunctionCallExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class FunctionCallExprContext(PrimaryExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.PrimaryExprContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def qualifiedName(self):
+            return self.getTypedRuleContext(MinisqlParser.QualifiedNameContext,0)
+
+        def expr(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.ExprContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.ExprContext,i)
+
+        def over(self):
+            return self.getTypedRuleContext(MinisqlParser.OverContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFunctionCallExpr" ):
+                listener.enterFunctionCallExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFunctionCallExpr" ):
+                listener.exitFunctionCallExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitFunctionCallExpr" ):
+                return visitor.visitFunctionCallExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class CaseExprContext(PrimaryExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.PrimaryExprContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def CASE(self):
+            return self.getToken(MinisqlParser.CASE, 0)
+        def END(self):
+            return self.getToken(MinisqlParser.END, 0)
+        def caseItem(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.CaseItemContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.CaseItemContext,i)
+
+        def ELSE(self):
+            return self.getToken(MinisqlParser.ELSE, 0)
+        def expr(self):
+            return self.getTypedRuleContext(MinisqlParser.ExprContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCaseExpr" ):
+                listener.enterCaseExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCaseExpr" ):
+                listener.exitCaseExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitCaseExpr" ):
+                return visitor.visitCaseExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class ParenExprContext(PrimaryExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.PrimaryExprContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def expr(self):
+            return self.getTypedRuleContext(MinisqlParser.ExprContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterParenExpr" ):
+                listener.enterParenExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitParenExpr" ):
+                listener.exitParenExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitParenExpr" ):
+                return visitor.visitParenExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def primaryExpr(self):
+
+        localctx = MinisqlParser.PrimaryExprContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 24, self.RULE_primaryExpr)
+        self._la = 0 # Token type
+        try:
+            self.state = 284
+            self._errHandler.sync(self)
+            la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
+            if la_ == 1:
+                localctx = MinisqlParser.FunctionCallExprContext(self, localctx)
+                self.enterOuterAlt(localctx, 1)
+                self.state = 240
+                self.qualifiedName()
+                self.state = 241
+                self.match(MinisqlParser.T__2)
+                self.state = 250
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & -278069787018297336) != 0):
+                    self.state = 242
+                    self.expr()
+                    self.state = 247
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    while _la==2:
+                        self.state = 243
+                        self.match(MinisqlParser.T__1)
+                        self.state = 244
+                        self.expr()
+                        self.state = 249
+                        self._errHandler.sync(self)
+                        _la = self._input.LA(1)
+
+
+
+                self.state = 252
+                self.match(MinisqlParser.T__3)
+                self.state = 254
+                self._errHandler.sync(self)
+                la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
+                if la_ == 1:
+                    self.state = 253
+                    self.over()
+
+
+                pass
+
+            elif la_ == 2:
+                localctx = MinisqlParser.StarFunctionCallExprContext(self, localctx)
+                self.enterOuterAlt(localctx, 2)
+                self.state = 256
+                self.qualifiedName()
+                self.state = 257
+                self.match(MinisqlParser.T__2)
+                self.state = 258
+                self.match(MinisqlParser.T__4)
+                self.state = 259
+                self.match(MinisqlParser.T__3)
+                self.state = 261
+                self._errHandler.sync(self)
+                la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
+                if la_ == 1:
+                    self.state = 260
+                    self.over()
+
+
+                pass
+
+            elif la_ == 3:
+                localctx = MinisqlParser.CaseExprContext(self, localctx)
+                self.enterOuterAlt(localctx, 3)
+                self.state = 263
+                self.match(MinisqlParser.CASE)
+                self.state = 267
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==55:
+                    self.state = 264
+                    self.caseItem()
+                    self.state = 269
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+                self.state = 272
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if _la==29:
+                    self.state = 270
+                    self.match(MinisqlParser.ELSE)
+                    self.state = 271
+                    self.expr()
+
+
+                self.state = 274
+                self.match(MinisqlParser.END)
+                pass
+
+            elif la_ == 4:
+                localctx = MinisqlParser.SelectExprContext(self, localctx)
+                self.enterOuterAlt(localctx, 4)
+                self.state = 275
+                self.match(MinisqlParser.T__2)
+                self.state = 276
+                self.select()
+                self.state = 277
+                self.match(MinisqlParser.T__3)
+                pass
+
+            elif la_ == 5:
+                localctx = MinisqlParser.ParenExprContext(self, localctx)
+                self.enterOuterAlt(localctx, 5)
+                self.state = 279
+                self.match(MinisqlParser.T__2)
+                self.state = 280
+                self.expr()
+                self.state = 281
+                self.match(MinisqlParser.T__3)
+                pass
+
+            elif la_ == 6:
+                localctx = MinisqlParser.SimplePrimaryExprContext(self, localctx)
+                self.enterOuterAlt(localctx, 6)
+                self.state = 283
+                self.simpleExpr()
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class SimpleExprContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def qualifiedName(self):
+            return self.getTypedRuleContext(MinisqlParser.QualifiedNameContext,0)
+
+
+        def number(self):
+            return self.getTypedRuleContext(MinisqlParser.NumberContext,0)
+
+
+        def string(self):
+            return self.getTypedRuleContext(MinisqlParser.StringContext,0)
+
+
+        def null(self):
+            return self.getTypedRuleContext(MinisqlParser.NullContext,0)
+
+
+        def true(self):
+            return self.getTypedRuleContext(MinisqlParser.TrueContext,0)
+
+
+        def false(self):
+            return self.getTypedRuleContext(MinisqlParser.FalseContext,0)
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_simpleExpr
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSimpleExpr" ):
+                listener.enterSimpleExpr(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSimpleExpr" ):
+                listener.exitSimpleExpr(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSimpleExpr" ):
+                return visitor.visitSimpleExpr(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def simpleExpr(self):
+
+        localctx = MinisqlParser.SimpleExprContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 26, self.RULE_simpleExpr)
+        try:
+            self.state = 292
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [40, 50, 62, 63]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 286
+                self.qualifiedName()
+                pass
+            elif token in [59, 60, 61]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 287
+                self.number()
+                pass
+            elif token in [58]:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 288
+                self.string()
+                pass
+            elif token in [44]:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 289
+                self.null()
+                pass
+            elif token in [53]:
+                self.enterOuterAlt(localctx, 5)
+                self.state = 290
+                self.true()
+                pass
+            elif token in [31]:
+                self.enterOuterAlt(localctx, 6)
+                self.state = 291
+                self.false()
+                pass
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class CaseItemContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def WHEN(self):
+            return self.getToken(MinisqlParser.WHEN, 0)
+
+        def expr(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.ExprContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.ExprContext,i)
+
+
+        def THEN(self):
+            return self.getToken(MinisqlParser.THEN, 0)
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_caseItem
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCaseItem" ):
+                listener.enterCaseItem(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCaseItem" ):
+                listener.exitCaseItem(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitCaseItem" ):
+                return visitor.visitCaseItem(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def caseItem(self):
+
+        localctx = MinisqlParser.CaseItemContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 28, self.RULE_caseItem)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 294
+            self.match(MinisqlParser.WHEN)
+            self.state = 295
+            self.expr()
+            self.state = 296
+            self.match(MinisqlParser.THEN)
+            self.state = 297
+            self.expr()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class OverContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def OVER(self):
+            return self.getToken(MinisqlParser.OVER, 0)
+
+        def ORDER(self):
+            return self.getToken(MinisqlParser.ORDER, 0)
+
+        def BY(self):
+            return self.getToken(MinisqlParser.BY, 0)
+
+        def sortItem(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.SortItemContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.SortItemContext,i)
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_over
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterOver" ):
+                listener.enterOver(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitOver" ):
+                listener.exitOver(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitOver" ):
+                return visitor.visitOver(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def over(self):
+
+        localctx = MinisqlParser.OverContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 30, self.RULE_over)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 299
+            self.match(MinisqlParser.OVER)
+            self.state = 300
+            self.match(MinisqlParser.T__2)
+            self.state = 311
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==47:
+                self.state = 301
+                self.match(MinisqlParser.ORDER)
+                self.state = 302
+                self.match(MinisqlParser.BY)
+                self.state = 303
+                self.sortItem()
+                self.state = 308
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==2:
+                    self.state = 304
+                    self.match(MinisqlParser.T__1)
+                    self.state = 305
+                    self.sortItem()
+                    self.state = 310
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+
+
+            self.state = 313
+            self.match(MinisqlParser.T__3)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class SortItemContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+            self.direction = None # Token
+
+        def expr(self):
+            return self.getTypedRuleContext(MinisqlParser.ExprContext,0)
+
+
+        def ASC(self):
+            return self.getToken(MinisqlParser.ASC, 0)
+
+        def DESC(self):
+            return self.getToken(MinisqlParser.DESC, 0)
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_sortItem
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSortItem" ):
+                listener.enterSortItem(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSortItem" ):
+                listener.exitSortItem(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSortItem" ):
+                return visitor.visitSortItem(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def sortItem(self):
+
+        localctx = MinisqlParser.SortItemContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 32, self.RULE_sortItem)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 315
+            self.expr()
+            self.state = 317
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==23 or _la==27:
+                self.state = 316
+                localctx.direction = self._input.LT(1)
+                _la = self._input.LA(1)
+                if not(_la==23 or _la==27):
+                    localctx.direction = self._errHandler.recoverInline(self)
+                else:
+                    self._errHandler.reportMatch(self)
+                    self.consume()
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class RelationContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_relation
+
+     
+        def copyFrom(self, ctx:ParserRuleContext):
+            super().copyFrom(ctx)
+
+
+    class AliasedRelationContext(RelationContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.RelationContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def relation(self):
+            return self.getTypedRuleContext(MinisqlParser.RelationContext,0)
+
+        def ident(self):
+            return self.getTypedRuleContext(MinisqlParser.IdentContext,0)
+
+        def AS(self):
+            return self.getToken(MinisqlParser.AS, 0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterAliasedRelation" ):
+                listener.enterAliasedRelation(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitAliasedRelation" ):
+                listener.exitAliasedRelation(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAliasedRelation" ):
+                return visitor.visitAliasedRelation(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class JoinRelationContext(RelationContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.RelationContext
+            super().__init__(parser)
+            self.left = None # RelationContext
+            self.ty = None # JoinTypeContext
+            self.right = None # RelationContext
+            self.cond = None # BooleanExprContext
+            self.copyFrom(ctx)
+
+        def JOIN(self):
+            return self.getToken(MinisqlParser.JOIN, 0)
+        def relation(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.RelationContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.RelationContext,i)
+
+        def ON(self):
+            return self.getToken(MinisqlParser.ON, 0)
+        def joinType(self):
+            return self.getTypedRuleContext(MinisqlParser.JoinTypeContext,0)
+
+        def booleanExpr(self):
+            return self.getTypedRuleContext(MinisqlParser.BooleanExprContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterJoinRelation" ):
+                listener.enterJoinRelation(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitJoinRelation" ):
+                listener.exitJoinRelation(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitJoinRelation" ):
+                return visitor.visitJoinRelation(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class SelectRelationContext(RelationContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.RelationContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def select(self):
+            return self.getTypedRuleContext(MinisqlParser.SelectContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSelectRelation" ):
+                listener.enterSelectRelation(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSelectRelation" ):
+                listener.exitSelectRelation(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSelectRelation" ):
+                return visitor.visitSelectRelation(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class TableRelationContext(RelationContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.RelationContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def qualifiedName(self):
+            return self.getTypedRuleContext(MinisqlParser.QualifiedNameContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTableRelation" ):
+                listener.enterTableRelation(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTableRelation" ):
+                listener.exitTableRelation(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitTableRelation" ):
+                return visitor.visitTableRelation(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class ParenRelationContext(RelationContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.RelationContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def relation(self):
+            return self.getTypedRuleContext(MinisqlParser.RelationContext,0)
+
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterParenRelation" ):
+                listener.enterParenRelation(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitParenRelation" ):
+                listener.exitParenRelation(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitParenRelation" ):
+                return visitor.visitParenRelation(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def relation(self, _p:int=0):
+        _parentctx = self._ctx
+        _parentState = self.state
+        localctx = MinisqlParser.RelationContext(self, self._ctx, _parentState)
+        _prevctx = localctx
+        _startState = 34
+        self.enterRecursionRule(localctx, 34, self.RULE_relation, _p)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 329
+            self._errHandler.sync(self)
+            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
+            if la_ == 1:
+                localctx = MinisqlParser.SelectRelationContext(self, localctx)
+                self._ctx = localctx
+                _prevctx = localctx
+
+                self.state = 320
+                self.match(MinisqlParser.T__2)
+                self.state = 321
+                self.select()
+                self.state = 322
+                self.match(MinisqlParser.T__3)
+                pass
+
+            elif la_ == 2:
+                localctx = MinisqlParser.ParenRelationContext(self, localctx)
+                self._ctx = localctx
+                _prevctx = localctx
+                self.state = 324
+                self.match(MinisqlParser.T__2)
+                self.state = 325
+                self.relation(0)
+                self.state = 326
+                self.match(MinisqlParser.T__3)
+                pass
+
+            elif la_ == 3:
+                localctx = MinisqlParser.TableRelationContext(self, localctx)
+                self._ctx = localctx
+                _prevctx = localctx
+                self.state = 328
+                self.qualifiedName()
+                pass
+
+
+            self._ctx.stop = self._input.LT(-1)
+            self.state = 348
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,44,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    if self._parseListeners is not None:
+                        self.triggerExitRuleEvent()
+                    _prevctx = localctx
+                    self.state = 346
+                    self._errHandler.sync(self)
+                    la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
+                    if la_ == 1:
+                        localctx = MinisqlParser.AliasedRelationContext(self, MinisqlParser.RelationContext(self, _parentctx, _parentState))
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_relation)
+                        self.state = 331
+                        if not self.precpred(self._ctx, 5):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
+                        self.state = 333
+                        self._errHandler.sync(self)
+                        _la = self._input.LA(1)
+                        if _la==22:
+                            self.state = 332
+                            self.match(MinisqlParser.AS)
+
+
+                        self.state = 335
+                        self.ident()
+                        pass
+
+                    elif la_ == 2:
+                        localctx = MinisqlParser.JoinRelationContext(self, MinisqlParser.RelationContext(self, _parentctx, _parentState))
+                        localctx.left = _prevctx
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_relation)
+                        self.state = 336
+                        if not self.precpred(self._ctx, 4):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
+                        self.state = 338
+                        self._errHandler.sync(self)
+                        _la = self._input.LA(1)
+                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1131543560978432) != 0):
+                            self.state = 337
+                            localctx.ty = self.joinType()
+
+
+                        self.state = 340
+                        self.match(MinisqlParser.JOIN)
+                        self.state = 341
+                        localctx.right = self.relation(0)
+                        self.state = 344
+                        self._errHandler.sync(self)
+                        la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
+                        if la_ == 1:
+                            self.state = 342
+                            self.match(MinisqlParser.ON)
+                            self.state = 343
+                            localctx.cond = self.booleanExpr(0)
+
+
+                        pass
+
+             
+                self.state = 350
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,44,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+
+    class GroupByContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def expr(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.ExprContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.ExprContext,i)
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_groupBy
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterGroupBy" ):
+                listener.enterGroupBy(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitGroupBy" ):
+                listener.exitGroupBy(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitGroupBy" ):
+                return visitor.visitGroupBy(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def groupBy(self):
+
+        localctx = MinisqlParser.GroupByContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 36, self.RULE_groupBy)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 351
+            self.expr()
+            self.state = 356
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==2:
+                self.state = 352
+                self.match(MinisqlParser.T__1)
+                self.state = 353
+                self.expr()
+                self.state = 358
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class QualifiedNameContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def ident(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.IdentContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.IdentContext,i)
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_qualifiedName
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterQualifiedName" ):
+                listener.enterQualifiedName(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitQualifiedName" ):
+                listener.exitQualifiedName(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitQualifiedName" ):
+                return visitor.visitQualifiedName(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def qualifiedName(self):
+
+        localctx = MinisqlParser.QualifiedNameContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 38, self.RULE_qualifiedName)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 359
+            self.ident()
+            self.state = 364
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,46,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    self.state = 360
+                    self.match(MinisqlParser.T__6)
+                    self.state = 361
+                    self.ident() 
+                self.state = 366
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,46,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class IdentListContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def ident(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(MinisqlParser.IdentContext)
+            else:
+                return self.getTypedRuleContext(MinisqlParser.IdentContext,i)
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_identList
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterIdentList" ):
+                listener.enterIdentList(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitIdentList" ):
+                listener.exitIdentList(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitIdentList" ):
+                return visitor.visitIdentList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def identList(self):
+
+        localctx = MinisqlParser.IdentListContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 40, self.RULE_identList)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 367
+            self.ident()
+            self.state = 372
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==2:
+                self.state = 368
+                self.match(MinisqlParser.T__1)
+                self.state = 369
+                self.ident()
+                self.state = 374
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class IdentContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def unquotedIdent(self):
+            return self.getTypedRuleContext(MinisqlParser.UnquotedIdentContext,0)
+
+
+        def quotedIdent(self):
+            return self.getTypedRuleContext(MinisqlParser.QuotedIdentContext,0)
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_ident
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterIdent" ):
+                listener.enterIdent(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitIdent" ):
+                listener.exitIdent(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitIdent" ):
+                return visitor.visitIdent(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def ident(self):
+
+        localctx = MinisqlParser.IdentContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 42, self.RULE_ident)
+        try:
+            self.state = 377
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [40, 50, 62]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 375
+                self.unquotedIdent()
+                pass
+            elif token in [63]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 376
+                self.quotedIdent()
+                pass
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class QuotedIdentContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def QUOTED_IDENT(self):
+            return self.getToken(MinisqlParser.QUOTED_IDENT, 0)
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_quotedIdent
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterQuotedIdent" ):
+                listener.enterQuotedIdent(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitQuotedIdent" ):
+                listener.exitQuotedIdent(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitQuotedIdent" ):
+                return visitor.visitQuotedIdent(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def quotedIdent(self):
+
+        localctx = MinisqlParser.QuotedIdentContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 44, self.RULE_quotedIdent)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 379
+            self.match(MinisqlParser.QUOTED_IDENT)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class NumberContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_number
+
+     
+        def copyFrom(self, ctx:ParserRuleContext):
+            super().copyFrom(ctx)
+
+
+
+    class DecimalNumberContext(NumberContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.NumberContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def DECIMAL_VALUE(self):
+            return self.getToken(MinisqlParser.DECIMAL_VALUE, 0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDecimalNumber" ):
+                listener.enterDecimalNumber(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDecimalNumber" ):
+                listener.exitDecimalNumber(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDecimalNumber" ):
+                return visitor.visitDecimalNumber(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class IntegerNumberContext(NumberContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.NumberContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def INTEGER_VALUE(self):
+            return self.getToken(MinisqlParser.INTEGER_VALUE, 0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterIntegerNumber" ):
+                listener.enterIntegerNumber(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitIntegerNumber" ):
+                listener.exitIntegerNumber(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitIntegerNumber" ):
+                return visitor.visitIntegerNumber(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class FloatNumberContext(NumberContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a MinisqlParser.NumberContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def FLOAT_VALUE(self):
+            return self.getToken(MinisqlParser.FLOAT_VALUE, 0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFloatNumber" ):
+                listener.enterFloatNumber(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFloatNumber" ):
+                listener.exitFloatNumber(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitFloatNumber" ):
+                return visitor.visitFloatNumber(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def number(self):
+
+        localctx = MinisqlParser.NumberContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 46, self.RULE_number)
+        try:
+            self.state = 384
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [59]:
+                localctx = MinisqlParser.IntegerNumberContext(self, localctx)
+                self.enterOuterAlt(localctx, 1)
+                self.state = 381
+                self.match(MinisqlParser.INTEGER_VALUE)
+                pass
+            elif token in [60]:
+                localctx = MinisqlParser.DecimalNumberContext(self, localctx)
+                self.enterOuterAlt(localctx, 2)
+                self.state = 382
+                self.match(MinisqlParser.DECIMAL_VALUE)
+                pass
+            elif token in [61]:
+                localctx = MinisqlParser.FloatNumberContext(self, localctx)
+                self.enterOuterAlt(localctx, 3)
+                self.state = 383
+                self.match(MinisqlParser.FLOAT_VALUE)
+                pass
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class StringContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def STRING(self):
+            return self.getToken(MinisqlParser.STRING, 0)
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_string
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterString" ):
+                listener.enterString(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitString" ):
+                listener.exitString(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitString" ):
+                return visitor.visitString(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def string(self):
+
+        localctx = MinisqlParser.StringContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 48, self.RULE_string)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 386
+            self.match(MinisqlParser.STRING)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class NullContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def NULL(self):
+            return self.getToken(MinisqlParser.NULL, 0)
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_null
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterNull" ):
+                listener.enterNull(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitNull" ):
+                listener.exitNull(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitNull" ):
+                return visitor.visitNull(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def null(self):
+
+        localctx = MinisqlParser.NullContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 50, self.RULE_null)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 388
+            self.match(MinisqlParser.NULL)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class TrueContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def TRUE(self):
+            return self.getToken(MinisqlParser.TRUE, 0)
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_true
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterTrue" ):
+                listener.enterTrue(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitTrue" ):
+                listener.exitTrue(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitTrue" ):
+                return visitor.visitTrue(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def true(self):
+
+        localctx = MinisqlParser.TrueContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 52, self.RULE_true)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 390
+            self.match(MinisqlParser.TRUE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class FalseContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def FALSE(self):
+            return self.getToken(MinisqlParser.FALSE, 0)
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_false
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterFalse" ):
+                listener.enterFalse(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitFalse" ):
+                listener.exitFalse(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitFalse" ):
+                return visitor.visitFalse(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def false(self):
+
+        localctx = MinisqlParser.FalseContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 54, self.RULE_false)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 392
+            self.match(MinisqlParser.FALSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class SetQuantifierContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def DISTINCT(self):
+            return self.getToken(MinisqlParser.DISTINCT, 0)
+
+        def ALL(self):
+            return self.getToken(MinisqlParser.ALL, 0)
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_setQuantifier
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSetQuantifier" ):
+                listener.enterSetQuantifier(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSetQuantifier" ):
+                listener.exitSetQuantifier(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSetQuantifier" ):
+                return visitor.visitSetQuantifier(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def setQuantifier(self):
+
+        localctx = MinisqlParser.SetQuantifierContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 56, self.RULE_setQuantifier)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 394
+            _la = self._input.LA(1)
+            if not(_la==20 or _la==28):
+                self._errHandler.recoverInline(self)
+            else:
+                self._errHandler.reportMatch(self)
+                self.consume()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class JoinTypeContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def INNER(self):
+            return self.getToken(MinisqlParser.INNER, 0)
+
+        def LEFT(self):
+            return self.getToken(MinisqlParser.LEFT, 0)
+
+        def OUTER(self):
+            return self.getToken(MinisqlParser.OUTER, 0)
+
+        def RIGHT(self):
+            return self.getToken(MinisqlParser.RIGHT, 0)
+
+        def FULL(self):
+            return self.getToken(MinisqlParser.FULL, 0)
+
+        def CROSS(self):
+            return self.getToken(MinisqlParser.CROSS, 0)
+
+        def NATURAL(self):
+            return self.getToken(MinisqlParser.NATURAL, 0)
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_joinType
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterJoinType" ):
+                listener.enterJoinType(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitJoinType" ):
+                listener.exitJoinType(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitJoinType" ):
+                return visitor.visitJoinType(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def joinType(self):
+
+        localctx = MinisqlParser.JoinTypeContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 58, self.RULE_joinType)
+        try:
+            self.state = 408
+            self._errHandler.sync(self)
+            la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 396
+                self.match(MinisqlParser.INNER)
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 397
+                self.match(MinisqlParser.LEFT)
+                pass
+
+            elif la_ == 3:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 398
+                self.match(MinisqlParser.LEFT)
+                self.state = 399
+                self.match(MinisqlParser.OUTER)
+                pass
+
+            elif la_ == 4:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 400
+                self.match(MinisqlParser.RIGHT)
+                pass
+
+            elif la_ == 5:
+                self.enterOuterAlt(localctx, 5)
+                self.state = 401
+                self.match(MinisqlParser.RIGHT)
+                self.state = 402
+                self.match(MinisqlParser.OUTER)
+                pass
+
+            elif la_ == 6:
+                self.enterOuterAlt(localctx, 6)
+                self.state = 403
+                self.match(MinisqlParser.FULL)
+                pass
+
+            elif la_ == 7:
+                self.enterOuterAlt(localctx, 7)
+                self.state = 404
+                self.match(MinisqlParser.FULL)
+                self.state = 405
+                self.match(MinisqlParser.OUTER)
+                pass
+
+            elif la_ == 8:
+                self.enterOuterAlt(localctx, 8)
+                self.state = 406
+                self.match(MinisqlParser.CROSS)
+                pass
+
+            elif la_ == 9:
+                self.enterOuterAlt(localctx, 9)
+                self.state = 407
+                self.match(MinisqlParser.NATURAL)
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class CmpOpContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_cmpOp
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterCmpOp" ):
+                listener.enterCmpOp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitCmpOp" ):
+                listener.exitCmpOp(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitCmpOp" ):
+                return visitor.visitCmpOp(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def cmpOp(self):
+
+        localctx = MinisqlParser.CmpOpContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 60, self.RULE_cmpOp)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 410
+            _la = self._input.LA(1)
+            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 32512) != 0)):
+                self._errHandler.recoverInline(self)
+            else:
+                self._errHandler.reportMatch(self)
+                self.consume()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ArithOpContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_arithOp
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterArithOp" ):
+                listener.enterArithOp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitArithOp" ):
+                listener.exitArithOp(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitArithOp" ):
+                return visitor.visitArithOp(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def arithOp(self):
+
+        localctx = MinisqlParser.ArithOpContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 62, self.RULE_arithOp)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 412
+            _la = self._input.LA(1)
+            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 1015840) != 0)):
+                self._errHandler.recoverInline(self)
+            else:
+                self._errHandler.reportMatch(self)
+                self.consume()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class UnaryOpContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_unaryOp
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterUnaryOp" ):
+                listener.enterUnaryOp(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitUnaryOp" ):
+                listener.exitUnaryOp(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitUnaryOp" ):
+                return visitor.visitUnaryOp(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def unaryOp(self):
+
+        localctx = MinisqlParser.UnaryOpContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 64, self.RULE_unaryOp)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 414
+            _la = self._input.LA(1)
+            if not(_la==15 or _la==16):
+                self._errHandler.recoverInline(self)
+            else:
+                self._errHandler.reportMatch(self)
+                self.consume()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class UnquotedIdentContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def IDENT(self):
+            return self.getToken(MinisqlParser.IDENT, 0)
+
+        def LEFT(self):
+            return self.getToken(MinisqlParser.LEFT, 0)
+
+        def RIGHT(self):
+            return self.getToken(MinisqlParser.RIGHT, 0)
+
+        def getRuleIndex(self):
+            return MinisqlParser.RULE_unquotedIdent
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterUnquotedIdent" ):
+                listener.enterUnquotedIdent(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitUnquotedIdent" ):
+                listener.exitUnquotedIdent(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitUnquotedIdent" ):
+                return visitor.visitUnquotedIdent(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def unquotedIdent(self):
+
+        localctx = MinisqlParser.UnquotedIdentContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 66, self.RULE_unquotedIdent)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 416
+            _la = self._input.LA(1)
+            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 4612813017845858304) != 0)):
+                self._errHandler.recoverInline(self)
+            else:
+                self._errHandler.reportMatch(self)
+                self.consume()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+
+    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
+        if self._predicates == None:
+            self._predicates = dict()
+        self._predicates[9] = self.booleanExpr_sempred
+        self._predicates[11] = self.valueExpr_sempred
+        self._predicates[17] = self.relation_sempred
+        pred = self._predicates.get(ruleIndex, None)
+        if pred is None:
+            raise Exception("No predicate with index:" + str(ruleIndex))
+        else:
+            return pred(localctx, predIndex)
+
+    def booleanExpr_sempred(self, localctx:BooleanExprContext, predIndex:int):
+            if predIndex == 0:
+                return self.precpred(self._ctx, 2)
+         
+
+            if predIndex == 1:
+                return self.precpred(self._ctx, 1)
+         
+
+    def valueExpr_sempred(self, localctx:ValueExprContext, predIndex:int):
+            if predIndex == 2:
+                return self.precpred(self._ctx, 1)
+         
+
+    def relation_sempred(self, localctx:RelationContext, predIndex:int):
+            if predIndex == 3:
+                return self.precpred(self._ctx, 5)
+         
+
+            if predIndex == 4:
+                return self.precpred(self._ctx, 4)
+         
+
+
+
+