1<?php
2
3/*
4 * Generated from D:/dokuwiki/lib/plugins/combo/grammar\PageSql.g4 by ANTLR 4.9.3
5 */
6
7namespace ComboStrap\PageSqlParser {
8	use Antlr\Antlr4\Runtime\Atn\ATN;
9	use Antlr\Antlr4\Runtime\Atn\ATNDeserializer;
10	use Antlr\Antlr4\Runtime\Atn\ParserATNSimulator;
11	use Antlr\Antlr4\Runtime\Dfa\DFA;
12	use Antlr\Antlr4\Runtime\Error\Exceptions\FailedPredicateException;
13	use Antlr\Antlr4\Runtime\Error\Exceptions\NoViableAltException;
14	use Antlr\Antlr4\Runtime\PredictionContexts\PredictionContextCache;
15	use Antlr\Antlr4\Runtime\Error\Exceptions\RecognitionException;
16	use Antlr\Antlr4\Runtime\RuleContext;
17	use Antlr\Antlr4\Runtime\Token;
18	use Antlr\Antlr4\Runtime\TokenStream;
19	use Antlr\Antlr4\Runtime\Vocabulary;
20	use Antlr\Antlr4\Runtime\VocabularyImpl;
21	use Antlr\Antlr4\Runtime\RuntimeMetaData;
22	use Antlr\Antlr4\Runtime\Parser;
23
24	final class PageSqlParser extends Parser
25	{
26		public const SCOL = 1, DOT = 2, LPAREN = 3, RPAREN = 4, LSQUARE = 5, RSQUARE = 6,
27               LCURLY = 7, RCURLY = 8, COMMA = 9, BITWISEXOR = 10, DOLLAR = 11,
28               EQUAL = 12, STAR = 13, PLUS = 14, MINUS = 15, TILDE = 16,
29               PIPE2 = 17, DIV = 18, MOD = 19, LT2 = 20, GT2 = 21, AMP = 22,
30               PIPE = 23, QUESTION = 24, LESS_THAN = 25, LESS_THAN_OR_EQUAL = 26,
31               GREATER_THAN = 27, GREATER_THAN_OR_EQUAL = 28, EQ = 29, NOT_EQUAL = 30,
32               NOT_EQ2 = 31, AND = 32, AS = 33, ASC = 34, BETWEEN = 35,
33               BY = 36, DESC = 37, ESCAPE = 38, FALSE = 39, FROM = 40, GLOB = 41,
34               IN = 42, IS = 43, ISNULL = 44, LIKE = 45, LIMIT = 46, NOT = 47,
35               NOTNULL = 48, NOW = 49, NULL = 50, OR = 51, ORDER = 52, SELECT = 53,
36               TRUE = 54, WHERE = 55, RANDOM = 56, DATE = 57, DATETIME = 58,
37               PAGES = 59, BACKLINKS = 60, DESCENDANTS = 61, StringLiteral = 62,
38               CharSetLiteral = 63, IntegralLiteral = 64, Number = 65, NumberLiteral = 66,
39               ByteLengthLiteral = 67, SqlName = 68, SPACES = 69;
40
41		public const RULE_functionNames = 0, RULE_tableNames = 1, RULE_sqlNames = 2,
42               RULE_column = 3, RULE_pattern = 4, RULE_expression = 5, RULE_predicate = 6,
43               RULE_columns = 7, RULE_predicateGroup = 8, RULE_predicates = 9,
44               RULE_tables = 10, RULE_limit = 11, RULE_orderBys = 12, RULE_orderByDef = 13,
45               RULE_pageSql = 14;
46
47		/**
48		 * @var array<string>
49		 */
50		public const RULE_NAMES = [
51			'functionNames', 'tableNames', 'sqlNames', 'column', 'pattern', 'expression',
52			'predicate', 'columns', 'predicateGroup', 'predicates', 'tables', 'limit',
53			'orderBys', 'orderByDef', 'pageSql'
54		];
55
56		/**
57		 * @var array<string|null>
58		 */
59		private const LITERAL_NAMES = [
60		    null, "';'", "'.'", "'('", "')'", "'['", "']'", "'{'", "'}'", "','",
61		    "'^'", "'\$'", "'='", "'*'", "'+'", "'-'", "'~'", "'||'", "'/'", "'%'",
62		    "'<<'", "'>>'", "'&'", "'|'", "'?'", "'<'", "'<='", "'>'", "'>='",
63		    "'=='", "'!='", "'<>'"
64		];
65
66		/**
67		 * @var array<string>
68		 */
69		private const SYMBOLIC_NAMES = [
70		    null, "SCOL", "DOT", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", "LCURLY",
71		    "RCURLY", "COMMA", "BITWISEXOR", "DOLLAR", "EQUAL", "STAR", "PLUS",
72		    "MINUS", "TILDE", "PIPE2", "DIV", "MOD", "LT2", "GT2", "AMP", "PIPE",
73		    "QUESTION", "LESS_THAN", "LESS_THAN_OR_EQUAL", "GREATER_THAN", "GREATER_THAN_OR_EQUAL",
74		    "EQ", "NOT_EQUAL", "NOT_EQ2", "AND", "AS", "ASC", "BETWEEN", "BY",
75		    "DESC", "ESCAPE", "FALSE", "FROM", "GLOB", "IN", "IS", "ISNULL", "LIKE",
76		    "LIMIT", "NOT", "NOTNULL", "NOW", "NULL", "OR", "ORDER", "SELECT",
77		    "TRUE", "WHERE", "RANDOM", "DATE", "DATETIME", "PAGES", "BACKLINKS",
78		    "DESCENDANTS", "StringLiteral", "CharSetLiteral", "IntegralLiteral",
79		    "Number", "NumberLiteral", "ByteLengthLiteral", "SqlName", "SPACES"
80		];
81
82		/**
83		 * @var string
84		 */
85		private const SERIALIZED_ATN =
86			"\u{3}\u{608B}\u{A72A}\u{8133}\u{B9ED}\u{417C}\u{3BE7}\u{7786}\u{5964}" .
87		    "\u{3}\u{47}\u{BD}\u{4}\u{2}\u{9}\u{2}\u{4}\u{3}\u{9}\u{3}\u{4}\u{4}" .
88		    "\u{9}\u{4}\u{4}\u{5}\u{9}\u{5}\u{4}\u{6}\u{9}\u{6}\u{4}\u{7}\u{9}" .
89		    "\u{7}\u{4}\u{8}\u{9}\u{8}\u{4}\u{9}\u{9}\u{9}\u{4}\u{A}\u{9}\u{A}" .
90		    "\u{4}\u{B}\u{9}\u{B}\u{4}\u{C}\u{9}\u{C}\u{4}\u{D}\u{9}\u{D}\u{4}" .
91		    "\u{E}\u{9}\u{E}\u{4}\u{F}\u{9}\u{F}\u{4}\u{10}\u{9}\u{10}\u{3}\u{2}" .
92		    "\u{3}\u{2}\u{3}\u{3}\u{3}\u{3}\u{3}\u{4}\u{3}\u{4}\u{3}\u{5}\u{3}" .
93		    "\u{5}\u{3}\u{5}\u{5}\u{5}\u{2A}\u{A}\u{5}\u{3}\u{5}\u{3}\u{5}\u{3}" .
94		    "\u{5}\u{5}\u{5}\u{2F}\u{A}\u{5}\u{5}\u{5}\u{31}\u{A}\u{5}\u{3}\u{6}" .
95		    "\u{3}\u{6}\u{3}\u{7}\u{3}\u{7}\u{3}\u{7}\u{3}\u{7}\u{5}\u{7}\u{39}" .
96		    "\u{A}\u{7}\u{3}\u{7}\u{3}\u{7}\u{7}\u{7}\u{3D}\u{A}\u{7}\u{C}\u{7}" .
97		    "\u{E}\u{7}\u{40}\u{B}\u{7}\u{3}\u{7}\u{3}\u{7}\u{5}\u{7}\u{44}\u{A}" .
98		    "\u{7}\u{3}\u{8}\u{3}\u{8}\u{3}\u{8}\u{3}\u{8}\u{5}\u{8}\u{4A}\u{A}" .
99		    "\u{8}\u{3}\u{8}\u{3}\u{8}\u{3}\u{8}\u{3}\u{8}\u{5}\u{8}\u{50}\u{A}" .
100		    "\u{8}\u{3}\u{8}\u{3}\u{8}\u{5}\u{8}\u{54}\u{A}\u{8}\u{3}\u{8}\u{5}" .
101		    "\u{8}\u{57}\u{A}\u{8}\u{3}\u{8}\u{3}\u{8}\u{3}\u{8}\u{3}\u{8}\u{3}" .
102		    "\u{8}\u{3}\u{8}\u{5}\u{8}\u{5F}\u{A}\u{8}\u{3}\u{8}\u{3}\u{8}\u{3}" .
103		    "\u{8}\u{3}\u{8}\u{3}\u{8}\u{7}\u{8}\u{66}\u{A}\u{8}\u{C}\u{8}\u{E}" .
104		    "\u{8}\u{69}\u{B}\u{8}\u{5}\u{8}\u{6B}\u{A}\u{8}\u{3}\u{8}\u{5}\u{8}" .
105		    "\u{6E}\u{A}\u{8}\u{3}\u{9}\u{3}\u{9}\u{3}\u{9}\u{7}\u{9}\u{73}\u{A}" .
106		    "\u{9}\u{C}\u{9}\u{E}\u{9}\u{76}\u{B}\u{9}\u{3}\u{A}\u{3}\u{A}\u{3}" .
107		    "\u{A}\u{3}\u{A}\u{7}\u{A}\u{7C}\u{A}\u{A}\u{C}\u{A}\u{E}\u{A}\u{7F}" .
108		    "\u{B}\u{A}\u{3}\u{A}\u{3}\u{A}\u{3}\u{B}\u{3}\u{B}\u{3}\u{B}\u{5}" .
109		    "\u{B}\u{86}\u{A}\u{B}\u{3}\u{B}\u{3}\u{B}\u{3}\u{B}\u{5}\u{B}\u{8B}" .
110		    "\u{A}\u{B}\u{7}\u{B}\u{8D}\u{A}\u{B}\u{C}\u{B}\u{E}\u{B}\u{90}\u{B}" .
111		    "\u{B}\u{3}\u{C}\u{3}\u{C}\u{3}\u{C}\u{3}\u{D}\u{3}\u{D}\u{3}\u{D}" .
112		    "\u{3}\u{E}\u{3}\u{E}\u{3}\u{E}\u{3}\u{E}\u{3}\u{E}\u{3}\u{E}\u{7}" .
113		    "\u{E}\u{9E}\u{A}\u{E}\u{C}\u{E}\u{E}\u{E}\u{A1}\u{B}\u{E}\u{5}\u{E}" .
114		    "\u{A3}\u{A}\u{E}\u{3}\u{F}\u{3}\u{F}\u{5}\u{F}\u{A7}\u{A}\u{F}\u{3}" .
115		    "\u{10}\u{3}\u{10}\u{5}\u{10}\u{AB}\u{A}\u{10}\u{3}\u{10}\u{3}\u{10}" .
116		    "\u{5}\u{10}\u{AF}\u{A}\u{10}\u{3}\u{10}\u{5}\u{10}\u{B2}\u{A}\u{10}" .
117		    "\u{3}\u{10}\u{5}\u{10}\u{B5}\u{A}\u{10}\u{3}\u{10}\u{5}\u{10}\u{B8}" .
118		    "\u{A}\u{10}\u{3}\u{10}\u{5}\u{10}\u{BB}\u{A}\u{10}\u{3}\u{10}\u{2}" .
119		    "\u{2}\u{11}\u{2}\u{4}\u{6}\u{8}\u{A}\u{C}\u{E}\u{10}\u{12}\u{14}\u{16}" .
120		    "\u{18}\u{1A}\u{1C}\u{1E}\u{2}\u{A}\u{3}\u{2}\u{3B}\u{3C}\u{3}\u{2}" .
121		    "\u{3D}\u{3F}\u{4}\u{2}\u{43}\u{43}\u{46}\u{46}\u{4}\u{2}\u{40}\u{40}" .
122		    "\u{44}\u{44}\u{5}\u{2}\u{40}\u{40}\u{43}\u{44}\u{46}\u{46}\u{5}\u{2}" .
123		    "\u{E}\u{E}\u{1B}\u{1E}\u{20}\u{20}\u{4}\u{2}\u{22}\u{22}\u{35}\u{35}" .
124		    "\u{4}\u{2}\u{24}\u{24}\u{27}\u{27}\u{2}\u{CC}\u{2}\u{20}\u{3}\u{2}" .
125		    "\u{2}\u{2}\u{4}\u{22}\u{3}\u{2}\u{2}\u{2}\u{6}\u{24}\u{3}\u{2}\u{2}" .
126		    "\u{2}\u{8}\u{26}\u{3}\u{2}\u{2}\u{2}\u{A}\u{32}\u{3}\u{2}\u{2}\u{2}" .
127		    "\u{C}\u{43}\u{3}\u{2}\u{2}\u{2}\u{E}\u{45}\u{3}\u{2}\u{2}\u{2}\u{10}" .
128		    "\u{6F}\u{3}\u{2}\u{2}\u{2}\u{12}\u{77}\u{3}\u{2}\u{2}\u{2}\u{14}\u{82}" .
129		    "\u{3}\u{2}\u{2}\u{2}\u{16}\u{91}\u{3}\u{2}\u{2}\u{2}\u{18}\u{94}\u{3}" .
130		    "\u{2}\u{2}\u{2}\u{1A}\u{97}\u{3}\u{2}\u{2}\u{2}\u{1C}\u{A4}\u{3}\u{2}" .
131		    "\u{2}\u{2}\u{1E}\u{A8}\u{3}\u{2}\u{2}\u{2}\u{20}\u{21}\u{9}\u{2}\u{2}" .
132		    "\u{2}\u{21}\u{3}\u{3}\u{2}\u{2}\u{2}\u{22}\u{23}\u{9}\u{3}\u{2}\u{2}" .
133		    "\u{23}\u{5}\u{3}\u{2}\u{2}\u{2}\u{24}\u{25}\u{9}\u{4}\u{2}\u{2}\u{25}" .
134		    "\u{7}\u{3}\u{2}\u{2}\u{2}\u{26}\u{29}\u{5}\u{6}\u{4}\u{2}\u{27}\u{28}" .
135		    "\u{7}\u{4}\u{2}\u{2}\u{28}\u{2A}\u{5}\u{6}\u{4}\u{2}\u{29}\u{27}\u{3}" .
136		    "\u{2}\u{2}\u{2}\u{29}\u{2A}\u{3}\u{2}\u{2}\u{2}\u{2A}\u{30}\u{3}\u{2}" .
137		    "\u{2}\u{2}\u{2B}\u{2E}\u{7}\u{23}\u{2}\u{2}\u{2C}\u{2F}\u{5}\u{6}" .
138		    "\u{4}\u{2}\u{2D}\u{2F}\u{7}\u{40}\u{2}\u{2}\u{2E}\u{2C}\u{3}\u{2}" .
139		    "\u{2}\u{2}\u{2E}\u{2D}\u{3}\u{2}\u{2}\u{2}\u{2F}\u{31}\u{3}\u{2}\u{2}" .
140		    "\u{2}\u{30}\u{2B}\u{3}\u{2}\u{2}\u{2}\u{30}\u{31}\u{3}\u{2}\u{2}\u{2}" .
141		    "\u{31}\u{9}\u{3}\u{2}\u{2}\u{2}\u{32}\u{33}\u{9}\u{5}\u{2}\u{2}\u{33}" .
142		    "\u{B}\u{3}\u{2}\u{2}\u{2}\u{34}\u{44}\u{9}\u{6}\u{2}\u{2}\u{35}\u{36}" .
143		    "\u{5}\u{2}\u{2}\u{2}\u{36}\u{38}\u{7}\u{5}\u{2}\u{2}\u{37}\u{39}\u{5}" .
144		    "\u{C}\u{7}\u{2}\u{38}\u{37}\u{3}\u{2}\u{2}\u{2}\u{38}\u{39}\u{3}\u{2}" .
145		    "\u{2}\u{2}\u{39}\u{3E}\u{3}\u{2}\u{2}\u{2}\u{3A}\u{3B}\u{7}\u{B}\u{2}" .
146		    "\u{2}\u{3B}\u{3D}\u{5}\u{C}\u{7}\u{2}\u{3C}\u{3A}\u{3}\u{2}\u{2}\u{2}" .
147		    "\u{3D}\u{40}\u{3}\u{2}\u{2}\u{2}\u{3E}\u{3C}\u{3}\u{2}\u{2}\u{2}\u{3E}" .
148		    "\u{3F}\u{3}\u{2}\u{2}\u{2}\u{3F}\u{41}\u{3}\u{2}\u{2}\u{2}\u{40}\u{3E}" .
149		    "\u{3}\u{2}\u{2}\u{2}\u{41}\u{42}\u{7}\u{6}\u{2}\u{2}\u{42}\u{44}\u{3}" .
150		    "\u{2}\u{2}\u{2}\u{43}\u{34}\u{3}\u{2}\u{2}\u{2}\u{43}\u{35}\u{3}\u{2}" .
151		    "\u{2}\u{2}\u{44}\u{D}\u{3}\u{2}\u{2}\u{2}\u{45}\u{6D}\u{5}\u{6}\u{4}" .
152		    "\u{2}\u{46}\u{47}\u{9}\u{7}\u{2}\u{2}\u{47}\u{6E}\u{5}\u{C}\u{7}\u{2}" .
153		    "\u{48}\u{4A}\u{7}\u{31}\u{2}\u{2}\u{49}\u{48}\u{3}\u{2}\u{2}\u{2}" .
154		    "\u{49}\u{4A}\u{3}\u{2}\u{2}\u{2}\u{4A}\u{4B}\u{3}\u{2}\u{2}\u{2}\u{4B}" .
155		    "\u{4C}\u{7}\u{2F}\u{2}\u{2}\u{4C}\u{4F}\u{5}\u{A}\u{6}\u{2}\u{4D}" .
156		    "\u{4E}\u{7}\u{28}\u{2}\u{2}\u{4E}\u{50}\u{7}\u{40}\u{2}\u{2}\u{4F}" .
157		    "\u{4D}\u{3}\u{2}\u{2}\u{2}\u{4F}\u{50}\u{3}\u{2}\u{2}\u{2}\u{50}\u{54}" .
158		    "\u{3}\u{2}\u{2}\u{2}\u{51}\u{52}\u{7}\u{2B}\u{2}\u{2}\u{52}\u{54}" .
159		    "\u{5}\u{A}\u{6}\u{2}\u{53}\u{49}\u{3}\u{2}\u{2}\u{2}\u{53}\u{51}\u{3}" .
160		    "\u{2}\u{2}\u{2}\u{54}\u{6E}\u{3}\u{2}\u{2}\u{2}\u{55}\u{57}\u{7}\u{31}" .
161		    "\u{2}\u{2}\u{56}\u{55}\u{3}\u{2}\u{2}\u{2}\u{56}\u{57}\u{3}\u{2}\u{2}" .
162		    "\u{2}\u{57}\u{58}\u{3}\u{2}\u{2}\u{2}\u{58}\u{59}\u{7}\u{25}\u{2}" .
163		    "\u{2}\u{59}\u{5A}\u{5}\u{C}\u{7}\u{2}\u{5A}\u{5B}\u{7}\u{22}\u{2}" .
164		    "\u{2}\u{5B}\u{5C}\u{5}\u{C}\u{7}\u{2}\u{5C}\u{6E}\u{3}\u{2}\u{2}\u{2}" .
165		    "\u{5D}\u{5F}\u{7}\u{31}\u{2}\u{2}\u{5E}\u{5D}\u{3}\u{2}\u{2}\u{2}" .
166		    "\u{5E}\u{5F}\u{3}\u{2}\u{2}\u{2}\u{5F}\u{60}\u{3}\u{2}\u{2}\u{2}\u{60}" .
167		    "\u{61}\u{7}\u{2C}\u{2}\u{2}\u{61}\u{6A}\u{7}\u{5}\u{2}\u{2}\u{62}" .
168		    "\u{67}\u{5}\u{C}\u{7}\u{2}\u{63}\u{64}\u{7}\u{B}\u{2}\u{2}\u{64}\u{66}" .
169		    "\u{5}\u{C}\u{7}\u{2}\u{65}\u{63}\u{3}\u{2}\u{2}\u{2}\u{66}\u{69}\u{3}" .
170		    "\u{2}\u{2}\u{2}\u{67}\u{65}\u{3}\u{2}\u{2}\u{2}\u{67}\u{68}\u{3}\u{2}" .
171		    "\u{2}\u{2}\u{68}\u{6B}\u{3}\u{2}\u{2}\u{2}\u{69}\u{67}\u{3}\u{2}\u{2}" .
172		    "\u{2}\u{6A}\u{62}\u{3}\u{2}\u{2}\u{2}\u{6A}\u{6B}\u{3}\u{2}\u{2}\u{2}" .
173		    "\u{6B}\u{6C}\u{3}\u{2}\u{2}\u{2}\u{6C}\u{6E}\u{7}\u{6}\u{2}\u{2}\u{6D}" .
174		    "\u{46}\u{3}\u{2}\u{2}\u{2}\u{6D}\u{53}\u{3}\u{2}\u{2}\u{2}\u{6D}\u{56}" .
175		    "\u{3}\u{2}\u{2}\u{2}\u{6D}\u{5E}\u{3}\u{2}\u{2}\u{2}\u{6E}\u{F}\u{3}" .
176		    "\u{2}\u{2}\u{2}\u{6F}\u{74}\u{5}\u{8}\u{5}\u{2}\u{70}\u{71}\u{7}\u{B}" .
177		    "\u{2}\u{2}\u{71}\u{73}\u{5}\u{8}\u{5}\u{2}\u{72}\u{70}\u{3}\u{2}\u{2}" .
178		    "\u{2}\u{73}\u{76}\u{3}\u{2}\u{2}\u{2}\u{74}\u{72}\u{3}\u{2}\u{2}\u{2}" .
179		    "\u{74}\u{75}\u{3}\u{2}\u{2}\u{2}\u{75}\u{11}\u{3}\u{2}\u{2}\u{2}\u{76}" .
180		    "\u{74}\u{3}\u{2}\u{2}\u{2}\u{77}\u{78}\u{7}\u{5}\u{2}\u{2}\u{78}\u{7D}" .
181		    "\u{5}\u{E}\u{8}\u{2}\u{79}\u{7A}\u{9}\u{8}\u{2}\u{2}\u{7A}\u{7C}\u{5}" .
182		    "\u{E}\u{8}\u{2}\u{7B}\u{79}\u{3}\u{2}\u{2}\u{2}\u{7C}\u{7F}\u{3}\u{2}" .
183		    "\u{2}\u{2}\u{7D}\u{7B}\u{3}\u{2}\u{2}\u{2}\u{7D}\u{7E}\u{3}\u{2}\u{2}" .
184		    "\u{2}\u{7E}\u{80}\u{3}\u{2}\u{2}\u{2}\u{7F}\u{7D}\u{3}\u{2}\u{2}\u{2}" .
185		    "\u{80}\u{81}\u{7}\u{6}\u{2}\u{2}\u{81}\u{13}\u{3}\u{2}\u{2}\u{2}\u{82}" .
186		    "\u{85}\u{7}\u{39}\u{2}\u{2}\u{83}\u{86}\u{5}\u{E}\u{8}\u{2}\u{84}" .
187		    "\u{86}\u{5}\u{12}\u{A}\u{2}\u{85}\u{83}\u{3}\u{2}\u{2}\u{2}\u{85}" .
188		    "\u{84}\u{3}\u{2}\u{2}\u{2}\u{86}\u{8E}\u{3}\u{2}\u{2}\u{2}\u{87}\u{8A}" .
189		    "\u{9}\u{8}\u{2}\u{2}\u{88}\u{8B}\u{5}\u{E}\u{8}\u{2}\u{89}\u{8B}\u{5}" .
190		    "\u{12}\u{A}\u{2}\u{8A}\u{88}\u{3}\u{2}\u{2}\u{2}\u{8A}\u{89}\u{3}" .
191		    "\u{2}\u{2}\u{2}\u{8B}\u{8D}\u{3}\u{2}\u{2}\u{2}\u{8C}\u{87}\u{3}\u{2}" .
192		    "\u{2}\u{2}\u{8D}\u{90}\u{3}\u{2}\u{2}\u{2}\u{8E}\u{8C}\u{3}\u{2}\u{2}" .
193		    "\u{2}\u{8E}\u{8F}\u{3}\u{2}\u{2}\u{2}\u{8F}\u{15}\u{3}\u{2}\u{2}\u{2}" .
194		    "\u{90}\u{8E}\u{3}\u{2}\u{2}\u{2}\u{91}\u{92}\u{7}\u{2A}\u{2}\u{2}" .
195		    "\u{92}\u{93}\u{5}\u{4}\u{3}\u{2}\u{93}\u{17}\u{3}\u{2}\u{2}\u{2}\u{94}" .
196		    "\u{95}\u{7}\u{30}\u{2}\u{2}\u{95}\u{96}\u{7}\u{43}\u{2}\u{2}\u{96}" .
197		    "\u{19}\u{3}\u{2}\u{2}\u{2}\u{97}\u{A2}\u{7}\u{36}\u{2}\u{2}\u{98}" .
198		    "\u{A3}\u{7}\u{3A}\u{2}\u{2}\u{99}\u{9A}\u{7}\u{26}\u{2}\u{2}\u{9A}" .
199		    "\u{9F}\u{5}\u{1C}\u{F}\u{2}\u{9B}\u{9C}\u{7}\u{B}\u{2}\u{2}\u{9C}" .
200		    "\u{9E}\u{5}\u{1C}\u{F}\u{2}\u{9D}\u{9B}\u{3}\u{2}\u{2}\u{2}\u{9E}" .
201		    "\u{A1}\u{3}\u{2}\u{2}\u{2}\u{9F}\u{9D}\u{3}\u{2}\u{2}\u{2}\u{9F}\u{A0}" .
202		    "\u{3}\u{2}\u{2}\u{2}\u{A0}\u{A3}\u{3}\u{2}\u{2}\u{2}\u{A1}\u{9F}\u{3}" .
203		    "\u{2}\u{2}\u{2}\u{A2}\u{98}\u{3}\u{2}\u{2}\u{2}\u{A2}\u{99}\u{3}\u{2}" .
204		    "\u{2}\u{2}\u{A3}\u{1B}\u{3}\u{2}\u{2}\u{2}\u{A4}\u{A6}\u{7}\u{46}" .
205		    "\u{2}\u{2}\u{A5}\u{A7}\u{9}\u{9}\u{2}\u{2}\u{A6}\u{A5}\u{3}\u{2}\u{2}" .
206		    "\u{2}\u{A6}\u{A7}\u{3}\u{2}\u{2}\u{2}\u{A7}\u{1D}\u{3}\u{2}\u{2}\u{2}" .
207		    "\u{A8}\u{AA}\u{7}\u{37}\u{2}\u{2}\u{A9}\u{AB}\u{7}\u{3A}\u{2}\u{2}" .
208		    "\u{AA}\u{A9}\u{3}\u{2}\u{2}\u{2}\u{AA}\u{AB}\u{3}\u{2}\u{2}\u{2}\u{AB}" .
209		    "\u{AE}\u{3}\u{2}\u{2}\u{2}\u{AC}\u{AF}\u{7}\u{F}\u{2}\u{2}\u{AD}\u{AF}" .
210		    "\u{5}\u{10}\u{9}\u{2}\u{AE}\u{AC}\u{3}\u{2}\u{2}\u{2}\u{AE}\u{AD}" .
211		    "\u{3}\u{2}\u{2}\u{2}\u{AE}\u{AF}\u{3}\u{2}\u{2}\u{2}\u{AF}\u{B1}\u{3}" .
212		    "\u{2}\u{2}\u{2}\u{B0}\u{B2}\u{5}\u{16}\u{C}\u{2}\u{B1}\u{B0}\u{3}" .
213		    "\u{2}\u{2}\u{2}\u{B1}\u{B2}\u{3}\u{2}\u{2}\u{2}\u{B2}\u{B4}\u{3}\u{2}" .
214		    "\u{2}\u{2}\u{B3}\u{B5}\u{5}\u{14}\u{B}\u{2}\u{B4}\u{B3}\u{3}\u{2}" .
215		    "\u{2}\u{2}\u{B4}\u{B5}\u{3}\u{2}\u{2}\u{2}\u{B5}\u{B7}\u{3}\u{2}\u{2}" .
216		    "\u{2}\u{B6}\u{B8}\u{5}\u{1A}\u{E}\u{2}\u{B7}\u{B6}\u{3}\u{2}\u{2}" .
217		    "\u{2}\u{B7}\u{B8}\u{3}\u{2}\u{2}\u{2}\u{B8}\u{BA}\u{3}\u{2}\u{2}\u{2}" .
218		    "\u{B9}\u{BB}\u{5}\u{18}\u{D}\u{2}\u{BA}\u{B9}\u{3}\u{2}\u{2}\u{2}" .
219		    "\u{BA}\u{BB}\u{3}\u{2}\u{2}\u{2}\u{BB}\u{1F}\u{3}\u{2}\u{2}\u{2}\u{1E}" .
220		    "\u{29}\u{2E}\u{30}\u{38}\u{3E}\u{43}\u{49}\u{4F}\u{53}\u{56}\u{5E}" .
221		    "\u{67}\u{6A}\u{6D}\u{74}\u{7D}\u{85}\u{8A}\u{8E}\u{9F}\u{A2}\u{A6}" .
222		    "\u{AA}\u{AE}\u{B1}\u{B4}\u{B7}\u{BA}";
223
224		protected static $atn;
225		protected static $decisionToDFA;
226		protected static $sharedContextCache;
227
228		public function __construct(TokenStream $input)
229		{
230			parent::__construct($input);
231
232			self::initialize();
233
234			$this->interp = new ParserATNSimulator($this, self::$atn, self::$decisionToDFA, self::$sharedContextCache);
235		}
236
237		private static function initialize() : void
238		{
239			if (self::$atn !== null) {
240				return;
241			}
242
243			RuntimeMetaData::checkVersion('4.9.3', RuntimeMetaData::VERSION);
244
245			$atn = (new ATNDeserializer())->deserialize(self::SERIALIZED_ATN);
246
247			$decisionToDFA = [];
248			for ($i = 0, $count = $atn->getNumberOfDecisions(); $i < $count; $i++) {
249				$decisionToDFA[] = new DFA($atn->getDecisionState($i), $i);
250			}
251
252			self::$atn = $atn;
253			self::$decisionToDFA = $decisionToDFA;
254			self::$sharedContextCache = new PredictionContextCache();
255		}
256
257		public function getGrammarFileName() : string
258		{
259			return "PageSql.g4";
260		}
261
262		public function getRuleNames() : array
263		{
264			return self::RULE_NAMES;
265		}
266
267		public function getSerializedATN() : string
268		{
269			return self::SERIALIZED_ATN;
270		}
271
272		public function getATN() : ATN
273		{
274			return self::$atn;
275		}
276
277		public function getVocabulary() : Vocabulary
278        {
279            static $vocabulary;
280
281			return $vocabulary = $vocabulary ?? new VocabularyImpl(self::LITERAL_NAMES, self::SYMBOLIC_NAMES);
282        }
283
284		/**
285		 * @throws RecognitionException
286		 */
287		public function functionNames() : Context\FunctionNamesContext
288		{
289		    $localContext = new Context\FunctionNamesContext($this->ctx, $this->getState());
290
291		    $this->enterRule($localContext, 0, self::RULE_functionNames);
292
293		    try {
294		        $this->enterOuterAlt($localContext, 1);
295		        $this->setState(30);
296
297		        $_la = $this->input->LA(1);
298
299		        if (!($_la === self::DATE || $_la === self::DATETIME)) {
300		        $this->errorHandler->recoverInline($this);
301		        } else {
302		        	if ($this->input->LA(1) === Token::EOF) {
303		        	    $this->matchedEOF = true;
304		            }
305
306		        	$this->errorHandler->reportMatch($this);
307		        	$this->consume();
308		        }
309		    } catch (RecognitionException $exception) {
310		        $localContext->exception = $exception;
311		        $this->errorHandler->reportError($this, $exception);
312		        $this->errorHandler->recover($this, $exception);
313		    } finally {
314		        $this->exitRule();
315		    }
316
317		    return $localContext;
318		}
319
320		/**
321		 * @throws RecognitionException
322		 */
323		public function tableNames() : Context\TableNamesContext
324		{
325		    $localContext = new Context\TableNamesContext($this->ctx, $this->getState());
326
327		    $this->enterRule($localContext, 2, self::RULE_tableNames);
328
329		    try {
330		        $this->enterOuterAlt($localContext, 1);
331		        $this->setState(32);
332
333		        $_la = $this->input->LA(1);
334
335		        if (!(((($_la) & ~0x3f) === 0 && ((1 << $_la) & ((1 << self::PAGES) | (1 << self::BACKLINKS) | (1 << self::DESCENDANTS))) !== 0))) {
336		        $this->errorHandler->recoverInline($this);
337		        } else {
338		        	if ($this->input->LA(1) === Token::EOF) {
339		        	    $this->matchedEOF = true;
340		            }
341
342		        	$this->errorHandler->reportMatch($this);
343		        	$this->consume();
344		        }
345		    } catch (RecognitionException $exception) {
346		        $localContext->exception = $exception;
347		        $this->errorHandler->reportError($this, $exception);
348		        $this->errorHandler->recover($this, $exception);
349		    } finally {
350		        $this->exitRule();
351		    }
352
353		    return $localContext;
354		}
355
356		/**
357		 * @throws RecognitionException
358		 */
359		public function sqlNames() : Context\SqlNamesContext
360		{
361		    $localContext = new Context\SqlNamesContext($this->ctx, $this->getState());
362
363		    $this->enterRule($localContext, 4, self::RULE_sqlNames);
364
365		    try {
366		        $this->enterOuterAlt($localContext, 1);
367		        $this->setState(34);
368
369		        $_la = $this->input->LA(1);
370
371		        if (!($_la === self::Number || $_la === self::SqlName)) {
372		        $this->errorHandler->recoverInline($this);
373		        } else {
374		        	if ($this->input->LA(1) === Token::EOF) {
375		        	    $this->matchedEOF = true;
376		            }
377
378		        	$this->errorHandler->reportMatch($this);
379		        	$this->consume();
380		        }
381		    } catch (RecognitionException $exception) {
382		        $localContext->exception = $exception;
383		        $this->errorHandler->reportError($this, $exception);
384		        $this->errorHandler->recover($this, $exception);
385		    } finally {
386		        $this->exitRule();
387		    }
388
389		    return $localContext;
390		}
391
392		/**
393		 * @throws RecognitionException
394		 */
395		public function column() : Context\ColumnContext
396		{
397		    $localContext = new Context\ColumnContext($this->ctx, $this->getState());
398
399		    $this->enterRule($localContext, 6, self::RULE_column);
400
401		    try {
402		        $this->enterOuterAlt($localContext, 1);
403		        $this->setState(36);
404		        $this->sqlNames();
405		        $this->setState(39);
406		        $this->errorHandler->sync($this);
407		        $_la = $this->input->LA(1);
408
409		        if ($_la === self::DOT) {
410		        	$this->setState(37);
411		        	$this->match(self::DOT);
412		        	$this->setState(38);
413		        	$this->sqlNames();
414		        }
415		        $this->setState(46);
416		        $this->errorHandler->sync($this);
417		        $_la = $this->input->LA(1);
418
419		        if ($_la === self::AS) {
420		        	$this->setState(41);
421		        	$this->match(self::AS);
422		        	$this->setState(44);
423		        	$this->errorHandler->sync($this);
424
425		        	switch ($this->input->LA(1)) {
426		        	    case self::Number:
427		        	    case self::SqlName:
428		        	    	$this->setState(42);
429		        	    	$this->sqlNames();
430		        	    	break;
431
432		        	    case self::StringLiteral:
433		        	    	$this->setState(43);
434		        	    	$this->match(self::StringLiteral);
435		        	    	break;
436
437		        	default:
438		        		throw new NoViableAltException($this);
439		        	}
440		        }
441		    } catch (RecognitionException $exception) {
442		        $localContext->exception = $exception;
443		        $this->errorHandler->reportError($this, $exception);
444		        $this->errorHandler->recover($this, $exception);
445		    } finally {
446		        $this->exitRule();
447		    }
448
449		    return $localContext;
450		}
451
452		/**
453		 * @throws RecognitionException
454		 */
455		public function pattern() : Context\PatternContext
456		{
457		    $localContext = new Context\PatternContext($this->ctx, $this->getState());
458
459		    $this->enterRule($localContext, 8, self::RULE_pattern);
460
461		    try {
462		        $this->enterOuterAlt($localContext, 1);
463		        $this->setState(48);
464
465		        $_la = $this->input->LA(1);
466
467		        if (!($_la === self::StringLiteral || $_la === self::NumberLiteral)) {
468		        $this->errorHandler->recoverInline($this);
469		        } else {
470		        	if ($this->input->LA(1) === Token::EOF) {
471		        	    $this->matchedEOF = true;
472		            }
473
474		        	$this->errorHandler->reportMatch($this);
475		        	$this->consume();
476		        }
477		    } catch (RecognitionException $exception) {
478		        $localContext->exception = $exception;
479		        $this->errorHandler->reportError($this, $exception);
480		        $this->errorHandler->recover($this, $exception);
481		    } finally {
482		        $this->exitRule();
483		    }
484
485		    return $localContext;
486		}
487
488		/**
489		 * @throws RecognitionException
490		 */
491		public function expression() : Context\ExpressionContext
492		{
493		    $localContext = new Context\ExpressionContext($this->ctx, $this->getState());
494
495		    $this->enterRule($localContext, 10, self::RULE_expression);
496
497		    try {
498		        $this->setState(65);
499		        $this->errorHandler->sync($this);
500
501		        switch ($this->input->LA(1)) {
502		            case self::StringLiteral:
503		            case self::Number:
504		            case self::NumberLiteral:
505		            case self::SqlName:
506		            	$this->enterOuterAlt($localContext, 1);
507		            	$this->setState(50);
508
509		            	$_la = $this->input->LA(1);
510
511		            	if (!((((($_la - 62)) & ~0x3f) === 0 && ((1 << ($_la - 62)) & ((1 << (self::StringLiteral - 62)) | (1 << (self::Number - 62)) | (1 << (self::NumberLiteral - 62)) | (1 << (self::SqlName - 62)))) !== 0))) {
512		            	$this->errorHandler->recoverInline($this);
513		            	} else {
514		            		if ($this->input->LA(1) === Token::EOF) {
515		            		    $this->matchedEOF = true;
516		            	    }
517
518		            		$this->errorHandler->reportMatch($this);
519		            		$this->consume();
520		            	}
521		            	break;
522
523		            case self::DATE:
524		            case self::DATETIME:
525		            	$this->enterOuterAlt($localContext, 2);
526		            	$this->setState(51);
527		            	$this->functionNames();
528		            	$this->setState(52);
529		            	$this->match(self::LPAREN);
530		            	$this->setState(54);
531		            	$this->errorHandler->sync($this);
532		            	$_la = $this->input->LA(1);
533
534		            	if ((((($_la - 57)) & ~0x3f) === 0 && ((1 << ($_la - 57)) & ((1 << (self::DATE - 57)) | (1 << (self::DATETIME - 57)) | (1 << (self::StringLiteral - 57)) | (1 << (self::Number - 57)) | (1 << (self::NumberLiteral - 57)) | (1 << (self::SqlName - 57)))) !== 0)) {
535		            		$this->setState(53);
536		            		$this->expression();
537		            	}
538		            	$this->setState(60);
539		            	$this->errorHandler->sync($this);
540
541		            	$_la = $this->input->LA(1);
542		            	while ($_la === self::COMMA) {
543		            		$this->setState(56);
544		            		$this->match(self::COMMA);
545		            		$this->setState(57);
546		            		$this->expression();
547		            		$this->setState(62);
548		            		$this->errorHandler->sync($this);
549		            		$_la = $this->input->LA(1);
550		            	}
551		            	$this->setState(63);
552		            	$this->match(self::RPAREN);
553		            	break;
554
555		        default:
556		        	throw new NoViableAltException($this);
557		        }
558		    } catch (RecognitionException $exception) {
559		        $localContext->exception = $exception;
560		        $this->errorHandler->reportError($this, $exception);
561		        $this->errorHandler->recover($this, $exception);
562		    } finally {
563		        $this->exitRule();
564		    }
565
566		    return $localContext;
567		}
568
569		/**
570		 * @throws RecognitionException
571		 */
572		public function predicate() : Context\PredicateContext
573		{
574		    $localContext = new Context\PredicateContext($this->ctx, $this->getState());
575
576		    $this->enterRule($localContext, 12, self::RULE_predicate);
577
578		    try {
579		        $this->enterOuterAlt($localContext, 1);
580		        $this->setState(67);
581		        $this->sqlNames();
582		        $this->setState(107);
583		        $this->errorHandler->sync($this);
584
585		        switch ($this->getInterpreter()->adaptivePredict($this->input, 13, $this->ctx)) {
586		        	case 1:
587		        	    $this->setState(68);
588
589		        	    $_la = $this->input->LA(1);
590
591		        	    if (!(((($_la) & ~0x3f) === 0 && ((1 << $_la) & ((1 << self::EQUAL) | (1 << self::LESS_THAN) | (1 << self::LESS_THAN_OR_EQUAL) | (1 << self::GREATER_THAN) | (1 << self::GREATER_THAN_OR_EQUAL) | (1 << self::NOT_EQUAL))) !== 0))) {
592		        	    $this->errorHandler->recoverInline($this);
593		        	    } else {
594		        	    	if ($this->input->LA(1) === Token::EOF) {
595		        	    	    $this->matchedEOF = true;
596		        	        }
597
598		        	    	$this->errorHandler->reportMatch($this);
599		        	    	$this->consume();
600		        	    }
601		        	    $this->setState(69);
602		        	    $this->expression();
603		        	break;
604
605		        	case 2:
606		        	    $this->setState(81);
607		        	    $this->errorHandler->sync($this);
608
609		        	    switch ($this->input->LA(1)) {
610		        	        case self::LIKE:
611		        	        case self::NOT:
612		        	        	$this->setState(71);
613		        	        	$this->errorHandler->sync($this);
614		        	        	$_la = $this->input->LA(1);
615
616		        	        	if ($_la === self::NOT) {
617		        	        		$this->setState(70);
618		        	        		$this->match(self::NOT);
619		        	        	}
620
621		        	        	$this->setState(73);
622		        	        	$this->match(self::LIKE);
623		        	        	$this->setState(74);
624		        	        	$this->pattern();
625		        	        	$this->setState(77);
626		        	        	$this->errorHandler->sync($this);
627		        	        	$_la = $this->input->LA(1);
628
629		        	        	if ($_la === self::ESCAPE) {
630		        	        		$this->setState(75);
631		        	        		$this->match(self::ESCAPE);
632		        	        		$this->setState(76);
633		        	        		$this->match(self::StringLiteral);
634		        	        	}
635		        	        	break;
636
637		        	        case self::GLOB:
638		        	        	$this->setState(79);
639		        	        	$this->match(self::GLOB);
640		        	        	$this->setState(80);
641		        	        	$this->pattern();
642		        	        	break;
643
644		        	    default:
645		        	    	throw new NoViableAltException($this);
646		        	    }
647		        	break;
648
649		        	case 3:
650		        	    $this->setState(84);
651		        	    $this->errorHandler->sync($this);
652		        	    $_la = $this->input->LA(1);
653
654		        	    if ($_la === self::NOT) {
655		        	    	$this->setState(83);
656		        	    	$this->match(self::NOT);
657		        	    }
658		        	    $this->setState(86);
659		        	    $this->match(self::BETWEEN);
660		        	    $this->setState(87);
661		        	    $this->expression();
662		        	    $this->setState(88);
663		        	    $this->match(self::AND);
664		        	    $this->setState(89);
665		        	    $this->expression();
666		        	break;
667
668		        	case 4:
669		        	    $this->setState(92);
670		        	    $this->errorHandler->sync($this);
671		        	    $_la = $this->input->LA(1);
672
673		        	    if ($_la === self::NOT) {
674		        	    	$this->setState(91);
675		        	    	$this->match(self::NOT);
676		        	    }
677		        	    $this->setState(94);
678		        	    $this->match(self::IN);
679		        	    $this->setState(95);
680		        	    $this->match(self::LPAREN);
681		        	    $this->setState(104);
682		        	    $this->errorHandler->sync($this);
683		        	    $_la = $this->input->LA(1);
684
685		        	    if ((((($_la - 57)) & ~0x3f) === 0 && ((1 << ($_la - 57)) & ((1 << (self::DATE - 57)) | (1 << (self::DATETIME - 57)) | (1 << (self::StringLiteral - 57)) | (1 << (self::Number - 57)) | (1 << (self::NumberLiteral - 57)) | (1 << (self::SqlName - 57)))) !== 0)) {
686		        	    	$this->setState(96);
687		        	    	$this->expression();
688		        	    	$this->setState(101);
689		        	    	$this->errorHandler->sync($this);
690
691		        	    	$_la = $this->input->LA(1);
692		        	    	while ($_la === self::COMMA) {
693		        	    		$this->setState(97);
694		        	    		$this->match(self::COMMA);
695		        	    		$this->setState(98);
696		        	    		$this->expression();
697		        	    		$this->setState(103);
698		        	    		$this->errorHandler->sync($this);
699		        	    		$_la = $this->input->LA(1);
700		        	    	}
701		        	    }
702		        	    $this->setState(106);
703		        	    $this->match(self::RPAREN);
704		        	break;
705		        }
706		    } catch (RecognitionException $exception) {
707		        $localContext->exception = $exception;
708		        $this->errorHandler->reportError($this, $exception);
709		        $this->errorHandler->recover($this, $exception);
710		    } finally {
711		        $this->exitRule();
712		    }
713
714		    return $localContext;
715		}
716
717		/**
718		 * @throws RecognitionException
719		 */
720		public function columns() : Context\ColumnsContext
721		{
722		    $localContext = new Context\ColumnsContext($this->ctx, $this->getState());
723
724		    $this->enterRule($localContext, 14, self::RULE_columns);
725
726		    try {
727		        $this->enterOuterAlt($localContext, 1);
728		        $this->setState(109);
729		        $this->column();
730		        $this->setState(114);
731		        $this->errorHandler->sync($this);
732
733		        $_la = $this->input->LA(1);
734		        while ($_la === self::COMMA) {
735		        	$this->setState(110);
736		        	$this->match(self::COMMA);
737		        	$this->setState(111);
738		        	$this->column();
739		        	$this->setState(116);
740		        	$this->errorHandler->sync($this);
741		        	$_la = $this->input->LA(1);
742		        }
743		    } catch (RecognitionException $exception) {
744		        $localContext->exception = $exception;
745		        $this->errorHandler->reportError($this, $exception);
746		        $this->errorHandler->recover($this, $exception);
747		    } finally {
748		        $this->exitRule();
749		    }
750
751		    return $localContext;
752		}
753
754		/**
755		 * @throws RecognitionException
756		 */
757		public function predicateGroup() : Context\PredicateGroupContext
758		{
759		    $localContext = new Context\PredicateGroupContext($this->ctx, $this->getState());
760
761		    $this->enterRule($localContext, 16, self::RULE_predicateGroup);
762
763		    try {
764		        $this->enterOuterAlt($localContext, 1);
765		        $this->setState(117);
766		        $this->match(self::LPAREN);
767		        $this->setState(118);
768		        $this->predicate();
769		        $this->setState(123);
770		        $this->errorHandler->sync($this);
771
772		        $_la = $this->input->LA(1);
773		        while ($_la === self::AND || $_la === self::OR) {
774		        	$this->setState(119);
775
776		        	$_la = $this->input->LA(1);
777
778		        	if (!($_la === self::AND || $_la === self::OR)) {
779		        	$this->errorHandler->recoverInline($this);
780		        	} else {
781		        		if ($this->input->LA(1) === Token::EOF) {
782		        		    $this->matchedEOF = true;
783		        	    }
784
785		        		$this->errorHandler->reportMatch($this);
786		        		$this->consume();
787		        	}
788		        	$this->setState(120);
789		        	$this->predicate();
790		        	$this->setState(125);
791		        	$this->errorHandler->sync($this);
792		        	$_la = $this->input->LA(1);
793		        }
794		        $this->setState(126);
795		        $this->match(self::RPAREN);
796		    } catch (RecognitionException $exception) {
797		        $localContext->exception = $exception;
798		        $this->errorHandler->reportError($this, $exception);
799		        $this->errorHandler->recover($this, $exception);
800		    } finally {
801		        $this->exitRule();
802		    }
803
804		    return $localContext;
805		}
806
807		/**
808		 * @throws RecognitionException
809		 */
810		public function predicates() : Context\PredicatesContext
811		{
812		    $localContext = new Context\PredicatesContext($this->ctx, $this->getState());
813
814		    $this->enterRule($localContext, 18, self::RULE_predicates);
815
816		    try {
817		        $this->enterOuterAlt($localContext, 1);
818		        $this->setState(128);
819		        $this->match(self::WHERE);
820		        $this->setState(131);
821		        $this->errorHandler->sync($this);
822
823		        switch ($this->input->LA(1)) {
824		            case self::Number:
825		            case self::SqlName:
826		            	$this->setState(129);
827		            	$this->predicate();
828		            	break;
829
830		            case self::LPAREN:
831		            	$this->setState(130);
832		            	$this->predicateGroup();
833		            	break;
834
835		        default:
836		        	throw new NoViableAltException($this);
837		        }
838		        $this->setState(140);
839		        $this->errorHandler->sync($this);
840
841		        $_la = $this->input->LA(1);
842		        while ($_la === self::AND || $_la === self::OR) {
843		        	$this->setState(133);
844
845		        	$_la = $this->input->LA(1);
846
847		        	if (!($_la === self::AND || $_la === self::OR)) {
848		        	$this->errorHandler->recoverInline($this);
849		        	} else {
850		        		if ($this->input->LA(1) === Token::EOF) {
851		        		    $this->matchedEOF = true;
852		        	    }
853
854		        		$this->errorHandler->reportMatch($this);
855		        		$this->consume();
856		        	}
857		        	$this->setState(136);
858		        	$this->errorHandler->sync($this);
859
860		        	switch ($this->input->LA(1)) {
861		        	    case self::Number:
862		        	    case self::SqlName:
863		        	    	$this->setState(134);
864		        	    	$this->predicate();
865		        	    	break;
866
867		        	    case self::LPAREN:
868		        	    	$this->setState(135);
869		        	    	$this->predicateGroup();
870		        	    	break;
871
872		        	default:
873		        		throw new NoViableAltException($this);
874		        	}
875		        	$this->setState(142);
876		        	$this->errorHandler->sync($this);
877		        	$_la = $this->input->LA(1);
878		        }
879		    } catch (RecognitionException $exception) {
880		        $localContext->exception = $exception;
881		        $this->errorHandler->reportError($this, $exception);
882		        $this->errorHandler->recover($this, $exception);
883		    } finally {
884		        $this->exitRule();
885		    }
886
887		    return $localContext;
888		}
889
890		/**
891		 * @throws RecognitionException
892		 */
893		public function tables() : Context\TablesContext
894		{
895		    $localContext = new Context\TablesContext($this->ctx, $this->getState());
896
897		    $this->enterRule($localContext, 20, self::RULE_tables);
898
899		    try {
900		        $this->enterOuterAlt($localContext, 1);
901		        $this->setState(143);
902		        $this->match(self::FROM);
903		        $this->setState(144);
904		        $this->tableNames();
905		    } catch (RecognitionException $exception) {
906		        $localContext->exception = $exception;
907		        $this->errorHandler->reportError($this, $exception);
908		        $this->errorHandler->recover($this, $exception);
909		    } finally {
910		        $this->exitRule();
911		    }
912
913		    return $localContext;
914		}
915
916		/**
917		 * @throws RecognitionException
918		 */
919		public function limit() : Context\LimitContext
920		{
921		    $localContext = new Context\LimitContext($this->ctx, $this->getState());
922
923		    $this->enterRule($localContext, 22, self::RULE_limit);
924
925		    try {
926		        $this->enterOuterAlt($localContext, 1);
927		        $this->setState(146);
928		        $this->match(self::LIMIT);
929		        $this->setState(147);
930		        $this->match(self::Number);
931		    } catch (RecognitionException $exception) {
932		        $localContext->exception = $exception;
933		        $this->errorHandler->reportError($this, $exception);
934		        $this->errorHandler->recover($this, $exception);
935		    } finally {
936		        $this->exitRule();
937		    }
938
939		    return $localContext;
940		}
941
942		/**
943		 * @throws RecognitionException
944		 */
945		public function orderBys() : Context\OrderBysContext
946		{
947		    $localContext = new Context\OrderBysContext($this->ctx, $this->getState());
948
949		    $this->enterRule($localContext, 24, self::RULE_orderBys);
950
951		    try {
952		        $this->enterOuterAlt($localContext, 1);
953		        $this->setState(149);
954		        $this->match(self::ORDER);
955		        $this->setState(160);
956		        $this->errorHandler->sync($this);
957
958		        switch ($this->input->LA(1)) {
959		            case self::RANDOM:
960		            	$this->setState(150);
961		            	$this->match(self::RANDOM);
962		            	break;
963
964		            case self::BY:
965		            	$this->setState(151);
966		            	$this->match(self::BY);
967		            	$this->setState(152);
968		            	$this->orderByDef();
969		            	$this->setState(157);
970		            	$this->errorHandler->sync($this);
971
972		            	$_la = $this->input->LA(1);
973		            	while ($_la === self::COMMA) {
974		            		$this->setState(153);
975		            		$this->match(self::COMMA);
976		            		$this->setState(154);
977		            		$this->orderByDef();
978		            		$this->setState(159);
979		            		$this->errorHandler->sync($this);
980		            		$_la = $this->input->LA(1);
981		            	}
982		            	break;
983
984		        default:
985		        	throw new NoViableAltException($this);
986		        }
987		    } catch (RecognitionException $exception) {
988		        $localContext->exception = $exception;
989		        $this->errorHandler->reportError($this, $exception);
990		        $this->errorHandler->recover($this, $exception);
991		    } finally {
992		        $this->exitRule();
993		    }
994
995		    return $localContext;
996		}
997
998		/**
999		 * @throws RecognitionException
1000		 */
1001		public function orderByDef() : Context\OrderByDefContext
1002		{
1003		    $localContext = new Context\OrderByDefContext($this->ctx, $this->getState());
1004
1005		    $this->enterRule($localContext, 26, self::RULE_orderByDef);
1006
1007		    try {
1008		        $this->enterOuterAlt($localContext, 1);
1009		        $this->setState(162);
1010		        $this->match(self::SqlName);
1011		        $this->setState(164);
1012		        $this->errorHandler->sync($this);
1013		        $_la = $this->input->LA(1);
1014
1015		        if ($_la === self::ASC || $_la === self::DESC) {
1016		        	$this->setState(163);
1017
1018		        	$_la = $this->input->LA(1);
1019
1020		        	if (!($_la === self::ASC || $_la === self::DESC)) {
1021		        	$this->errorHandler->recoverInline($this);
1022		        	} else {
1023		        		if ($this->input->LA(1) === Token::EOF) {
1024		        		    $this->matchedEOF = true;
1025		        	    }
1026
1027		        		$this->errorHandler->reportMatch($this);
1028		        		$this->consume();
1029		        	}
1030		        }
1031		    } catch (RecognitionException $exception) {
1032		        $localContext->exception = $exception;
1033		        $this->errorHandler->reportError($this, $exception);
1034		        $this->errorHandler->recover($this, $exception);
1035		    } finally {
1036		        $this->exitRule();
1037		    }
1038
1039		    return $localContext;
1040		}
1041
1042		/**
1043		 * @throws RecognitionException
1044		 */
1045		public function pageSql() : Context\PageSqlContext
1046		{
1047		    $localContext = new Context\PageSqlContext($this->ctx, $this->getState());
1048
1049		    $this->enterRule($localContext, 28, self::RULE_pageSql);
1050
1051		    try {
1052		        $this->enterOuterAlt($localContext, 1);
1053		        $this->setState(166);
1054		        $this->match(self::SELECT);
1055		        $this->setState(168);
1056		        $this->errorHandler->sync($this);
1057		        $_la = $this->input->LA(1);
1058
1059		        if ($_la === self::RANDOM) {
1060		        	$this->setState(167);
1061		        	$this->match(self::RANDOM);
1062		        }
1063		        $this->setState(172);
1064		        $this->errorHandler->sync($this);
1065
1066		        switch ($this->input->LA(1)) {
1067		            case self::STAR:
1068		            	$this->setState(170);
1069		            	$this->match(self::STAR);
1070		            	break;
1071
1072		            case self::Number:
1073		            case self::SqlName:
1074		            	$this->setState(171);
1075		            	$this->columns();
1076		            	break;
1077
1078		            case self::EOF:
1079		            case self::FROM:
1080		            case self::LIMIT:
1081		            case self::ORDER:
1082		            case self::WHERE:
1083		            	break;
1084
1085		        default:
1086		        	break;
1087		        }
1088		        $this->setState(175);
1089		        $this->errorHandler->sync($this);
1090		        $_la = $this->input->LA(1);
1091
1092		        if ($_la === self::FROM) {
1093		        	$this->setState(174);
1094		        	$this->tables();
1095		        }
1096		        $this->setState(178);
1097		        $this->errorHandler->sync($this);
1098		        $_la = $this->input->LA(1);
1099
1100		        if ($_la === self::WHERE) {
1101		        	$this->setState(177);
1102		        	$this->predicates();
1103		        }
1104		        $this->setState(181);
1105		        $this->errorHandler->sync($this);
1106		        $_la = $this->input->LA(1);
1107
1108		        if ($_la === self::ORDER) {
1109		        	$this->setState(180);
1110		        	$this->orderBys();
1111		        }
1112		        $this->setState(184);
1113		        $this->errorHandler->sync($this);
1114		        $_la = $this->input->LA(1);
1115
1116		        if ($_la === self::LIMIT) {
1117		        	$this->setState(183);
1118		        	$this->limit();
1119		        }
1120		    } catch (RecognitionException $exception) {
1121		        $localContext->exception = $exception;
1122		        $this->errorHandler->reportError($this, $exception);
1123		        $this->errorHandler->recover($this, $exception);
1124		    } finally {
1125		        $this->exitRule();
1126		    }
1127
1128		    return $localContext;
1129		}
1130	}
1131}
1132
1133namespace ComboStrap\PageSqlParser\Context {
1134	use Antlr\Antlr4\Runtime\ParserRuleContext;
1135	use Antlr\Antlr4\Runtime\Token;
1136	use Antlr\Antlr4\Runtime\Tree\ParseTreeVisitor;
1137	use Antlr\Antlr4\Runtime\Tree\TerminalNode;
1138	use Antlr\Antlr4\Runtime\Tree\ParseTreeListener;
1139	use ComboStrap\PageSqlParser\PageSqlParser;
1140	use ComboStrap\PageSqlParser\PageSqlListener;
1141
1142	class FunctionNamesContext extends ParserRuleContext
1143	{
1144		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1145		{
1146			parent::__construct($parent, $invokingState);
1147		}
1148
1149		public function getRuleIndex() : int
1150		{
1151		    return PageSqlParser::RULE_functionNames;
1152	    }
1153
1154	    public function DATE() : ?TerminalNode
1155	    {
1156	        return $this->getToken(PageSqlParser::DATE, 0);
1157	    }
1158
1159	    public function DATETIME() : ?TerminalNode
1160	    {
1161	        return $this->getToken(PageSqlParser::DATETIME, 0);
1162	    }
1163
1164		public function enterRule(ParseTreeListener $listener) : void
1165		{
1166			if ($listener instanceof PageSqlListener) {
1167			    $listener->enterFunctionNames($this);
1168		    }
1169		}
1170
1171		public function exitRule(ParseTreeListener $listener) : void
1172		{
1173			if ($listener instanceof PageSqlListener) {
1174			    $listener->exitFunctionNames($this);
1175		    }
1176		}
1177	}
1178
1179	class TableNamesContext extends ParserRuleContext
1180	{
1181		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1182		{
1183			parent::__construct($parent, $invokingState);
1184		}
1185
1186		public function getRuleIndex() : int
1187		{
1188		    return PageSqlParser::RULE_tableNames;
1189	    }
1190
1191	    public function PAGES() : ?TerminalNode
1192	    {
1193	        return $this->getToken(PageSqlParser::PAGES, 0);
1194	    }
1195
1196	    public function BACKLINKS() : ?TerminalNode
1197	    {
1198	        return $this->getToken(PageSqlParser::BACKLINKS, 0);
1199	    }
1200
1201	    public function DESCENDANTS() : ?TerminalNode
1202	    {
1203	        return $this->getToken(PageSqlParser::DESCENDANTS, 0);
1204	    }
1205
1206		public function enterRule(ParseTreeListener $listener) : void
1207		{
1208			if ($listener instanceof PageSqlListener) {
1209			    $listener->enterTableNames($this);
1210		    }
1211		}
1212
1213		public function exitRule(ParseTreeListener $listener) : void
1214		{
1215			if ($listener instanceof PageSqlListener) {
1216			    $listener->exitTableNames($this);
1217		    }
1218		}
1219	}
1220
1221	class SqlNamesContext extends ParserRuleContext
1222	{
1223		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1224		{
1225			parent::__construct($parent, $invokingState);
1226		}
1227
1228		public function getRuleIndex() : int
1229		{
1230		    return PageSqlParser::RULE_sqlNames;
1231	    }
1232
1233	    public function SqlName() : ?TerminalNode
1234	    {
1235	        return $this->getToken(PageSqlParser::SqlName, 0);
1236	    }
1237
1238	    public function Number() : ?TerminalNode
1239	    {
1240	        return $this->getToken(PageSqlParser::Number, 0);
1241	    }
1242
1243		public function enterRule(ParseTreeListener $listener) : void
1244		{
1245			if ($listener instanceof PageSqlListener) {
1246			    $listener->enterSqlNames($this);
1247		    }
1248		}
1249
1250		public function exitRule(ParseTreeListener $listener) : void
1251		{
1252			if ($listener instanceof PageSqlListener) {
1253			    $listener->exitSqlNames($this);
1254		    }
1255		}
1256	}
1257
1258	class ColumnContext extends ParserRuleContext
1259	{
1260		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1261		{
1262			parent::__construct($parent, $invokingState);
1263		}
1264
1265		public function getRuleIndex() : int
1266		{
1267		    return PageSqlParser::RULE_column;
1268	    }
1269
1270	    /**
1271	     * @return array<SqlNamesContext>|SqlNamesContext|null
1272	     */
1273	    public function sqlNames(?int $index = null)
1274	    {
1275	    	if ($index === null) {
1276	    		return $this->getTypedRuleContexts(SqlNamesContext::class);
1277	    	}
1278
1279	        return $this->getTypedRuleContext(SqlNamesContext::class, $index);
1280	    }
1281
1282	    public function DOT() : ?TerminalNode
1283	    {
1284	        return $this->getToken(PageSqlParser::DOT, 0);
1285	    }
1286
1287	    public function AS() : ?TerminalNode
1288	    {
1289	        return $this->getToken(PageSqlParser::AS, 0);
1290	    }
1291
1292	    public function StringLiteral() : ?TerminalNode
1293	    {
1294	        return $this->getToken(PageSqlParser::StringLiteral, 0);
1295	    }
1296
1297		public function enterRule(ParseTreeListener $listener) : void
1298		{
1299			if ($listener instanceof PageSqlListener) {
1300			    $listener->enterColumn($this);
1301		    }
1302		}
1303
1304		public function exitRule(ParseTreeListener $listener) : void
1305		{
1306			if ($listener instanceof PageSqlListener) {
1307			    $listener->exitColumn($this);
1308		    }
1309		}
1310	}
1311
1312	class PatternContext extends ParserRuleContext
1313	{
1314		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1315		{
1316			parent::__construct($parent, $invokingState);
1317		}
1318
1319		public function getRuleIndex() : int
1320		{
1321		    return PageSqlParser::RULE_pattern;
1322	    }
1323
1324	    public function StringLiteral() : ?TerminalNode
1325	    {
1326	        return $this->getToken(PageSqlParser::StringLiteral, 0);
1327	    }
1328
1329	    public function NumberLiteral() : ?TerminalNode
1330	    {
1331	        return $this->getToken(PageSqlParser::NumberLiteral, 0);
1332	    }
1333
1334		public function enterRule(ParseTreeListener $listener) : void
1335		{
1336			if ($listener instanceof PageSqlListener) {
1337			    $listener->enterPattern($this);
1338		    }
1339		}
1340
1341		public function exitRule(ParseTreeListener $listener) : void
1342		{
1343			if ($listener instanceof PageSqlListener) {
1344			    $listener->exitPattern($this);
1345		    }
1346		}
1347	}
1348
1349	class ExpressionContext extends ParserRuleContext
1350	{
1351		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1352		{
1353			parent::__construct($parent, $invokingState);
1354		}
1355
1356		public function getRuleIndex() : int
1357		{
1358		    return PageSqlParser::RULE_expression;
1359	    }
1360
1361	    public function SqlName() : ?TerminalNode
1362	    {
1363	        return $this->getToken(PageSqlParser::SqlName, 0);
1364	    }
1365
1366	    public function StringLiteral() : ?TerminalNode
1367	    {
1368	        return $this->getToken(PageSqlParser::StringLiteral, 0);
1369	    }
1370
1371	    public function NumberLiteral() : ?TerminalNode
1372	    {
1373	        return $this->getToken(PageSqlParser::NumberLiteral, 0);
1374	    }
1375
1376	    public function Number() : ?TerminalNode
1377	    {
1378	        return $this->getToken(PageSqlParser::Number, 0);
1379	    }
1380
1381	    public function functionNames() : ?FunctionNamesContext
1382	    {
1383	    	return $this->getTypedRuleContext(FunctionNamesContext::class, 0);
1384	    }
1385
1386	    public function LPAREN() : ?TerminalNode
1387	    {
1388	        return $this->getToken(PageSqlParser::LPAREN, 0);
1389	    }
1390
1391	    public function RPAREN() : ?TerminalNode
1392	    {
1393	        return $this->getToken(PageSqlParser::RPAREN, 0);
1394	    }
1395
1396	    /**
1397	     * @return array<ExpressionContext>|ExpressionContext|null
1398	     */
1399	    public function expression(?int $index = null)
1400	    {
1401	    	if ($index === null) {
1402	    		return $this->getTypedRuleContexts(ExpressionContext::class);
1403	    	}
1404
1405	        return $this->getTypedRuleContext(ExpressionContext::class, $index);
1406	    }
1407
1408	    /**
1409	     * @return array<TerminalNode>|TerminalNode|null
1410	     */
1411	    public function COMMA(?int $index = null)
1412	    {
1413	    	if ($index === null) {
1414	    		return $this->getTokens(PageSqlParser::COMMA);
1415	    	}
1416
1417	        return $this->getToken(PageSqlParser::COMMA, $index);
1418	    }
1419
1420		public function enterRule(ParseTreeListener $listener) : void
1421		{
1422			if ($listener instanceof PageSqlListener) {
1423			    $listener->enterExpression($this);
1424		    }
1425		}
1426
1427		public function exitRule(ParseTreeListener $listener) : void
1428		{
1429			if ($listener instanceof PageSqlListener) {
1430			    $listener->exitExpression($this);
1431		    }
1432		}
1433	}
1434
1435	class PredicateContext extends ParserRuleContext
1436	{
1437		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1438		{
1439			parent::__construct($parent, $invokingState);
1440		}
1441
1442		public function getRuleIndex() : int
1443		{
1444		    return PageSqlParser::RULE_predicate;
1445	    }
1446
1447	    public function sqlNames() : ?SqlNamesContext
1448	    {
1449	    	return $this->getTypedRuleContext(SqlNamesContext::class, 0);
1450	    }
1451
1452	    /**
1453	     * @return array<ExpressionContext>|ExpressionContext|null
1454	     */
1455	    public function expression(?int $index = null)
1456	    {
1457	    	if ($index === null) {
1458	    		return $this->getTypedRuleContexts(ExpressionContext::class);
1459	    	}
1460
1461	        return $this->getTypedRuleContext(ExpressionContext::class, $index);
1462	    }
1463
1464	    public function BETWEEN() : ?TerminalNode
1465	    {
1466	        return $this->getToken(PageSqlParser::BETWEEN, 0);
1467	    }
1468
1469	    public function AND() : ?TerminalNode
1470	    {
1471	        return $this->getToken(PageSqlParser::AND, 0);
1472	    }
1473
1474	    public function IN() : ?TerminalNode
1475	    {
1476	        return $this->getToken(PageSqlParser::IN, 0);
1477	    }
1478
1479	    public function LPAREN() : ?TerminalNode
1480	    {
1481	        return $this->getToken(PageSqlParser::LPAREN, 0);
1482	    }
1483
1484	    public function RPAREN() : ?TerminalNode
1485	    {
1486	        return $this->getToken(PageSqlParser::RPAREN, 0);
1487	    }
1488
1489	    public function LESS_THAN() : ?TerminalNode
1490	    {
1491	        return $this->getToken(PageSqlParser::LESS_THAN, 0);
1492	    }
1493
1494	    public function LESS_THAN_OR_EQUAL() : ?TerminalNode
1495	    {
1496	        return $this->getToken(PageSqlParser::LESS_THAN_OR_EQUAL, 0);
1497	    }
1498
1499	    public function GREATER_THAN() : ?TerminalNode
1500	    {
1501	        return $this->getToken(PageSqlParser::GREATER_THAN, 0);
1502	    }
1503
1504	    public function GREATER_THAN_OR_EQUAL() : ?TerminalNode
1505	    {
1506	        return $this->getToken(PageSqlParser::GREATER_THAN_OR_EQUAL, 0);
1507	    }
1508
1509	    public function NOT_EQUAL() : ?TerminalNode
1510	    {
1511	        return $this->getToken(PageSqlParser::NOT_EQUAL, 0);
1512	    }
1513
1514	    public function EQUAL() : ?TerminalNode
1515	    {
1516	        return $this->getToken(PageSqlParser::EQUAL, 0);
1517	    }
1518
1519	    public function LIKE() : ?TerminalNode
1520	    {
1521	        return $this->getToken(PageSqlParser::LIKE, 0);
1522	    }
1523
1524	    public function pattern() : ?PatternContext
1525	    {
1526	    	return $this->getTypedRuleContext(PatternContext::class, 0);
1527	    }
1528
1529	    public function GLOB() : ?TerminalNode
1530	    {
1531	        return $this->getToken(PageSqlParser::GLOB, 0);
1532	    }
1533
1534	    public function NOT() : ?TerminalNode
1535	    {
1536	        return $this->getToken(PageSqlParser::NOT, 0);
1537	    }
1538
1539	    public function ESCAPE() : ?TerminalNode
1540	    {
1541	        return $this->getToken(PageSqlParser::ESCAPE, 0);
1542	    }
1543
1544	    public function StringLiteral() : ?TerminalNode
1545	    {
1546	        return $this->getToken(PageSqlParser::StringLiteral, 0);
1547	    }
1548
1549	    /**
1550	     * @return array<TerminalNode>|TerminalNode|null
1551	     */
1552	    public function COMMA(?int $index = null)
1553	    {
1554	    	if ($index === null) {
1555	    		return $this->getTokens(PageSqlParser::COMMA);
1556	    	}
1557
1558	        return $this->getToken(PageSqlParser::COMMA, $index);
1559	    }
1560
1561		public function enterRule(ParseTreeListener $listener) : void
1562		{
1563			if ($listener instanceof PageSqlListener) {
1564			    $listener->enterPredicate($this);
1565		    }
1566		}
1567
1568		public function exitRule(ParseTreeListener $listener) : void
1569		{
1570			if ($listener instanceof PageSqlListener) {
1571			    $listener->exitPredicate($this);
1572		    }
1573		}
1574	}
1575
1576	class ColumnsContext extends ParserRuleContext
1577	{
1578		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1579		{
1580			parent::__construct($parent, $invokingState);
1581		}
1582
1583		public function getRuleIndex() : int
1584		{
1585		    return PageSqlParser::RULE_columns;
1586	    }
1587
1588	    /**
1589	     * @return array<ColumnContext>|ColumnContext|null
1590	     */
1591	    public function column(?int $index = null)
1592	    {
1593	    	if ($index === null) {
1594	    		return $this->getTypedRuleContexts(ColumnContext::class);
1595	    	}
1596
1597	        return $this->getTypedRuleContext(ColumnContext::class, $index);
1598	    }
1599
1600	    /**
1601	     * @return array<TerminalNode>|TerminalNode|null
1602	     */
1603	    public function COMMA(?int $index = null)
1604	    {
1605	    	if ($index === null) {
1606	    		return $this->getTokens(PageSqlParser::COMMA);
1607	    	}
1608
1609	        return $this->getToken(PageSqlParser::COMMA, $index);
1610	    }
1611
1612		public function enterRule(ParseTreeListener $listener) : void
1613		{
1614			if ($listener instanceof PageSqlListener) {
1615			    $listener->enterColumns($this);
1616		    }
1617		}
1618
1619		public function exitRule(ParseTreeListener $listener) : void
1620		{
1621			if ($listener instanceof PageSqlListener) {
1622			    $listener->exitColumns($this);
1623		    }
1624		}
1625	}
1626
1627	class PredicateGroupContext extends ParserRuleContext
1628	{
1629		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1630		{
1631			parent::__construct($parent, $invokingState);
1632		}
1633
1634		public function getRuleIndex() : int
1635		{
1636		    return PageSqlParser::RULE_predicateGroup;
1637	    }
1638
1639	    public function LPAREN() : ?TerminalNode
1640	    {
1641	        return $this->getToken(PageSqlParser::LPAREN, 0);
1642	    }
1643
1644	    /**
1645	     * @return array<PredicateContext>|PredicateContext|null
1646	     */
1647	    public function predicate(?int $index = null)
1648	    {
1649	    	if ($index === null) {
1650	    		return $this->getTypedRuleContexts(PredicateContext::class);
1651	    	}
1652
1653	        return $this->getTypedRuleContext(PredicateContext::class, $index);
1654	    }
1655
1656	    public function RPAREN() : ?TerminalNode
1657	    {
1658	        return $this->getToken(PageSqlParser::RPAREN, 0);
1659	    }
1660
1661	    /**
1662	     * @return array<TerminalNode>|TerminalNode|null
1663	     */
1664	    public function AND(?int $index = null)
1665	    {
1666	    	if ($index === null) {
1667	    		return $this->getTokens(PageSqlParser::AND);
1668	    	}
1669
1670	        return $this->getToken(PageSqlParser::AND, $index);
1671	    }
1672
1673	    /**
1674	     * @return array<TerminalNode>|TerminalNode|null
1675	     */
1676	    public function OR(?int $index = null)
1677	    {
1678	    	if ($index === null) {
1679	    		return $this->getTokens(PageSqlParser::OR);
1680	    	}
1681
1682	        return $this->getToken(PageSqlParser::OR, $index);
1683	    }
1684
1685		public function enterRule(ParseTreeListener $listener) : void
1686		{
1687			if ($listener instanceof PageSqlListener) {
1688			    $listener->enterPredicateGroup($this);
1689		    }
1690		}
1691
1692		public function exitRule(ParseTreeListener $listener) : void
1693		{
1694			if ($listener instanceof PageSqlListener) {
1695			    $listener->exitPredicateGroup($this);
1696		    }
1697		}
1698	}
1699
1700	class PredicatesContext extends ParserRuleContext
1701	{
1702		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1703		{
1704			parent::__construct($parent, $invokingState);
1705		}
1706
1707		public function getRuleIndex() : int
1708		{
1709		    return PageSqlParser::RULE_predicates;
1710	    }
1711
1712	    public function WHERE() : ?TerminalNode
1713	    {
1714	        return $this->getToken(PageSqlParser::WHERE, 0);
1715	    }
1716
1717	    /**
1718	     * @return array<PredicateContext>|PredicateContext|null
1719	     */
1720	    public function predicate(?int $index = null)
1721	    {
1722	    	if ($index === null) {
1723	    		return $this->getTypedRuleContexts(PredicateContext::class);
1724	    	}
1725
1726	        return $this->getTypedRuleContext(PredicateContext::class, $index);
1727	    }
1728
1729	    /**
1730	     * @return array<PredicateGroupContext>|PredicateGroupContext|null
1731	     */
1732	    public function predicateGroup(?int $index = null)
1733	    {
1734	    	if ($index === null) {
1735	    		return $this->getTypedRuleContexts(PredicateGroupContext::class);
1736	    	}
1737
1738	        return $this->getTypedRuleContext(PredicateGroupContext::class, $index);
1739	    }
1740
1741	    /**
1742	     * @return array<TerminalNode>|TerminalNode|null
1743	     */
1744	    public function AND(?int $index = null)
1745	    {
1746	    	if ($index === null) {
1747	    		return $this->getTokens(PageSqlParser::AND);
1748	    	}
1749
1750	        return $this->getToken(PageSqlParser::AND, $index);
1751	    }
1752
1753	    /**
1754	     * @return array<TerminalNode>|TerminalNode|null
1755	     */
1756	    public function OR(?int $index = null)
1757	    {
1758	    	if ($index === null) {
1759	    		return $this->getTokens(PageSqlParser::OR);
1760	    	}
1761
1762	        return $this->getToken(PageSqlParser::OR, $index);
1763	    }
1764
1765		public function enterRule(ParseTreeListener $listener) : void
1766		{
1767			if ($listener instanceof PageSqlListener) {
1768			    $listener->enterPredicates($this);
1769		    }
1770		}
1771
1772		public function exitRule(ParseTreeListener $listener) : void
1773		{
1774			if ($listener instanceof PageSqlListener) {
1775			    $listener->exitPredicates($this);
1776		    }
1777		}
1778	}
1779
1780	class TablesContext extends ParserRuleContext
1781	{
1782		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1783		{
1784			parent::__construct($parent, $invokingState);
1785		}
1786
1787		public function getRuleIndex() : int
1788		{
1789		    return PageSqlParser::RULE_tables;
1790	    }
1791
1792	    public function FROM() : ?TerminalNode
1793	    {
1794	        return $this->getToken(PageSqlParser::FROM, 0);
1795	    }
1796
1797	    public function tableNames() : ?TableNamesContext
1798	    {
1799	    	return $this->getTypedRuleContext(TableNamesContext::class, 0);
1800	    }
1801
1802		public function enterRule(ParseTreeListener $listener) : void
1803		{
1804			if ($listener instanceof PageSqlListener) {
1805			    $listener->enterTables($this);
1806		    }
1807		}
1808
1809		public function exitRule(ParseTreeListener $listener) : void
1810		{
1811			if ($listener instanceof PageSqlListener) {
1812			    $listener->exitTables($this);
1813		    }
1814		}
1815	}
1816
1817	class LimitContext extends ParserRuleContext
1818	{
1819		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1820		{
1821			parent::__construct($parent, $invokingState);
1822		}
1823
1824		public function getRuleIndex() : int
1825		{
1826		    return PageSqlParser::RULE_limit;
1827	    }
1828
1829	    public function LIMIT() : ?TerminalNode
1830	    {
1831	        return $this->getToken(PageSqlParser::LIMIT, 0);
1832	    }
1833
1834	    public function Number() : ?TerminalNode
1835	    {
1836	        return $this->getToken(PageSqlParser::Number, 0);
1837	    }
1838
1839		public function enterRule(ParseTreeListener $listener) : void
1840		{
1841			if ($listener instanceof PageSqlListener) {
1842			    $listener->enterLimit($this);
1843		    }
1844		}
1845
1846		public function exitRule(ParseTreeListener $listener) : void
1847		{
1848			if ($listener instanceof PageSqlListener) {
1849			    $listener->exitLimit($this);
1850		    }
1851		}
1852	}
1853
1854	class OrderBysContext extends ParserRuleContext
1855	{
1856		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1857		{
1858			parent::__construct($parent, $invokingState);
1859		}
1860
1861		public function getRuleIndex() : int
1862		{
1863		    return PageSqlParser::RULE_orderBys;
1864	    }
1865
1866	    public function ORDER() : ?TerminalNode
1867	    {
1868	        return $this->getToken(PageSqlParser::ORDER, 0);
1869	    }
1870
1871	    public function RANDOM() : ?TerminalNode
1872	    {
1873	        return $this->getToken(PageSqlParser::RANDOM, 0);
1874	    }
1875
1876	    public function BY() : ?TerminalNode
1877	    {
1878	        return $this->getToken(PageSqlParser::BY, 0);
1879	    }
1880
1881	    /**
1882	     * @return array<OrderByDefContext>|OrderByDefContext|null
1883	     */
1884	    public function orderByDef(?int $index = null)
1885	    {
1886	    	if ($index === null) {
1887	    		return $this->getTypedRuleContexts(OrderByDefContext::class);
1888	    	}
1889
1890	        return $this->getTypedRuleContext(OrderByDefContext::class, $index);
1891	    }
1892
1893	    /**
1894	     * @return array<TerminalNode>|TerminalNode|null
1895	     */
1896	    public function COMMA(?int $index = null)
1897	    {
1898	    	if ($index === null) {
1899	    		return $this->getTokens(PageSqlParser::COMMA);
1900	    	}
1901
1902	        return $this->getToken(PageSqlParser::COMMA, $index);
1903	    }
1904
1905		public function enterRule(ParseTreeListener $listener) : void
1906		{
1907			if ($listener instanceof PageSqlListener) {
1908			    $listener->enterOrderBys($this);
1909		    }
1910		}
1911
1912		public function exitRule(ParseTreeListener $listener) : void
1913		{
1914			if ($listener instanceof PageSqlListener) {
1915			    $listener->exitOrderBys($this);
1916		    }
1917		}
1918	}
1919
1920	class OrderByDefContext extends ParserRuleContext
1921	{
1922		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1923		{
1924			parent::__construct($parent, $invokingState);
1925		}
1926
1927		public function getRuleIndex() : int
1928		{
1929		    return PageSqlParser::RULE_orderByDef;
1930	    }
1931
1932	    public function SqlName() : ?TerminalNode
1933	    {
1934	        return $this->getToken(PageSqlParser::SqlName, 0);
1935	    }
1936
1937	    public function ASC() : ?TerminalNode
1938	    {
1939	        return $this->getToken(PageSqlParser::ASC, 0);
1940	    }
1941
1942	    public function DESC() : ?TerminalNode
1943	    {
1944	        return $this->getToken(PageSqlParser::DESC, 0);
1945	    }
1946
1947		public function enterRule(ParseTreeListener $listener) : void
1948		{
1949			if ($listener instanceof PageSqlListener) {
1950			    $listener->enterOrderByDef($this);
1951		    }
1952		}
1953
1954		public function exitRule(ParseTreeListener $listener) : void
1955		{
1956			if ($listener instanceof PageSqlListener) {
1957			    $listener->exitOrderByDef($this);
1958		    }
1959		}
1960	}
1961
1962	class PageSqlContext extends ParserRuleContext
1963	{
1964		public function __construct(?ParserRuleContext $parent, ?int $invokingState = null)
1965		{
1966			parent::__construct($parent, $invokingState);
1967		}
1968
1969		public function getRuleIndex() : int
1970		{
1971		    return PageSqlParser::RULE_pageSql;
1972	    }
1973
1974	    public function SELECT() : ?TerminalNode
1975	    {
1976	        return $this->getToken(PageSqlParser::SELECT, 0);
1977	    }
1978
1979	    public function RANDOM() : ?TerminalNode
1980	    {
1981	        return $this->getToken(PageSqlParser::RANDOM, 0);
1982	    }
1983
1984	    public function STAR() : ?TerminalNode
1985	    {
1986	        return $this->getToken(PageSqlParser::STAR, 0);
1987	    }
1988
1989	    public function columns() : ?ColumnsContext
1990	    {
1991	    	return $this->getTypedRuleContext(ColumnsContext::class, 0);
1992	    }
1993
1994	    public function tables() : ?TablesContext
1995	    {
1996	    	return $this->getTypedRuleContext(TablesContext::class, 0);
1997	    }
1998
1999	    public function predicates() : ?PredicatesContext
2000	    {
2001	    	return $this->getTypedRuleContext(PredicatesContext::class, 0);
2002	    }
2003
2004	    public function orderBys() : ?OrderBysContext
2005	    {
2006	    	return $this->getTypedRuleContext(OrderBysContext::class, 0);
2007	    }
2008
2009	    public function limit() : ?LimitContext
2010	    {
2011	    	return $this->getTypedRuleContext(LimitContext::class, 0);
2012	    }
2013
2014		public function enterRule(ParseTreeListener $listener) : void
2015		{
2016			if ($listener instanceof PageSqlListener) {
2017			    $listener->enterPageSql($this);
2018		    }
2019		}
2020
2021		public function exitRule(ParseTreeListener $listener) : void
2022		{
2023			if ($listener instanceof PageSqlListener) {
2024			    $listener->exitPageSql($this);
2025		    }
2026		}
2027	}
2028}