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