thecodingmachine /
magic-query
@@ -43,7 +43,6 @@ discard block |
||
| 43 | 43 | /** |
| 44 | 44 | * Prints an array only if debug mode is on. |
| 45 | 45 | * |
| 46 | - * @param array $s |
|
| 47 | 46 | * @param bool $return, if true, the formatted array is returned via return parameter |
| 48 | 47 | */ |
| 49 | 48 | protected function preprint($arr, $return = false) |
@@ -80,6 +79,7 @@ discard block |
||
| 80 | 79 | |
| 81 | 80 | /** |
| 82 | 81 | * Revokes the escaping characters from an expression. |
| 82 | + * @param string $sql |
|
| 83 | 83 | */ |
| 84 | 84 | protected function revokeEscaping($sql) |
| 85 | 85 | { |
@@ -73,6 +73,9 @@ discard block |
||
| 73 | 73 | return $parsed; |
| 74 | 74 | } |
| 75 | 75 | |
| 76 | + /** |
|
| 77 | + * @param string $sql |
|
| 78 | + */ |
|
| 76 | 79 | private function findPositionWithinString($sql, $value, $expr_type) |
| 77 | 80 | { |
| 78 | 81 | $offset = 0; |
@@ -130,6 +133,10 @@ discard block |
||
| 130 | 133 | return $pos; |
| 131 | 134 | } |
| 132 | 135 | |
| 136 | + /** |
|
| 137 | + * @param integer $charPos |
|
| 138 | + * @param integer $key |
|
| 139 | + */ |
|
| 133 | 140 | private function lookForBaseExpression($sql, &$charPos, &$parsed, $key, &$backtracking) |
| 134 | 141 | { |
| 135 | 142 | if (!is_numeric($key)) { |
@@ -44,7 +44,7 @@ |
||
| 44 | 44 | { |
| 45 | 45 | private static $allowedOnOperator = array("\t", "\n", "\r", ' ', ',', '(', ')', '_', "'", '"'); |
| 46 | 46 | private static $allowedOnOther = array("\t", "\n", "\r", ' ', ',', '(', ')', '<', '>', '*', '+', '-', '/', '|', |
| 47 | - '&', '=', '!', ';', ); |
|
| 47 | + '&', '=', '!', ';', ); |
|
| 48 | 48 | |
| 49 | 49 | private function printPos($text, $sql, $charPos, $key, $parsed, $backtracking) |
| 50 | 50 | { |
@@ -44,7 +44,7 @@ |
||
| 44 | 44 | { |
| 45 | 45 | private static $allowedOnOperator = array("\t", "\n", "\r", ' ', ',', '(', ')', '_', "'", '"'); |
| 46 | 46 | private static $allowedOnOther = array("\t", "\n", "\r", ' ', ',', '(', ')', '<', '>', '*', '+', '-', '/', '|', |
| 47 | - '&', '=', '!', ';', ); |
|
| 47 | + '&', '=', '!', ';',); |
|
| 48 | 48 | |
| 49 | 49 | private function printPos($text, $sql, $charPos, $key, $parsed, $backtracking) |
| 50 | 50 | { |
@@ -277,7 +277,7 @@ |
||
| 277 | 277 | * |
| 278 | 278 | * @param Connection $dbConnection |
| 279 | 279 | * @param array $parameters |
| 280 | - * @param number $indent |
|
| 280 | + * @param integer $indent |
|
| 281 | 281 | * @param int $conditionsMode |
| 282 | 282 | * |
| 283 | 283 | * @return string |
@@ -360,7 +360,7 @@ |
||
| 360 | 360 | if ($children) { |
| 361 | 361 | if (is_array($children)) { |
| 362 | 362 | foreach ($children as $key => $operand) { |
| 363 | - if($operand) { |
|
| 363 | + if ($operand) { |
|
| 364 | 364 | $result2 = $operand->walk($visitor); |
| 365 | 365 | if ($result2 === NodeTraverser::REMOVE_NODE) { |
| 366 | 366 | unset($children[$key]); |
@@ -51,6 +51,9 @@ discard block |
||
| 51 | 51 | } |
| 52 | 52 | } |
| 53 | 53 | |
| 54 | + /** |
|
| 55 | + * @param string|boolean $sql |
|
| 56 | + */ |
|
| 54 | 57 | public function parse($sql, $calcPositions = false) |
| 55 | 58 | { |
| 56 | 59 | #lex the SQL statement |
@@ -499,6 +502,9 @@ discard block |
||
| 499 | 502 | return $this->processSQLParts($out); |
| 500 | 503 | } |
| 501 | 504 | |
| 505 | + /** |
|
| 506 | + * @param boolean $out |
|
| 507 | + */ |
|
| 502 | 508 | private function processSQLParts($out) |
| 503 | 509 | { |
| 504 | 510 | if (!$out) { |
@@ -565,6 +571,7 @@ discard block |
||
| 565 | 571 | /** |
| 566 | 572 | * A SET list is simply a list of key = value expressions separated by comma (,). |
| 567 | 573 | * This function produces a list of the key/value expressions. |
| 574 | + * @param string $base_expr |
|
| 568 | 575 | */ |
| 569 | 576 | private function getAssignment($base_expr) |
| 570 | 577 | { |
@@ -574,6 +581,9 @@ discard block |
||
| 574 | 581 | 'sub_tree' => $assignment, ); |
| 575 | 582 | } |
| 576 | 583 | |
| 584 | + /** |
|
| 585 | + * @param string $expression |
|
| 586 | + */ |
|
| 577 | 587 | private function getVariableType($expression) |
| 578 | 588 | { |
| 579 | 589 | // $expression must contain only upper-case characters |
@@ -601,6 +611,7 @@ discard block |
||
| 601 | 611 | |
| 602 | 612 | /** |
| 603 | 613 | * It can be UPDATE SET or SET alone. |
| 614 | + * @param boolean $isUpdate |
|
| 604 | 615 | */ |
| 605 | 616 | private function process_set_list($tokens, $isUpdate) |
| 606 | 617 | { |
@@ -730,6 +741,9 @@ discard block |
||
| 730 | 741 | return (trim($token) === ''); |
| 731 | 742 | } |
| 732 | 743 | |
| 744 | + /** |
|
| 745 | + * @param string $token |
|
| 746 | + */ |
|
| 733 | 747 | private function isCommentToken($token) |
| 734 | 748 | { |
| 735 | 749 | return isset($token[0]) && isset($token[1]) |
@@ -1490,6 +1504,7 @@ discard block |
||
| 1490 | 1504 | |
| 1491 | 1505 | /** |
| 1492 | 1506 | * This method handles INSERT and REPLACE statements. |
| 1507 | + * @param string $token_category |
|
| 1493 | 1508 | */ |
| 1494 | 1509 | private function processInsertOrReplace($tokenList, $token_category) |
| 1495 | 1510 | { |
@@ -571,7 +571,7 @@ discard block |
||
| 571 | 571 | $assignment = $this->process_expr_list($this->splitSQLIntoTokens($base_expr)); |
| 572 | 572 | |
| 573 | 573 | return array('expr_type' => ExpressionType::EXPRESSION, 'base_expr' => trim($base_expr), |
| 574 | - 'sub_tree' => $assignment, ); |
|
| 574 | + 'sub_tree' => $assignment, ); |
|
| 575 | 575 | } |
| 576 | 576 | |
| 577 | 577 | private function getVariableType($expression) |
@@ -843,7 +843,7 @@ discard block |
||
| 843 | 843 | || $this->isFunction($prev) || $this->isExpression($prev) || $this->isSubQuery($prev) |
| 844 | 844 | || $this->isColumnReference($prev) || $this->isBracketExpression($prev)) { |
| 845 | 845 | $alias = array('as' => false, 'name' => trim($last['base_expr']), |
| 846 | - 'base_expr' => trim($last['base_expr']), ); |
|
| 846 | + 'base_expr' => trim($last['base_expr']), ); |
|
| 847 | 847 | #remove the last token |
| 848 | 848 | array_pop($tokens); |
| 849 | 849 | $base_expr = implode('', $tokens); |
@@ -873,7 +873,7 @@ discard block |
||
| 873 | 873 | } |
| 874 | 874 | |
| 875 | 875 | return array('expr_type' => $type, 'alias' => $alias, 'base_expr' => trim($base_expr), |
| 876 | - 'sub_tree' => $processed, ); |
|
| 876 | + 'sub_tree' => $processed, ); |
|
| 877 | 877 | } |
| 878 | 878 | |
| 879 | 879 | /** |
@@ -1013,9 +1013,9 @@ discard block |
||
| 1013 | 1013 | } |
| 1014 | 1014 | # loop init |
| 1015 | 1015 | return array('expression' => '', 'token_count' => 0, 'table' => '', 'alias' => false, 'join_type' => '', |
| 1016 | - 'next_join_type' => '', 'saved_join_type' => $parseInfo['saved_join_type'], |
|
| 1017 | - 'ref_type' => false, 'ref_expr' => false, 'base_expr' => false, 'sub_tree' => false, |
|
| 1018 | - 'subquery' => '', ); |
|
| 1016 | + 'next_join_type' => '', 'saved_join_type' => $parseInfo['saved_join_type'], |
|
| 1017 | + 'ref_type' => false, 'ref_expr' => false, 'base_expr' => false, 'sub_tree' => false, |
|
| 1018 | + 'subquery' => '', ); |
|
| 1019 | 1019 | } |
| 1020 | 1020 | |
| 1021 | 1021 | private function processFromExpression(&$parseInfo) |
@@ -1099,7 +1099,7 @@ discard block |
||
| 1099 | 1099 | } |
| 1100 | 1100 | |
| 1101 | 1101 | return array('expr_type' => $parseInfo['type'], 'base_expr' => $parseInfo['expr'], |
| 1102 | - 'direction' => $parseInfo['dir'], ); |
|
| 1102 | + 'direction' => $parseInfo['dir'], ); |
|
| 1103 | 1103 | } |
| 1104 | 1104 | |
| 1105 | 1105 | private function initParseInfoForOrder() |
@@ -245,246 +245,246 @@ discard block |
||
| 245 | 245 | switch ($upper) { |
| 246 | 246 | |
| 247 | 247 | /* Tokens that get their own sections. These keywords have subclauses. */ |
| 248 | - case 'SELECT': |
|
| 249 | - case 'ORDER': |
|
| 250 | - case 'LIMIT': |
|
| 251 | - case 'SET': |
|
| 252 | - case 'DUPLICATE': |
|
| 253 | - case 'VALUES': |
|
| 254 | - case 'GROUP': |
|
| 255 | - case 'HAVING': |
|
| 256 | - case 'WHERE': |
|
| 257 | - case 'RENAME': |
|
| 258 | - case 'CALL': |
|
| 259 | - case 'PROCEDURE': |
|
| 260 | - case 'FUNCTION': |
|
| 261 | - case 'SERVER': |
|
| 262 | - case 'LOGFILE': |
|
| 263 | - case 'DEFINER': |
|
| 264 | - case 'RETURNS': |
|
| 265 | - case 'TABLESPACE': |
|
| 266 | - case 'TRIGGER': |
|
| 267 | - case 'DO': |
|
| 268 | - case 'PLUGIN': |
|
| 269 | - case 'FROM': |
|
| 270 | - case 'FLUSH': |
|
| 271 | - case 'KILL': |
|
| 272 | - case 'RESET': |
|
| 273 | - case 'START': |
|
| 274 | - case 'STOP': |
|
| 275 | - case 'PURGE': |
|
| 276 | - case 'EXECUTE': |
|
| 277 | - case 'PREPARE': |
|
| 278 | - case 'DEALLOCATE': |
|
| 279 | - if ($trim === 'DEALLOCATE') { |
|
| 280 | - $skip_next = true; |
|
| 281 | - } |
|
| 282 | - /* this FROM is different from FROM in other DML (not join related) */ |
|
| 283 | - if ($token_category === 'PREPARE' && $upper === 'FROM') { |
|
| 284 | - continue 2; |
|
| 285 | - } |
|
| 286 | - |
|
| 287 | - $token_category = $upper; |
|
| 288 | - break; |
|
| 289 | - |
|
| 290 | - case 'DATABASE': |
|
| 291 | - case 'SCHEMA': |
|
| 292 | - if ($prev_category === 'DROP') { |
|
| 293 | - continue; |
|
| 294 | - } |
|
| 295 | - $token_category = $upper; |
|
| 296 | - break; |
|
| 248 | + case 'SELECT': |
|
| 249 | + case 'ORDER': |
|
| 250 | + case 'LIMIT': |
|
| 251 | + case 'SET': |
|
| 252 | + case 'DUPLICATE': |
|
| 253 | + case 'VALUES': |
|
| 254 | + case 'GROUP': |
|
| 255 | + case 'HAVING': |
|
| 256 | + case 'WHERE': |
|
| 257 | + case 'RENAME': |
|
| 258 | + case 'CALL': |
|
| 259 | + case 'PROCEDURE': |
|
| 260 | + case 'FUNCTION': |
|
| 261 | + case 'SERVER': |
|
| 262 | + case 'LOGFILE': |
|
| 263 | + case 'DEFINER': |
|
| 264 | + case 'RETURNS': |
|
| 265 | + case 'TABLESPACE': |
|
| 266 | + case 'TRIGGER': |
|
| 267 | + case 'DO': |
|
| 268 | + case 'PLUGIN': |
|
| 269 | + case 'FROM': |
|
| 270 | + case 'FLUSH': |
|
| 271 | + case 'KILL': |
|
| 272 | + case 'RESET': |
|
| 273 | + case 'START': |
|
| 274 | + case 'STOP': |
|
| 275 | + case 'PURGE': |
|
| 276 | + case 'EXECUTE': |
|
| 277 | + case 'PREPARE': |
|
| 278 | + case 'DEALLOCATE': |
|
| 279 | + if ($trim === 'DEALLOCATE') { |
|
| 280 | + $skip_next = true; |
|
| 281 | + } |
|
| 282 | + /* this FROM is different from FROM in other DML (not join related) */ |
|
| 283 | + if ($token_category === 'PREPARE' && $upper === 'FROM') { |
|
| 284 | + continue 2; |
|
| 285 | + } |
|
| 297 | 286 | |
| 298 | - case 'EVENT': |
|
| 299 | - # issue 71 |
|
| 300 | - if ($prev_category === 'DROP' || $prev_category === 'ALTER' || $prev_category === 'CREATE') { |
|
| 301 | 287 | $token_category = $upper; |
| 302 | - } |
|
| 303 | - break; |
|
| 288 | + break; |
|
| 304 | 289 | |
| 305 | - case 'DATA': |
|
| 306 | - # prevent wrong handling of DATA as keyword |
|
| 307 | - if ($prev_category === 'LOAD') { |
|
| 290 | + case 'DATABASE': |
|
| 291 | + case 'SCHEMA': |
|
| 292 | + if ($prev_category === 'DROP') { |
|
| 293 | + continue; |
|
| 294 | + } |
|
| 308 | 295 | $token_category = $upper; |
| 309 | - } |
|
| 310 | - break; |
|
| 296 | + break; |
|
| 311 | 297 | |
| 312 | - case 'INTO': |
|
| 313 | - # prevent wrong handling of CACHE within LOAD INDEX INTO CACHE... |
|
| 314 | - if ($prev_category === 'LOAD') { |
|
| 315 | - $out[$prev_category][] = $upper; |
|
| 316 | - continue 2; |
|
| 317 | - } |
|
| 318 | - $token_category = $upper; |
|
| 319 | - break; |
|
| 298 | + case 'EVENT': |
|
| 299 | + # issue 71 |
|
| 300 | + if ($prev_category === 'DROP' || $prev_category === 'ALTER' || $prev_category === 'CREATE') { |
|
| 301 | + $token_category = $upper; |
|
| 302 | + } |
|
| 303 | + break; |
|
| 320 | 304 | |
| 321 | - case 'USER': |
|
| 322 | - # prevent wrong processing as keyword |
|
| 323 | - if ($prev_category === 'CREATE' || $prev_category === 'RENAME' || $prev_category === 'DROP') { |
|
| 324 | - $token_category = $upper; |
|
| 325 | - } |
|
| 326 | - break; |
|
| 305 | + case 'DATA': |
|
| 306 | + # prevent wrong handling of DATA as keyword |
|
| 307 | + if ($prev_category === 'LOAD') { |
|
| 308 | + $token_category = $upper; |
|
| 309 | + } |
|
| 310 | + break; |
|
| 327 | 311 | |
| 328 | - case 'VIEW': |
|
| 329 | - # prevent wrong processing as keyword |
|
| 330 | - if ($prev_category === 'CREATE' || $prev_category === 'ALTER' || $prev_category === 'DROP') { |
|
| 312 | + case 'INTO': |
|
| 313 | + # prevent wrong handling of CACHE within LOAD INDEX INTO CACHE... |
|
| 314 | + if ($prev_category === 'LOAD') { |
|
| 315 | + $out[$prev_category][] = $upper; |
|
| 316 | + continue 2; |
|
| 317 | + } |
|
| 331 | 318 | $token_category = $upper; |
| 332 | - } |
|
| 333 | - break; |
|
| 319 | + break; |
|
| 334 | 320 | |
| 335 | - /* These tokens get their own section, but have no subclauses. |
|
| 321 | + case 'USER': |
|
| 322 | + # prevent wrong processing as keyword |
|
| 323 | + if ($prev_category === 'CREATE' || $prev_category === 'RENAME' || $prev_category === 'DROP') { |
|
| 324 | + $token_category = $upper; |
|
| 325 | + } |
|
| 326 | + break; |
|
| 327 | + |
|
| 328 | + case 'VIEW': |
|
| 329 | + # prevent wrong processing as keyword |
|
| 330 | + if ($prev_category === 'CREATE' || $prev_category === 'ALTER' || $prev_category === 'DROP') { |
|
| 331 | + $token_category = $upper; |
|
| 332 | + } |
|
| 333 | + break; |
|
| 334 | + |
|
| 335 | + /* These tokens get their own section, but have no subclauses. |
|
| 336 | 336 | These tokens identify the statement but have no specific subclauses of their own. */ |
| 337 | - case 'DELETE': |
|
| 338 | - case 'ALTER': |
|
| 339 | - case 'INSERT': |
|
| 340 | - case 'REPLACE': |
|
| 341 | - case 'TRUNCATE': |
|
| 342 | - case 'CREATE': |
|
| 343 | - case 'TRUNCATE': |
|
| 344 | - case 'OPTIMIZE': |
|
| 345 | - case 'GRANT': |
|
| 346 | - case 'REVOKE': |
|
| 347 | - case 'SHOW': |
|
| 348 | - case 'HANDLER': |
|
| 349 | - case 'LOAD': |
|
| 350 | - case 'ROLLBACK': |
|
| 351 | - case 'SAVEPOINT': |
|
| 352 | - case 'UNLOCK': |
|
| 353 | - case 'INSTALL': |
|
| 354 | - case 'UNINSTALL': |
|
| 355 | - case 'ANALZYE': |
|
| 356 | - case 'BACKUP': |
|
| 357 | - case 'CHECK': |
|
| 358 | - case 'CHECKSUM': |
|
| 359 | - case 'REPAIR': |
|
| 360 | - case 'RESTORE': |
|
| 361 | - case 'DESCRIBE': |
|
| 362 | - case 'EXPLAIN': |
|
| 363 | - case 'USE': |
|
| 364 | - case 'HELP': |
|
| 365 | - $token_category = $upper; /* set the category in case these get subclauses |
|
| 337 | + case 'DELETE': |
|
| 338 | + case 'ALTER': |
|
| 339 | + case 'INSERT': |
|
| 340 | + case 'REPLACE': |
|
| 341 | + case 'TRUNCATE': |
|
| 342 | + case 'CREATE': |
|
| 343 | + case 'TRUNCATE': |
|
| 344 | + case 'OPTIMIZE': |
|
| 345 | + case 'GRANT': |
|
| 346 | + case 'REVOKE': |
|
| 347 | + case 'SHOW': |
|
| 348 | + case 'HANDLER': |
|
| 349 | + case 'LOAD': |
|
| 350 | + case 'ROLLBACK': |
|
| 351 | + case 'SAVEPOINT': |
|
| 352 | + case 'UNLOCK': |
|
| 353 | + case 'INSTALL': |
|
| 354 | + case 'UNINSTALL': |
|
| 355 | + case 'ANALZYE': |
|
| 356 | + case 'BACKUP': |
|
| 357 | + case 'CHECK': |
|
| 358 | + case 'CHECKSUM': |
|
| 359 | + case 'REPAIR': |
|
| 360 | + case 'RESTORE': |
|
| 361 | + case 'DESCRIBE': |
|
| 362 | + case 'EXPLAIN': |
|
| 363 | + case 'USE': |
|
| 364 | + case 'HELP': |
|
| 365 | + $token_category = $upper; /* set the category in case these get subclauses |
|
| 366 | 366 | in a future version of MySQL */ |
| 367 | - $out[$upper][0] = $upper; |
|
| 368 | - continue 2; |
|
| 369 | - break; |
|
| 370 | - |
|
| 371 | - case 'CACHE': |
|
| 372 | - if ($prev_category === '' || $prev_category === 'RESET' || $prev_category === 'FLUSH' |
|
| 373 | - || $prev_category === 'LOAD') { |
|
| 374 | - $token_category = $upper; |
|
| 367 | + $out[$upper][0] = $upper; |
|
| 375 | 368 | continue 2; |
| 376 | - } |
|
| 377 | - break; |
|
| 369 | + break; |
|
| 378 | 370 | |
| 379 | - /* This is either LOCK TABLES or SELECT ... LOCK IN SHARE MODE*/ |
|
| 380 | - case 'LOCK': |
|
| 381 | - if ($token_category === '') { |
|
| 382 | - $token_category = $upper; |
|
| 383 | - $out[$upper][0] = $upper; |
|
| 384 | - } else { |
|
| 385 | - $trim = 'LOCK IN SHARE MODE'; |
|
| 386 | - $skip_next = true; |
|
| 387 | - $out['OPTIONS'][] = $trim; |
|
| 388 | - } |
|
| 389 | - continue 2; |
|
| 390 | - break; |
|
| 371 | + case 'CACHE': |
|
| 372 | + if ($prev_category === '' || $prev_category === 'RESET' || $prev_category === 'FLUSH' |
|
| 373 | + || $prev_category === 'LOAD') { |
|
| 374 | + $token_category = $upper; |
|
| 375 | + continue 2; |
|
| 376 | + } |
|
| 377 | + break; |
|
| 391 | 378 | |
| 392 | - case 'USING': /* USING in FROM clause is different from USING w/ prepared statement*/ |
|
| 393 | - if ($token_category === 'EXECUTE') { |
|
| 394 | - $token_category = $upper; |
|
| 395 | - continue 2; |
|
| 396 | - } |
|
| 397 | - if ($token_category === 'FROM' && !empty($out['DELETE'])) { |
|
| 398 | - $token_category = $upper; |
|
| 379 | + /* This is either LOCK TABLES or SELECT ... LOCK IN SHARE MODE*/ |
|
| 380 | + case 'LOCK': |
|
| 381 | + if ($token_category === '') { |
|
| 382 | + $token_category = $upper; |
|
| 383 | + $out[$upper][0] = $upper; |
|
| 384 | + } else { |
|
| 385 | + $trim = 'LOCK IN SHARE MODE'; |
|
| 386 | + $skip_next = true; |
|
| 387 | + $out['OPTIONS'][] = $trim; |
|
| 388 | + } |
|
| 399 | 389 | continue 2; |
| 400 | - } |
|
| 401 | - break; |
|
| 390 | + break; |
|
| 402 | 391 | |
| 403 | - /* DROP TABLE is different from ALTER TABLE DROP ... */ |
|
| 404 | - case 'DROP': |
|
| 405 | - if ($token_category !== 'ALTER') { |
|
| 406 | - $token_category = $upper; |
|
| 407 | - continue 2; |
|
| 408 | - } |
|
| 409 | - break; |
|
| 392 | + case 'USING': /* USING in FROM clause is different from USING w/ prepared statement*/ |
|
| 393 | + if ($token_category === 'EXECUTE') { |
|
| 394 | + $token_category = $upper; |
|
| 395 | + continue 2; |
|
| 396 | + } |
|
| 397 | + if ($token_category === 'FROM' && !empty($out['DELETE'])) { |
|
| 398 | + $token_category = $upper; |
|
| 399 | + continue 2; |
|
| 400 | + } |
|
| 401 | + break; |
|
| 410 | 402 | |
| 411 | - case 'FOR': |
|
| 412 | - $skip_next = true; |
|
| 413 | - $out['OPTIONS'][] = 'FOR UPDATE'; |
|
| 414 | - continue 2; |
|
| 415 | - break; |
|
| 403 | + /* DROP TABLE is different from ALTER TABLE DROP ... */ |
|
| 404 | + case 'DROP': |
|
| 405 | + if ($token_category !== 'ALTER') { |
|
| 406 | + $token_category = $upper; |
|
| 407 | + continue 2; |
|
| 408 | + } |
|
| 409 | + break; |
|
| 416 | 410 | |
| 417 | - case 'UPDATE': |
|
| 418 | - if ($token_category === '') { |
|
| 419 | - $token_category = $upper; |
|
| 420 | - continue 2; |
|
| 421 | - } |
|
| 422 | - if ($token_category === 'DUPLICATE') { |
|
| 411 | + case 'FOR': |
|
| 412 | + $skip_next = true; |
|
| 413 | + $out['OPTIONS'][] = 'FOR UPDATE'; |
|
| 423 | 414 | continue 2; |
| 424 | - } |
|
| 425 | - break; |
|
| 415 | + break; |
|
| 426 | 416 | |
| 427 | - case 'START': |
|
| 428 | - $trim = 'BEGIN'; |
|
| 429 | - $out[$upper][0] = $upper; |
|
| 430 | - $skip_next = true; |
|
| 431 | - break; |
|
| 417 | + case 'UPDATE': |
|
| 418 | + if ($token_category === '') { |
|
| 419 | + $token_category = $upper; |
|
| 420 | + continue 2; |
|
| 421 | + } |
|
| 422 | + if ($token_category === 'DUPLICATE') { |
|
| 423 | + continue 2; |
|
| 424 | + } |
|
| 425 | + break; |
|
| 432 | 426 | |
| 433 | - /* These tokens are ignored. */ |
|
| 434 | - case 'BY': |
|
| 435 | - case 'ALL': |
|
| 436 | - case 'SHARE': |
|
| 437 | - case 'MODE': |
|
| 438 | - case 'TO': |
|
| 439 | - case ';': |
|
| 440 | - continue 2; |
|
| 441 | - break; |
|
| 427 | + case 'START': |
|
| 428 | + $trim = 'BEGIN'; |
|
| 429 | + $out[$upper][0] = $upper; |
|
| 430 | + $skip_next = true; |
|
| 431 | + break; |
|
| 442 | 432 | |
| 443 | - case 'KEY': |
|
| 444 | - if ($token_category === 'DUPLICATE') { |
|
| 433 | + /* These tokens are ignored. */ |
|
| 434 | + case 'BY': |
|
| 435 | + case 'ALL': |
|
| 436 | + case 'SHARE': |
|
| 437 | + case 'MODE': |
|
| 438 | + case 'TO': |
|
| 439 | + case ';': |
|
| 445 | 440 | continue 2; |
| 446 | - } |
|
| 447 | - break; |
|
| 441 | + break; |
|
| 448 | 442 | |
| 449 | - /* These tokens set particular options for the statement. They never stand alone.*/ |
|
| 450 | - case 'DISTINCTROW': |
|
| 451 | - $trim = 'DISTINCT'; |
|
| 452 | - case 'DISTINCT': |
|
| 453 | - case 'HIGH_PRIORITY': |
|
| 454 | - case 'LOW_PRIORITY': |
|
| 455 | - case 'DELAYED': |
|
| 456 | - case 'IGNORE': |
|
| 457 | - case 'FORCE': |
|
| 458 | - case 'STRAIGHT_JOIN': |
|
| 459 | - case 'SQL_SMALL_RESULT': |
|
| 460 | - case 'SQL_BIG_RESULT': |
|
| 461 | - case 'QUICK': |
|
| 462 | - case 'SQL_BUFFER_RESULT': |
|
| 463 | - case 'SQL_CACHE': |
|
| 464 | - case 'SQL_NO_CACHE': |
|
| 465 | - case 'SQL_CALC_FOUND_ROWS': |
|
| 466 | - $out['OPTIONS'][] = $upper; |
|
| 467 | - continue 2; |
|
| 468 | - break; |
|
| 443 | + case 'KEY': |
|
| 444 | + if ($token_category === 'DUPLICATE') { |
|
| 445 | + continue 2; |
|
| 446 | + } |
|
| 447 | + break; |
|
| 469 | 448 | |
| 470 | - case 'WITH': |
|
| 471 | - if ($token_category === 'GROUP') { |
|
| 472 | - $skip_next = true; |
|
| 473 | - $out['OPTIONS'][] = 'WITH ROLLUP'; |
|
| 449 | + /* These tokens set particular options for the statement. They never stand alone.*/ |
|
| 450 | + case 'DISTINCTROW': |
|
| 451 | + $trim = 'DISTINCT'; |
|
| 452 | + case 'DISTINCT': |
|
| 453 | + case 'HIGH_PRIORITY': |
|
| 454 | + case 'LOW_PRIORITY': |
|
| 455 | + case 'DELAYED': |
|
| 456 | + case 'IGNORE': |
|
| 457 | + case 'FORCE': |
|
| 458 | + case 'STRAIGHT_JOIN': |
|
| 459 | + case 'SQL_SMALL_RESULT': |
|
| 460 | + case 'SQL_BIG_RESULT': |
|
| 461 | + case 'QUICK': |
|
| 462 | + case 'SQL_BUFFER_RESULT': |
|
| 463 | + case 'SQL_CACHE': |
|
| 464 | + case 'SQL_NO_CACHE': |
|
| 465 | + case 'SQL_CALC_FOUND_ROWS': |
|
| 466 | + $out['OPTIONS'][] = $upper; |
|
| 474 | 467 | continue 2; |
| 475 | - } |
|
| 476 | - break; |
|
| 468 | + break; |
|
| 477 | 469 | |
| 478 | - case 'AS': |
|
| 479 | - break; |
|
| 470 | + case 'WITH': |
|
| 471 | + if ($token_category === 'GROUP') { |
|
| 472 | + $skip_next = true; |
|
| 473 | + $out['OPTIONS'][] = 'WITH ROLLUP'; |
|
| 474 | + continue 2; |
|
| 475 | + } |
|
| 476 | + break; |
|
| 480 | 477 | |
| 481 | - case '': |
|
| 482 | - case ',': |
|
| 483 | - case ';': |
|
| 484 | - break; |
|
| 478 | + case 'AS': |
|
| 479 | + break; |
|
| 485 | 480 | |
| 486 | - default: |
|
| 487 | - break; |
|
| 481 | + case '': |
|
| 482 | + case ',': |
|
| 483 | + case ';': |
|
| 484 | + break; |
|
| 485 | + |
|
| 486 | + default: |
|
| 487 | + break; |
|
| 488 | 488 | } |
| 489 | 489 | |
| 490 | 490 | # remove obsolete category after union (empty category because of |
@@ -584,16 +584,16 @@ discard block |
||
| 584 | 584 | $type = substr($expression, 2, strpos($expression, '.', 2)); |
| 585 | 585 | |
| 586 | 586 | switch ($type) { |
| 587 | - case 'GLOBAL': |
|
| 588 | - $type = ExpressionType::GLOBAL_VARIABLE; |
|
| 589 | - break; |
|
| 590 | - case 'LOCAL': |
|
| 591 | - $type = ExpressionType::LOCAL_VARIABLE; |
|
| 592 | - break; |
|
| 593 | - case 'SESSION': |
|
| 594 | - default: |
|
| 595 | - $type = ExpressionType::SESSION_VARIABLE; |
|
| 596 | - break; |
|
| 587 | + case 'GLOBAL': |
|
| 588 | + $type = ExpressionType::GLOBAL_VARIABLE; |
|
| 589 | + break; |
|
| 590 | + case 'LOCAL': |
|
| 591 | + $type = ExpressionType::LOCAL_VARIABLE; |
|
| 592 | + break; |
|
| 593 | + case 'SESSION': |
|
| 594 | + default: |
|
| 595 | + $type = ExpressionType::SESSION_VARIABLE; |
|
| 596 | + break; |
|
| 597 | 597 | } |
| 598 | 598 | |
| 599 | 599 | return $type; |
@@ -613,27 +613,27 @@ discard block |
||
| 613 | 613 | $upper = strtoupper(trim($token)); |
| 614 | 614 | |
| 615 | 615 | switch ($upper) { |
| 616 | - case 'LOCAL': |
|
| 617 | - case 'SESSION': |
|
| 618 | - case 'GLOBAL': |
|
| 619 | - if (!$isUpdate) { |
|
| 620 | - $varType = $this->getVariableType('@@'.$upper.'.'); |
|
| 616 | + case 'LOCAL': |
|
| 617 | + case 'SESSION': |
|
| 618 | + case 'GLOBAL': |
|
| 619 | + if (!$isUpdate) { |
|
| 620 | + $varType = $this->getVariableType('@@'.$upper.'.'); |
|
| 621 | + $baseExpr = ''; |
|
| 622 | + continue 2; |
|
| 623 | + } |
|
| 624 | + break; |
|
| 625 | + |
|
| 626 | + case ',': |
|
| 627 | + $assignment = $this->getAssignment($baseExpr); |
|
| 628 | + if (!$isUpdate && $varType !== false) { |
|
| 629 | + $assignment['sub_tree'][0]['expr_type'] = $varType; |
|
| 630 | + } |
|
| 631 | + $result[] = $assignment; |
|
| 621 | 632 | $baseExpr = ''; |
| 633 | + $varType = false; |
|
| 622 | 634 | continue 2; |
| 623 | - } |
|
| 624 | - break; |
|
| 625 | - |
|
| 626 | - case ',': |
|
| 627 | - $assignment = $this->getAssignment($baseExpr); |
|
| 628 | - if (!$isUpdate && $varType !== false) { |
|
| 629 | - $assignment['sub_tree'][0]['expr_type'] = $varType; |
|
| 630 | - } |
|
| 631 | - $result[] = $assignment; |
|
| 632 | - $baseExpr = ''; |
|
| 633 | - $varType = false; |
|
| 634 | - continue 2; |
|
| 635 | 635 | |
| 636 | - default: |
|
| 636 | + default: |
|
| 637 | 637 | } |
| 638 | 638 | $baseExpr .= $token; |
| 639 | 639 | } |
@@ -901,101 +901,101 @@ discard block |
||
| 901 | 901 | } |
| 902 | 902 | |
| 903 | 903 | switch ($upper) { |
| 904 | - case 'OUTER': |
|
| 905 | - case 'LEFT': |
|
| 906 | - case 'RIGHT': |
|
| 907 | - case 'NATURAL': |
|
| 908 | - case 'CROSS': |
|
| 909 | - case ',': |
|
| 910 | - case 'JOIN': |
|
| 911 | - case 'INNER': |
|
| 912 | - break; |
|
| 904 | + case 'OUTER': |
|
| 905 | + case 'LEFT': |
|
| 906 | + case 'RIGHT': |
|
| 907 | + case 'NATURAL': |
|
| 908 | + case 'CROSS': |
|
| 909 | + case ',': |
|
| 910 | + case 'JOIN': |
|
| 911 | + case 'INNER': |
|
| 912 | + break; |
|
| 913 | 913 | |
| 914 | - default: |
|
| 915 | - $parseInfo['expression'] .= $token; |
|
| 916 | - if ($parseInfo['ref_type'] !== false) { # all after ON / USING |
|
| 917 | - $parseInfo['ref_expr'] .= $token; |
|
| 918 | - } |
|
| 919 | - break; |
|
| 914 | + default: |
|
| 915 | + $parseInfo['expression'] .= $token; |
|
| 916 | + if ($parseInfo['ref_type'] !== false) { # all after ON / USING |
|
| 917 | + $parseInfo['ref_expr'] .= $token; |
|
| 918 | + } |
|
| 919 | + break; |
|
| 920 | 920 | } |
| 921 | 921 | |
| 922 | 922 | switch ($upper) { |
| 923 | - case 'AS': |
|
| 924 | - $parseInfo['alias'] = array('as' => true, 'name' => '', 'base_expr' => $token); |
|
| 925 | - ++$parseInfo['token_count']; |
|
| 926 | - $n = 1; |
|
| 927 | - $str = ''; |
|
| 928 | - while ($str == '') { |
|
| 929 | - $parseInfo['alias']['base_expr'] .= ($tokens[$i + $n] === '' ? ' ' : $tokens[$i + $n]); |
|
| 930 | - $str = trim($tokens[$i + $n]); |
|
| 931 | - ++$n; |
|
| 932 | - } |
|
| 933 | - $parseInfo['alias']['name'] = $str; |
|
| 934 | - $parseInfo['alias']['base_expr'] = trim($parseInfo['alias']['base_expr']); |
|
| 935 | - continue; |
|
| 923 | + case 'AS': |
|
| 924 | + $parseInfo['alias'] = array('as' => true, 'name' => '', 'base_expr' => $token); |
|
| 925 | + ++$parseInfo['token_count']; |
|
| 926 | + $n = 1; |
|
| 927 | + $str = ''; |
|
| 928 | + while ($str == '') { |
|
| 929 | + $parseInfo['alias']['base_expr'] .= ($tokens[$i + $n] === '' ? ' ' : $tokens[$i + $n]); |
|
| 930 | + $str = trim($tokens[$i + $n]); |
|
| 931 | + ++$n; |
|
| 932 | + } |
|
| 933 | + $parseInfo['alias']['name'] = $str; |
|
| 934 | + $parseInfo['alias']['base_expr'] = trim($parseInfo['alias']['base_expr']); |
|
| 935 | + continue; |
|
| 936 | 936 | |
| 937 | - case 'INDEX': |
|
| 938 | - if ($token_category == 'CREATE') { |
|
| 939 | - $token_category = $upper; |
|
| 940 | - continue 2; |
|
| 941 | - } |
|
| 937 | + case 'INDEX': |
|
| 938 | + if ($token_category == 'CREATE') { |
|
| 939 | + $token_category = $upper; |
|
| 940 | + continue 2; |
|
| 941 | + } |
|
| 942 | 942 | |
| 943 | - break; |
|
| 943 | + break; |
|
| 944 | 944 | |
| 945 | - case 'USING': |
|
| 946 | - case 'ON': |
|
| 947 | - $parseInfo['ref_type'] = $upper; |
|
| 948 | - $parseInfo['ref_expr'] = ''; |
|
| 949 | - |
|
| 950 | - case 'CROSS': |
|
| 951 | - case 'USE': |
|
| 952 | - case 'FORCE': |
|
| 953 | - case 'IGNORE': |
|
| 954 | - case 'INNER': |
|
| 955 | - case 'OUTER': |
|
| 956 | - $parseInfo['token_count']++; |
|
| 957 | - continue; |
|
| 958 | - break; |
|
| 945 | + case 'USING': |
|
| 946 | + case 'ON': |
|
| 947 | + $parseInfo['ref_type'] = $upper; |
|
| 948 | + $parseInfo['ref_expr'] = ''; |
|
| 949 | + |
|
| 950 | + case 'CROSS': |
|
| 951 | + case 'USE': |
|
| 952 | + case 'FORCE': |
|
| 953 | + case 'IGNORE': |
|
| 954 | + case 'INNER': |
|
| 955 | + case 'OUTER': |
|
| 956 | + $parseInfo['token_count']++; |
|
| 957 | + continue; |
|
| 958 | + break; |
|
| 959 | 959 | |
| 960 | - case 'FOR': |
|
| 961 | - $parseInfo['token_count']++; |
|
| 962 | - $skip_next = true; |
|
| 963 | - continue; |
|
| 964 | - break; |
|
| 960 | + case 'FOR': |
|
| 961 | + $parseInfo['token_count']++; |
|
| 962 | + $skip_next = true; |
|
| 963 | + continue; |
|
| 964 | + break; |
|
| 965 | 965 | |
| 966 | - case 'LEFT': |
|
| 967 | - case 'RIGHT': |
|
| 968 | - case 'STRAIGHT_JOIN': |
|
| 969 | - $parseInfo['next_join_type'] = $upper; |
|
| 970 | - break; |
|
| 966 | + case 'LEFT': |
|
| 967 | + case 'RIGHT': |
|
| 968 | + case 'STRAIGHT_JOIN': |
|
| 969 | + $parseInfo['next_join_type'] = $upper; |
|
| 970 | + break; |
|
| 971 | 971 | |
| 972 | - case ',': |
|
| 973 | - $parseInfo['next_join_type'] = 'CROSS'; |
|
| 972 | + case ',': |
|
| 973 | + $parseInfo['next_join_type'] = 'CROSS'; |
|
| 974 | 974 | |
| 975 | - case 'JOIN': |
|
| 976 | - if ($parseInfo['subquery']) { |
|
| 977 | - $parseInfo['sub_tree'] = $this->parse($this->removeParenthesisFromStart($parseInfo['subquery'])); |
|
| 978 | - $parseInfo['expression'] = $parseInfo['subquery']; |
|
| 979 | - } |
|
| 975 | + case 'JOIN': |
|
| 976 | + if ($parseInfo['subquery']) { |
|
| 977 | + $parseInfo['sub_tree'] = $this->parse($this->removeParenthesisFromStart($parseInfo['subquery'])); |
|
| 978 | + $parseInfo['expression'] = $parseInfo['subquery']; |
|
| 979 | + } |
|
| 980 | 980 | |
| 981 | - $expr[] = $this->processFromExpression($parseInfo); |
|
| 982 | - $parseInfo = $this->initParseInfoForFrom($parseInfo); |
|
| 983 | - break; |
|
| 981 | + $expr[] = $this->processFromExpression($parseInfo); |
|
| 982 | + $parseInfo = $this->initParseInfoForFrom($parseInfo); |
|
| 983 | + break; |
|
| 984 | 984 | |
| 985 | - default: |
|
| 986 | - if ($upper === '') { |
|
| 987 | - continue; # ends the switch statement! |
|
| 988 | - } |
|
| 985 | + default: |
|
| 986 | + if ($upper === '') { |
|
| 987 | + continue; # ends the switch statement! |
|
| 988 | + } |
|
| 989 | 989 | |
| 990 | - if ($parseInfo['token_count'] === 0) { |
|
| 991 | - if ($parseInfo['table'] === '') { |
|
| 992 | - $parseInfo['table'] = $token; |
|
| 990 | + if ($parseInfo['token_count'] === 0) { |
|
| 991 | + if ($parseInfo['table'] === '') { |
|
| 992 | + $parseInfo['table'] = $token; |
|
| 993 | + } |
|
| 994 | + } elseif ($parseInfo['token_count'] === 1) { |
|
| 995 | + $parseInfo['alias'] = array('as' => false, 'name' => trim($token), 'base_expr' => trim($token)); |
|
| 993 | 996 | } |
| 994 | - } elseif ($parseInfo['token_count'] === 1) { |
|
| 995 | - $parseInfo['alias'] = array('as' => false, 'name' => trim($token), 'base_expr' => trim($token)); |
|
| 996 | - } |
|
| 997 | - ++$parseInfo['token_count']; |
|
| 998 | - break; |
|
| 997 | + ++$parseInfo['token_count']; |
|
| 998 | + break; |
|
| 999 | 999 | } |
| 1000 | 1000 | ++$i; |
| 1001 | 1001 | } |
@@ -1122,21 +1122,21 @@ discard block |
||
| 1122 | 1122 | foreach ($tokens as $token) { |
| 1123 | 1123 | $upper = strtoupper(trim($token)); |
| 1124 | 1124 | switch ($upper) { |
| 1125 | - case ',': |
|
| 1126 | - $out[] = $this->processOrderExpression($parseInfo, $select); |
|
| 1127 | - $parseInfo = $this->initParseInfoForOrder(); |
|
| 1128 | - break; |
|
| 1125 | + case ',': |
|
| 1126 | + $out[] = $this->processOrderExpression($parseInfo, $select); |
|
| 1127 | + $parseInfo = $this->initParseInfoForOrder(); |
|
| 1128 | + break; |
|
| 1129 | 1129 | |
| 1130 | - case 'DESC': |
|
| 1131 | - $parseInfo['dir'] = 'DESC'; |
|
| 1132 | - break; |
|
| 1130 | + case 'DESC': |
|
| 1131 | + $parseInfo['dir'] = 'DESC'; |
|
| 1132 | + break; |
|
| 1133 | 1133 | |
| 1134 | - case 'ASC': |
|
| 1135 | - $parseInfo['dir'] = 'ASC'; |
|
| 1136 | - break; |
|
| 1134 | + case 'ASC': |
|
| 1135 | + $parseInfo['dir'] = 'ASC'; |
|
| 1136 | + break; |
|
| 1137 | 1137 | |
| 1138 | - default: |
|
| 1139 | - $parseInfo['expr'] .= $token; |
|
| 1138 | + default: |
|
| 1139 | + $parseInfo['expr'] .= $token; |
|
| 1140 | 1140 | |
| 1141 | 1141 | } |
| 1142 | 1142 | } |
@@ -1161,15 +1161,15 @@ discard block |
||
| 1161 | 1161 | foreach ($tokens as $token) { |
| 1162 | 1162 | $trim = strtoupper(trim($token)); |
| 1163 | 1163 | switch ($trim) { |
| 1164 | - case ',': |
|
| 1165 | - $parsed = $this->processOrderExpression($parseInfo, $select); |
|
| 1166 | - unset($parsed['direction']); |
|
| 1164 | + case ',': |
|
| 1165 | + $parsed = $this->processOrderExpression($parseInfo, $select); |
|
| 1166 | + unset($parsed['direction']); |
|
| 1167 | 1167 | |
| 1168 | - $out[] = $parsed; |
|
| 1169 | - $parseInfo = $this->initParseInfoForOrder(); |
|
| 1170 | - break; |
|
| 1171 | - default: |
|
| 1172 | - $parseInfo['expr'] .= $token; |
|
| 1168 | + $out[] = $parsed; |
|
| 1169 | + $parseInfo = $this->initParseInfoForOrder(); |
|
| 1170 | + break; |
|
| 1171 | + default: |
|
| 1172 | + $parseInfo['expr'] .= $token; |
|
| 1173 | 1173 | |
| 1174 | 1174 | } |
| 1175 | 1175 | } |
@@ -1229,14 +1229,14 @@ discard block |
||
| 1229 | 1229 | foreach ($localTokenList as $k => $v) { |
| 1230 | 1230 | $tmpToken = new ExpressionToken($k, $v); |
| 1231 | 1231 | switch ($tmpToken->getUpper()) { |
| 1232 | - case 'WITH': |
|
| 1233 | - $match_mode = 'WITH QUERY EXPANSION'; |
|
| 1234 | - break; |
|
| 1235 | - case 'IN': |
|
| 1236 | - $match_mode = 'IN BOOLEAN MODE'; |
|
| 1237 | - break; |
|
| 1238 | - |
|
| 1239 | - default: |
|
| 1232 | + case 'WITH': |
|
| 1233 | + $match_mode = 'WITH QUERY EXPANSION'; |
|
| 1234 | + break; |
|
| 1235 | + case 'IN': |
|
| 1236 | + $match_mode = 'IN BOOLEAN MODE'; |
|
| 1237 | + break; |
|
| 1238 | + |
|
| 1239 | + default: |
|
| 1240 | 1240 | } |
| 1241 | 1241 | |
| 1242 | 1242 | if ($match_mode !== false) { |
@@ -1291,117 +1291,117 @@ discard block |
||
| 1291 | 1291 | /* it is either an operator, a colref or a constant */ |
| 1292 | 1292 | switch ($curr->getUpper()) { |
| 1293 | 1293 | |
| 1294 | - case '*': |
|
| 1295 | - $curr->setSubTree(false); #no subtree |
|
| 1296 | - |
|
| 1297 | - # single or first element of expression list -> all-column-alias |
|
| 1298 | - if (empty($resultList)) { |
|
| 1299 | - $curr->setTokenType(ExpressionType::COLREF); |
|
| 1300 | - break; |
|
| 1301 | - } |
|
| 1302 | - |
|
| 1303 | - # if the last token is colref, const or expression |
|
| 1304 | - # then * is an operator |
|
| 1305 | - # but if the previous colref ends with a dot, the * is the all-columns-alias |
|
| 1306 | - if (!$prev->isColumnReference() && !$prev->isConstant() && !$prev->isExpression() |
|
| 1307 | - && !$prev->isBracketExpression()) { |
|
| 1308 | - $curr->setTokenType(ExpressionType::COLREF); |
|
| 1309 | - break; |
|
| 1310 | - } |
|
| 1311 | - |
|
| 1312 | - if ($prev->isColumnReference() && $prev->endsWith('.')) { |
|
| 1313 | - $prev->addToken('*'); # tablealias dot * |
|
| 1314 | - continue 2; # skip the current token |
|
| 1315 | - } |
|
| 1316 | - |
|
| 1317 | - $curr->setTokenType(ExpressionType::OPERATOR); |
|
| 1318 | - break; |
|
| 1294 | + case '*': |
|
| 1295 | + $curr->setSubTree(false); #no subtree |
|
| 1319 | 1296 | |
| 1320 | - case 'AND': |
|
| 1321 | - case '&&': |
|
| 1322 | - case 'BETWEEN': |
|
| 1323 | - case 'AND': |
|
| 1324 | - case 'BINARY': |
|
| 1325 | - case '&': |
|
| 1326 | - case '~': |
|
| 1327 | - case '|': |
|
| 1328 | - case '^': |
|
| 1329 | - case 'DIV': |
|
| 1330 | - case '/': |
|
| 1331 | - case '<=>': |
|
| 1332 | - case '=': |
|
| 1333 | - case '>=': |
|
| 1334 | - case '>': |
|
| 1335 | - case 'IS': |
|
| 1336 | - case 'NOT': |
|
| 1337 | - case '<<': |
|
| 1338 | - case '<=': |
|
| 1339 | - case '<': |
|
| 1340 | - case 'LIKE': |
|
| 1341 | - case '%': |
|
| 1342 | - case '!=': |
|
| 1343 | - case '<>': |
|
| 1344 | - case 'REGEXP': |
|
| 1345 | - case '!': |
|
| 1346 | - case '||': |
|
| 1347 | - case 'OR': |
|
| 1348 | - case '>>': |
|
| 1349 | - case 'RLIKE': |
|
| 1350 | - case 'SOUNDS': |
|
| 1351 | - case 'XOR': |
|
| 1352 | - case 'IN': |
|
| 1353 | - $curr->setSubTree(false); |
|
| 1354 | - $curr->setTokenType(ExpressionType::OPERATOR); |
|
| 1355 | - break; |
|
| 1297 | + # single or first element of expression list -> all-column-alias |
|
| 1298 | + if (empty($resultList)) { |
|
| 1299 | + $curr->setTokenType(ExpressionType::COLREF); |
|
| 1300 | + break; |
|
| 1301 | + } |
|
| 1356 | 1302 | |
| 1357 | - case 'NULL': |
|
| 1358 | - $curr->setSubTree(false); |
|
| 1359 | - $curr->setTokenType(ExpressionType::CONSTANT); |
|
| 1360 | - break; |
|
| 1303 | + # if the last token is colref, const or expression |
|
| 1304 | + # then * is an operator |
|
| 1305 | + # but if the previous colref ends with a dot, the * is the all-columns-alias |
|
| 1306 | + if (!$prev->isColumnReference() && !$prev->isConstant() && !$prev->isExpression() |
|
| 1307 | + && !$prev->isBracketExpression()) { |
|
| 1308 | + $curr->setTokenType(ExpressionType::COLREF); |
|
| 1309 | + break; |
|
| 1310 | + } |
|
| 1361 | 1311 | |
| 1362 | - case '-': |
|
| 1363 | - case '+': |
|
| 1364 | - // differ between preceding sign and operator |
|
| 1365 | - $curr->setSubTree(false); |
|
| 1312 | + if ($prev->isColumnReference() && $prev->endsWith('.')) { |
|
| 1313 | + $prev->addToken('*'); # tablealias dot * |
|
| 1314 | + continue 2; # skip the current token |
|
| 1315 | + } |
|
| 1366 | 1316 | |
| 1367 | - if ($prev->isColumnReference() || $prev->isFunction() || $prev->isAggregateFunction() |
|
| 1368 | - || $prev->isConstant() || $prev->isSubQuery() || $prev->isExpression() |
|
| 1369 | - || $prev->isBracketExpression()) { |
|
| 1370 | 1317 | $curr->setTokenType(ExpressionType::OPERATOR); |
| 1371 | - } else { |
|
| 1372 | - $curr->setTokenType(ExpressionType::SIGN); |
|
| 1373 | - } |
|
| 1374 | - break; |
|
| 1318 | + break; |
|
| 1375 | 1319 | |
| 1376 | - default: |
|
| 1377 | - $curr->setSubTree(false); |
|
| 1320 | + case 'AND': |
|
| 1321 | + case '&&': |
|
| 1322 | + case 'BETWEEN': |
|
| 1323 | + case 'AND': |
|
| 1324 | + case 'BINARY': |
|
| 1325 | + case '&': |
|
| 1326 | + case '~': |
|
| 1327 | + case '|': |
|
| 1328 | + case '^': |
|
| 1329 | + case 'DIV': |
|
| 1330 | + case '/': |
|
| 1331 | + case '<=>': |
|
| 1332 | + case '=': |
|
| 1333 | + case '>=': |
|
| 1334 | + case '>': |
|
| 1335 | + case 'IS': |
|
| 1336 | + case 'NOT': |
|
| 1337 | + case '<<': |
|
| 1338 | + case '<=': |
|
| 1339 | + case '<': |
|
| 1340 | + case 'LIKE': |
|
| 1341 | + case '%': |
|
| 1342 | + case '!=': |
|
| 1343 | + case '<>': |
|
| 1344 | + case 'REGEXP': |
|
| 1345 | + case '!': |
|
| 1346 | + case '||': |
|
| 1347 | + case 'OR': |
|
| 1348 | + case '>>': |
|
| 1349 | + case 'RLIKE': |
|
| 1350 | + case 'SOUNDS': |
|
| 1351 | + case 'XOR': |
|
| 1352 | + case 'IN': |
|
| 1353 | + $curr->setSubTree(false); |
|
| 1354 | + $curr->setTokenType(ExpressionType::OPERATOR); |
|
| 1355 | + break; |
|
| 1378 | 1356 | |
| 1379 | - switch ($curr->getToken(0)) { |
|
| 1380 | - case "'": |
|
| 1381 | - case '"': |
|
| 1382 | - # it is a string literal |
|
| 1357 | + case 'NULL': |
|
| 1358 | + $curr->setSubTree(false); |
|
| 1383 | 1359 | $curr->setTokenType(ExpressionType::CONSTANT); |
| 1384 | 1360 | break; |
| 1385 | - case '`': |
|
| 1386 | - # it is an escaped colum name |
|
| 1387 | - $curr->setTokenType(ExpressionType::COLREF); |
|
| 1361 | + |
|
| 1362 | + case '-': |
|
| 1363 | + case '+': |
|
| 1364 | + // differ between preceding sign and operator |
|
| 1365 | + $curr->setSubTree(false); |
|
| 1366 | + |
|
| 1367 | + if ($prev->isColumnReference() || $prev->isFunction() || $prev->isAggregateFunction() |
|
| 1368 | + || $prev->isConstant() || $prev->isSubQuery() || $prev->isExpression() |
|
| 1369 | + || $prev->isBracketExpression()) { |
|
| 1370 | + $curr->setTokenType(ExpressionType::OPERATOR); |
|
| 1371 | + } else { |
|
| 1372 | + $curr->setTokenType(ExpressionType::SIGN); |
|
| 1373 | + } |
|
| 1388 | 1374 | break; |
| 1389 | 1375 | |
| 1390 | 1376 | default: |
| 1391 | - if (is_numeric($curr->getToken())) { |
|
| 1392 | - if ($prev->isSign()) { |
|
| 1393 | - $prev->addToken($curr->getToken()); # it is a negative numeric constant |
|
| 1394 | - $prev->setTokenType(ExpressionType::CONSTANT); |
|
| 1395 | - continue 3; |
|
| 1396 | - # skip current token |
|
| 1397 | - } else { |
|
| 1377 | + $curr->setSubTree(false); |
|
| 1378 | + |
|
| 1379 | + switch ($curr->getToken(0)) { |
|
| 1380 | + case "'": |
|
| 1381 | + case '"': |
|
| 1382 | + # it is a string literal |
|
| 1398 | 1383 | $curr->setTokenType(ExpressionType::CONSTANT); |
| 1399 | - } |
|
| 1400 | - } else { |
|
| 1401 | - $curr->setTokenType(ExpressionType::COLREF); |
|
| 1384 | + break; |
|
| 1385 | + case '`': |
|
| 1386 | + # it is an escaped colum name |
|
| 1387 | + $curr->setTokenType(ExpressionType::COLREF); |
|
| 1388 | + break; |
|
| 1389 | + |
|
| 1390 | + default: |
|
| 1391 | + if (is_numeric($curr->getToken())) { |
|
| 1392 | + if ($prev->isSign()) { |
|
| 1393 | + $prev->addToken($curr->getToken()); # it is a negative numeric constant |
|
| 1394 | + $prev->setTokenType(ExpressionType::CONSTANT); |
|
| 1395 | + continue 3; |
|
| 1396 | + # skip current token |
|
| 1397 | + } else { |
|
| 1398 | + $curr->setTokenType(ExpressionType::CONSTANT); |
|
| 1399 | + } |
|
| 1400 | + } else { |
|
| 1401 | + $curr->setTokenType(ExpressionType::COLREF); |
|
| 1402 | + } |
|
| 1403 | + break; |
|
| 1402 | 1404 | } |
| 1403 | - break; |
|
| 1404 | - } |
|
| 1405 | 1405 | } |
| 1406 | 1406 | } |
| 1407 | 1407 | |
@@ -1607,35 +1607,35 @@ discard block |
||
| 1607 | 1607 | } |
| 1608 | 1608 | |
| 1609 | 1609 | switch ($token->getUpper()) { |
| 1610 | - case 'VIEW': |
|
| 1611 | - case 'SCHEMA': |
|
| 1612 | - case 'DATABASE': |
|
| 1613 | - case 'TABLE': |
|
| 1614 | - $expr_type = strtolower($token->getTrim()); |
|
| 1615 | - break; |
|
| 1610 | + case 'VIEW': |
|
| 1611 | + case 'SCHEMA': |
|
| 1612 | + case 'DATABASE': |
|
| 1613 | + case 'TABLE': |
|
| 1614 | + $expr_type = strtolower($token->getTrim()); |
|
| 1615 | + break; |
|
| 1616 | 1616 | |
| 1617 | - case 'IF': |
|
| 1618 | - $warning = false; |
|
| 1619 | - $skip = true; |
|
| 1620 | - break; |
|
| 1617 | + case 'IF': |
|
| 1618 | + $warning = false; |
|
| 1619 | + $skip = true; |
|
| 1620 | + break; |
|
| 1621 | 1621 | |
| 1622 | - case 'TEMPORARY': |
|
| 1623 | - $expr_type = ExpressionType::TEMPORARY_TABLE; |
|
| 1624 | - $skip = true; |
|
| 1625 | - break; |
|
| 1622 | + case 'TEMPORARY': |
|
| 1623 | + $expr_type = ExpressionType::TEMPORARY_TABLE; |
|
| 1624 | + $skip = true; |
|
| 1625 | + break; |
|
| 1626 | 1626 | |
| 1627 | - case 'RESTRICT': |
|
| 1628 | - case 'CASCADE': |
|
| 1629 | - $option = $token->getUpper(); |
|
| 1630 | - break; |
|
| 1627 | + case 'RESTRICT': |
|
| 1628 | + case 'CASCADE': |
|
| 1629 | + $option = $token->getUpper(); |
|
| 1630 | + break; |
|
| 1631 | 1631 | |
| 1632 | - case ',': |
|
| 1633 | - $resultList[] = array('expr_type' => $expr_type, 'base_expr' => $base_expr); |
|
| 1634 | - $base_expr = ''; |
|
| 1635 | - break; |
|
| 1632 | + case ',': |
|
| 1633 | + $resultList[] = array('expr_type' => $expr_type, 'base_expr' => $base_expr); |
|
| 1634 | + $base_expr = ''; |
|
| 1635 | + break; |
|
| 1636 | 1636 | |
| 1637 | - default: |
|
| 1638 | - $base_expr .= $token->getToken(); |
|
| 1637 | + default: |
|
| 1638 | + $base_expr .= $token->getToken(); |
|
| 1639 | 1639 | } |
| 1640 | 1640 | } |
| 1641 | 1641 | |
@@ -571,7 +571,7 @@ discard block |
||
| 571 | 571 | $assignment = $this->process_expr_list($this->splitSQLIntoTokens($base_expr)); |
| 572 | 572 | |
| 573 | 573 | return array('expr_type' => ExpressionType::EXPRESSION, 'base_expr' => trim($base_expr), |
| 574 | - 'sub_tree' => $assignment, ); |
|
| 574 | + 'sub_tree' => $assignment,); |
|
| 575 | 575 | } |
| 576 | 576 | |
| 577 | 577 | private function getVariableType($expression) |
@@ -843,7 +843,7 @@ discard block |
||
| 843 | 843 | || $this->isFunction($prev) || $this->isExpression($prev) || $this->isSubQuery($prev) |
| 844 | 844 | || $this->isColumnReference($prev) || $this->isBracketExpression($prev)) { |
| 845 | 845 | $alias = array('as' => false, 'name' => trim($last['base_expr']), |
| 846 | - 'base_expr' => trim($last['base_expr']), ); |
|
| 846 | + 'base_expr' => trim($last['base_expr']),); |
|
| 847 | 847 | #remove the last token |
| 848 | 848 | array_pop($tokens); |
| 849 | 849 | $base_expr = implode('', $tokens); |
@@ -873,7 +873,7 @@ discard block |
||
| 873 | 873 | } |
| 874 | 874 | |
| 875 | 875 | return array('expr_type' => $type, 'alias' => $alias, 'base_expr' => trim($base_expr), |
| 876 | - 'sub_tree' => $processed, ); |
|
| 876 | + 'sub_tree' => $processed,); |
|
| 877 | 877 | } |
| 878 | 878 | |
| 879 | 879 | /** |
@@ -1015,7 +1015,7 @@ discard block |
||
| 1015 | 1015 | return array('expression' => '', 'token_count' => 0, 'table' => '', 'alias' => false, 'join_type' => '', |
| 1016 | 1016 | 'next_join_type' => '', 'saved_join_type' => $parseInfo['saved_join_type'], |
| 1017 | 1017 | 'ref_type' => false, 'ref_expr' => false, 'base_expr' => false, 'sub_tree' => false, |
| 1018 | - 'subquery' => '', ); |
|
| 1018 | + 'subquery' => '',); |
|
| 1019 | 1019 | } |
| 1020 | 1020 | |
| 1021 | 1021 | private function processFromExpression(&$parseInfo) |
@@ -1099,7 +1099,7 @@ discard block |
||
| 1099 | 1099 | } |
| 1100 | 1100 | |
| 1101 | 1101 | return array('expr_type' => $parseInfo['type'], 'base_expr' => $parseInfo['expr'], |
| 1102 | - 'direction' => $parseInfo['dir'], ); |
|
| 1102 | + 'direction' => $parseInfo['dir'],); |
|
| 1103 | 1103 | } |
| 1104 | 1104 | |
| 1105 | 1105 | private function initParseInfoForOrder() |
@@ -1559,7 +1559,7 @@ discard block |
||
| 1559 | 1559 | unset($values[$k]); |
| 1560 | 1560 | } else { |
| 1561 | 1561 | $values[$k] = array('expr_type' => ExpressionType::RECORD, 'base_expr' => $v, |
| 1562 | - 'data' => $this->process_record($v), ); |
|
| 1562 | + 'data' => $this->process_record($v),); |
|
| 1563 | 1563 | } |
| 1564 | 1564 | } |
| 1565 | 1565 | |
@@ -37,7 +37,7 @@ |
||
| 37 | 37 | class LexerSplitter |
| 38 | 38 | { |
| 39 | 39 | private static $splitters = array("\r\n", '!=', '>=', '<=', '<>', ':=', '\\', '&&', '>', '<', '|', '=', '^', '(', |
| 40 | - ')', "\t", "\n", "'", '"', '`', ',', '@', ' ', '+', '-', '*', '/', ';', ); |
|
| 40 | + ')', "\t", "\n", "'", '"', '`', ',', '@', ' ', '+', '-', '*', '/', ';', ); |
|
| 41 | 41 | private $tokenSize; |
| 42 | 42 | private $hashSet; |
| 43 | 43 | |
@@ -37,7 +37,7 @@ |
||
| 37 | 37 | class LexerSplitter |
| 38 | 38 | { |
| 39 | 39 | private static $splitters = array("\r\n", '!=', '>=', '<=', '<>', ':=', '\\', '&&', '>', '<', '|', '=', '^', '(', |
| 40 | - ')', "\t", "\n", "'", '"', '`', ',', '@', ' ', '+', '-', '*', '/', ';', ); |
|
| 40 | + ')', "\t", "\n", "'", '"', '`', ',', '@', ' ', '+', '-', '*', '/', ';',); |
|
| 41 | 41 | private $tokenSize; |
| 42 | 42 | private $hashSet; |
| 43 | 43 | |
@@ -180,7 +180,7 @@ discard block |
||
| 180 | 180 | return "'".addslashes($this->autoPrepend.$item.$this->autoAppend)."'"; |
| 181 | 181 | }, $parameters[$this->name])).')'; |
| 182 | 182 | } else{ |
| 183 | - return "'".addslashes($this->autoPrepend.$parameters[$this->name].$this->autoAppend)."'"; |
|
| 183 | + return "'".addslashes($this->autoPrepend.$parameters[$this->name].$this->autoAppend)."'"; |
|
| 184 | 184 | } |
| 185 | 185 | |
| 186 | 186 | } |
@@ -212,6 +212,6 @@ discard block |
||
| 212 | 212 | * @return bool |
| 213 | 213 | */ |
| 214 | 214 | public function isDiscardedOnNull() { |
| 215 | - return $this->discardedOnNull; |
|
| 215 | + return $this->discardedOnNull; |
|
| 216 | 216 | } |
| 217 | 217 | } |
@@ -68,8 +68,8 @@ discard block |
||
| 68 | 68 | */ |
| 69 | 69 | public function setName($name) |
| 70 | 70 | { |
| 71 | - if (strrpos($name, '!') === strlen($name)-1) { |
|
| 72 | - $this->name = substr($name, 0, strlen($name)-1); |
|
| 71 | + if (strrpos($name, '!') === strlen($name) - 1) { |
|
| 72 | + $this->name = substr($name, 0, strlen($name) - 1); |
|
| 73 | 73 | $this->discardedOnNull = false; |
| 74 | 74 | } else { |
| 75 | 75 | $this->name = $name; |
@@ -164,22 +164,22 @@ discard block |
||
| 164 | 164 | { |
| 165 | 165 | if (isset($parameters[$this->name])) { |
| 166 | 166 | if ($dbConnection) { |
| 167 | - if(is_array($parameters[$this->name])){ |
|
| 168 | - return '('.implode(',',array_map(function($item) use ($dbConnection) { |
|
| 167 | + if (is_array($parameters[$this->name])) { |
|
| 168 | + return '('.implode(',', array_map(function($item) use ($dbConnection) { |
|
| 169 | 169 | return $dbConnection->quote($this->autoPrepend.$item.$this->autoAppend); |
| 170 | 170 | }, $parameters[$this->name])).')'; |
| 171 | - } else{ |
|
| 171 | + } else { |
|
| 172 | 172 | return $dbConnection->quote($this->autoPrepend.$parameters[$this->name].$this->autoAppend); |
| 173 | 173 | } |
| 174 | 174 | } else { |
| 175 | 175 | if ($parameters[$this->name] === null) { |
| 176 | 176 | return "null"; |
| 177 | 177 | } else { |
| 178 | - if(is_array($parameters[$this->name])){ |
|
| 179 | - return '('.implode(',',array_map(function($item) { |
|
| 178 | + if (is_array($parameters[$this->name])) { |
|
| 179 | + return '('.implode(',', array_map(function($item) { |
|
| 180 | 180 | return "'".addslashes($this->autoPrepend.$item.$this->autoAppend)."'"; |
| 181 | 181 | }, $parameters[$this->name])).')'; |
| 182 | - } else{ |
|
| 182 | + } else { |
|
| 183 | 183 | return "'".addslashes($this->autoPrepend.$parameters[$this->name].$this->autoAppend)."'"; |
| 184 | 184 | } |
| 185 | 185 | |
@@ -46,25 +46,25 @@ |
||
| 46 | 46 | $k = key($parsed); |
| 47 | 47 | switch ($k) { |
| 48 | 48 | |
| 49 | - case 'UNION': |
|
| 50 | - case 'UNION ALL': |
|
| 51 | - throw new UnsupportedFeatureException($k); |
|
| 52 | - break; |
|
| 53 | - case 'SELECT': |
|
| 54 | - $this->created = $this->processSelectStatement($parsed); |
|
| 55 | - break; |
|
| 56 | - case 'INSERT': |
|
| 57 | - $this->created = $this->processInsertStatement($parsed); |
|
| 58 | - break; |
|
| 59 | - case 'DELETE': |
|
| 60 | - $this->created = $this->processDeleteStatement($parsed); |
|
| 61 | - break; |
|
| 62 | - case 'UPDATE': |
|
| 63 | - $this->created = $this->processUpdateStatement($parsed); |
|
| 64 | - break; |
|
| 65 | - default: |
|
| 66 | - throw new UnsupportedFeatureException($k); |
|
| 67 | - break; |
|
| 49 | + case 'UNION': |
|
| 50 | + case 'UNION ALL': |
|
| 51 | + throw new UnsupportedFeatureException($k); |
|
| 52 | + break; |
|
| 53 | + case 'SELECT': |
|
| 54 | + $this->created = $this->processSelectStatement($parsed); |
|
| 55 | + break; |
|
| 56 | + case 'INSERT': |
|
| 57 | + $this->created = $this->processInsertStatement($parsed); |
|
| 58 | + break; |
|
| 59 | + case 'DELETE': |
|
| 60 | + $this->created = $this->processDeleteStatement($parsed); |
|
| 61 | + break; |
|
| 62 | + case 'UPDATE': |
|
| 63 | + $this->created = $this->processUpdateStatement($parsed); |
|
| 64 | + break; |
|
| 65 | + default: |
|
| 66 | + throw new UnsupportedFeatureException($k); |
|
| 67 | + break; |
|
| 68 | 68 | } |
| 69 | 69 | |
| 70 | 70 | return $this->created; |
@@ -36,102 +36,102 @@ discard block |
||
| 36 | 36 | class PHPSQLParserConstants |
| 37 | 37 | { |
| 38 | 38 | protected static $reserved = array('ABS', 'ACOS', 'ADDDATE', 'ADDTIME', 'AES_ENCRYPT', 'AES_DECRYPT', 'AGAINST', |
| 39 | - 'ASCII', 'ASIN', 'ATAN', 'AVG', 'BENCHMARK', 'BIN', 'BIT_AND', 'BIT_OR', |
|
| 40 | - 'BITCOUNT', 'BITLENGTH', 'CAST', 'CEILING', 'CHAR', 'CHAR_LENGTH', |
|
| 41 | - 'CHARACTER_LENGTH', 'CHARSET', 'COALESCE', 'COERCIBILITY', 'COLLATION', |
|
| 42 | - 'COMPRESS', 'CONCAT', 'CONCAT_WS', 'CONNECTION_ID', 'CONV', 'CONVERT', |
|
| 43 | - 'CONVERT_TZ', 'COS', 'COT', 'COUNT', 'CRC32', 'CURDATE', 'CURRENT_USER', |
|
| 44 | - 'CURRVAL', 'CURTIME', 'DATABASE', 'DATETIME', 'DATE_ADD', 'DATE_DIFF', |
|
| 45 | - 'DATE_FORMAT', 'DATE_SUB', 'DAY', 'DAYNAME', 'DAYOFMONTH', 'DAYOFWEEK', |
|
| 46 | - 'DAYOFYEAR', 'DECODE', 'DEFAULT', 'DEGREES', 'DES_DECRYPT', 'DES_ENCRYPT', |
|
| 47 | - 'ELT', 'ENCODE', 'ENCRYPT', 'EXP', 'EXPORT_SET', 'EXTRACT', 'FIELD', |
|
| 48 | - 'FIND_IN_SET', 'FLOOR', 'FORMAT', 'FOUND_ROWS', 'FROM_DAYS', 'FROM_UNIXTIME', |
|
| 49 | - 'GET_FORMAT', 'GET_LOCK', 'GROUP_CONCAT', 'GREATEST', 'HEX', 'HOUR', 'IF', |
|
| 50 | - 'IFNULL', 'IN', 'INET_ATON', 'INET_NTOA', 'INSERT', 'INSTR', 'INTERVAL', |
|
| 51 | - 'IS_FREE_LOCK', 'IS_USED_LOCK', 'LAST_DAY', 'LAST_INSERT_ID', 'LCASE', 'LEAST', |
|
| 52 | - 'LEFT', 'LENGTH', 'LN', 'LOAD_FILE', 'LOCALTIME', 'LOCALTIMESTAMP', 'LOCATE', |
|
| 53 | - 'LOG', 'LOG2', 'LOG10', 'LOWER', 'LPAD', 'LTRIM', 'MAKE_SET', 'MAKEDATE', |
|
| 54 | - 'MAKETIME', 'MASTER_POS_WAIT', 'MATCH', 'MAX', 'MD5', 'MICROSECOND', 'MID', |
|
| 55 | - 'MIN', 'MINUTE', 'MOD', 'MONTH', 'MONTHNAME', 'NEXTVAL', 'NOW', 'NULLIF', 'OCT', |
|
| 56 | - 'OCTET_LENGTH', 'OLD_PASSWORD', 'ORD', 'PASSWORD', 'PERIOD_ADD', 'PERIOD_DIFF', |
|
| 57 | - 'PI', 'POSITION', 'POW', 'POWER', 'QUARTER', 'QUOTE', 'RADIANS', 'RAND', |
|
| 58 | - 'RELEASE_LOCK', 'REPEAT', 'REPLACE', 'REVERSE', 'RIGHT', 'ROUND', 'ROW_COUNT', |
|
| 59 | - 'RPAD', 'RTRIM', 'SEC_TO_TIME', 'SECOND', 'SESSION_USER', 'SHA', 'SHA1', 'SIGN', |
|
| 60 | - 'SOUNDEX', 'SPACE', 'SQRT', 'STD', 'STDDEV', 'STDDEV_POP', 'STDDEV_SAMP', |
|
| 61 | - 'STRCMP', 'STR_TO_DATE', 'SUBDATE', 'SUBSTRING', 'SUBSTRING_INDEX', 'SUBTIME', |
|
| 62 | - 'SUM', 'SYSDATE', 'SYSTEM_USER', 'TAN', 'TIME', 'TIMEDIFF', 'TIMESTAMP', |
|
| 63 | - 'TIMESTAMPADD', 'TIMESTAMPDIFF', 'TIME_FORMAT', 'TIME_TO_SEC', 'TO_DAYS', |
|
| 64 | - 'TRIM', 'TRUNCATE', 'UCASE', 'UNCOMPRESS', 'UNCOMPRESSED_LENGTH', 'UNHEX', |
|
| 65 | - 'UNIX_TIMESTAMP', 'UPPER', 'USER', 'UTC_DATE', 'UTC_TIME', 'UTC_TIMESTAMP', |
|
| 66 | - 'UUID', 'VAR_POP', 'VAR_SAMP', 'VARIANCE', 'VERSION', 'WEEK', 'WEEKDAY', |
|
| 67 | - 'WEEKOFYEAR', 'YEAR', 'YEARWEEK', 'ADD', 'ALL', 'ALTER', 'ANALYZE', 'AND', 'AS', |
|
| 68 | - 'ASC', 'ASENSITIVE', 'AUTO_INCREMENT', 'BDB', 'BEFORE', 'BERKELEYDB', 'BETWEEN', |
|
| 69 | - 'BIGINT', 'BINARY', 'BLOB', 'BOTH', 'BY', 'CALL', 'CASCADE', 'CASE', 'CHANGE', |
|
| 70 | - 'CHAR', 'CHARACTER', 'CHECK', 'COLLATE', 'COLUMN', 'COLUMNS', 'CONDITION', |
|
| 71 | - 'CONNECTION', 'CONSTRAINT', 'CONTINUE', 'CREATE', 'CROSS', 'CURRENT_DATE', |
|
| 72 | - 'CURRENT_TIME', 'CURRENT_TIMESTAMP', 'CURSOR', 'DATABASE', 'DATABASES', |
|
| 73 | - 'DAY_HOUR', 'DAY_MICROSECOND', 'DAY_MINUTE', 'DAY_SECOND', 'DEC', 'DECIMAL', |
|
| 74 | - 'DECLARE', 'DEFAULT', 'DELAYED', 'DELETE', 'DESC', 'DESCRIBE', 'DETERMINISTIC', |
|
| 75 | - 'DISTINCT', 'DISTINCTROW', 'DIV', 'DOUBLE', 'DROP', 'ELSE', 'ELSEIF', 'END', |
|
| 76 | - 'ENCLOSED', 'ESCAPED', 'EXISTS', 'EXIT', 'EXPLAIN', 'FALSE', 'FETCH', 'FIELDS', |
|
| 77 | - 'FLOAT', 'FOR', 'FORCE', 'FOREIGN', 'FOUND', 'FRAC_SECOND', 'FROM', 'FULLTEXT', |
|
| 78 | - 'GRANT', 'GROUP', 'HAVING', 'HIGH_PRIORITY', 'HOUR_MICROSECOND', 'HOUR_MINUTE', |
|
| 79 | - 'HOUR_SECOND', 'IF', 'IGNORE', 'IN', 'INDEX', 'INFILE', 'INNER', 'INNODB', |
|
| 80 | - 'INOUT', 'INSENSITIVE', 'INSERT', 'INT', 'INTEGER', 'INTERVAL', 'INTO', |
|
| 81 | - 'IO_THREAD', 'IS', 'ITERATE', 'JOIN', 'KEY', 'KEYS', 'KILL', 'LEADING', 'LEAVE', |
|
| 82 | - 'LEFT', 'LIKE', 'LIMIT', 'LINES', 'LOAD', 'LOCALTIME', 'LOCALTIMESTAMP', 'LOCK', |
|
| 83 | - 'LONG', 'LONGBLOB', 'LONGTEXT', 'LOOP', 'LOW_PRIORITY', 'MASTER_SERVER_ID', |
|
| 84 | - 'MATCH', 'MEDIUMBLOB', 'MEDIUMINT', 'MEDIUMTEXT', 'MIDDLEINT', |
|
| 85 | - 'MINUTE_MICROSECOND', 'MINUTE_SECOND', 'MOD', 'NATURAL', 'NOT', |
|
| 86 | - 'NO_WRITE_TO_BINLOG', 'NULL', 'NUMERIC', 'ON', 'OPTIMIZE', 'OPTION', |
|
| 87 | - 'OPTIONALLY', 'OR', 'ORDER', 'OUT', 'OUTER', 'OUTFILE', 'PRECISION', 'PRIMARY', |
|
| 88 | - 'PRIVILEGES', 'PROCEDURE', 'PURGE', 'READ', 'REAL', 'REFERENCES', 'REGEXP', |
|
| 89 | - 'RENAME', 'REPEAT', 'REPLACE', 'REQUIRE', 'RESTRICT', 'RETURN', 'REVOKE', |
|
| 90 | - 'RIGHT', 'RLIKE', 'SECOND_MICROSECOND', 'SELECT', 'SENSITIVE', 'SEPARATOR', |
|
| 91 | - 'SET', 'SHOW', 'SMALLINT', 'SOME', 'SONAME', 'SPATIAL', 'SPECIFIC', 'SQL', |
|
| 92 | - 'SQLEXCEPTION', 'SQLSTATE', 'SQLWARNING', 'SQL_BIG_RESULT', |
|
| 93 | - 'SQL_CALC_FOUND_ROWS', 'SQL_SMALL_RESULT', 'SQL_TSI_DAY', 'SQL_TSI_FRAC_SECOND', |
|
| 94 | - 'SQL_TSI_HOUR', 'SQL_TSI_MINUTE', 'SQL_TSI_MONTH', 'SQL_TSI_QUARTER', |
|
| 95 | - 'SQL_TSI_SECOND', 'SQL_TSI_WEEK', 'SQL_TSI_YEAR', 'SSL', 'STARTING', |
|
| 96 | - 'STRAIGHT_JOIN', 'STRIPED', 'TABLE', 'TABLES', 'TERMINATED', 'THEN', |
|
| 97 | - 'TIMESTAMPADD', 'TIMESTAMPDIFF', 'TINYBLOB', 'TINYINT', 'TINYTEXT', 'TO', |
|
| 98 | - 'TRAILING', 'TRUE', 'UNDO', 'UNION', 'UNIQUE', 'UNLOCK', 'UNSIGNED', 'UPDATE', |
|
| 99 | - 'USAGE', 'USE', 'USER_RESOURCES', 'USING', 'UTC_DATE', 'UTC_TIME', |
|
| 100 | - 'UTC_TIMESTAMP', 'VALUES', 'VARBINARY', 'VARCHAR', 'VARCHARACTER', 'VARYING', |
|
| 101 | - 'WHEN', 'WHERE', 'WHILE', 'WITH', 'WRITE', 'XOR', 'YEAR_MONTH', 'ZEROFILL', ); |
|
| 39 | + 'ASCII', 'ASIN', 'ATAN', 'AVG', 'BENCHMARK', 'BIN', 'BIT_AND', 'BIT_OR', |
|
| 40 | + 'BITCOUNT', 'BITLENGTH', 'CAST', 'CEILING', 'CHAR', 'CHAR_LENGTH', |
|
| 41 | + 'CHARACTER_LENGTH', 'CHARSET', 'COALESCE', 'COERCIBILITY', 'COLLATION', |
|
| 42 | + 'COMPRESS', 'CONCAT', 'CONCAT_WS', 'CONNECTION_ID', 'CONV', 'CONVERT', |
|
| 43 | + 'CONVERT_TZ', 'COS', 'COT', 'COUNT', 'CRC32', 'CURDATE', 'CURRENT_USER', |
|
| 44 | + 'CURRVAL', 'CURTIME', 'DATABASE', 'DATETIME', 'DATE_ADD', 'DATE_DIFF', |
|
| 45 | + 'DATE_FORMAT', 'DATE_SUB', 'DAY', 'DAYNAME', 'DAYOFMONTH', 'DAYOFWEEK', |
|
| 46 | + 'DAYOFYEAR', 'DECODE', 'DEFAULT', 'DEGREES', 'DES_DECRYPT', 'DES_ENCRYPT', |
|
| 47 | + 'ELT', 'ENCODE', 'ENCRYPT', 'EXP', 'EXPORT_SET', 'EXTRACT', 'FIELD', |
|
| 48 | + 'FIND_IN_SET', 'FLOOR', 'FORMAT', 'FOUND_ROWS', 'FROM_DAYS', 'FROM_UNIXTIME', |
|
| 49 | + 'GET_FORMAT', 'GET_LOCK', 'GROUP_CONCAT', 'GREATEST', 'HEX', 'HOUR', 'IF', |
|
| 50 | + 'IFNULL', 'IN', 'INET_ATON', 'INET_NTOA', 'INSERT', 'INSTR', 'INTERVAL', |
|
| 51 | + 'IS_FREE_LOCK', 'IS_USED_LOCK', 'LAST_DAY', 'LAST_INSERT_ID', 'LCASE', 'LEAST', |
|
| 52 | + 'LEFT', 'LENGTH', 'LN', 'LOAD_FILE', 'LOCALTIME', 'LOCALTIMESTAMP', 'LOCATE', |
|
| 53 | + 'LOG', 'LOG2', 'LOG10', 'LOWER', 'LPAD', 'LTRIM', 'MAKE_SET', 'MAKEDATE', |
|
| 54 | + 'MAKETIME', 'MASTER_POS_WAIT', 'MATCH', 'MAX', 'MD5', 'MICROSECOND', 'MID', |
|
| 55 | + 'MIN', 'MINUTE', 'MOD', 'MONTH', 'MONTHNAME', 'NEXTVAL', 'NOW', 'NULLIF', 'OCT', |
|
| 56 | + 'OCTET_LENGTH', 'OLD_PASSWORD', 'ORD', 'PASSWORD', 'PERIOD_ADD', 'PERIOD_DIFF', |
|
| 57 | + 'PI', 'POSITION', 'POW', 'POWER', 'QUARTER', 'QUOTE', 'RADIANS', 'RAND', |
|
| 58 | + 'RELEASE_LOCK', 'REPEAT', 'REPLACE', 'REVERSE', 'RIGHT', 'ROUND', 'ROW_COUNT', |
|
| 59 | + 'RPAD', 'RTRIM', 'SEC_TO_TIME', 'SECOND', 'SESSION_USER', 'SHA', 'SHA1', 'SIGN', |
|
| 60 | + 'SOUNDEX', 'SPACE', 'SQRT', 'STD', 'STDDEV', 'STDDEV_POP', 'STDDEV_SAMP', |
|
| 61 | + 'STRCMP', 'STR_TO_DATE', 'SUBDATE', 'SUBSTRING', 'SUBSTRING_INDEX', 'SUBTIME', |
|
| 62 | + 'SUM', 'SYSDATE', 'SYSTEM_USER', 'TAN', 'TIME', 'TIMEDIFF', 'TIMESTAMP', |
|
| 63 | + 'TIMESTAMPADD', 'TIMESTAMPDIFF', 'TIME_FORMAT', 'TIME_TO_SEC', 'TO_DAYS', |
|
| 64 | + 'TRIM', 'TRUNCATE', 'UCASE', 'UNCOMPRESS', 'UNCOMPRESSED_LENGTH', 'UNHEX', |
|
| 65 | + 'UNIX_TIMESTAMP', 'UPPER', 'USER', 'UTC_DATE', 'UTC_TIME', 'UTC_TIMESTAMP', |
|
| 66 | + 'UUID', 'VAR_POP', 'VAR_SAMP', 'VARIANCE', 'VERSION', 'WEEK', 'WEEKDAY', |
|
| 67 | + 'WEEKOFYEAR', 'YEAR', 'YEARWEEK', 'ADD', 'ALL', 'ALTER', 'ANALYZE', 'AND', 'AS', |
|
| 68 | + 'ASC', 'ASENSITIVE', 'AUTO_INCREMENT', 'BDB', 'BEFORE', 'BERKELEYDB', 'BETWEEN', |
|
| 69 | + 'BIGINT', 'BINARY', 'BLOB', 'BOTH', 'BY', 'CALL', 'CASCADE', 'CASE', 'CHANGE', |
|
| 70 | + 'CHAR', 'CHARACTER', 'CHECK', 'COLLATE', 'COLUMN', 'COLUMNS', 'CONDITION', |
|
| 71 | + 'CONNECTION', 'CONSTRAINT', 'CONTINUE', 'CREATE', 'CROSS', 'CURRENT_DATE', |
|
| 72 | + 'CURRENT_TIME', 'CURRENT_TIMESTAMP', 'CURSOR', 'DATABASE', 'DATABASES', |
|
| 73 | + 'DAY_HOUR', 'DAY_MICROSECOND', 'DAY_MINUTE', 'DAY_SECOND', 'DEC', 'DECIMAL', |
|
| 74 | + 'DECLARE', 'DEFAULT', 'DELAYED', 'DELETE', 'DESC', 'DESCRIBE', 'DETERMINISTIC', |
|
| 75 | + 'DISTINCT', 'DISTINCTROW', 'DIV', 'DOUBLE', 'DROP', 'ELSE', 'ELSEIF', 'END', |
|
| 76 | + 'ENCLOSED', 'ESCAPED', 'EXISTS', 'EXIT', 'EXPLAIN', 'FALSE', 'FETCH', 'FIELDS', |
|
| 77 | + 'FLOAT', 'FOR', 'FORCE', 'FOREIGN', 'FOUND', 'FRAC_SECOND', 'FROM', 'FULLTEXT', |
|
| 78 | + 'GRANT', 'GROUP', 'HAVING', 'HIGH_PRIORITY', 'HOUR_MICROSECOND', 'HOUR_MINUTE', |
|
| 79 | + 'HOUR_SECOND', 'IF', 'IGNORE', 'IN', 'INDEX', 'INFILE', 'INNER', 'INNODB', |
|
| 80 | + 'INOUT', 'INSENSITIVE', 'INSERT', 'INT', 'INTEGER', 'INTERVAL', 'INTO', |
|
| 81 | + 'IO_THREAD', 'IS', 'ITERATE', 'JOIN', 'KEY', 'KEYS', 'KILL', 'LEADING', 'LEAVE', |
|
| 82 | + 'LEFT', 'LIKE', 'LIMIT', 'LINES', 'LOAD', 'LOCALTIME', 'LOCALTIMESTAMP', 'LOCK', |
|
| 83 | + 'LONG', 'LONGBLOB', 'LONGTEXT', 'LOOP', 'LOW_PRIORITY', 'MASTER_SERVER_ID', |
|
| 84 | + 'MATCH', 'MEDIUMBLOB', 'MEDIUMINT', 'MEDIUMTEXT', 'MIDDLEINT', |
|
| 85 | + 'MINUTE_MICROSECOND', 'MINUTE_SECOND', 'MOD', 'NATURAL', 'NOT', |
|
| 86 | + 'NO_WRITE_TO_BINLOG', 'NULL', 'NUMERIC', 'ON', 'OPTIMIZE', 'OPTION', |
|
| 87 | + 'OPTIONALLY', 'OR', 'ORDER', 'OUT', 'OUTER', 'OUTFILE', 'PRECISION', 'PRIMARY', |
|
| 88 | + 'PRIVILEGES', 'PROCEDURE', 'PURGE', 'READ', 'REAL', 'REFERENCES', 'REGEXP', |
|
| 89 | + 'RENAME', 'REPEAT', 'REPLACE', 'REQUIRE', 'RESTRICT', 'RETURN', 'REVOKE', |
|
| 90 | + 'RIGHT', 'RLIKE', 'SECOND_MICROSECOND', 'SELECT', 'SENSITIVE', 'SEPARATOR', |
|
| 91 | + 'SET', 'SHOW', 'SMALLINT', 'SOME', 'SONAME', 'SPATIAL', 'SPECIFIC', 'SQL', |
|
| 92 | + 'SQLEXCEPTION', 'SQLSTATE', 'SQLWARNING', 'SQL_BIG_RESULT', |
|
| 93 | + 'SQL_CALC_FOUND_ROWS', 'SQL_SMALL_RESULT', 'SQL_TSI_DAY', 'SQL_TSI_FRAC_SECOND', |
|
| 94 | + 'SQL_TSI_HOUR', 'SQL_TSI_MINUTE', 'SQL_TSI_MONTH', 'SQL_TSI_QUARTER', |
|
| 95 | + 'SQL_TSI_SECOND', 'SQL_TSI_WEEK', 'SQL_TSI_YEAR', 'SSL', 'STARTING', |
|
| 96 | + 'STRAIGHT_JOIN', 'STRIPED', 'TABLE', 'TABLES', 'TERMINATED', 'THEN', |
|
| 97 | + 'TIMESTAMPADD', 'TIMESTAMPDIFF', 'TINYBLOB', 'TINYINT', 'TINYTEXT', 'TO', |
|
| 98 | + 'TRAILING', 'TRUE', 'UNDO', 'UNION', 'UNIQUE', 'UNLOCK', 'UNSIGNED', 'UPDATE', |
|
| 99 | + 'USAGE', 'USE', 'USER_RESOURCES', 'USING', 'UTC_DATE', 'UTC_TIME', |
|
| 100 | + 'UTC_TIMESTAMP', 'VALUES', 'VARBINARY', 'VARCHAR', 'VARCHARACTER', 'VARYING', |
|
| 101 | + 'WHEN', 'WHERE', 'WHILE', 'WITH', 'WRITE', 'XOR', 'YEAR_MONTH', 'ZEROFILL', ); |
|
| 102 | 102 | |
| 103 | 103 | protected static $parameterizedFunctions = array('ABS', 'ACOS', 'ADDDATE', 'ADDTIME', 'AES_ENCRYPT', 'AES_DECRYPT', |
| 104 | - 'AGAINST', 'ASCII', 'ASIN', 'ATAN', 'AVG', 'BENCHMARK', 'BIN', |
|
| 105 | - 'BIT_AND', 'BIT_OR', 'BITCOUNT', 'BITLENGTH', 'CAST', 'CEILING', |
|
| 106 | - 'CHAR', 'CHAR_LENGTH', 'CHARACTER_LENGTH', 'CHARSET', 'COALESCE', |
|
| 107 | - 'COERCIBILITY', 'COLLATION', 'COMPRESS', 'CONCAT', 'CONCAT_WS', |
|
| 108 | - 'CONV', 'CONVERT', 'CONVERT_TZ', 'COS', 'COT', 'COUNT', 'CRC32', |
|
| 109 | - 'CURRVAL', 'DATE_ADD', 'DATE_DIFF', 'DATE_FORMAT', 'DATE_SUB', |
|
| 110 | - 'DAY', 'DAYNAME', 'DAYOFMONTH', 'DAYOFWEEK', 'DAYOFYEAR', |
|
| 111 | - 'DECODE', 'DEFAULT', 'DEGREES', 'DES_DECRYPT', 'DES_ENCRYPT', |
|
| 112 | - 'ELT', 'ENCODE', 'ENCRYPT', 'EXP', 'EXPORT_SET', 'EXTRACT', |
|
| 113 | - 'FIELD', 'FIND_IN_SET', 'FLOOR', 'FORMAT', 'FROM_DAYS', |
|
| 114 | - 'FROM_UNIXTIME', 'GET_FORMAT', 'GET_LOCK', 'GROUP_CONCAT', |
|
| 115 | - 'GREATEST', 'HEX', 'HOUR', 'IF', 'IFNULL', 'IN', 'INET_ATON', |
|
| 116 | - 'INET_NTOA', 'INSERT', 'INSTR', 'INTERVAL', 'IS_FREE_LOCK', |
|
| 117 | - 'IS_USED_LOCK', 'LAST_DAY', 'LCASE', 'LEAST', 'LEFT', 'LENGTH', |
|
| 118 | - 'LN', 'LOAD_FILE', 'LOCATE', 'LOG', 'LOG2', 'LOG10', 'LOWER', |
|
| 119 | - 'LPAD', 'LTRIM', 'MAKE_SET', 'MAKEDATE', 'MAKETIME', |
|
| 120 | - 'MASTER_POS_WAIT', 'MATCH', 'MAX', 'MD5', 'MICROSECOND', 'MID', |
|
| 121 | - 'MIN', 'MINUTE', 'MOD', 'MONTH', 'MONTHNAME', 'NEXTVAL', 'NULLIF', |
|
| 122 | - 'OCT', 'OCTET_LENGTH', 'OLD_PASSWORD', 'ORD', 'PASSWORD', |
|
| 123 | - 'PERIOD_ADD', 'PERIOD_DIFF', 'PI', 'POSITION', 'POW', 'POWER', |
|
| 124 | - 'QUARTER', 'QUOTE', 'RADIANS', 'RELEASE_LOCK', 'REPEAT', |
|
| 125 | - 'REPLACE', 'REVERSE', 'RIGHT', 'ROUND', 'RPAD', 'RTRIM', |
|
| 126 | - 'SEC_TO_TIME', 'SECOND', 'SHA', 'SHA1', 'SIGN', 'SOUNDEX', |
|
| 127 | - 'SPACE', 'SQRT', 'STD', 'STDDEV', 'STDDEV_POP', 'STDDEV_SAMP', |
|
| 128 | - 'STRCMP', 'STR_TO_DATE', 'SUBDATE', 'SUBSTRING', |
|
| 129 | - 'SUBSTRING_INDEX', 'SUBTIME', 'SUM', 'TAN', 'TIME', 'TIMEDIFF', |
|
| 130 | - 'TIMESTAMP', 'TIMESTAMPADD', 'TIMESTAMPDIFF', 'TIME_FORMAT', |
|
| 131 | - 'TIME_TO_SEC', 'TO_DAYS', 'TRIM', 'TRUNCATE', 'UCASE', |
|
| 132 | - 'UNCOMPRESS', 'UNCOMPRESSED_LENGTH', 'UNHEX', 'UPPER', 'VAR_POP', |
|
| 133 | - 'VAR_SAMP', 'VARIANCE', 'WEEK', 'WEEKDAY', 'WEEKOFYEAR', 'YEAR', |
|
| 134 | - 'YEARWEEK', ); |
|
| 104 | + 'AGAINST', 'ASCII', 'ASIN', 'ATAN', 'AVG', 'BENCHMARK', 'BIN', |
|
| 105 | + 'BIT_AND', 'BIT_OR', 'BITCOUNT', 'BITLENGTH', 'CAST', 'CEILING', |
|
| 106 | + 'CHAR', 'CHAR_LENGTH', 'CHARACTER_LENGTH', 'CHARSET', 'COALESCE', |
|
| 107 | + 'COERCIBILITY', 'COLLATION', 'COMPRESS', 'CONCAT', 'CONCAT_WS', |
|
| 108 | + 'CONV', 'CONVERT', 'CONVERT_TZ', 'COS', 'COT', 'COUNT', 'CRC32', |
|
| 109 | + 'CURRVAL', 'DATE_ADD', 'DATE_DIFF', 'DATE_FORMAT', 'DATE_SUB', |
|
| 110 | + 'DAY', 'DAYNAME', 'DAYOFMONTH', 'DAYOFWEEK', 'DAYOFYEAR', |
|
| 111 | + 'DECODE', 'DEFAULT', 'DEGREES', 'DES_DECRYPT', 'DES_ENCRYPT', |
|
| 112 | + 'ELT', 'ENCODE', 'ENCRYPT', 'EXP', 'EXPORT_SET', 'EXTRACT', |
|
| 113 | + 'FIELD', 'FIND_IN_SET', 'FLOOR', 'FORMAT', 'FROM_DAYS', |
|
| 114 | + 'FROM_UNIXTIME', 'GET_FORMAT', 'GET_LOCK', 'GROUP_CONCAT', |
|
| 115 | + 'GREATEST', 'HEX', 'HOUR', 'IF', 'IFNULL', 'IN', 'INET_ATON', |
|
| 116 | + 'INET_NTOA', 'INSERT', 'INSTR', 'INTERVAL', 'IS_FREE_LOCK', |
|
| 117 | + 'IS_USED_LOCK', 'LAST_DAY', 'LCASE', 'LEAST', 'LEFT', 'LENGTH', |
|
| 118 | + 'LN', 'LOAD_FILE', 'LOCATE', 'LOG', 'LOG2', 'LOG10', 'LOWER', |
|
| 119 | + 'LPAD', 'LTRIM', 'MAKE_SET', 'MAKEDATE', 'MAKETIME', |
|
| 120 | + 'MASTER_POS_WAIT', 'MATCH', 'MAX', 'MD5', 'MICROSECOND', 'MID', |
|
| 121 | + 'MIN', 'MINUTE', 'MOD', 'MONTH', 'MONTHNAME', 'NEXTVAL', 'NULLIF', |
|
| 122 | + 'OCT', 'OCTET_LENGTH', 'OLD_PASSWORD', 'ORD', 'PASSWORD', |
|
| 123 | + 'PERIOD_ADD', 'PERIOD_DIFF', 'PI', 'POSITION', 'POW', 'POWER', |
|
| 124 | + 'QUARTER', 'QUOTE', 'RADIANS', 'RELEASE_LOCK', 'REPEAT', |
|
| 125 | + 'REPLACE', 'REVERSE', 'RIGHT', 'ROUND', 'RPAD', 'RTRIM', |
|
| 126 | + 'SEC_TO_TIME', 'SECOND', 'SHA', 'SHA1', 'SIGN', 'SOUNDEX', |
|
| 127 | + 'SPACE', 'SQRT', 'STD', 'STDDEV', 'STDDEV_POP', 'STDDEV_SAMP', |
|
| 128 | + 'STRCMP', 'STR_TO_DATE', 'SUBDATE', 'SUBSTRING', |
|
| 129 | + 'SUBSTRING_INDEX', 'SUBTIME', 'SUM', 'TAN', 'TIME', 'TIMEDIFF', |
|
| 130 | + 'TIMESTAMP', 'TIMESTAMPADD', 'TIMESTAMPDIFF', 'TIME_FORMAT', |
|
| 131 | + 'TIME_TO_SEC', 'TO_DAYS', 'TRIM', 'TRUNCATE', 'UCASE', |
|
| 132 | + 'UNCOMPRESS', 'UNCOMPRESSED_LENGTH', 'UNHEX', 'UPPER', 'VAR_POP', |
|
| 133 | + 'VAR_SAMP', 'VARIANCE', 'WEEK', 'WEEKDAY', 'WEEKOFYEAR', 'YEAR', |
|
| 134 | + 'YEARWEEK', ); |
|
| 135 | 135 | |
| 136 | 136 | protected static $functions = array('ABS', 'ACOS', 'ADDDATE', 'ADDTIME', 'AES_ENCRYPT', 'AES_DECRYPT', 'AGAINST', |
| 137 | 137 | 'ASCII', 'ASIN', 'ATAN', 'AVG', 'BENCHMARK', 'BIN', 'BIT_AND', 'BIT_OR', |
@@ -165,6 +165,6 @@ discard block |
||
| 165 | 165 | 'VERSION', 'WEEK', 'WEEKDAY', 'WEEKOFYEAR', 'YEAR', 'YEARWEEK', ); |
| 166 | 166 | |
| 167 | 167 | protected static $aggregateFunctions = array('AVG', 'SUM', 'COUNT', 'MIN', 'MAX', 'STDDEV', 'STDDEV_SAMP', |
| 168 | - 'STDDEV_POP', 'VARIANCE', 'VAR_SAMP', 'VAR_POP', 'GROUP_CONCAT', |
|
| 169 | - 'BIT_AND', 'BIT_OR', 'BIT_XOR', ); |
|
| 168 | + 'STDDEV_POP', 'VARIANCE', 'VAR_SAMP', 'VAR_POP', 'GROUP_CONCAT', |
|
| 169 | + 'BIT_AND', 'BIT_OR', 'BIT_XOR', ); |
|
| 170 | 170 | } |
@@ -98,7 +98,7 @@ discard block |
||
| 98 | 98 | 'TRAILING', 'TRUE', 'UNDO', 'UNION', 'UNIQUE', 'UNLOCK', 'UNSIGNED', 'UPDATE', |
| 99 | 99 | 'USAGE', 'USE', 'USER_RESOURCES', 'USING', 'UTC_DATE', 'UTC_TIME', |
| 100 | 100 | 'UTC_TIMESTAMP', 'VALUES', 'VARBINARY', 'VARCHAR', 'VARCHARACTER', 'VARYING', |
| 101 | - 'WHEN', 'WHERE', 'WHILE', 'WITH', 'WRITE', 'XOR', 'YEAR_MONTH', 'ZEROFILL', ); |
|
| 101 | + 'WHEN', 'WHERE', 'WHILE', 'WITH', 'WRITE', 'XOR', 'YEAR_MONTH', 'ZEROFILL',); |
|
| 102 | 102 | |
| 103 | 103 | protected static $parameterizedFunctions = array('ABS', 'ACOS', 'ADDDATE', 'ADDTIME', 'AES_ENCRYPT', 'AES_DECRYPT', |
| 104 | 104 | 'AGAINST', 'ASCII', 'ASIN', 'ATAN', 'AVG', 'BENCHMARK', 'BIN', |
@@ -131,7 +131,7 @@ discard block |
||
| 131 | 131 | 'TIME_TO_SEC', 'TO_DAYS', 'TRIM', 'TRUNCATE', 'UCASE', |
| 132 | 132 | 'UNCOMPRESS', 'UNCOMPRESSED_LENGTH', 'UNHEX', 'UPPER', 'VAR_POP', |
| 133 | 133 | 'VAR_SAMP', 'VARIANCE', 'WEEK', 'WEEKDAY', 'WEEKOFYEAR', 'YEAR', |
| 134 | - 'YEARWEEK', ); |
|
| 134 | + 'YEARWEEK',); |
|
| 135 | 135 | |
| 136 | 136 | protected static $functions = array('ABS', 'ACOS', 'ADDDATE', 'ADDTIME', 'AES_ENCRYPT', 'AES_DECRYPT', 'AGAINST', |
| 137 | 137 | 'ASCII', 'ASIN', 'ATAN', 'AVG', 'BENCHMARK', 'BIN', 'BIT_AND', 'BIT_OR', |
@@ -162,9 +162,9 @@ discard block |
||
| 162 | 162 | 'TIME_TO_SEC', 'TO_DAYS', 'TRIM', 'TRUNCATE', 'UCASE', 'UNCOMPRESS', |
| 163 | 163 | 'UNCOMPRESSED_LENGTH', 'UNHEX', 'UNIX_TIMESTAMP', 'UPPER', 'USER', 'UTC_DATE', |
| 164 | 164 | 'UTC_TIME', 'UTC_TIMESTAMP', 'UUID', 'VAR_POP', 'VAR_SAMP', 'VARIANCE', |
| 165 | - 'VERSION', 'WEEK', 'WEEKDAY', 'WEEKOFYEAR', 'YEAR', 'YEARWEEK', ); |
|
| 165 | + 'VERSION', 'WEEK', 'WEEKDAY', 'WEEKOFYEAR', 'YEAR', 'YEARWEEK',); |
|
| 166 | 166 | |
| 167 | 167 | protected static $aggregateFunctions = array('AVG', 'SUM', 'COUNT', 'MIN', 'MAX', 'STDDEV', 'STDDEV_SAMP', |
| 168 | 168 | 'STDDEV_POP', 'VARIANCE', 'VAR_SAMP', 'VAR_POP', 'GROUP_CONCAT', |
| 169 | - 'BIT_AND', 'BIT_OR', 'BIT_XOR', ); |
|
| 169 | + 'BIT_AND', 'BIT_OR', 'BIT_XOR',); |
|
| 170 | 170 | } |
@@ -48,7 +48,7 @@ |
||
| 48 | 48 | if (isset($desc['SELECT'])) { |
| 49 | 49 | $select = new Select(); |
| 50 | 50 | |
| 51 | - $columns = array_map(function ($item) { |
|
| 51 | + $columns = array_map(function($item) { |
|
| 52 | 52 | return NodeFactory::toObject($item); |
| 53 | 53 | }, $desc['SELECT']); |
| 54 | 54 | $columns = NodeFactory::simplify($columns); |
