redCOMPONENT-COM / redCORE

extensions/libraries/redcore/layouts/webservice/documentationoperation/example.php

Switch Indentation +33 added lines, -33 removed lines

@@ -31,39 +31,39 @@
 
 switch ($operationName)
 {
-	case 'create' :
-		$method = 'POST';
-		$errorList = array(201, 400, 404, 405, 406, 500);
-		break;
-	case 'read list' :
-		$method = 'GET';
-		$noteName = '_LIST';
-		$errorList = array(200, 405, 500);
-		break;
-	case 'read item' :
-		$fields = RApiHalHelper::getFieldsArray($operationXml, true, true);
-		$method = 'GET';
-		$noteName = '_ITEM';
-		$errorList = array(200, 404, 405, 500);
-
-		foreach ($fields as $primaryKey => $primaryKeyField)
-		{
-			$defaultValue = !empty($primaryKeyField['defaultValue']) ? $primaryKeyField['defaultValue'] : 1;
-			$basicUrl .= '&' . $primaryKey . '=' . $defaultValue;
-		}
-		break;
-	case 'update' :
-		$method = 'PUT';
-		$errorList = array(200, 400, 405, 406, 500);
-		break;
-	case 'delete' :
-		$method = 'DELETE';
-		$errorList = array(200, 400, 405, 406, 500);
-		break;
-	case 'task' :
-		$method = 'GET / POST';
-		$errorList = array(200, 400, 405, 406, 500);
-		break;
+		case 'create' :
+			$method = 'POST';
+			$errorList = array(201, 400, 404, 405, 406, 500);
+			break;
+		case 'read list' :
+			$method = 'GET';
+			$noteName = '_LIST';
+			$errorList = array(200, 405, 500);
+			break;
+		case 'read item' :
+			$fields = RApiHalHelper::getFieldsArray($operationXml, true, true);
+			$method = 'GET';
+			$noteName = '_ITEM';
+			$errorList = array(200, 404, 405, 500);
+
+			foreach ($fields as $primaryKey => $primaryKeyField)
+			{
+				$defaultValue = !empty($primaryKeyField['defaultValue']) ? $primaryKeyField['defaultValue'] : 1;
+				$basicUrl .= '&' . $primaryKey . '=' . $defaultValue;
+			}
+			break;
+		case 'update' :
+			$method = 'PUT';
+			$errorList = array(200, 400, 405, 406, 500);
+			break;
+		case 'delete' :
+			$method = 'DELETE';
+			$errorList = array(200, 400, 405, 406, 500);
+			break;
+		case 'task' :
+			$method = 'GET / POST';
+			$errorList = array(200, 400, 405, 406, 500);
+			break;
 }
 
 if (!$authorizationNotNeeded):

extensions/libraries/redcore/database/sqlparser/sqlcreator.php

Switch Indentation +19 added lines, -19 removed lines

@@ -51,25 +51,25 @@
 		$k = key($parsed);
 		switch ($k) {
 
-		case "UNION":
-		case "UNION ALL":
-			throw new Exception($k . " not implemented.", 20);
-			break;
-		case "SELECT":
-			$this->created = $this->processSelectStatement($parsed);
-			break;
-		case "INSERT":
-			$this->created = $this->processInsertStatement($parsed);
-			break;
-		case "DELETE":
-			$this->created = $this->processDeleteStatement($parsed);
-			break;
-		case "UPDATE":
-			$this->created = $this->processUpdateStatement($parsed);
-			break;
-		default:
-			throw new Exception($k . " not implemented.", 20);
-			break;
+			case "UNION":
+			case "UNION ALL":
+				throw new Exception($k . " not implemented.", 20);
+				break;
+			case "SELECT":
+				$this->created = $this->processSelectStatement($parsed);
+				break;
+			case "INSERT":
+				$this->created = $this->processInsertStatement($parsed);
+				break;
+			case "DELETE":
+				$this->created = $this->processDeleteStatement($parsed);
+				break;
+			case "UPDATE":
+				$this->created = $this->processUpdateStatement($parsed);
+				break;
+			default:
+				throw new Exception($k . " not implemented.", 20);
+				break;
 		}
 		return $this->created;
 	}

extensions/libraries/redcore/database/sqlparser/sqlparser.php

Switch Indentation +473 added lines, -473 removed lines

@@ -243,244 +243,244 @@ 
 			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 '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;
+					}
 
