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}