RDatabaseSqlparserSqltranslation::parseTableReplacements()

Complexity

Conditions	37
Paths	2

Size

Total Lines	191
Code Lines	105

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

<?php
	public static function parseTableReplacements($parsedSql, $translationTables, &$foundTables, &$originalTables, $language, &$subQueryFound)
	{
		if (!empty($parsedSql) && is_array($parsedSql))
		{
			// Replace all Tables and keys
			foreach ($parsedSql as $groupKey => $parsedGroup)
			{
				if (!empty($parsedGroup))
				{
					$filteredGroup            = array();
					$filteredGroupEndPosition = array();

					foreach ($parsedGroup as $tagKey => $tagValue)
					{
						$tableName   = null;
						$newTagValue = null;

						if (!empty($tagValue['expr_type']) && $tagValue['expr_type'] == 'table' && !empty($tagValue['table']))
						{
							$tableName = self::getNameIfIncluded(
								$tagValue['table'],
								!empty($tagValue['alias']['name']) ? $tagValue['alias']['name'] : '',
								$translationTables,
								true,
								$groupKey
							);

							if (!empty($tableName))
							{
								$newTagValue                      = $tagValue;
								$newTagValue['originalTableName'] = $tableName;
								$newTagValue['table']             = RTranslationTable::getTranslationsTableName($tableName, '');
								$newTagValue['join_type']         = 'LEFT';
								$newTagValue['ref_type']          = 'ON';
								$alias                            = self::getUniqueAlias($tableName, $originalTables);

								if (!empty($newTagValue['alias']['name']))
								{
									$alias = $newTagValue['alias']['name'];
								}

								$tagValue['alias'] = array(
									'as'        => true,
									'name'      => $alias,
									'base_expr' => ''
								);

								$newTagValue['alias'] = array(
									'as'           => true,
									'name'         => self::getUniqueAlias($newTagValue['table'], $foundTables),
									'originalName' => $alias,
									'base_expr'    => ''
								);

								$refClause                                             = self::createParserJoinOperand(
									$newTagValue['alias']['name'],
									'=',
									$newTagValue['alias']['originalName'],
									$translationTables[$tableName],
									$language
								);
								$newTagValue['ref_clause']                             = $refClause;
								$newTagValue['index_hints']                            = false;
								$foundTables[]                                         = $newTagValue;
								$originalTables[$newTagValue['alias']['originalName']] = isset($originalTables[$newTagValue['alias']['originalName']]) ?
									$originalTables[$newTagValue['alias']['originalName']]++ : 1;
							}
						}
						// There is an issue in sql parser for UNION and UNION ALL, this is a solution for it
						elseif (!empty($tagValue['union_tree']) && is_array($tagValue['union_tree']) && in_array('UNION', $tagValue['union_tree']))
						{
							$subQueryFound = true;
							$unionTree     = array();

							foreach ($tagValue['union_tree'] as $union)
							{
								$union = trim($union);

								if (!empty($union) && strtoupper($union) != 'UNION')
								{
									$parsedSubQuery = self::buildTranslationQuery(self::removeParenthesisFromStart($union));
									$unionTree[]    = !empty($parsedSubQuery) ? '(' . $parsedSubQuery . ')' : $union;
								}
							}

							$tagValue['base_expr'] = '(' . implode(' UNION ', $unionTree) . ')';
							$tagValue['expr_type'] = 'const';

							if (!empty($tagValue['sub_tree']))
							{
								unset($tagValue['sub_tree']);
							}

							if (!empty($tagValue['join_type']))
							{
								unset($tagValue['join_type']);
							}
						}
						// Other types of expressions
						elseif (!empty($tagValue['sub_tree']))
						{
							if (!empty($tagValue['expr_type']) && $tagValue['expr_type'] == 'subquery')
							{
								$parsedSubQuery = self::buildTranslationQuery($tagValue['base_expr']);

								if (!empty($parsedSubQuery))
								{
									$sqlParser             = new RDatabaseSqlparserSqlparser($parsedSubQuery);
									$tagValue['sub_tree']  = $sqlParser->parsed;
									$tagValue['base_expr'] = $parsedSubQuery;
									$subQueryFound         = true;
								}
							}
							elseif (!empty($tagValue['expr_type']) && in_array($tagValue['expr_type'], array('expression')))
							{
								foreach ($tagValue['sub_tree'] as $subKey => $subTree)
								{
									// In case we have a Subquery directly under the expression we handle it separately
									if (!empty($subTree['expr_type']) && $subTree['expr_type'] == 'subquery')
									{
										// We need to remove brackets from the query or else the query will not be parsed properly
										$sqlBracketLess = self::removeParenthesisFromStart($subTree['base_expr']);
										$parsedSubQuery = self::buildTranslationQuery($sqlBracketLess);

										if (!empty($parsedSubQuery))
										{
											$sqlParser                                  = new RDatabaseSqlparserSqlparser($parsedSubQuery);
											$tagValue['sub_tree'][$subKey]['sub_tree']  = $sqlParser->parsed;
											$tagValue['sub_tree'][$subKey]['base_expr'] = '(' . $parsedSubQuery . ')';
											$subQueryFound                              = true;
										}
									}
									elseif (!empty($tagValue['sub_tree'][$subKey]['sub_tree']))
									{
										$tagValue['sub_tree'][$subKey]['sub_tree'] = self::parseTableReplacements(
											$tagValue['sub_tree'][$subKey]['sub_tree'],
											$translationTables,
											$foundTables,
											$originalTables,
											$language,
											$subQueryFound
										);
									}
								}
							}
							else
							{
								$tagValue['sub_tree'] = self::parseTableReplacements(
									$tagValue['sub_tree'],
									$translationTables,
									$foundTables,
									$originalTables,
									$language,
									$subQueryFound
								);
							}
						}

						if (!is_numeric($tagKey))
						{
							$filteredGroup[$tagKey] = $tagValue;
						}
						else
						{
							$filteredGroup[] = $tagValue;
						}

						if (!empty($newTagValue))
						{
							if (!empty($translationTables[$tableName]->tableJoinEndPosition))
							{
								$filteredGroupEndPosition[] = $newTagValue;
							}
							else
							{
								$filteredGroup[] = $newTagValue;
							}
						}
					}

					foreach ($filteredGroupEndPosition as $table)
					{
						$filteredGroup[] = $table;
					}

					$parsedSql[$groupKey] = $filteredGroup;
				}
			}
		}

		return $parsedSql;
	}