-			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') {
-					$token_category = $upper;
-				}
-				break;
+				case 'EVENT':
+					// issue 71
+					if ($prev_category === 'DROP' || $prev_category === 'ALTER' || $prev_category === 'CREATE') {
+						$token_category = $upper;
+					}
+					break;
 
-			case 'PASSWORD':
-				// prevent wrong handling of PASSWORD as keyword
-				if ($prev_category === 'SET') {
-					$token_category = $upper;
-				}
-				break;
+				case 'DATA':
+					// prevent wrong handling of DATA as keyword
+					if ($prev_category === 'LOAD') {
+						$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 'PASSWORD':
+					// prevent wrong handling of PASSWORD as keyword
+					if ($prev_category === 'SET') {
+						$token_category = $upper;
+					}
+					break;
 
-			case 'USER':
-				// prevent wrong processing as keyword
-				if ($prev_category === 'CREATE' || $prev_category === 'RENAME' || $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;
 
-			case 'VIEW':
-				// prevent wrong processing as keyword
-				if ($prev_category === 'CREATE' || $prev_category === 'ALTER' || $prev_category === 'DROP') {
-					$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 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')
-				{
-					continue;
-				}
-				$token_category = $upper; /* set the category in case these get subclauses
+				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')
+					{
+						continue;
+					}
+					$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;
+					$out[$upper][0] = $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 '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;
 
-			/* 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 '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;
+				/* 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 'UPDATE':
-				if ($token_category === "") {
-					$token_category = $upper;
+				case 'FOR':
+					$skip_next = true;
+					$out['OPTIONS'][] = 'FOR UPDATE';
 					continue 2;
 
-				}
-				if ($token_category === 'DUPLICATE') {
-					continue 2;
-				}
-				break;
+				case 'UPDATE':
+					if ($token_category === "") {
+						$token_category = $upper;
+						continue 2;
 
-			/*case 'START':
+					}
+					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') {
+				/* These tokens are ignored. */
+				case 'BY':
+				case 'ALL':
+				case 'SHARE':
+				case 'MODE':
+				case 'TO':
+				case ';':
 					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';
+				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;
-				}
-				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
@@ -570,14 +570,14 @@ 
 		$type = substr($expression, 2, strpos($expression, ".", 2));
 
 		switch ($type) {
-		case 'GLOBAL':
-		case 'LOCAL':
-		case 'SESSION':
-			$type = strtolower($type) . '_variable';
-			break;
-		default:
-			$type = 'session_variable';
-			break;
+			case 'GLOBAL':
+			case 'LOCAL':
+			case 'SESSION':
+				$type = strtolower($type) . '_variable';
+				break;
+			default:
+				$type = 'session_variable';
+				break;
 		}
 		return $type;
 	}
@@ -591,29 +591,29 @@ 
 			$upper = strtoupper(trim($token));
 
 			switch ($upper) {
-			case 'LOCAL':
-			case 'SESSION':
-			case 'GLOBAL':
-				if (!$isUpdate) {
-					$varType = strtolower($upper) . '_variable';
-					$baseExpr = "";
-					continue 2;
-				}
-				break;
+				case 'LOCAL':
+				case 'SESSION':
+				case 'GLOBAL':
+					if (!$isUpdate) {
+						$varType = strtolower($upper) . '_variable';
+						$baseExpr = "";
+						continue 2;
+					}
+					break;
 
-			case ',':
-				$assignment = $this->getAssignment($baseExpr);
-				if (!$isUpdate) {
-					if ($varType !== false) {
-						$assignment['sub_tree'][0]['expr_type'] = $varType;
+				case ',':
+					$assignment = $this->getAssignment($baseExpr);
+					if (!$isUpdate) {
+						if ($varType !== false) {
+							$assignment['sub_tree'][0]['expr_type'] = $varType;
+						}
 					}
-				}
-				$result[] = $assignment;
-				$baseExpr = "";
-				$varType = false;
-				continue 2;
+					$result[] = $assignment;
+					$baseExpr = "";
+					$varType = false;
+					continue 2;
 
-			default:
+				default:
 			}
 			$baseExpr .= $token;
 		}
@@ -867,122 +867,122 @@ 
 			}
 
 			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 'INDEX':
-				if (!empty($token_category) && $token_category == 'CREATE') {
-					$token_category = $upper;
-					continue 2;
-				}
+				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;
 
-				break;
+				case 'INDEX':
+					if (!empty($token_category) && $token_category == 'CREATE') {
+						$token_category = $upper;
+						continue 2;
+					}
 
