thecodingmachine / magic-query

src/Mouf/Database/MagicQuery/Twig/SqlTwigEnvironmentFactory.php

Unused Use Statements -2 removed lines

@@ -1,8 +1,6 @@
 <?php
 namespace Mouf\Database\MagicQuery\Twig;
 
-use Doctrine\DBAL\Connection;
-
 /**
  * Class in charge of creating the Twig environment
  */

src/Mouf/Database/QueryWriter/Condition/ParamNotAvailableCondition.php

Doc Comments -1 removed lines

@@ -24,7 +24,6 @@
     }
 
     /**
-     * @param string $caller
      */
     public function isOk($parameters = null)
     {

src/SQLParser/Node/NodeFactory.php

Doc Comments +4 added lines, -1 removed lines

@@ -635,6 +635,9 @@ 
         });
     }
 
+    /**
+     * @param \Closure $callback
+     */
     private static function array_map_deep($array, $callback)
     {
         $new = array();
@@ -661,7 +664,7 @@ 
      * @param array       $parameters
      * @param string      $delimiter
      * @param bool|string $wrapInBrackets
-     * @param int|number  $indent
+     * @param integer  $indent
      * @param int         $conditionsMode
      *
      * @return null|string

Spacing +4 added lines, -4 removed lines

@@ -335,7 +335,7 @@ 
             if (!empty($subTree) && !isset($subTree[0])) {
                 $subTree = StatementFactory::toObject($subTree);
             } else {
-                $subTree = array_map(function ($item) {
+                $subTree = array_map(function($item) {
                     if (is_array($item)) {
                         return self::toObject($item);
                     } else {
@@ -365,7 +365,7 @@ 
             array('NOT'),
             array('&&', 'AND'),
             array('XOR'),
-            array('||', 'OR'), );
+            array('||', 'OR'),);
 
     private static $OPERATOR_TO_CLASS = array(
             '=' => 'SQLParser\Node\Equal',
@@ -626,7 +626,7 @@ 
     {
         $instanceDescriptor = $moufManager->createInstance(get_called_class());
 
-        return self::array_map_deep($node, function ($item) use ($moufManager) {
+        return self::array_map_deep($node, function($item) use ($moufManager) {
             if ($item instanceof NodeInterface) {
                 return $item->toInstanceDescriptor($moufManager);
             } else {
@@ -670,7 +670,7 @@ 
     {
         if (is_array($nodes)) {
             $elems = array();
-            array_walk_recursive($nodes, function ($item) use (&$elems, $dbConnection, $indent, $delimiter, $parameters, $conditionsMode) {
+            array_walk_recursive($nodes, function($item) use (&$elems, $dbConnection, $indent, $delimiter, $parameters, $conditionsMode) {
                 if ($item instanceof SqlRenderInterface) {
                     $itemSql = $item->toSql($parameters, $dbConnection, $indent, $conditionsMode);
                     if ($itemSql !== null) {

src/SQLParser/Node/SubQuery.php

Doc Comments +1 added lines, -1 removed lines

@@ -181,7 +181,7 @@
      *
      * @param Connection $dbConnection
      * @param array $parameters
-     * @param number $indent
+     * @param integer $indent
      * @param int $conditionsMode
      *
      * @return string

Unused Use Statements -1 removed lines

@@ -39,7 +39,6 @@
 use SQLParser\Query\Select;
 use Mouf\MoufInstanceDescriptor;
 use Mouf\MoufManager;
-use SQLParser\SqlRenderInterface;
 
 /**
  * This class represents a subquery (and optionally a JOIN .. ON expression in an SQL expression.

src/SQLParser/OracleSQLTranslator.php

Doc Comments +13 added lines

@@ -57,6 +57,9 @@ 
         $this->allTables = array();
     }
 
+    /**
+     * @param string $txt
+     */
     public static function dbgprint($txt)
     {
         if (isset($_ENV['DEBUG'])) {
@@ -95,6 +98,9 @@ 
         return 'DELETE';
     }
 
+    /**
+     * @param string $column
+     */
     public static function getColumnNameFor($column)
     {
         if (strtolower($column) === 'uid') {
@@ -198,6 +204,10 @@ 
         return ($res >= 1);
     }
 
+    /**
+     * @param string $table
+     * @param string $column
+     */
     protected function isCLOBColumn($table, $column)
     {
         $tables = end($this->allTables);
@@ -314,6 +324,9 @@ 
         return 'SELECT '.$sql;
     }
 
+    /**
+     * @param string $sql
+     */
     private function correctColRefStatement($sql)
     {
         $alias = '';

Switch Indentation +8 added lines, -8 removed lines

@@ -368,14 +368,14 @@
     {
         $k = key($parsed);
         switch ($k) {
-        case 'USE':
-        # this statement is not an Oracle statement
-            $this->created = '';
-            break;
-
-        default:
-            $this->created = parent::create($parsed);
-            break;
+            case 'USE':
+            # this statement is not an Oracle statement
+                $this->created = '';
+                break;
+
+            default:
+                $this->created = parent::create($parsed);
+                break;
         }
 
         return $this->created;

src/SQLParser/PHPSQLLexer.php

Doc Comments +4 added lines

@@ -237,6 +237,10 @@
 
     # backticks are not balanced within one token, so we have
     # to re-combine some tokens
+
+    /**
+     * @param integer $idx
+     */
     private function balanceCharacter($tokens, $idx, $char)
     {
         $token_count = count($tokens);

src/SQLParser/PHPSQLParserUtils.php

Doc Comments +1 added lines, -1 removed lines

@@ -43,7 +43,6 @@ 
     /**
      * Prints an array only if debug mode is on.
      *
-     * @param array $s
      * @param bool  $return, if true, the formatted array is returned via return parameter
      */
     protected function preprint($arr, $return = false)
@@ -80,6 +79,7 @@ 
 
     /**
      * Revokes the escaping characters from an expression.
+     * @param string $sql
      */
     protected function revokeEscaping($sql)
     {

src/SQLParser/PositionCalculator.php

Doc Comments +7 added lines

@@ -73,6 +73,9 @@ 
         return $parsed;
     }
 
+    /**
+     * @param string $sql
+     */
     private function findPositionWithinString($sql, $value, $expr_type)
     {
         $offset = 0;
@@ -130,6 +133,10 @@ 
         return $pos;
     }
 
+    /**
+     * @param integer $charPos
+     * @param integer $key
+     */
     private function lookForBaseExpression($sql, &$charPos, &$parsed, $key, &$backtracking)
     {
         if (!is_numeric($key)) {

Indentation +1 added lines, -1 removed lines

@@ -44,7 +44,7 @@
 {
     private static $allowedOnOperator = array("\t", "\n", "\r", ' ', ',', '(', ')', '_', "'", '"');
     private static $allowedOnOther = array("\t", "\n", "\r", ' ', ',', '(', ')', '<', '>', '*', '+', '-', '/', '|',
-                                           '&', '=', '!', ';', );
+                                            '&', '=', '!', ';', );
 
     private function printPos($text, $sql, $charPos, $key, $parsed, $backtracking)
     {

Spacing +1 added lines, -1 removed lines

@@ -44,7 +44,7 @@
 {
     private static $allowedOnOperator = array("\t", "\n", "\r", ' ', ',', '(', ')', '_', "'", '"');
     private static $allowedOnOther = array("\t", "\n", "\r", ' ', ',', '(', ')', '<', '>', '*', '+', '-', '/', '|',
-                                           '&', '=', '!', ';', );
+                                           '&', '=', '!', ';',);
 
     private function printPos($text, $sql, $charPos, $key, $parsed, $backtracking)
     {

src/SQLParser/SQLParser.php

Doc Comments +15 added lines

@@ -51,6 +51,9 @@ 
         }
     }
 
+    /**
+     * @param string|boolean $sql
+     */
     public function parse($sql, $calcPositions = false)
     {
         #lex the SQL statement
@@ -499,6 +502,9 @@ 
         return $this->processSQLParts($out);
     }
 
+    /**
+     * @param boolean $out
+     */
     private function processSQLParts($out)
     {
         if (!$out) {
@@ -565,6 +571,7 @@ 
     /**
      *  A SET list is simply a list of key = value expressions separated by comma (,).
      *  This function produces a list of the key/value expressions.
+     * @param string $base_expr
      */
     private function getAssignment($base_expr)
     {
@@ -574,6 +581,9 @@ 
                      'sub_tree' => $assignment, );
     }
 
+    /**
+     * @param string $expression
+     */
     private function getVariableType($expression)
     {
         // $expression must contain only upper-case characters
@@ -601,6 +611,7 @@ 
 
     /**
      * It can be UPDATE SET or SET alone.
+     * @param boolean $isUpdate
      */
     private function process_set_list($tokens, $isUpdate)
     {
@@ -730,6 +741,9 @@ 
         return (trim($token) === '');
     }
 
+    /**
+     * @param string $token
+     */
     private function isCommentToken($token)
     {
         return isset($token[0]) && isset($token[1])
@@ -1490,6 +1504,7 @@ 
 
     /**
      * This method handles INSERT and REPLACE statements.
+     * @param string $token_category
      */
     private function processInsertOrReplace($tokenList, $token_category)
     {

Indentation +7 added lines, -7 removed lines

@@ -571,7 +571,7 @@ 
         $assignment = $this->process_expr_list($this->splitSQLIntoTokens($base_expr));
 
         return array('expr_type' => ExpressionType::EXPRESSION, 'base_expr' => trim($base_expr),
-                     'sub_tree' => $assignment, );
+                        'sub_tree' => $assignment, );
     }
 
     private function getVariableType($expression)
@@ -843,7 +843,7 @@ 
                     || $this->isFunction($prev) || $this->isExpression($prev) || $this->isSubQuery($prev)
                     || $this->isColumnReference($prev) || $this->isBracketExpression($prev)) {
                 $alias = array('as' => false, 'name' => trim($last['base_expr']),
-                               'base_expr' => trim($last['base_expr']), );
+                                'base_expr' => trim($last['base_expr']), );
                 #remove the last token
                 array_pop($tokens);
                 $base_expr = implode('', $tokens);
@@ -873,7 +873,7 @@ 
         }
 
         return array('expr_type' => $type, 'alias' => $alias, 'base_expr' => trim($base_expr),
-                     'sub_tree' => $processed, );
+                        'sub_tree' => $processed, );
     }
 
     /**
@@ -1013,9 +1013,9 @@ 
         }
         # loop init
         return array('expression' => '', 'token_count' => 0, 'table' => '', 'alias' => false, 'join_type' => '',
-                     'next_join_type' => '', 'saved_join_type' => $parseInfo['saved_join_type'],
-                     'ref_type' => false, 'ref_expr' => false, 'base_expr' => false, 'sub_tree' => false,
-                     'subquery' => '', );
+                        'next_join_type' => '', 'saved_join_type' => $parseInfo['saved_join_type'],
+                        'ref_type' => false, 'ref_expr' => false, 'base_expr' => false, 'sub_tree' => false,
+                        'subquery' => '', );
     }
 
     private function processFromExpression(&$parseInfo)
@@ -1099,7 +1099,7 @@ 
         }
 
         return array('expr_type' => $parseInfo['type'], 'base_expr' => $parseInfo['expr'],
-                     'direction' => $parseInfo['dir'], );
+                        'direction' => $parseInfo['dir'], );
     }
 
     private function initParseInfoForOrder()

Switch Indentation +468 added lines, -468 removed lines

@@ -245,246 +245,246 @@ 
             switch ($upper) {
 
             /* Tokens that get their own sections. These keywords have subclauses. */
-            case 'SELECT':
-            case 'ORDER':
-            case 'LIMIT':
-            case 'SET':
-            case 'DUPLICATE':
-            case 'VALUES':
-            case 'GROUP':
-            case 'HAVING':
-            case 'WHERE':
-            case 'RENAME':
-            case 'CALL':
-            case 'PROCEDURE':
-            case 'FUNCTION':
-            case 'SERVER':
-            case 'LOGFILE':
-            case 'DEFINER':
-            case 'RETURNS':
-            case 'TABLESPACE':
-            case 'TRIGGER':
-            case 'DO':
-            case 'PLUGIN':
-            case 'FROM':
-            case 'FLUSH':
-            case 'KILL':
-            case 'RESET':
-            case 'START':
-            case 'STOP':
-            case 'PURGE':
-            case 'EXECUTE':
-            case 'PREPARE':
-            case 'DEALLOCATE':
-                if ($trim === 'DEALLOCATE') {
-                    $skip_next = true;
-                }
-                /* this FROM is different from FROM in other DML (not join related) */
-                if ($token_category === 'PREPARE' && $upper === 'FROM') {
-                    continue 2;
-                }
-
-                $token_category = $upper;
-                break;
-
-            case 'DATABASE':
-            case 'SCHEMA':
-                if ($prev_category === 'DROP') {
-                    continue;
-                }
-                $token_category = $upper;
-                break;
+                case 'SELECT':
+                case 'ORDER':
+                case 'LIMIT':
+                case 'SET':
+                case 'DUPLICATE':
+                case 'VALUES':
+                case 'GROUP':
+                case 'HAVING':
+                case 'WHERE':
+                case 'RENAME':
+                case 'CALL':
+                case 'PROCEDURE':
+                case 'FUNCTION':
+                case 'SERVER':
+                case 'LOGFILE':
+                case 'DEFINER':
+                case 'RETURNS':
+                case 'TABLESPACE':
+                case 'TRIGGER':
+                case 'DO':
+                case 'PLUGIN':
+                case 'FROM':
+                case 'FLUSH':
+                case 'KILL':
+                case 'RESET':
+                case 'START':
+                case 'STOP':
+                case 'PURGE':
+                case 'EXECUTE':
+                case 'PREPARE':
+                case 'DEALLOCATE':
+                    if ($trim === 'DEALLOCATE') {
+                        $skip_next = true;
+                    }
+                    /* this FROM is different from FROM in other DML (not join related) */
+                    if ($token_category === 'PREPARE' && $upper === 'FROM') {
+                        continue 2;
+                    }
 
-            case 'EVENT':
-            # issue 71
-                if ($prev_category === 'DROP' || $prev_category === 'ALTER' || $prev_category === 'CREATE') {
                     $token_category = $upper;
-                }
-                break;
+                    break;
 
-            case 'DATA':
-            # prevent wrong handling of DATA as keyword
-                if ($prev_category === 'LOAD') {
+                case 'DATABASE':
+                case 'SCHEMA':
+                    if ($prev_category === 'DROP') {
+                        continue;
+                    }
                     $token_category = $upper;
-                }
-                break;
+                    break;
 
-            case 'INTO':
-            # prevent wrong handling of CACHE within LOAD INDEX INTO CACHE...
-                if ($prev_category === 'LOAD') {
-                    $out[$prev_category][] = $upper;
-                    continue 2;
-                }
-                $token_category = $upper;
-                break;
+                case 'EVENT':
+                # issue 71
+                    if ($prev_category === 'DROP' || $prev_category === 'ALTER' || $prev_category === 'CREATE') {
+                        $token_category = $upper;
+                    }
+                    break;
 
-            case 'USER':
-            # prevent wrong processing as keyword
-                if ($prev_category === 'CREATE' || $prev_category === 'RENAME' || $prev_category === 'DROP') {
-                    $token_category = $upper;
-                }
-                break;
+                case 'DATA':
+                # prevent wrong handling of DATA as keyword
+                    if ($prev_category === 'LOAD') {
+                        $token_category = $upper;
+                    }
+                    break;
 
-            case 'VIEW':
-            # prevent wrong processing as keyword
-                if ($prev_category === 'CREATE' || $prev_category === 'ALTER' || $prev_category === 'DROP') {
+                case 'INTO':
+                # prevent wrong handling of CACHE within LOAD INDEX INTO CACHE...
+                    if ($prev_category === 'LOAD') {
+                        $out[$prev_category][] = $upper;
+                        continue 2;
+                    }
                     $token_category = $upper;
-                }
-                break;
+                    break;
 
-            /* These tokens get their own section, but have no subclauses.
+                case 'USER':
+                # prevent wrong processing as keyword
+                    if ($prev_category === 'CREATE' || $prev_category === 'RENAME' || $prev_category === 'DROP') {
+                        $token_category = $upper;
+                    }
+                    break;
+
+                case 'VIEW':
+                # prevent wrong processing as keyword
+                    if ($prev_category === 'CREATE' || $prev_category === 'ALTER' || $prev_category === 'DROP') {
+                        $token_category = $upper;
+                    }
+                    break;
+
+                /* These tokens get their own section, but have no subclauses.
              These tokens identify the statement but have no specific subclauses of their own. */
-            case 'DELETE':
-            case 'ALTER':
-            case 'INSERT':
-            case 'REPLACE':
-            case 'TRUNCATE':
-            case 'CREATE':
-            case 'TRUNCATE':
-            case 'OPTIMIZE':
-            case 'GRANT':
-            case 'REVOKE':
-            case 'SHOW':
-            case 'HANDLER':
-            case 'LOAD':
-            case 'ROLLBACK':
-            case 'SAVEPOINT':
-            case 'UNLOCK':
-            case 'INSTALL':
-            case 'UNINSTALL':
-            case 'ANALZYE':
-            case 'BACKUP':
-            case 'CHECK':
-            case 'CHECKSUM':
-            case 'REPAIR':
-            case 'RESTORE':
-            case 'DESCRIBE':
-            case 'EXPLAIN':
-            case 'USE':
-            case 'HELP':
-                $token_category = $upper; /* set the category in case these get subclauses
+                case 'DELETE':
+                case 'ALTER':
+                case 'INSERT':
+                case 'REPLACE':
+                case 'TRUNCATE':
+                case 'CREATE':
+                case 'TRUNCATE':
+                case 'OPTIMIZE':
+                case 'GRANT':
+                case 'REVOKE':
+                case 'SHOW':
+                case 'HANDLER':
+                case 'LOAD':
+                case 'ROLLBACK':
+                case 'SAVEPOINT':
+                case 'UNLOCK':
+                case 'INSTALL':
+                case 'UNINSTALL':
+                case 'ANALZYE':
+                case 'BACKUP':
+                case 'CHECK':
+                case 'CHECKSUM':
+                case 'REPAIR':
+                case 'RESTORE':
+                case 'DESCRIBE':
+                case 'EXPLAIN':
+                case 'USE':
+                case 'HELP':
+                    $token_category = $upper; /* set the category in case these get subclauses
                                           in a future version of MySQL */
-                $out[$upper][0] = $upper;
-                continue 2;
-                break;
-
-            case 'CACHE':
-                if ($prev_category === '' || $prev_category === 'RESET' || $prev_category === 'FLUSH'
-                        || $prev_category === 'LOAD') {
-                    $token_category = $upper;
+                    $out[$upper][0] = $upper;
                     continue 2;
-                }
-                break;
+                    break;
 
-            /* This is either LOCK TABLES or SELECT ... LOCK IN SHARE MODE*/
-            case 'LOCK':
-                if ($token_category === '') {
-                    $token_category = $upper;
-                    $out[$upper][0] = $upper;
-                } else {
-                    $trim = 'LOCK IN SHARE MODE';
-                    $skip_next = true;
-                    $out['OPTIONS'][] = $trim;
-                }
-                continue 2;
-                break;
+                case 'CACHE':
+                    if ($prev_category === '' || $prev_category === 'RESET' || $prev_category === 'FLUSH'
+                            || $prev_category === 'LOAD') {
+                        $token_category = $upper;
+                        continue 2;
+                    }
+                    break;
 
-            case 'USING': /* USING in FROM clause is different from USING w/ prepared statement*/
-                if ($token_category === 'EXECUTE') {
-                    $token_category = $upper;
-                    continue 2;
-                }
-                if ($token_category === 'FROM' && !empty($out['DELETE'])) {
-                    $token_category = $upper;
+                /* This is either LOCK TABLES or SELECT ... LOCK IN SHARE MODE*/
+                case 'LOCK':
+                    if ($token_category === '') {
+                        $token_category = $upper;
+                        $out[$upper][0] = $upper;
+                    } else {
+                        $trim = 'LOCK IN SHARE MODE';
+                        $skip_next = true;
+                        $out['OPTIONS'][] = $trim;
+                    }
                     continue 2;
-                }
-                break;
+                    break;
 
-            /* DROP TABLE is different from ALTER TABLE DROP ... */
-            case 'DROP':
-                if ($token_category !== 'ALTER') {
-                    $token_category = $upper;
-                    continue 2;
-                }
-                break;
+                case 'USING': /* USING in FROM clause is different from USING w/ prepared statement*/
+                    if ($token_category === 'EXECUTE') {
+                        $token_category = $upper;
+                        continue 2;
+                    }
+                    if ($token_category === 'FROM' && !empty($out['DELETE'])) {
+                        $token_category = $upper;
+                        continue 2;
+                    }
+                    break;
 
-            case 'FOR':
-                $skip_next = true;
-                $out['OPTIONS'][] = 'FOR UPDATE';
-                continue 2;
-                break;
+                /* DROP TABLE is different from ALTER TABLE DROP ... */
+                case 'DROP':
+                    if ($token_category !== 'ALTER') {
+                        $token_category = $upper;
+                        continue 2;
+                    }
+                    break;
 
-            case 'UPDATE':
-                if ($token_category === '') {
-                    $token_category = $upper;
-                    continue 2;
-                }
-                if ($token_category === 'DUPLICATE') {
+                case 'FOR':
+                    $skip_next = true;
+                    $out['OPTIONS'][] = 'FOR UPDATE';
                     continue 2;
-                }
-                break;
+                    break;
 
-            case 'START':
-                $trim = 'BEGIN';
-                $out[$upper][0] = $upper;
-                $skip_next = true;
-                break;
+                case 'UPDATE':
+                    if ($token_category === '') {
+                        $token_category = $upper;
+                        continue 2;
+                    }
+                    if ($token_category === 'DUPLICATE') {
+                        continue 2;
+                    }
+                    break;
 
-            /* These tokens are ignored. */
-            case 'BY':
-            case 'ALL':
-            case 'SHARE':
-            case 'MODE':
-            case 'TO':
-            case ';':
-                continue 2;
-                break;
+                case 'START':
+                    $trim = 'BEGIN';
+                    $out[$upper][0] = $upper;
+                    $skip_next = true;
+                    break;
 
-            case 'KEY':
-                if ($token_category === 'DUPLICATE') {
+                /* These tokens are ignored. */
+                case 'BY':
+                case 'ALL':
+                case 'SHARE':
+                case 'MODE':
+                case 'TO':
+                case ';':
                     continue 2;
-                }
-                break;
+                    break;
 
-            /* These tokens set particular options for the statement.  They never stand alone.*/
-            case 'DISTINCTROW':
-                $trim = 'DISTINCT';
-            case 'DISTINCT':
-            case 'HIGH_PRIORITY':
-            case 'LOW_PRIORITY':
-            case 'DELAYED':
-            case 'IGNORE':
-            case 'FORCE':
-            case 'STRAIGHT_JOIN':
-            case 'SQL_SMALL_RESULT':
-            case 'SQL_BIG_RESULT':
-            case 'QUICK':
-            case 'SQL_BUFFER_RESULT':
-            case 'SQL_CACHE':
-            case 'SQL_NO_CACHE':
-            case 'SQL_CALC_FOUND_ROWS':
-                $out['OPTIONS'][] = $upper;
-                continue 2;
-                break;
+                case 'KEY':
+                    if ($token_category === 'DUPLICATE') {
+                        continue 2;
+                    }
+                    break;
 
-            case 'WITH':
-                if ($token_category === 'GROUP') {
-                    $skip_next = true;
-                    $out['OPTIONS'][] = 'WITH ROLLUP';
+                /* These tokens set particular options for the statement.  They never stand alone.*/
+                case 'DISTINCTROW':
+                    $trim = 'DISTINCT';
+                case 'DISTINCT':
+                case 'HIGH_PRIORITY':
+                case 'LOW_PRIORITY':
+                case 'DELAYED':
+                case 'IGNORE':
+                case 'FORCE':
+                case 'STRAIGHT_JOIN':
+                case 'SQL_SMALL_RESULT':
+                case 'SQL_BIG_RESULT':
+                case 'QUICK':
+                case 'SQL_BUFFER_RESULT':
+                case 'SQL_CACHE':
+                case 'SQL_NO_CACHE':
+                case 'SQL_CALC_FOUND_ROWS':
+                    $out['OPTIONS'][] = $upper;
                     continue 2;
-                }
-                break;
+                    break;
 
-            case 'AS':
-                break;
+                case 'WITH':
+                    if ($token_category === 'GROUP') {
+                        $skip_next = true;
+                        $out['OPTIONS'][] = 'WITH ROLLUP';
+                        continue 2;
+                    }
+                    break;
 
-            case '':
-            case ',':
-            case ';':
-                break;
+                case 'AS':
+                    break;
 
-            default:
-                break;
+                case '':
+                case ',':
+                case ';':
+                    break;
+
+                default:
+                    break;
             }
 
             # remove obsolete category after union (empty category because of
@@ -584,16 +584,16 @@ 
         $type = substr($expression, 2, strpos($expression, '.', 2));
 
         switch ($type) {
-        case 'GLOBAL':
-            $type = ExpressionType::GLOBAL_VARIABLE;
-            break;
-        case 'LOCAL':
-            $type = ExpressionType::LOCAL_VARIABLE;
-            break;
-        case 'SESSION':
-        default:
-            $type = ExpressionType::SESSION_VARIABLE;
-            break;
+            case 'GLOBAL':
+                $type = ExpressionType::GLOBAL_VARIABLE;
+                break;
+            case 'LOCAL':
+                $type = ExpressionType::LOCAL_VARIABLE;
+                break;
+            case 'SESSION':
+            default:
+                $type = ExpressionType::SESSION_VARIABLE;
+                break;
         }
 
         return $type;
@@ -613,27 +613,27 @@ 
             $upper = strtoupper(trim($token));
 
             switch ($upper) {
-            case 'LOCAL':
-            case 'SESSION':
-            case 'GLOBAL':
-                if (!$isUpdate) {
-                    $varType = $this->getVariableType('@@'.$upper.'.');
+                case 'LOCAL':
+                case 'SESSION':
+                case 'GLOBAL':
+                    if (!$isUpdate) {
+                        $varType = $this->getVariableType('@@'.$upper.'.');
+                        $baseExpr = '';
+                        continue 2;
+                    }
+                    break;
+
+                case ',':
+                    $assignment = $this->getAssignment($baseExpr);
+                    if (!$isUpdate && $varType !== false) {
+                        $assignment['sub_tree'][0]['expr_type'] = $varType;
+                    }
+                    $result[] = $assignment;
                     $baseExpr = '';
+                    $varType = false;
                     continue 2;
-                }
-                break;
-
-            case ',':
-                $assignment = $this->getAssignment($baseExpr);
-                if (!$isUpdate && $varType !== false) {
-                    $assignment['sub_tree'][0]['expr_type'] = $varType;
-                }
-                $result[] = $assignment;
-                $baseExpr = '';
-                $varType = false;
-                continue 2;
 
-            default:
+                default:
             }
             $baseExpr .= $token;
         }
@@ -901,101 +901,101 @@ 
             }
 
             switch ($upper) {
-            case 'OUTER':
-            case 'LEFT':
-            case 'RIGHT':
-            case 'NATURAL':
-            case 'CROSS':
-            case ',':
-            case 'JOIN':
-            case 'INNER':
-                break;
+                case 'OUTER':
+                case 'LEFT':
+                case 'RIGHT':
+                case 'NATURAL':
+                case 'CROSS':
+                case ',':
+                case 'JOIN':
+                case 'INNER':
+                    break;
 
-            default:
-                $parseInfo['expression'] .= $token;
-                if ($parseInfo['ref_type'] !== false) { # all after ON / USING
-                    $parseInfo['ref_expr'] .= $token;
-                }
-                break;
+                default:
+                    $parseInfo['expression'] .= $token;
+                    if ($parseInfo['ref_type'] !== false) { # all after ON / USING
+                        $parseInfo['ref_expr'] .= $token;
+                    }
+                    break;
             }
 
             switch ($upper) {
-            case 'AS':
-                $parseInfo['alias'] = array('as' => true, 'name' => '', 'base_expr' => $token);
-                ++$parseInfo['token_count'];
-                $n = 1;
-                $str = '';
-                while ($str == '') {
-                    $parseInfo['alias']['base_expr'] .= ($tokens[$i + $n] === '' ? ' ' : $tokens[$i + $n]);
-                    $str = trim($tokens[$i + $n]);
-                    ++$n;
-                }
-                $parseInfo['alias']['name'] = $str;
-                $parseInfo['alias']['base_expr'] = trim($parseInfo['alias']['base_expr']);
-                continue;
+                case 'AS':
+                    $parseInfo['alias'] = array('as' => true, 'name' => '', 'base_expr' => $token);
+                    ++$parseInfo['token_count'];
+                    $n = 1;
+                    $str = '';
+                    while ($str == '') {
+                        $parseInfo['alias']['base_expr'] .= ($tokens[$i + $n] === '' ? ' ' : $tokens[$i + $n]);
+                        $str = trim($tokens[$i + $n]);
+                        ++$n;
+                    }
+                    $parseInfo['alias']['name'] = $str;
+                    $parseInfo['alias']['base_expr'] = trim($parseInfo['alias']['base_expr']);
+                    continue;
 
-            case 'INDEX':
-                if ($token_category == 'CREATE') {
-                    $token_category = $upper;
-                    continue 2;
-                }
+                case 'INDEX':
+                    if ($token_category == 'CREATE') {
+                        $token_category = $upper;
+                        continue 2;
+                    }
 
-                break;
+                    break;
 
-            case 'USING':
-            case 'ON':
-                $parseInfo['ref_type'] = $upper;
-                $parseInfo['ref_expr'] = '';
-
-            case 'CROSS':
-            case 'USE':
-            case 'FORCE':
-            case 'IGNORE':
-            case 'INNER':
-            case 'OUTER':
-                $parseInfo['token_count']++;
-                continue;
-                break;
+                case 'USING':
+                case 'ON':
+                    $parseInfo['ref_type'] = $upper;
+                    $parseInfo['ref_expr'] = '';
+
+                case 'CROSS':
+                case 'USE':
+                case 'FORCE':
+                case 'IGNORE':
+                case 'INNER':
+                case 'OUTER':
+                    $parseInfo['token_count']++;
+                    continue;
+                    break;
 
-            case 'FOR':
-                $parseInfo['token_count']++;
-                $skip_next = true;
-                continue;
-                break;
+                case 'FOR':
+                    $parseInfo['token_count']++;
+                    $skip_next = true;
+                    continue;
+                    break;
 
-            case 'LEFT':
-            case 'RIGHT':
-            case 'STRAIGHT_JOIN':
-                $parseInfo['next_join_type'] = $upper;
-                break;
+                case 'LEFT':
+                case 'RIGHT':
+                case 'STRAIGHT_JOIN':
+                    $parseInfo['next_join_type'] = $upper;
+                    break;
 
-            case ',':
-                $parseInfo['next_join_type'] = 'CROSS';
+                case ',':
+                    $parseInfo['next_join_type'] = 'CROSS';
 
-            case 'JOIN':
-                if ($parseInfo['subquery']) {
-                    $parseInfo['sub_tree'] = $this->parse($this->removeParenthesisFromStart($parseInfo['subquery']));
-                    $parseInfo['expression'] = $parseInfo['subquery'];
-                }
+                case 'JOIN':
+                    if ($parseInfo['subquery']) {
+                        $parseInfo['sub_tree'] = $this->parse($this->removeParenthesisFromStart($parseInfo['subquery']));
+                        $parseInfo['expression'] = $parseInfo['subquery'];
+                    }
 
-                $expr[] = $this->processFromExpression($parseInfo);
-                $parseInfo = $this->initParseInfoForFrom($parseInfo);
-                break;
+                    $expr[] = $this->processFromExpression($parseInfo);
+                    $parseInfo = $this->initParseInfoForFrom($parseInfo);
+                    break;
 
-            default:
-                if ($upper === '') {
-                    continue; # ends the switch statement!
-                }
+                default:
+                    if ($upper === '') {
+                        continue; # ends the switch statement!
+                    }
 
-                if ($parseInfo['token_count'] === 0) {
-                    if ($parseInfo['table'] === '') {
-                        $parseInfo['table'] = $token;
+                    if ($parseInfo['token_count'] === 0) {
+                        if ($parseInfo['table'] === '') {
+                            $parseInfo['table'] = $token;
+                        }
+                    } elseif ($parseInfo['token_count'] === 1) {
+                        $parseInfo['alias'] = array('as' => false, 'name' => trim($token), 'base_expr' => trim($token));
                     }
-                } elseif ($parseInfo['token_count'] === 1) {
-                    $parseInfo['alias'] = array('as' => false, 'name' => trim($token), 'base_expr' => trim($token));
-                }
-                ++$parseInfo['token_count'];
-                break;
+                    ++$parseInfo['token_count'];
+                    break;
             }
             ++$i;
         }
@@ -1122,21 +1122,21 @@ 
         foreach ($tokens as $token) {
             $upper = strtoupper(trim($token));
             switch ($upper) {
-            case ',':
-                $out[] = $this->processOrderExpression($parseInfo, $select);
-                $parseInfo = $this->initParseInfoForOrder();
-                break;
+                case ',':
+                    $out[] = $this->processOrderExpression($parseInfo, $select);
+                    $parseInfo = $this->initParseInfoForOrder();
+                    break;
 
-            case 'DESC':
-                $parseInfo['dir'] = 'DESC';
-                break;
+                case 'DESC':
+                    $parseInfo['dir'] = 'DESC';
+                    break;
 
-            case 'ASC':
-                $parseInfo['dir'] = 'ASC';
-                break;
+                case 'ASC':
+                    $parseInfo['dir'] = 'ASC';
+                    break;
 
-            default:
-                $parseInfo['expr'] .= $token;
+                default:
+                    $parseInfo['expr'] .= $token;
 
             }
         }
@@ -1161,15 +1161,15 @@ 
         foreach ($tokens as $token) {
             $trim = strtoupper(trim($token));
             switch ($trim) {
-            case ',':
-                $parsed = $this->processOrderExpression($parseInfo, $select);
-                unset($parsed['direction']);
+                case ',':
+                    $parsed = $this->processOrderExpression($parseInfo, $select);
+                    unset($parsed['direction']);
 
-                $out[] = $parsed;
-                $parseInfo = $this->initParseInfoForOrder();
-                break;
-            default:
-                $parseInfo['expr'] .= $token;
+                    $out[] = $parsed;
+                    $parseInfo = $this->initParseInfoForOrder();
+                    break;
+                default:
+                    $parseInfo['expr'] .= $token;
 
             }
         }
@@ -1229,14 +1229,14 @@ 
                     foreach ($localTokenList as $k => $v) {
                         $tmpToken = new ExpressionToken($k, $v);
                         switch ($tmpToken->getUpper()) {
-                        case 'WITH':
-                            $match_mode = 'WITH QUERY EXPANSION';
-                            break;
-                        case 'IN':
-                            $match_mode = 'IN BOOLEAN MODE';
-                            break;
-
-                        default:
+                            case 'WITH':
+                                $match_mode = 'WITH QUERY EXPANSION';
+                                break;
+                            case 'IN':
+                                $match_mode = 'IN BOOLEAN MODE';
+                                break;
+
+                            default:
                         }
 
                         if ($match_mode !== false) {
@@ -1291,117 +1291,117 @@ 
                 /* it is either an operator, a colref or a constant */
                 switch ($curr->getUpper()) {
 
-                case '*':
-                    $curr->setSubTree(false); #no subtree
-
-                    # single or first element of expression list -> all-column-alias
-                    if (empty($resultList)) {
-                        $curr->setTokenType(ExpressionType::COLREF);
-                        break;
-                    }
-
-                    # if the last token is colref, const or expression
-                    # then * is an operator
-                    # but if the previous colref ends with a dot, the * is the all-columns-alias
-                    if (!$prev->isColumnReference() && !$prev->isConstant() && !$prev->isExpression()
-                            && !$prev->isBracketExpression()) {
-                        $curr->setTokenType(ExpressionType::COLREF);
-                        break;
-                    }
-
-                    if ($prev->isColumnReference() && $prev->endsWith('.')) {
-                        $prev->addToken('*'); # tablealias dot *
-                        continue 2; # skip the current token
-                    }
-
-                    $curr->setTokenType(ExpressionType::OPERATOR);
-                    break;
+                    case '*':
+                        $curr->setSubTree(false); #no subtree
 
-                case 'AND':
-                case '&&':
-                case 'BETWEEN':
-                case 'AND':
-                case 'BINARY':
-                case '&':
-                case '~':
-                case '|':
-                case '^':
-                case 'DIV':
-                case '/':
-                case '<=>':
-                case '=':
-                case '>=':
-                case '>':
-                case 'IS':
-                case 'NOT':
-                case '<<':
-                case '<=':
-                case '<':
-                case 'LIKE':
-                case '%':
-                case '!=':
-                case '<>':
-                case 'REGEXP':
-                case '!':
-                case '||':
-                case 'OR':
-                case '>>':
-                case 'RLIKE':
-                case 'SOUNDS':
-                case 'XOR':
-                case 'IN':
-                    $curr->setSubTree(false);
-                    $curr->setTokenType(ExpressionType::OPERATOR);
-                    break;
+                        # single or first element of expression list -> all-column-alias
+                        if (empty($resultList)) {
+                            $curr->setTokenType(ExpressionType::COLREF);
+                            break;
+                        }
 
-                case 'NULL':
-                    $curr->setSubTree(false);
-                    $curr->setTokenType(ExpressionType::CONSTANT);
-                    break;
+                        # if the last token is colref, const or expression
+                        # then * is an operator
+                        # but if the previous colref ends with a dot, the * is the all-columns-alias
+                        if (!$prev->isColumnReference() && !$prev->isConstant() && !$prev->isExpression()
+                                && !$prev->isBracketExpression()) {
+                            $curr->setTokenType(ExpressionType::COLREF);
+                            break;
+                        }
 
-                case '-':
-                case '+':
-                // differ between preceding sign and operator
-                    $curr->setSubTree(false);
+                        if ($prev->isColumnReference() && $prev->endsWith('.')) {
+                            $prev->addToken('*'); # tablealias dot *
+                            continue 2; # skip the current token
+                        }
 
-                    if ($prev->isColumnReference() || $prev->isFunction() || $prev->isAggregateFunction()
-                            || $prev->isConstant() || $prev->isSubQuery() || $prev->isExpression()
-                            || $prev->isBracketExpression()) {
                         $curr->setTokenType(ExpressionType::OPERATOR);
-                    } else {
-                        $curr->setTokenType(ExpressionType::SIGN);
-                    }
-                    break;
+                        break;
 
-                default:
-                    $curr->setSubTree(false);
+                    case 'AND':
+                    case '&&':
+                    case 'BETWEEN':
+                    case 'AND':
+                    case 'BINARY':
+                    case '&':
+                    case '~':
+                    case '|':
+                    case '^':
+                    case 'DIV':
+                    case '/':
+                    case '<=>':
+                    case '=':
+                    case '>=':
+                    case '>':
+                    case 'IS':
+                    case 'NOT':
+                    case '<<':
+                    case '<=':
+                    case '<':
+                    case 'LIKE':
+                    case '%':
+                    case '!=':
+                    case '<>':
+                    case 'REGEXP':
+                    case '!':
+                    case '||':
+                    case 'OR':
+                    case '>>':
+                    case 'RLIKE':
+                    case 'SOUNDS':
+                    case 'XOR':
+                    case 'IN':
+                        $curr->setSubTree(false);
+                        $curr->setTokenType(ExpressionType::OPERATOR);
+                        break;
 
-                    switch ($curr->getToken(0)) {
-                    case "'":
-                    case '"':
-                    # it is a string literal
+                    case 'NULL':
+                        $curr->setSubTree(false);
                         $curr->setTokenType(ExpressionType::CONSTANT);
                         break;
-                    case '`':
-                    # it is an escaped colum name
-                        $curr->setTokenType(ExpressionType::COLREF);
+
+                    case '-':
+                    case '+':
+                    // differ between preceding sign and operator
+                        $curr->setSubTree(false);
+
+                        if ($prev->isColumnReference() || $prev->isFunction() || $prev->isAggregateFunction()
+                                || $prev->isConstant() || $prev->isSubQuery() || $prev->isExpression()
+                                || $prev->isBracketExpression()) {
+                            $curr->setTokenType(ExpressionType::OPERATOR);
+                        } else {
+                            $curr->setTokenType(ExpressionType::SIGN);
+                        }
                         break;
 
                     default:
-                        if (is_numeric($curr->getToken())) {
-                            if ($prev->isSign()) {
-                                $prev->addToken($curr->getToken()); # it is a negative numeric constant
-                                $prev->setTokenType(ExpressionType::CONSTANT);
-                                continue 3;
-                                # skip current token
-                            } else {
+                        $curr->setSubTree(false);
+
+                        switch ($curr->getToken(0)) {
+                            case "'":
+                            case '"':
+                            # it is a string literal
                                 $curr->setTokenType(ExpressionType::CONSTANT);
-                            }
-                        } else {
-                            $curr->setTokenType(ExpressionType::COLREF);
+                                break;
+                            case '`':
+                            # it is an escaped colum name
+                                $curr->setTokenType(ExpressionType::COLREF);
+                                break;
+
+                            default:
+                                if (is_numeric($curr->getToken())) {
+                                    if ($prev->isSign()) {
+                                        $prev->addToken($curr->getToken()); # it is a negative numeric constant
+                                        $prev->setTokenType(ExpressionType::CONSTANT);
+                                        continue 3;
+                                        # skip current token
+                                    } else {
+                                        $curr->setTokenType(ExpressionType::CONSTANT);
+                                    }
+                                } else {
+                                    $curr->setTokenType(ExpressionType::COLREF);
+                                }
+                                break;
                         }
-                        break;
-                    }
                 }
             }
 
@@ -1607,35 +1607,35 @@ 
             }
 
             switch ($token->getUpper()) {
-            case 'VIEW':
-            case 'SCHEMA':
-            case 'DATABASE':
-            case 'TABLE':
-                $expr_type = strtolower($token->getTrim());
-                break;
+                case 'VIEW':
+                case 'SCHEMA':
+                case 'DATABASE':
+                case 'TABLE':
+                    $expr_type = strtolower($token->getTrim());
+                    break;
 
-            case 'IF':
-                $warning = false;
-                $skip = true;
-                break;
+                case 'IF':
+                    $warning = false;
+                    $skip = true;
+                    break;
 
-            case 'TEMPORARY':
-                $expr_type = ExpressionType::TEMPORARY_TABLE;
-                $skip = true;
-                break;
+                case 'TEMPORARY':
+                    $expr_type = ExpressionType::TEMPORARY_TABLE;
+                    $skip = true;
+                    break;
 
-            case 'RESTRICT':
-            case 'CASCADE':
-                $option = $token->getUpper();
-                break;
+                case 'RESTRICT':
+                case 'CASCADE':
+                    $option = $token->getUpper();
+                    break;
 
-            case ',':
-                $resultList[] = array('expr_type' => $expr_type, 'base_expr' => $base_expr);
-                $base_expr = '';
-                break;
+                case ',':
+                    $resultList[] = array('expr_type' => $expr_type, 'base_expr' => $base_expr);
+                    $base_expr = '';
+                    break;
 
-            default:
-                $base_expr .= $token->getToken();
+                default:
+                    $base_expr .= $token->getToken();
             }
         }
 

Spacing +8 added lines, -8 removed lines

@@ -571,7 +571,7 @@ 
         $assignment = $this->process_expr_list($this->splitSQLIntoTokens($base_expr));
 
         return array('expr_type' => ExpressionType::EXPRESSION, 'base_expr' => trim($base_expr),
-                     'sub_tree' => $assignment, );
+                     'sub_tree' => $assignment,);
     }
 
     private function getVariableType($expression)
@@ -692,8 +692,8 @@ 
         }
 
         return [
-            ['expr_type' => 'limit_const', 'base_expr' => trim($offset), 'sub_tree' => false ],
-            ['expr_type' => 'limit_const', 'base_expr' => trim($rowcount), 'sub_tree' => false ]
+            ['expr_type' => 'limit_const', 'base_expr' => trim($offset), 'sub_tree' => false],
+            ['expr_type' => 'limit_const', 'base_expr' => trim($rowcount), 'sub_tree' => false]
         ];
     }
 
@@ -846,7 +846,7 @@ 
                     || $this->isFunction($prev) || $this->isExpression($prev) || $this->isSubQuery($prev)
                     || $this->isColumnReference($prev) || $this->isBracketExpression($prev)) {
                 $alias = array('as' => false, 'name' => trim($last['base_expr']),
-                               'base_expr' => trim($last['base_expr']), );
+                               'base_expr' => trim($last['base_expr']),);
                 #remove the last token
                 array_pop($tokens);
                 $base_expr = implode('', $tokens);
@@ -876,7 +876,7 @@ 
         }
 
         return array('expr_type' => $type, 'alias' => $alias, 'base_expr' => trim($base_expr),
-                     'sub_tree' => $processed, );
+                     'sub_tree' => $processed,);
     }
 
     /**
@@ -1018,7 +1018,7 @@ 
         return array('expression' => '', 'token_count' => 0, 'table' => '', 'alias' => false, 'join_type' => '',
                      'next_join_type' => '', 'saved_join_type' => $parseInfo['saved_join_type'],
                      'ref_type' => false, 'ref_expr' => false, 'base_expr' => false, 'sub_tree' => false,
-                     'subquery' => '', );
+                     'subquery' => '',);
     }
 
     private function processFromExpression(&$parseInfo)
@@ -1102,7 +1102,7 @@ 
         }
 
         return array('expr_type' => $parseInfo['type'], 'base_expr' => $parseInfo['expr'],
-                     'direction' => $parseInfo['dir'], );
+                     'direction' => $parseInfo['dir'],);
     }
 
     private function initParseInfoForOrder()
@@ -1562,7 +1562,7 @@ 
                 unset($values[$k]);
             } else {
                 $values[$k] = array('expr_type' => ExpressionType::RECORD, 'base_expr' => $v,
-                                    'data' => $this->process_record($v), );
+                                    'data' => $this->process_record($v),);
             }
         }