RDatabaseSqlparserSqlparser::processSQL()

Complexity

Conditions	134
Paths	1389

Size

Total Lines	314
Code Lines	199

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
	private function processSQL(&$tokens)
	{
		$prev_category  = "";
		$token_category = "";
		$skip_next      = false;
		$out            = false;

		$tokenCount = count($tokens);

		for ($tokenNumber = 0; $tokenNumber < $tokenCount; ++$tokenNumber)
		{
			$token = $tokens[$tokenNumber];
			$trim  = trim($token); // this removes also \n and \t!

			// if it starts with an "(", it should follow a SELECT
			if ($trim !== "" && $trim[0] == "(" && $token_category == "")
			{
				$token_category = 'SELECT';
			}

			/* If it isn't obvious, when $skip_next is set, then we ignore the next real
			 token, that is we ignore whitespace.
			 */
			if ($skip_next)
			{
				if ($trim === "")
				{
					if ($token_category !== "")
					{ // is this correct??
						$out[$token_category][] = $token;
					}
					continue;
				}
				// to skip the token we replace it with whitespace
				$trim      = "";
				$token     = "";
				$skip_next = false;
			}

			$upper = strtoupper($trim);
			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 'DATABASE':
				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 'EVENT':
					// issue 71
					if ($prev_category === 'DROP' || $prev_category === 'ALTER' || $prev_category === 'CREATE')
					{
						$token_category = $upper;
					}
					break;

				case 'DATA':
					// prevent wrong handling of DATA as keyword
					if ($prev_category === 'LOAD')
					{
						$token_category = $upper;
					}
					break;

				case 'PASSWORD':
					// prevent wrong handling of PASSWORD as keyword
					if ($prev_category === 'SET')
					{
						$token_category = $upper;
					}
					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 '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 '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':
					// We are using USE from FROM statement, not separate token category
					if ($prev_category == 'FROM')
					{
						break;
					}
					$token_category = $upper; /* set the category in case these get subclauses
										  in a future version of MySQL */
					$out[$upper][0] = $upper;
					continue 2;

				case 'CACHE':
					if ($prev_category === "" || $prev_category === 'RESET' || $prev_category === 'FLUSH'
						|| $prev_category === 'LOAD')
					{
						$token_category = $upper;
						continue 2;
					}
					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;

				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;

				/* DROP TABLE is different from ALTER TABLE DROP ... */
				case 'DROP':
					if ($token_category !== 'ALTER')
					{
						$token_category = $upper;
						$out[$upper][0] = $upper;
						continue 2;
					}
					break;

				case 'FOR':
					$skip_next        = true;
					$out['OPTIONS'][] = 'FOR UPDATE';
					continue 2;

				case 'UPDATE':
					if ($token_category === "")
					{
						$token_category = $upper;
						continue 2;

					}
					if ($token_category === 'DUPLICATE')
					{
						continue 2;
					}
					break;

				/*case 'START':
					$trim = "BEGIN";
					$out[$upper][0] = $upper;
					$skip_next = true;
					break;*/

				/* These tokens are ignored. */
				case 'BY':
				case 'ALL':
				case 'SHARE':
				case 'MODE':
				case 'TO':
				case ';':
					continue 2;

				case 'KEY':
					if ($token_category === 'DUPLICATE')
					{
						continue 2;
					}
					break;

				/* These tokens set particular options for the statement.  They never stand alone.*/
				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;

				case 'WITH':
					if ($token_category === 'GROUP')
					{
						$skip_next        = true;
						$out['OPTIONS'][] = 'WITH ROLLUP';
						continue 2;
					}
					break;

				case 'AS':
					break;

				case '':
				case ',':
					//case ';':
					break;

				default:
					break;
			}

			// remove obsolete category after union (empty category because of
			// empty token before select)
			if ($token_category !== "" && ($prev_category === $token_category))
			{
				$out[$token_category][] = $token;
			}

			$prev_category = $token_category;
		}

		return $this->processSQLParts($out);

The expression return $this->processSQLParts($out) returns the type false which is incompatible with the documented return type void.

	}