-			case 'USING':
-			case 'ON':
-				$parseInfo['ref_type'] = $upper;
-				$parseInfo['ref_expr'] = "";
-				$parseInfo['token_count']++;
-				continue;
+					break;
 
-			case 'USE':
-			case 'FORCE':
-			case 'IGNORE':
-				$tableOptions = array('option' => $upper, 'name' => $upper, 'expr_type' => 'index_hints', 'base_expr' => $token);
-				$parseInfo['token_count']++;
-				$n = 1;
-				$tokenCount = count($token);
+				case 'USING':
+				case 'ON':
+					$parseInfo['ref_type'] = $upper;
+					$parseInfo['ref_expr'] = "";
+					$parseInfo['token_count']++;
+					continue;
 
-				while ($tokenCount < ($i + $n))
-				{
-					$tableOptions['base_expr'] .= ($tokens[$i + $n] === "" ? " " : $tokens[$i + $n]);
+				case 'USE':
+				case 'FORCE':
+				case 'IGNORE':
+					$tableOptions = array('option' => $upper, 'name' => $upper, 'expr_type' => 'index_hints', 'base_expr' => $token);
+					$parseInfo['token_count']++;
+					$n = 1;
+					$tokenCount = count($token);
 
-					if (strpos($tokens[$i + $n], ')') !== false)
+					while ($tokenCount < ($i + $n))
 					{
-						break;
-					}
+						$tableOptions['base_expr'] .= ($tokens[$i + $n] === "" ? " " : $tokens[$i + $n]);
 
-					++$n;
-				}
+						if (strpos($tokens[$i + $n], ')') !== false)
+						{
+							break;
+						}
 
-				$parseInfo['index_hints'] = $tableOptions;
-				continue;
-				break;
+						++$n;
+					}
 
-			case 'CROSS':
-			case 'INNER':
-			case 'OUTER':
-				$parseInfo['token_count']++;
-				continue;
+					$parseInfo['index_hints'] = $tableOptions;
+					continue;
+					break;
 
-			case 'FOR':
-				$parseInfo['token_count']++;
-				$skip_next = true;
-				continue;
+				case 'CROSS':
+				case 'INNER':
+				case 'OUTER':
+					$parseInfo['token_count']++;
+					continue;
 
-			case 'LEFT':
-			case 'RIGHT':
-			case 'STRAIGHT_JOIN':
-				$parseInfo['next_join_type'] = $upper;
-				break;
+				case 'FOR':
+					$parseInfo['token_count']++;
+					$skip_next = true;
+					continue;
 
-			case ',':
-				$parseInfo['next_join_type'] = 'CROSS';
+				case 'LEFT':
+				case 'RIGHT':
+				case 'STRAIGHT_JOIN':
+					$parseInfo['next_join_type'] = $upper;
+					break;
 
-			case 'JOIN':
-				if ($parseInfo['subquery']) {
-					$parseInfo['sub_tree'] = $this->parse($this->removeParenthesisFromStart($parseInfo['subquery']));
-					$parseInfo['expression'] = $parseInfo['subquery'];
-				}
+				case ',':
+					$parseInfo['next_join_type'] = 'CROSS';
 
-				$expr[] = $this->processFromExpression($parseInfo);
-				$parseInfo = $this->initParseInfoForFrom($parseInfo);
-				break;
+				case 'JOIN':
+					if ($parseInfo['subquery']) {
+						$parseInfo['sub_tree'] = $this->parse($this->removeParenthesisFromStart($parseInfo['subquery']));
+						$parseInfo['expression'] = $parseInfo['subquery'];
+					}
 
-			default:
-				if ($upper === "") {
-					continue; // ends the switch statement!
-				}
+					$expr[] = $this->processFromExpression($parseInfo);
+					$parseInfo = $this->initParseInfoForFrom($parseInfo);
+					break;
 
-				if ($parseInfo['token_count'] === 0) {
-					if ($parseInfo['table'] === "") {
-						$parseInfo['table'] = $token;
+				default:
+					if ($upper === "") {
+						continue; // ends the switch statement!
 					}
-				} else if ($parseInfo['token_count'] === 1) {
-					$parseInfo['alias'] = array('as' => false, 'name' => trim($token), 'base_expr' => trim($token));
-				}
-				$parseInfo['token_count']++;
-				break;
+
+					if ($parseInfo['token_count'] === 0) {
+						if ($parseInfo['table'] === "") {
+							$parseInfo['table'] = $token;
+						}
+					} else if ($parseInfo['token_count'] === 1) {
+						$parseInfo['alias'] = array('as' => false, 'name' => trim($token), 'base_expr' => trim($token));
+					}
+					$parseInfo['token_count']++;
+					break;
 			}
 			++$i;
 		}
@@ -1105,21 +1105,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;
 
 			}
 		}
@@ -1140,16 +1140,16 @@ 
 		foreach ($tokens as $token) {
 			$trim = strtoupper(trim($token));
 			switch ($trim) {
-			case ',':
-				$parsed = $this->processOrderExpression($parseInfo, $select, true);
-				unset($parsed['direction']);
+				case ',':
+					$parsed = $this->processOrderExpression($parseInfo, $select, true);
+					unset($parsed['direction']);
 
-				$out[] = $parsed;
-				$parseInfo = $this->initParseInfoForOrder();
-				break;
-			default:
-				$parseInfo['base_expr'] .= $token;
-				$parseInfo['expr'] .= $token;
+					$out[] = $parsed;
+					$parseInfo = $this->initParseInfoForOrder();
+					break;
+				default:
+					$parseInfo['base_expr'] .= $token;
+					$parseInfo['expr'] .= $token;
 			}
 		}
 
@@ -1311,116 +1311,116 @@ 
 				/* it is either an operator, a colref or a constant */
 				switch ($parseInfo['upper']) {
 
-				case '*':
-					$parseInfo['processed'] = false; // no subtree
-
-					// last token is colref, const or expression
-					// it is an operator, in all other cases it is an all-columns-alias
-					// if the previous colref ends with a dot, the * is the all-columns-alias
-					if (!is_array($parseInfo['expr'])) {
-						$parseInfo['tokenType'] = "colref"; // single or first element of select -> *
-						break;
-					}
-
-					$last = array_pop($parseInfo['expr']);
-					if ($last['expr_type'] !== 'colref' && $last['expr_type'] !== 'const'
-							&& $last['expr_type'] !== 'expression') {
-						$parseInfo['expr'][] = $last;
-						$parseInfo['tokenType'] = "colref";
-						break;
-					}
-
-					if ($last['expr_type'] === 'colref' && substr($last['base_expr'], -1, 1) === ".") {
-						$last['base_expr'] .= '*'; // tablealias dot *
-						$parseInfo['expr'][] = $last;
-						continue 2;
-					}
+					case '*':
+						$parseInfo['processed'] = false; // no subtree
 
-					$parseInfo['expr'][] = $last;
-					$parseInfo['tokenType'] = "operator";
-					break;
+						// last token is colref, const or expression
+						// it is an operator, in all other cases it is an all-columns-alias
+						// if the previous colref ends with a dot, the * is the all-columns-alias
+						if (!is_array($parseInfo['expr'])) {
+							$parseInfo['tokenType'] = "colref"; // single or first element of select -> *
+							break;
+						}
 
-				case 'AND':
-				case '&&':
-				case 'BETWEEN':
-				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':
-					$parseInfo['processed'] = false;
-					$parseInfo['tokenType'] = "operator";
-					break;
+						$last = array_pop($parseInfo['expr']);
+						if ($last['expr_type'] !== 'colref' && $last['expr_type'] !== 'const'
+								&& $last['expr_type'] !== 'expression') {
+							$parseInfo['expr'][] = $last;
+							$parseInfo['tokenType'] = "colref";
+							break;
+						}
 
-				case 'NULL':
-					$parseInfo['processed'] = false;
-					$parseInfo['tokenType'] = 'const';
-					break;
+						if ($last['expr_type'] === 'colref' && substr($last['base_expr'], -1, 1) === ".") {
+							$last['base_expr'] .= '*'; // tablealias dot *
+							$parseInfo['expr'][] = $last;
+							continue 2;
+						}
 
-				case '-':
-				case '+':
-				// differ between preceding sign and operator
-					$parseInfo['processed'] = false;
+						$parseInfo['expr'][] = $last;
+						$parseInfo['tokenType'] = "operator";
+						break;
 
-					if ($parseInfo['prevTokenType'] === 'colref' || $parseInfo['prevTokenType'] === 'function'
-							|| $parseInfo['prevTokenType'] === 'aggregate_function'
-							|| $parseInfo['prevTokenType'] === 'const'
-							|| $parseInfo['prevTokenType'] === 'subquery') {
+					case 'AND':
+					case '&&':
+					case 'BETWEEN':
+					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':
+						$parseInfo['processed'] = false;
 						$parseInfo['tokenType'] = "operator";
-					} else {
-						$parseInfo['tokenType'] = "sign";
-					}
-					break;
+						break;
 
-				default:
-					switch ($parseInfo['token'][0]) {
-					case "'":
-					case '"':
+					case 'NULL':
+						$parseInfo['processed'] = false;
 						$parseInfo['tokenType'] = 'const';
 						break;
-					case '`':
-						$parseInfo['tokenType'] = 'colref';
-						break;
 
-					default:
-						if (is_numeric($parseInfo['token'])) {
-							$parseInfo['tokenType'] = 'const';
-
-							if ($parseInfo['prevTokenType'] === 'sign') {
-								array_pop($parseInfo['expr']);
-								$parseInfo['token'] = $parseInfo['prevToken'] . $parseInfo['token'];
-							}
+					case '-':
+					case '+':
+					// differ between preceding sign and operator
+						$parseInfo['processed'] = false;
 
+						if ($parseInfo['prevTokenType'] === 'colref' || $parseInfo['prevTokenType'] === 'function'
+								|| $parseInfo['prevTokenType'] === 'aggregate_function'
+								|| $parseInfo['prevTokenType'] === 'const'
+								|| $parseInfo['prevTokenType'] === 'subquery') {
+							$parseInfo['tokenType'] = "operator";
 						} else {
-							$parseInfo['tokenType'] = 'colref';
+							$parseInfo['tokenType'] = "sign";
 						}
 						break;
 
-					}
+					default:
+						switch ($parseInfo['token'][0]) {
+							case "'":
+							case '"':
+								$parseInfo['tokenType'] = 'const';
+								break;
+							case '`':
+								$parseInfo['tokenType'] = 'colref';
+								break;
+
+							default:
+								if (is_numeric($parseInfo['token'])) {
+									$parseInfo['tokenType'] = 'const';
+
+									if ($parseInfo['prevTokenType'] === 'sign') {
+										array_pop($parseInfo['expr']);
+										$parseInfo['token'] = $parseInfo['prevToken'] . $parseInfo['token'];
+									}
+
+								} else {
+									$parseInfo['tokenType'] = 'colref';
+								}
+								break;
+
+						}
 					$parseInfo['processed'] = false;
 				}
 			}
@@ -1431,36 +1431,36 @@ 
 					&& in_array($parseInfo['upper'], parent::$reserved)) {
 
 				switch ($parseInfo['upper']) {
-				case 'AVG':
-				case 'SUM':
-				case 'COUNT':
-				case 'MIN':
-				case 'MAX':
-				case 'STDDEV':
-				case 'STDDEV_SAMP':
-				case 'STDDEV_POP':
-				case 'VARIANCE':
-				case 'VAR_SAMP':
-				case 'VAR_POP':
-				case 'GROUP_CONCAT':
-				case 'BIT_AND':
-				case 'BIT_OR':
-				case 'BIT_XOR':
-					$parseInfo['tokenType'] = 'aggregate_function';
-					break;
+					case 'AVG':
+					case 'SUM':
+					case 'COUNT':
+					case 'MIN':
+					case 'MAX':
+					case 'STDDEV':
+					case 'STDDEV_SAMP':
+					case 'STDDEV_POP':
+					case 'VARIANCE':
+					case 'VAR_SAMP':
+					case 'VAR_POP':
+					case 'GROUP_CONCAT':
+					case 'BIT_AND':
+					case 'BIT_OR':
+					case 'BIT_XOR':
+						$parseInfo['tokenType'] = 'aggregate_function';
+						break;
 
-				case 'NULL':
-				// it is a reserved word, but we would like to have set it as constant
-					$parseInfo['tokenType'] = 'const';
-					break;
+					case 'NULL':
+					// it is a reserved word, but we would like to have set it as constant
+						$parseInfo['tokenType'] = 'const';
+						break;
 
-				default:
-					if (in_array($parseInfo['upper'], parent::$functions)) {
-						$parseInfo['tokenType'] = 'function';
-					} else {
-						$parseInfo['tokenType'] = 'reserved';
-					}
-					break;
+					default:
+						if (in_array($parseInfo['upper'], parent::$functions)) {
+							$parseInfo['tokenType'] = 'function';
+						} else {
+							$parseInfo['tokenType'] = 'reserved';
+						}
+						break;
 				}
 			}