2083 lines
80 KiB
PHP
2083 lines
80 KiB
PHP
<?php
|
|
/*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* This software consists of voluntary contributions made by many individuals
|
|
* and is licensed under the LGPL. For more information, see
|
|
* <http://www.doctrine-project.org>.
|
|
*/
|
|
|
|
namespace Doctrine\ORM\Query;
|
|
|
|
use Doctrine\DBAL\LockMode,
|
|
Doctrine\ORM\Mapping\ClassMetadata,
|
|
Doctrine\ORM\Query,
|
|
Doctrine\ORM\Query\QueryException;
|
|
|
|
/**
|
|
* The SqlWalker is a TreeWalker that walks over a DQL AST and constructs
|
|
* the corresponding SQL.
|
|
*
|
|
* @author Roman Borschel <roman@code-factory.org>
|
|
* @author Benjamin Eberlei <kontakt@beberlei.de>
|
|
* @since 2.0
|
|
* @todo Rename: SQLWalker
|
|
*/
|
|
class SqlWalker implements TreeWalker
|
|
{
|
|
/**
|
|
* @var ResultSetMapping
|
|
*/
|
|
private $_rsm;
|
|
|
|
/** Counters for generating unique column aliases, table aliases and parameter indexes. */
|
|
private $_aliasCounter = 0;
|
|
private $_tableAliasCounter = 0;
|
|
private $_scalarResultCounter = 1;
|
|
private $_sqlParamIndex = 0;
|
|
|
|
/**
|
|
* @var ParserResult
|
|
*/
|
|
private $_parserResult;
|
|
|
|
/**
|
|
* @var EntityManager
|
|
*/
|
|
private $_em;
|
|
|
|
/**
|
|
* @var Doctrine\DBAL\Connection
|
|
*/
|
|
private $_conn;
|
|
|
|
/**
|
|
* @var AbstractQuery
|
|
*/
|
|
private $_query;
|
|
|
|
private $_tableAliasMap = array();
|
|
|
|
/** Map from result variable names to their SQL column alias names. */
|
|
private $_scalarResultAliasMap = array();
|
|
|
|
/** Map of all components/classes that appear in the DQL query. */
|
|
private $_queryComponents;
|
|
|
|
/** A list of classes that appear in non-scalar SelectExpressions. */
|
|
private $_selectedClasses = array();
|
|
|
|
/**
|
|
* The DQL alias of the root class of the currently traversed query.
|
|
*/
|
|
private $_rootAliases = array();
|
|
|
|
/**
|
|
* Flag that indicates whether to generate SQL table aliases in the SQL.
|
|
* These should only be generated for SELECT queries, not for UPDATE/DELETE.
|
|
*/
|
|
private $_useSqlTableAliases = true;
|
|
|
|
/**
|
|
* The database platform abstraction.
|
|
*
|
|
* @var AbstractPlatform
|
|
*/
|
|
private $_platform;
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
public function __construct($query, $parserResult, array $queryComponents)
|
|
{
|
|
$this->_query = $query;
|
|
$this->_parserResult = $parserResult;
|
|
$this->_queryComponents = $queryComponents;
|
|
$this->_rsm = $parserResult->getResultSetMapping();
|
|
$this->_em = $query->getEntityManager();
|
|
$this->_conn = $this->_em->getConnection();
|
|
$this->_platform = $this->_conn->getDatabasePlatform();
|
|
}
|
|
|
|
/**
|
|
* Gets the Query instance used by the walker.
|
|
*
|
|
* @return Query.
|
|
*/
|
|
public function getQuery()
|
|
{
|
|
return $this->_query;
|
|
}
|
|
|
|
/**
|
|
* Gets the Connection used by the walker.
|
|
*
|
|
* @return Connection
|
|
*/
|
|
public function getConnection()
|
|
{
|
|
return $this->_conn;
|
|
}
|
|
|
|
/**
|
|
* Gets the EntityManager used by the walker.
|
|
*
|
|
* @return EntityManager
|
|
*/
|
|
public function getEntityManager()
|
|
{
|
|
return $this->_em;
|
|
}
|
|
|
|
/**
|
|
* Gets the information about a single query component.
|
|
*
|
|
* @param string $dqlAlias The DQL alias.
|
|
* @return array
|
|
*/
|
|
public function getQueryComponent($dqlAlias)
|
|
{
|
|
return $this->_queryComponents[$dqlAlias];
|
|
}
|
|
|
|
/**
|
|
* Gets an executor that can be used to execute the result of this walker.
|
|
*
|
|
* @return AbstractExecutor
|
|
*/
|
|
public function getExecutor($AST)
|
|
{
|
|
$isDeleteStatement = $AST instanceof AST\DeleteStatement;
|
|
$isUpdateStatement = $AST instanceof AST\UpdateStatement;
|
|
|
|
if ($isDeleteStatement) {
|
|
$primaryClass = $this->_em->getClassMetadata(
|
|
$AST->deleteClause->abstractSchemaName
|
|
);
|
|
|
|
if ($primaryClass->isInheritanceTypeJoined()) {
|
|
return new Exec\MultiTableDeleteExecutor($AST, $this);
|
|
} else {
|
|
return new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
|
|
}
|
|
} else if ($isUpdateStatement) {
|
|
$primaryClass = $this->_em->getClassMetadata(
|
|
$AST->updateClause->abstractSchemaName
|
|
);
|
|
|
|
if ($primaryClass->isInheritanceTypeJoined()) {
|
|
return new Exec\MultiTableUpdateExecutor($AST, $this);
|
|
} else {
|
|
return new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
|
|
}
|
|
}
|
|
|
|
return new Exec\SingleSelectExecutor($AST, $this);
|
|
}
|
|
|
|
/**
|
|
* Generates a unique, short SQL table alias.
|
|
*
|
|
* @param string $tableName Table name
|
|
* @param string $dqlAlias The DQL alias.
|
|
* @return string Generated table alias.
|
|
*/
|
|
public function getSQLTableAlias($tableName, $dqlAlias = '')
|
|
{
|
|
$tableName .= ($dqlAlias) ? '@[' . $dqlAlias . ']' : '';
|
|
|
|
if ( ! isset($this->_tableAliasMap[$tableName])) {
|
|
$this->_tableAliasMap[$tableName] = strtolower(substr($tableName, 0, 1)) . $this->_tableAliasCounter++ . '_';
|
|
}
|
|
|
|
return $this->_tableAliasMap[$tableName];
|
|
}
|
|
|
|
/**
|
|
* Forces the SqlWalker to use a specific alias for a table name, rather than
|
|
* generating an alias on its own.
|
|
*
|
|
* @param string $tableName
|
|
* @param string $alias
|
|
* @param string $dqlAlias
|
|
* @return string
|
|
*/
|
|
public function setSQLTableAlias($tableName, $alias, $dqlAlias = '')
|
|
{
|
|
$tableName .= ($dqlAlias) ? '@[' . $dqlAlias . ']' : '';
|
|
|
|
$this->_tableAliasMap[$tableName] = $alias;
|
|
|
|
return $alias;
|
|
}
|
|
|
|
/**
|
|
* Gets an SQL column alias for a column name.
|
|
*
|
|
* @param string $columnName
|
|
* @return string
|
|
*/
|
|
public function getSQLColumnAlias($columnName)
|
|
{
|
|
return $columnName . $this->_aliasCounter++;
|
|
}
|
|
|
|
/**
|
|
* Generates the SQL JOINs that are necessary for Class Table Inheritance
|
|
* for the given class.
|
|
*
|
|
* @param ClassMetadata $class The class for which to generate the joins.
|
|
* @param string $dqlAlias The DQL alias of the class.
|
|
* @return string The SQL.
|
|
*/
|
|
private function _generateClassTableInheritanceJoins($class, $dqlAlias)
|
|
{
|
|
$sql = '';
|
|
|
|
$baseTableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
|
|
|
|
// INNER JOIN parent class tables
|
|
foreach ($class->parentClasses as $parentClassName) {
|
|
$parentClass = $this->_em->getClassMetadata($parentClassName);
|
|
$tableAlias = $this->getSQLTableAlias($parentClass->table['name'], $dqlAlias);
|
|
// If this is a joined association we must use left joins to preserve the correct result.
|
|
$sql .= isset($this->_queryComponents[$dqlAlias]['relation']) ? ' LEFT ' : ' INNER ';
|
|
$sql .= 'JOIN ' . $parentClass->getQuotedTableName($this->_platform)
|
|
. ' ' . $tableAlias . ' ON ';
|
|
$first = true;
|
|
foreach ($class->identifier as $idField) {
|
|
if ($first) $first = false; else $sql .= ' AND ';
|
|
|
|
$columnName = $class->getQuotedColumnName($idField, $this->_platform);
|
|
$sql .= $baseTableAlias . '.' . $columnName
|
|
. ' = '
|
|
. $tableAlias . '.' . $columnName;
|
|
}
|
|
}
|
|
|
|
// LEFT JOIN subclass tables, if partial objects disallowed.
|
|
if ( ! $this->_query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
|
|
foreach ($class->subClasses as $subClassName) {
|
|
$subClass = $this->_em->getClassMetadata($subClassName);
|
|
$tableAlias = $this->getSQLTableAlias($subClass->table['name'], $dqlAlias);
|
|
$sql .= ' LEFT JOIN ' . $subClass->getQuotedTableName($this->_platform)
|
|
. ' ' . $tableAlias . ' ON ';
|
|
$first = true;
|
|
foreach ($class->identifier as $idField) {
|
|
if ($first) $first = false; else $sql .= ' AND ';
|
|
|
|
$columnName = $class->getQuotedColumnName($idField, $this->_platform);
|
|
$sql .= $baseTableAlias . '.' . $columnName
|
|
. ' = '
|
|
. $tableAlias . '.' . $columnName;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
private function _generateOrderedCollectionOrderByItems()
|
|
{
|
|
$sql = '';
|
|
foreach ($this->_selectedClasses AS $dqlAlias => $class) {
|
|
$qComp = $this->_queryComponents[$dqlAlias];
|
|
if (isset($qComp['relation']['orderBy'])) {
|
|
foreach ($qComp['relation']['orderBy'] AS $fieldName => $orientation) {
|
|
if ($qComp['metadata']->isInheritanceTypeJoined()) {
|
|
$tableName = $this->_em->getUnitOfWork()->getEntityPersister($class->name)->getOwningTable($fieldName);
|
|
} else {
|
|
$tableName = $qComp['metadata']->table['name'];
|
|
}
|
|
|
|
if ($sql != '') {
|
|
$sql .= ', ';
|
|
}
|
|
$sql .= $this->getSQLTableAlias($tableName, $dqlAlias) . '.' .
|
|
$qComp['metadata']->getQuotedColumnName($fieldName, $this->_platform) . " $orientation";
|
|
}
|
|
}
|
|
}
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Generates a discriminator column SQL condition for the class with the given DQL alias.
|
|
*
|
|
* @param array $dqlAliases List of root DQL aliases to inspect for discriminator restrictions.
|
|
* @return string
|
|
*/
|
|
private function _generateDiscriminatorColumnConditionSQL(array $dqlAliases)
|
|
{
|
|
$encapsulate = false;
|
|
$sql = '';
|
|
|
|
foreach ($dqlAliases as $dqlAlias) {
|
|
$class = $this->_queryComponents[$dqlAlias]['metadata'];
|
|
|
|
if ($class->isInheritanceTypeSingleTable()) {
|
|
$conn = $this->_em->getConnection();
|
|
$values = array();
|
|
if ($class->discriminatorValue !== null) { // discrimnators can be 0
|
|
$values[] = $conn->quote($class->discriminatorValue);
|
|
}
|
|
|
|
foreach ($class->subClasses as $subclassName) {
|
|
$values[] = $conn->quote($this->_em->getClassMetadata($subclassName)->discriminatorValue);
|
|
}
|
|
|
|
if ($sql != '') {
|
|
$sql .= ' AND ';
|
|
$encapsulate = true;
|
|
}
|
|
|
|
$sql .= ($sql != '' ? ' AND ' : '')
|
|
. (($this->_useSqlTableAliases) ? $this->getSQLTableAlias($class->table['name'], $dqlAlias) . '.' : '')
|
|
. $class->discriminatorColumn['name'] . ' IN (' . implode(', ', $values) . ')';
|
|
}
|
|
}
|
|
|
|
return ($encapsulate) ? '(' . $sql . ')' : $sql;
|
|
}
|
|
|
|
private function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias)
|
|
{
|
|
$filterSql = '';
|
|
|
|
$first = true;
|
|
foreach($this->_em->getEnabledFilters() as $filter) {
|
|
if("" !== $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias)) {
|
|
if ( ! $first) $sql .= ' AND '; else $first = false;
|
|
$filterSql .= '(' . $filterExpr . ')';
|
|
}
|
|
}
|
|
|
|
return $filterSql;
|
|
}
|
|
/**
|
|
* Walks down a SelectStatement AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkSelectStatement(AST\SelectStatement $AST)
|
|
{
|
|
$sql = $this->walkSelectClause($AST->selectClause);
|
|
$sql .= $this->walkFromClause($AST->fromClause);
|
|
$sql .= $this->walkWhereClause($AST->whereClause);
|
|
$sql .= $AST->groupByClause ? $this->walkGroupByClause($AST->groupByClause) : '';
|
|
$sql .= $AST->havingClause ? $this->walkHavingClause($AST->havingClause) : '';
|
|
|
|
if (($orderByClause = $AST->orderByClause) !== null) {
|
|
$sql .= $AST->orderByClause ? $this->walkOrderByClause($AST->orderByClause) : '';
|
|
} else if (($orderBySql = $this->_generateOrderedCollectionOrderByItems()) !== '') {
|
|
$sql .= ' ORDER BY '.$orderBySql;
|
|
}
|
|
|
|
|
|
$sql = $this->_platform->modifyLimitQuery(
|
|
$sql, $this->_query->getMaxResults(), $this->_query->getFirstResult()
|
|
);
|
|
|
|
if (($lockMode = $this->_query->getHint(Query::HINT_LOCK_MODE)) !== false) {
|
|
if ($lockMode == LockMode::PESSIMISTIC_READ) {
|
|
$sql .= " " . $this->_platform->getReadLockSQL();
|
|
} else if ($lockMode == LockMode::PESSIMISTIC_WRITE) {
|
|
$sql .= " " . $this->_platform->getWriteLockSQL();
|
|
} else if ($lockMode == LockMode::OPTIMISTIC) {
|
|
foreach ($this->_selectedClasses AS $class) {
|
|
if ( ! $class->isVersioned) {
|
|
throw \Doctrine\ORM\OptimisticLockException::lockFailed();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down an UpdateStatement AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param UpdateStatement
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkUpdateStatement(AST\UpdateStatement $AST)
|
|
{
|
|
$this->_useSqlTableAliases = false;
|
|
$sql = $this->walkUpdateClause($AST->updateClause);
|
|
$sql .= $this->walkWhereClause($AST->whereClause);
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down a DeleteStatement AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param DeleteStatement
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkDeleteStatement(AST\DeleteStatement $AST)
|
|
{
|
|
$this->_useSqlTableAliases = false;
|
|
$sql = $this->walkDeleteClause($AST->deleteClause);
|
|
$sql .= $this->walkWhereClause($AST->whereClause);
|
|
|
|
return $sql;
|
|
}
|
|
|
|
|
|
/**
|
|
* Walks down an IdentificationVariable (no AST node associated), thereby generating the SQL.
|
|
*
|
|
* @param string $identificationVariable
|
|
* @param string $fieldName
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkIdentificationVariable($identificationVariable, $fieldName = null)
|
|
{
|
|
$class = $this->_queryComponents[$identificationVariable]['metadata'];
|
|
|
|
if (
|
|
$fieldName !== null && $class->isInheritanceTypeJoined() &&
|
|
isset($class->fieldMappings[$fieldName]['inherited'])
|
|
) {
|
|
$class = $this->_em->getClassMetadata($class->fieldMappings[$fieldName]['inherited']);
|
|
}
|
|
|
|
return $this->getSQLTableAlias($class->table['name'], $identificationVariable);
|
|
}
|
|
|
|
/**
|
|
* Walks down a PathExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param mixed
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkPathExpression($pathExpr)
|
|
{
|
|
$sql = '';
|
|
|
|
switch ($pathExpr->type) {
|
|
case AST\PathExpression::TYPE_STATE_FIELD:
|
|
$fieldName = $pathExpr->field;
|
|
$dqlAlias = $pathExpr->identificationVariable;
|
|
$class = $this->_queryComponents[$dqlAlias]['metadata'];
|
|
|
|
if ($this->_useSqlTableAliases) {
|
|
$sql .= $this->walkIdentificationVariable($dqlAlias, $fieldName) . '.';
|
|
}
|
|
|
|
$sql .= $class->getQuotedColumnName($fieldName, $this->_platform);
|
|
break;
|
|
|
|
case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
|
|
// 1- the owning side:
|
|
// Just use the foreign key, i.e. u.group_id
|
|
$fieldName = $pathExpr->field;
|
|
$dqlAlias = $pathExpr->identificationVariable;
|
|
$class = $this->_queryComponents[$dqlAlias]['metadata'];
|
|
|
|
if (isset($class->associationMappings[$fieldName]['inherited'])) {
|
|
$class = $this->_em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
|
|
}
|
|
|
|
$assoc = $class->associationMappings[$fieldName];
|
|
|
|
if ( ! $assoc['isOwningSide']) {
|
|
throw QueryException::associationPathInverseSideNotSupported();
|
|
}
|
|
|
|
// COMPOSITE KEYS NOT (YET?) SUPPORTED
|
|
if (count($assoc['sourceToTargetKeyColumns']) > 1) {
|
|
throw QueryException::associationPathCompositeKeyNotSupported();
|
|
}
|
|
|
|
if ($this->_useSqlTableAliases) {
|
|
$sql .= $this->getSQLTableAlias($class->table['name'], $dqlAlias) . '.';
|
|
}
|
|
|
|
$sql .= reset($assoc['targetToSourceKeyColumns']);
|
|
break;
|
|
|
|
default:
|
|
throw QueryException::invalidPathExpression($pathExpr);
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down a SelectClause AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param $selectClause
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkSelectClause($selectClause)
|
|
{
|
|
$sql = 'SELECT ' . (($selectClause->isDistinct) ? 'DISTINCT ' : '');
|
|
$sqlSelectExpressions = array_filter(array_map(array($this, 'walkSelectExpression'), $selectClause->selectExpressions));
|
|
|
|
$addMetaColumns = ! $this->_query->getHint(Query::HINT_FORCE_PARTIAL_LOAD) &&
|
|
$this->_query->getHydrationMode() == Query::HYDRATE_OBJECT
|
|
||
|
|
$this->_query->getHydrationMode() != Query::HYDRATE_OBJECT &&
|
|
$this->_query->getHint(Query::HINT_INCLUDE_META_COLUMNS);
|
|
|
|
foreach ($this->_selectedClasses as $dqlAlias => $class) {
|
|
// Register as entity or joined entity result
|
|
if ($this->_queryComponents[$dqlAlias]['relation'] === null) {
|
|
$this->_rsm->addEntityResult($class->name, $dqlAlias);
|
|
} else {
|
|
$this->_rsm->addJoinedEntityResult(
|
|
$class->name, $dqlAlias,
|
|
$this->_queryComponents[$dqlAlias]['parent'],
|
|
$this->_queryComponents[$dqlAlias]['relation']['fieldName']
|
|
);
|
|
}
|
|
|
|
if ($class->isInheritanceTypeSingleTable() || $class->isInheritanceTypeJoined()) {
|
|
// Add discriminator columns to SQL
|
|
$rootClass = $this->_em->getClassMetadata($class->rootEntityName);
|
|
$tblAlias = $this->getSQLTableAlias($rootClass->table['name'], $dqlAlias);
|
|
$discrColumn = $rootClass->discriminatorColumn;
|
|
$columnAlias = $this->getSQLColumnAlias($discrColumn['name']);
|
|
|
|
$sqlSelectExpressions[] = $tblAlias . '.' . $discrColumn['name'] . ' AS ' . $columnAlias;
|
|
|
|
$columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
|
|
$this->_rsm->setDiscriminatorColumn($dqlAlias, $columnAlias);
|
|
$this->_rsm->addMetaResult($dqlAlias, $columnAlias, $discrColumn['fieldName']);
|
|
|
|
// Add foreign key columns to SQL, if necessary
|
|
if ($addMetaColumns) {
|
|
//FIXME: Include foreign key columns of child classes also!!??
|
|
foreach ($class->associationMappings as $assoc) {
|
|
if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
|
|
if (isset($assoc['inherited'])) {
|
|
$owningClass = $this->_em->getClassMetadata($assoc['inherited']);
|
|
$sqlTableAlias = $this->getSQLTableAlias($owningClass->table['name'], $dqlAlias);
|
|
} else {
|
|
$sqlTableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
|
|
}
|
|
|
|
foreach ($assoc['targetToSourceKeyColumns'] as $srcColumn) {
|
|
$columnAlias = $this->getSQLColumnAlias($srcColumn);
|
|
|
|
$sqlSelectExpressions[] = $sqlTableAlias . '.' . $srcColumn . ' AS ' . $columnAlias;
|
|
|
|
$columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
|
|
$this->_rsm->addMetaResult($dqlAlias, $this->_platform->getSQLResultCasing($columnAlias), $srcColumn, (isset($assoc['id']) && $assoc['id'] === true));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Add foreign key columns to SQL, if necessary
|
|
if ($addMetaColumns) {
|
|
$sqlTableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
|
|
foreach ($class->associationMappings as $assoc) {
|
|
if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
|
|
foreach ($assoc['targetToSourceKeyColumns'] as $srcColumn) {
|
|
$columnAlias = $this->getSQLColumnAlias($srcColumn);
|
|
|
|
$sqlSelectExpressions[] = $sqlTableAlias . '.' . $srcColumn . ' AS ' . $columnAlias;
|
|
|
|
$columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
|
|
$this->_rsm->addMetaResult($dqlAlias, $this->_platform->getSQLResultCasing($columnAlias), $srcColumn, (isset($assoc['id']) && $assoc['id'] === true));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$sql .= implode(', ', $sqlSelectExpressions);
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down a FromClause AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkFromClause($fromClause)
|
|
{
|
|
$identificationVarDecls = $fromClause->identificationVariableDeclarations;
|
|
$sqlParts = array();
|
|
|
|
foreach ($identificationVarDecls as $identificationVariableDecl) {
|
|
$sql = '';
|
|
|
|
$rangeDecl = $identificationVariableDecl->rangeVariableDeclaration;
|
|
$dqlAlias = $rangeDecl->aliasIdentificationVariable;
|
|
|
|
$this->_rootAliases[] = $dqlAlias;
|
|
|
|
$class = $this->_em->getClassMetadata($rangeDecl->abstractSchemaName);
|
|
$sql .= $class->getQuotedTableName($this->_platform) . ' '
|
|
. $this->getSQLTableAlias($class->table['name'], $dqlAlias);
|
|
|
|
if ($class->isInheritanceTypeJoined()) {
|
|
$sql .= $this->_generateClassTableInheritanceJoins($class, $dqlAlias);
|
|
}
|
|
|
|
foreach ($identificationVariableDecl->joinVariableDeclarations as $joinVarDecl) {
|
|
$sql .= $this->walkJoinVariableDeclaration($joinVarDecl);
|
|
}
|
|
|
|
if ($identificationVariableDecl->indexBy) {
|
|
$this->_rsm->addIndexBy(
|
|
$identificationVariableDecl->indexBy->simpleStateFieldPathExpression->identificationVariable,
|
|
$identificationVariableDecl->indexBy->simpleStateFieldPathExpression->field
|
|
);
|
|
}
|
|
|
|
$sqlParts[] = $this->_platform->appendLockHint($sql, $this->_query->getHint(Query::HINT_LOCK_MODE));
|
|
}
|
|
|
|
return ' FROM ' . implode(', ', $sqlParts);
|
|
}
|
|
|
|
/**
|
|
* Walks down a FunctionNode AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkFunction($function)
|
|
{
|
|
return $function->getSql($this);
|
|
}
|
|
|
|
/**
|
|
* Walks down an OrderByClause AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param OrderByClause
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkOrderByClause($orderByClause)
|
|
{
|
|
$colSql = $this->_generateOrderedCollectionOrderByItems();
|
|
if ($colSql != '') {
|
|
$colSql = ", ".$colSql;
|
|
}
|
|
|
|
// OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
|
|
return ' ORDER BY ' . implode(
|
|
', ', array_map(array($this, 'walkOrderByItem'), $orderByClause->orderByItems)
|
|
) . $colSql;
|
|
}
|
|
|
|
/**
|
|
* Walks down an OrderByItem AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param OrderByItem
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkOrderByItem($orderByItem)
|
|
{
|
|
$sql = '';
|
|
$expr = $orderByItem->expression;
|
|
|
|
if ($expr instanceof AST\PathExpression) {
|
|
$sql = $this->walkPathExpression($expr);
|
|
} else {
|
|
$columnName = $this->_queryComponents[$expr]['token']['value'];
|
|
|
|
$sql = $this->_scalarResultAliasMap[$columnName];
|
|
}
|
|
|
|
return $sql . ' ' . strtoupper($orderByItem->type);
|
|
}
|
|
|
|
/**
|
|
* Walks down a HavingClause AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param HavingClause
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkHavingClause($havingClause)
|
|
{
|
|
return ' HAVING ' . $this->walkConditionalExpression($havingClause->conditionalExpression);
|
|
}
|
|
|
|
/**
|
|
* Walks down a JoinVariableDeclaration AST node and creates the corresponding SQL.
|
|
*
|
|
* @param JoinVariableDeclaration $joinVarDecl
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkJoinVariableDeclaration($joinVarDecl)
|
|
{
|
|
$join = $joinVarDecl->join;
|
|
$joinType = $join->joinType;
|
|
|
|
if ($joinVarDecl->indexBy) {
|
|
// For Many-To-One or One-To-One associations this obviously makes no sense, but is ignored silently.
|
|
$this->_rsm->addIndexBy(
|
|
$joinVarDecl->indexBy->simpleStateFieldPathExpression->identificationVariable,
|
|
$joinVarDecl->indexBy->simpleStateFieldPathExpression->field
|
|
);
|
|
}
|
|
|
|
if ($joinType == AST\Join::JOIN_TYPE_LEFT || $joinType == AST\Join::JOIN_TYPE_LEFTOUTER) {
|
|
$sql = ' LEFT JOIN ';
|
|
} else {
|
|
$sql = ' INNER JOIN ';
|
|
}
|
|
|
|
$joinAssocPathExpr = $join->joinAssociationPathExpression;
|
|
$joinedDqlAlias = $join->aliasIdentificationVariable;
|
|
$relation = $this->_queryComponents[$joinedDqlAlias]['relation'];
|
|
$targetClass = $this->_em->getClassMetadata($relation['targetEntity']);
|
|
$sourceClass = $this->_em->getClassMetadata($relation['sourceEntity']);
|
|
$targetTableName = $targetClass->getQuotedTableName($this->_platform);
|
|
$targetTableAlias = $this->getSQLTableAlias($targetClass->table['name'], $joinedDqlAlias);
|
|
$sourceTableAlias = $this->getSQLTableAlias($sourceClass->table['name'], $joinAssocPathExpr->identificationVariable);
|
|
|
|
// Ensure we got the owning side, since it has all mapping info
|
|
$assoc = ( ! $relation['isOwningSide']) ? $targetClass->associationMappings[$relation['mappedBy']] : $relation;
|
|
|
|
if ($this->_query->getHint(Query::HINT_INTERNAL_ITERATION) == true) {
|
|
if ($relation['type'] == ClassMetadata::ONE_TO_MANY || $relation['type'] == ClassMetadata::MANY_TO_MANY) {
|
|
throw QueryException::iterateWithFetchJoinNotAllowed($assoc);
|
|
}
|
|
}
|
|
|
|
if ($joinVarDecl->indexBy) {
|
|
// For Many-To-One or One-To-One associations this obviously makes no sense, but is ignored silently.
|
|
$this->_rsm->addIndexBy(
|
|
$joinVarDecl->indexBy->simpleStateFieldPathExpression->identificationVariable,
|
|
$joinVarDecl->indexBy->simpleStateFieldPathExpression->field
|
|
);
|
|
} else if (isset($relation['indexBy'])) {
|
|
$this->_rsm->addIndexBy($joinedDqlAlias, $relation['indexBy']);
|
|
}
|
|
|
|
// This condition is not checking ClassMetadata::MANY_TO_ONE, because by definition it cannot
|
|
// be the owning side and previously we ensured that $assoc is always the owning side of the associations.
|
|
// The owning side is necessary at this point because only it contains the JoinColumn information.
|
|
if ($assoc['type'] & ClassMetadata::TO_ONE) {
|
|
|
|
$sql .= $targetTableName . ' ' . $targetTableAlias . ' ON ';
|
|
$first = true;
|
|
|
|
foreach ($assoc['sourceToTargetKeyColumns'] as $sourceColumn => $targetColumn) {
|
|
if ( ! $first) $sql .= ' AND '; else $first = false;
|
|
|
|
if ($relation['isOwningSide']) {
|
|
if ($targetClass->containsForeignIdentifier && !isset($targetClass->fieldNames[$targetColumn])) {
|
|
$quotedTargetColumn = $targetColumn; // Join columns cannot be quoted.
|
|
} else {
|
|
$quotedTargetColumn = $targetClass->getQuotedColumnName($targetClass->fieldNames[$targetColumn], $this->_platform);
|
|
}
|
|
$sql .= $sourceTableAlias . '.' . $sourceColumn . ' = ' . $targetTableAlias . '.' . $quotedTargetColumn;
|
|
} else {
|
|
if ($sourceClass->containsForeignIdentifier && !isset($sourceClass->fieldNames[$targetColumn])) {
|
|
$quotedTargetColumn = $targetColumn; // Join columns cannot be quoted.
|
|
} else {
|
|
$quotedTargetColumn = $sourceClass->getQuotedColumnName($sourceClass->fieldNames[$targetColumn], $this->_platform);
|
|
}
|
|
$sql .= $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $targetTableAlias . '.' . $sourceColumn;
|
|
}
|
|
}
|
|
|
|
// Apply the filters
|
|
if("" !== $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias)) {
|
|
if ( ! $first) $sql .= ' AND '; else $first = false;
|
|
$sql .= $filterExpr;
|
|
}
|
|
} else if ($assoc['type'] == ClassMetadata::MANY_TO_MANY) {
|
|
// Join relation table
|
|
$joinTable = $assoc['joinTable'];
|
|
$joinTableAlias = $this->getSQLTableAlias($joinTable['name'], $joinedDqlAlias);
|
|
$sql .= $sourceClass->getQuotedJoinTableName($assoc, $this->_platform) . ' ' . $joinTableAlias . ' ON ';
|
|
|
|
$first = true;
|
|
if ($relation['isOwningSide']) {
|
|
foreach ($assoc['relationToSourceKeyColumns'] as $relationColumn => $sourceColumn) {
|
|
if ( ! $first) $sql .= ' AND '; else $first = false;
|
|
|
|
if ($sourceClass->containsForeignIdentifier && !isset($sourceClass->fieldNames[$sourceColumn])) {
|
|
$quotedTargetColumn = $sourceColumn; // Join columns cannot be quoted.
|
|
} else {
|
|
$quotedTargetColumn = $sourceClass->getQuotedColumnName($sourceClass->fieldNames[$sourceColumn], $this->_platform);
|
|
}
|
|
|
|
$sql .= $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $relationColumn;
|
|
}
|
|
} else {
|
|
foreach ($assoc['relationToTargetKeyColumns'] as $relationColumn => $targetColumn) {
|
|
if ( ! $first) $sql .= ' AND '; else $first = false;
|
|
|
|
if ($sourceClass->containsForeignIdentifier && !isset($sourceClass->fieldNames[$targetColumn])) {
|
|
$quotedTargetColumn = $targetColumn; // Join columns cannot be quoted.
|
|
} else {
|
|
$quotedTargetColumn = $sourceClass->getQuotedColumnName($sourceClass->fieldNames[$targetColumn], $this->_platform);
|
|
}
|
|
|
|
$sql .= $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $relationColumn;
|
|
}
|
|
}
|
|
|
|
// Join target table
|
|
$sql .= ($joinType == AST\Join::JOIN_TYPE_LEFT || $joinType == AST\Join::JOIN_TYPE_LEFTOUTER)
|
|
? ' LEFT JOIN ' : ' INNER JOIN ';
|
|
$sql .= $targetTableName . ' ' . $targetTableAlias . ' ON ';
|
|
|
|
$first = true;
|
|
if ($relation['isOwningSide']) {
|
|
foreach ($assoc['relationToTargetKeyColumns'] as $relationColumn => $targetColumn) {
|
|
if ( ! $first) $sql .= ' AND '; else $first = false;
|
|
|
|
if ($targetClass->containsForeignIdentifier && !isset($targetClass->fieldNames[$targetColumn])) {
|
|
$quotedTargetColumn = $targetColumn; // Join columns cannot be quoted.
|
|
} else {
|
|
$quotedTargetColumn = $targetClass->getQuotedColumnName($targetClass->fieldNames[$targetColumn], $this->_platform);
|
|
}
|
|
|
|
$sql .= $targetTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $relationColumn;
|
|
}
|
|
} else {
|
|
foreach ($assoc['relationToSourceKeyColumns'] as $relationColumn => $sourceColumn) {
|
|
if ( ! $first) $sql .= ' AND '; else $first = false;
|
|
|
|
if ($targetClass->containsForeignIdentifier && !isset($targetClass->fieldNames[$sourceColumn])) {
|
|
$quotedTargetColumn = $sourceColumn; // Join columns cannot be quoted.
|
|
} else {
|
|
$quotedTargetColumn = $targetClass->getQuotedColumnName($targetClass->fieldNames[$sourceColumn], $this->_platform);
|
|
}
|
|
|
|
$sql .= $targetTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $relationColumn;
|
|
}
|
|
}
|
|
|
|
// Apply the filters
|
|
if("" !== $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias)) {
|
|
if ( ! $first) $sql .= ' AND '; else $first = false;
|
|
$sql .= $filterExpr;
|
|
}
|
|
}
|
|
|
|
// Handle WITH clause
|
|
if (($condExpr = $join->conditionalExpression) !== null) {
|
|
// Phase 2 AST optimization: Skip processment of ConditionalExpression
|
|
// if only one ConditionalTerm is defined
|
|
$sql .= ' AND (' . $this->walkConditionalExpression($condExpr) . ')';
|
|
}
|
|
|
|
$discrSql = $this->_generateDiscriminatorColumnConditionSQL(array($joinedDqlAlias));
|
|
|
|
if ($discrSql) {
|
|
$sql .= ' AND ' . $discrSql;
|
|
}
|
|
|
|
// FIXME: these should either be nested or all forced to be left joins (DDC-XXX)
|
|
if ($targetClass->isInheritanceTypeJoined()) {
|
|
$sql .= $this->_generateClassTableInheritanceJoins($targetClass, $joinedDqlAlias);
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down a CaseExpression AST node and generates the corresponding SQL.
|
|
*
|
|
* @param CoalesceExpression|NullIfExpression|GeneralCaseExpression|SimpleCaseExpression $expression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkCaseExpression($expression)
|
|
{
|
|
switch (true) {
|
|
case ($expression instanceof AST\CoalesceExpression):
|
|
return $this->walkCoalesceExpression($expression);
|
|
|
|
case ($expression instanceof AST\NullIfExpression):
|
|
return $this->walkNullIfExpression($expression);
|
|
|
|
case ($expression instanceof AST\GeneralCaseExpression):
|
|
return $this->walkGeneralCaseExpression($expression);
|
|
|
|
case ($expression instanceof AST\SimpleCaseExpression):
|
|
return $this->walkSimpleCaseExpression($expression);
|
|
|
|
default:
|
|
return '';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Walks down a CoalesceExpression AST node and generates the corresponding SQL.
|
|
*
|
|
* @param CoalesceExpression $coalesceExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkCoalesceExpression($coalesceExpression)
|
|
{
|
|
$sql = 'COALESCE(';
|
|
|
|
$scalarExpressions = array();
|
|
|
|
foreach ($coalesceExpression->scalarExpressions as $scalarExpression) {
|
|
$scalarExpressions[] = $this->walkSimpleArithmeticExpression($scalarExpression);
|
|
}
|
|
|
|
$sql .= implode(', ', $scalarExpressions) . ')';
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down a NullIfExpression AST node and generates the corresponding SQL.
|
|
*
|
|
* @param NullIfExpression $nullIfExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkNullIfExpression($nullIfExpression)
|
|
{
|
|
$firstExpression = is_string($nullIfExpression->firstExpression)
|
|
? $this->_conn->quote($nullIfExpression->firstExpression)
|
|
: $this->walkSimpleArithmeticExpression($nullIfExpression->firstExpression);
|
|
|
|
$secondExpression = is_string($nullIfExpression->secondExpression)
|
|
? $this->_conn->quote($nullIfExpression->secondExpression)
|
|
: $this->walkSimpleArithmeticExpression($nullIfExpression->secondExpression);
|
|
|
|
return 'NULLIF(' . $firstExpression . ', ' . $secondExpression . ')';
|
|
}
|
|
|
|
/**
|
|
* Walks down a GeneralCaseExpression AST node and generates the corresponding SQL.
|
|
*
|
|
* @param GeneralCaseExpression $generalCaseExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkGeneralCaseExpression(AST\GeneralCaseExpression $generalCaseExpression)
|
|
{
|
|
$sql = 'CASE';
|
|
|
|
foreach ($generalCaseExpression->whenClauses as $whenClause) {
|
|
$sql .= ' WHEN ' . $this->walkConditionalExpression($whenClause->caseConditionExpression);
|
|
$sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($whenClause->thenScalarExpression);
|
|
}
|
|
|
|
$sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($generalCaseExpression->elseScalarExpression) . ' END';
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down a SimpleCaseExpression AST node and generates the corresponding SQL.
|
|
*
|
|
* @param SimpleCaseExpression $simpleCaseExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkSimpleCaseExpression($simpleCaseExpression)
|
|
{
|
|
$sql = 'CASE ' . $this->walkStateFieldPathExpression($simpleCaseExpression->caseOperand);
|
|
|
|
foreach ($simpleCaseExpression->simpleWhenClauses as $simpleWhenClause) {
|
|
$sql .= ' WHEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->caseScalarExpression);
|
|
$sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->thenScalarExpression);
|
|
}
|
|
|
|
$sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($simpleCaseExpression->elseScalarExpression) . ' END';
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down a SelectExpression AST node and generates the corresponding SQL.
|
|
*
|
|
* @param SelectExpression $selectExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkSelectExpression($selectExpression)
|
|
{
|
|
$sql = '';
|
|
$expr = $selectExpression->expression;
|
|
|
|
if ($expr instanceof AST\PathExpression) {
|
|
if ($expr->type !== AST\PathExpression::TYPE_STATE_FIELD) {
|
|
throw QueryException::invalidPathExpression($expr->type);
|
|
}
|
|
|
|
$fieldName = $expr->field;
|
|
$dqlAlias = $expr->identificationVariable;
|
|
$qComp = $this->_queryComponents[$dqlAlias];
|
|
$class = $qComp['metadata'];
|
|
|
|
if ( ! $selectExpression->fieldIdentificationVariable) {
|
|
$resultAlias = $fieldName;
|
|
} else {
|
|
$resultAlias = $selectExpression->fieldIdentificationVariable;
|
|
}
|
|
|
|
if ($class->isInheritanceTypeJoined()) {
|
|
$tableName = $this->_em->getUnitOfWork()->getEntityPersister($class->name)->getOwningTable($fieldName);
|
|
} else {
|
|
$tableName = $class->getTableName();
|
|
}
|
|
|
|
$sqlTableAlias = $this->getSQLTableAlias($tableName, $dqlAlias);
|
|
$columnName = $class->getQuotedColumnName($fieldName, $this->_platform);
|
|
|
|
$columnAlias = $this->getSQLColumnAlias($columnName);
|
|
$sql .= $sqlTableAlias . '.' . $columnName . ' AS ' . $columnAlias;
|
|
$columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
|
|
$this->_rsm->addScalarResult($columnAlias, $resultAlias);
|
|
} else if ($expr instanceof AST\AggregateExpression) {
|
|
if ( ! $selectExpression->fieldIdentificationVariable) {
|
|
$resultAlias = $this->_scalarResultCounter++;
|
|
} else {
|
|
$resultAlias = $selectExpression->fieldIdentificationVariable;
|
|
}
|
|
|
|
$columnAlias = 'sclr' . $this->_aliasCounter++;
|
|
$sql .= $this->walkAggregateExpression($expr) . ' AS ' . $columnAlias;
|
|
$this->_scalarResultAliasMap[$resultAlias] = $columnAlias;
|
|
|
|
$columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
|
|
$this->_rsm->addScalarResult($columnAlias, $resultAlias);
|
|
} else if ($expr instanceof AST\Subselect) {
|
|
if ( ! $selectExpression->fieldIdentificationVariable) {
|
|
$resultAlias = $this->_scalarResultCounter++;
|
|
} else {
|
|
$resultAlias = $selectExpression->fieldIdentificationVariable;
|
|
}
|
|
|
|
$columnAlias = 'sclr' . $this->_aliasCounter++;
|
|
$sql .= '(' . $this->walkSubselect($expr) . ') AS '.$columnAlias;
|
|
$this->_scalarResultAliasMap[$resultAlias] = $columnAlias;
|
|
|
|
$columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
|
|
$this->_rsm->addScalarResult($columnAlias, $resultAlias);
|
|
} else if ($expr instanceof AST\Functions\FunctionNode) {
|
|
if ( ! $selectExpression->fieldIdentificationVariable) {
|
|
$resultAlias = $this->_scalarResultCounter++;
|
|
} else {
|
|
$resultAlias = $selectExpression->fieldIdentificationVariable;
|
|
}
|
|
|
|
$columnAlias = 'sclr' . $this->_aliasCounter++;
|
|
$sql .= $this->walkFunction($expr) . ' AS ' . $columnAlias;
|
|
$this->_scalarResultAliasMap[$resultAlias] = $columnAlias;
|
|
|
|
$columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
|
|
$this->_rsm->addScalarResult($columnAlias, $resultAlias);
|
|
} else if (
|
|
$expr instanceof AST\SimpleArithmeticExpression ||
|
|
$expr instanceof AST\ArithmeticTerm ||
|
|
$expr instanceof AST\ArithmeticFactor ||
|
|
$expr instanceof AST\ArithmeticPrimary ||
|
|
$expr instanceof AST\Literal
|
|
) {
|
|
if ( ! $selectExpression->fieldIdentificationVariable) {
|
|
$resultAlias = $this->_scalarResultCounter++;
|
|
} else {
|
|
$resultAlias = $selectExpression->fieldIdentificationVariable;
|
|
}
|
|
|
|
$columnAlias = 'sclr' . $this->_aliasCounter++;
|
|
|
|
if ($expr instanceof AST\Literal) {
|
|
$sql .= $this->walkLiteral($expr) . ' AS ' .$columnAlias;
|
|
} else {
|
|
$sql .= $this->walkSimpleArithmeticExpression($expr) . ' AS ' . $columnAlias;
|
|
}
|
|
|
|
$this->_scalarResultAliasMap[$resultAlias] = $columnAlias;
|
|
|
|
$columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
|
|
$this->_rsm->addScalarResult($columnAlias, $resultAlias);
|
|
} else if (
|
|
$expr instanceof AST\NullIfExpression ||
|
|
$expr instanceof AST\CoalesceExpression ||
|
|
$expr instanceof AST\GeneralCaseExpression ||
|
|
$expr instanceof AST\SimpleCaseExpression
|
|
) {
|
|
if ( ! $selectExpression->fieldIdentificationVariable) {
|
|
$resultAlias = $this->_scalarResultCounter++;
|
|
} else {
|
|
$resultAlias = $selectExpression->fieldIdentificationVariable;
|
|
}
|
|
|
|
$columnAlias = 'sclr' . $this->_aliasCounter++;
|
|
|
|
$sql .= $this->walkCaseExpression($expr) . ' AS ' . $columnAlias;
|
|
|
|
$this->_scalarResultAliasMap[$resultAlias] = $columnAlias;
|
|
|
|
$columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
|
|
$this->_rsm->addScalarResult($columnAlias, $resultAlias);
|
|
} else {
|
|
// IdentificationVariable or PartialObjectExpression
|
|
if ($expr instanceof AST\PartialObjectExpression) {
|
|
$dqlAlias = $expr->identificationVariable;
|
|
$partialFieldSet = $expr->partialFieldSet;
|
|
} else {
|
|
$dqlAlias = $expr;
|
|
$partialFieldSet = array();
|
|
}
|
|
|
|
$queryComp = $this->_queryComponents[$dqlAlias];
|
|
$class = $queryComp['metadata'];
|
|
|
|
if ( ! isset($this->_selectedClasses[$dqlAlias])) {
|
|
$this->_selectedClasses[$dqlAlias] = $class;
|
|
}
|
|
|
|
$beginning = true;
|
|
// Select all fields from the queried class
|
|
foreach ($class->fieldMappings as $fieldName => $mapping) {
|
|
if ($partialFieldSet && !in_array($fieldName, $partialFieldSet)) {
|
|
continue;
|
|
}
|
|
|
|
if (isset($mapping['inherited'])) {
|
|
$tableName = $this->_em->getClassMetadata($mapping['inherited'])->table['name'];
|
|
} else {
|
|
$tableName = $class->table['name'];
|
|
}
|
|
|
|
if ($beginning) $beginning = false; else $sql .= ', ';
|
|
|
|
$sqlTableAlias = $this->getSQLTableAlias($tableName, $dqlAlias);
|
|
$columnAlias = $this->getSQLColumnAlias($mapping['columnName']);
|
|
$sql .= $sqlTableAlias . '.' . $class->getQuotedColumnName($fieldName, $this->_platform)
|
|
. ' AS ' . $columnAlias;
|
|
|
|
$columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
|
|
$this->_rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $class->name);
|
|
}
|
|
|
|
// Add any additional fields of subclasses (excluding inherited fields)
|
|
// 1) on Single Table Inheritance: always, since its marginal overhead
|
|
// 2) on Class Table Inheritance only if partial objects are disallowed,
|
|
// since it requires outer joining subtables.
|
|
if ($class->isInheritanceTypeSingleTable() || ! $this->_query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
|
|
foreach ($class->subClasses as $subClassName) {
|
|
$subClass = $this->_em->getClassMetadata($subClassName);
|
|
$sqlTableAlias = $this->getSQLTableAlias($subClass->table['name'], $dqlAlias);
|
|
foreach ($subClass->fieldMappings as $fieldName => $mapping) {
|
|
if (isset($mapping['inherited']) || $partialFieldSet && !in_array($fieldName, $partialFieldSet)) {
|
|
continue;
|
|
}
|
|
|
|
if ($beginning) $beginning = false; else $sql .= ', ';
|
|
|
|
$columnAlias = $this->getSQLColumnAlias($mapping['columnName']);
|
|
$sql .= $sqlTableAlias . '.' . $subClass->getQuotedColumnName($fieldName, $this->_platform)
|
|
. ' AS ' . $columnAlias;
|
|
|
|
$columnAlias = $this->_platform->getSQLResultCasing($columnAlias);
|
|
$this->_rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $subClassName);
|
|
}
|
|
|
|
// Add join columns (foreign keys) of the subclass
|
|
//TODO: Probably better do this in walkSelectClause to honor the INCLUDE_META_COLUMNS hint
|
|
foreach ($subClass->associationMappings as $fieldName => $assoc) {
|
|
if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE && ! isset($assoc['inherited'])) {
|
|
foreach ($assoc['targetToSourceKeyColumns'] as $srcColumn) {
|
|
if ($beginning) $beginning = false; else $sql .= ', ';
|
|
$columnAlias = $this->getSQLColumnAlias($srcColumn);
|
|
$sql .= $sqlTableAlias . '.' . $srcColumn . ' AS ' . $columnAlias;
|
|
$this->_rsm->addMetaResult($dqlAlias, $this->_platform->getSQLResultCasing($columnAlias), $srcColumn);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down a QuantifiedExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param QuantifiedExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkQuantifiedExpression($qExpr)
|
|
{
|
|
return ' ' . strtoupper($qExpr->type)
|
|
. '(' . $this->walkSubselect($qExpr->subselect) . ')';
|
|
}
|
|
|
|
/**
|
|
* Walks down a Subselect AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param Subselect
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkSubselect($subselect)
|
|
{
|
|
$useAliasesBefore = $this->_useSqlTableAliases;
|
|
$rootAliasesBefore = $this->_rootAliases;
|
|
|
|
$this->_rootAliases = array(); // reset the rootAliases for the subselect
|
|
$this->_useSqlTableAliases = true;
|
|
|
|
$sql = $this->walkSimpleSelectClause($subselect->simpleSelectClause);
|
|
$sql .= $this->walkSubselectFromClause($subselect->subselectFromClause);
|
|
$sql .= $this->walkWhereClause($subselect->whereClause);
|
|
$sql .= $subselect->groupByClause ? $this->walkGroupByClause($subselect->groupByClause) : '';
|
|
$sql .= $subselect->havingClause ? $this->walkHavingClause($subselect->havingClause) : '';
|
|
$sql .= $subselect->orderByClause ? $this->walkOrderByClause($subselect->orderByClause) : '';
|
|
|
|
$this->_rootAliases = $rootAliasesBefore; // put the main aliases back
|
|
$this->_useSqlTableAliases = $useAliasesBefore;
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down a SubselectFromClause AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param SubselectFromClause
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkSubselectFromClause($subselectFromClause)
|
|
{
|
|
$identificationVarDecls = $subselectFromClause->identificationVariableDeclarations;
|
|
$sqlParts = array ();
|
|
|
|
foreach ($identificationVarDecls as $subselectIdVarDecl) {
|
|
$sql = '';
|
|
|
|
$rangeDecl = $subselectIdVarDecl->rangeVariableDeclaration;
|
|
$dqlAlias = $rangeDecl->aliasIdentificationVariable;
|
|
|
|
$class = $this->_em->getClassMetadata($rangeDecl->abstractSchemaName);
|
|
$sql .= $class->getQuotedTableName($this->_platform) . ' '
|
|
. $this->getSQLTableAlias($class->table['name'], $dqlAlias);
|
|
|
|
$this->_rootAliases[] = $dqlAlias;
|
|
|
|
if ($class->isInheritanceTypeJoined()) {
|
|
$sql .= $this->_generateClassTableInheritanceJoins($class, $dqlAlias);
|
|
}
|
|
|
|
foreach ($subselectIdVarDecl->joinVariableDeclarations as $joinVarDecl) {
|
|
$sql .= $this->walkJoinVariableDeclaration($joinVarDecl);
|
|
}
|
|
|
|
$sqlParts[] = $this->_platform->appendLockHint($sql, $this->_query->getHint(Query::HINT_LOCK_MODE));
|
|
}
|
|
|
|
return ' FROM ' . implode(', ', $sqlParts);
|
|
}
|
|
|
|
/**
|
|
* Walks down a SimpleSelectClause AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param SimpleSelectClause
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkSimpleSelectClause($simpleSelectClause)
|
|
{
|
|
return 'SELECT' . ($simpleSelectClause->isDistinct ? ' DISTINCT' : '')
|
|
. $this->walkSimpleSelectExpression($simpleSelectClause->simpleSelectExpression);
|
|
}
|
|
|
|
/**
|
|
* Walks down a SimpleSelectExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param SimpleSelectExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkSimpleSelectExpression($simpleSelectExpression)
|
|
{
|
|
$sql = '';
|
|
$expr = $simpleSelectExpression->expression;
|
|
|
|
if ($expr instanceof AST\PathExpression) {
|
|
$sql .= $this->walkPathExpression($expr);
|
|
} else if ($expr instanceof AST\AggregateExpression) {
|
|
if ( ! $simpleSelectExpression->fieldIdentificationVariable) {
|
|
$alias = $this->_scalarResultCounter++;
|
|
} else {
|
|
$alias = $simpleSelectExpression->fieldIdentificationVariable;
|
|
}
|
|
|
|
$sql .= $this->walkAggregateExpression($expr) . ' AS dctrn__' . $alias;
|
|
} else if ($expr instanceof AST\Subselect) {
|
|
if ( ! $simpleSelectExpression->fieldIdentificationVariable) {
|
|
$alias = $this->_scalarResultCounter++;
|
|
} else {
|
|
$alias = $simpleSelectExpression->fieldIdentificationVariable;
|
|
}
|
|
|
|
$columnAlias = 'sclr' . $this->_aliasCounter++;
|
|
$sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
|
|
$this->_scalarResultAliasMap[$alias] = $columnAlias;
|
|
} else if ($expr instanceof AST\Functions\FunctionNode) {
|
|
if ( ! $simpleSelectExpression->fieldIdentificationVariable) {
|
|
$alias = $this->_scalarResultCounter++;
|
|
} else {
|
|
$alias = $simpleSelectExpression->fieldIdentificationVariable;
|
|
}
|
|
|
|
$columnAlias = 'sclr' . $this->_aliasCounter++;
|
|
$sql .= $this->walkFunction($expr) . ' AS ' . $columnAlias;
|
|
$this->_scalarResultAliasMap[$alias] = $columnAlias;
|
|
} else if (
|
|
$expr instanceof AST\SimpleArithmeticExpression ||
|
|
$expr instanceof AST\ArithmeticTerm ||
|
|
$expr instanceof AST\ArithmeticFactor ||
|
|
$expr instanceof AST\ArithmeticPrimary
|
|
) {
|
|
if ( ! $simpleSelectExpression->fieldIdentificationVariable) {
|
|
$alias = $this->_scalarResultCounter++;
|
|
} else {
|
|
$alias = $simpleSelectExpression->fieldIdentificationVariable;
|
|
}
|
|
|
|
$columnAlias = 'sclr' . $this->_aliasCounter++;
|
|
$sql .= $this->walkSimpleArithmeticExpression($expr) . ' AS ' . $columnAlias;
|
|
$this->_scalarResultAliasMap[$alias] = $columnAlias;
|
|
} else {
|
|
// IdentificationVariable
|
|
$class = $this->_queryComponents[$expr]['metadata'];
|
|
$tableAlias = $this->getSQLTableAlias($class->getTableName(), $expr);
|
|
$first = true;
|
|
|
|
foreach ($class->identifier as $identifier) {
|
|
if ($first) $first = false; else $sql .= ', ';
|
|
$sql .= $tableAlias . '.' . $class->getQuotedColumnName($identifier, $this->_platform);
|
|
}
|
|
}
|
|
|
|
return ' ' . $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down an AggregateExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param AggregateExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkAggregateExpression($aggExpression)
|
|
{
|
|
return $aggExpression->functionName . '(' . ($aggExpression->isDistinct ? 'DISTINCT ' : '')
|
|
. $this->walkSimpleArithmeticExpression($aggExpression->pathExpression) . ')';
|
|
}
|
|
|
|
/**
|
|
* Walks down a GroupByClause AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param GroupByClause
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkGroupByClause($groupByClause)
|
|
{
|
|
$sql = '';
|
|
foreach ($groupByClause->groupByItems AS $groupByItem) {
|
|
if (is_string($groupByItem)) {
|
|
foreach ($this->_queryComponents[$groupByItem]['metadata']->identifier AS $idField) {
|
|
if ($sql != '') {
|
|
$sql .= ', ';
|
|
}
|
|
$groupByItem = new AST\PathExpression(AST\PathExpression::TYPE_STATE_FIELD, $groupByItem, $idField);
|
|
$groupByItem->type = AST\PathExpression::TYPE_STATE_FIELD;
|
|
$sql .= $this->walkGroupByItem($groupByItem);
|
|
}
|
|
} else {
|
|
if ($sql != '') {
|
|
$sql .= ', ';
|
|
}
|
|
$sql .= $this->walkGroupByItem($groupByItem);
|
|
}
|
|
}
|
|
return ' GROUP BY ' . $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down a GroupByItem AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param GroupByItem
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkGroupByItem(AST\PathExpression $pathExpr)
|
|
{
|
|
return $this->walkPathExpression($pathExpr);
|
|
}
|
|
|
|
/**
|
|
* Walks down a DeleteClause AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param DeleteClause
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkDeleteClause(AST\DeleteClause $deleteClause)
|
|
{
|
|
$sql = 'DELETE FROM ';
|
|
$class = $this->_em->getClassMetadata($deleteClause->abstractSchemaName);
|
|
$sql .= $class->getQuotedTableName($this->_platform);
|
|
|
|
$this->setSQLTableAlias($class->getTableName(), $class->getTableName(), $deleteClause->aliasIdentificationVariable);
|
|
|
|
$this->_rootAliases[] = $deleteClause->aliasIdentificationVariable;
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down an UpdateClause AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param UpdateClause
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkUpdateClause($updateClause)
|
|
{
|
|
$sql = 'UPDATE ';
|
|
$class = $this->_em->getClassMetadata($updateClause->abstractSchemaName);
|
|
$sql .= $class->getQuotedTableName($this->_platform);
|
|
|
|
$this->setSQLTableAlias($class->getTableName(), $class->getTableName(), $updateClause->aliasIdentificationVariable);
|
|
|
|
$this->_rootAliases[] = $updateClause->aliasIdentificationVariable;
|
|
|
|
$sql .= ' SET ' . implode(
|
|
', ', array_map(array($this, 'walkUpdateItem'), $updateClause->updateItems)
|
|
);
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down an UpdateItem AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param UpdateItem
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkUpdateItem($updateItem)
|
|
{
|
|
$useTableAliasesBefore = $this->_useSqlTableAliases;
|
|
$this->_useSqlTableAliases = false;
|
|
|
|
$sql = $this->walkPathExpression($updateItem->pathExpression) . ' = ';
|
|
|
|
$newValue = $updateItem->newValue;
|
|
|
|
if ($newValue === null) {
|
|
$sql .= 'NULL';
|
|
} else if ($newValue instanceof AST\Node) {
|
|
$sql .= $newValue->dispatch($this);
|
|
} else {
|
|
$sql .= $this->_conn->quote($newValue);
|
|
}
|
|
|
|
$this->_useSqlTableAliases = $useTableAliasesBefore;
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down a WhereClause AST node, thereby generating the appropriate SQL.
|
|
* WhereClause or not, the appropriate discriminator sql is added.
|
|
*
|
|
* @param WhereClause
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkWhereClause($whereClause)
|
|
{
|
|
$condSql = null !== $whereClause ? $this->walkConditionalExpression($whereClause->conditionalExpression) : '';
|
|
$discrSql = $this->_generateDiscriminatorColumnConditionSql($this->_rootAliases);
|
|
|
|
$filterSql = '';
|
|
|
|
// Apply the filters for all entities in FROM
|
|
$first = true;
|
|
foreach ($this->_rootAliases as $dqlAlias) {
|
|
$class = $this->_queryComponents[$dqlAlias]['metadata'];
|
|
$tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
|
|
|
|
if("" !== $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias)) {
|
|
if ( ! $first) $filterSql .= ' AND '; else $first = false;
|
|
$filterSql .= $filterExpr;
|
|
}
|
|
}
|
|
|
|
if ('' !== $filterSql) {
|
|
if($condSql) $condSql .= ' AND ';
|
|
|
|
$condSql .= $filterSql;
|
|
}
|
|
|
|
if ($condSql) {
|
|
return ' WHERE ' . (( ! $discrSql) ? $condSql : '(' . $condSql . ') AND ' . $discrSql);
|
|
} else if ($discrSql) {
|
|
return ' WHERE ' . $discrSql;
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Walk down a ConditionalExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param ConditionalExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkConditionalExpression($condExpr)
|
|
{
|
|
// Phase 2 AST optimization: Skip processment of ConditionalExpression
|
|
// if only one ConditionalTerm is defined
|
|
return ( ! ($condExpr instanceof AST\ConditionalExpression))
|
|
? $this->walkConditionalTerm($condExpr)
|
|
: implode(
|
|
' OR ', array_map(array($this, 'walkConditionalTerm'), $condExpr->conditionalTerms)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Walks down a ConditionalTerm AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param ConditionalTerm
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkConditionalTerm($condTerm)
|
|
{
|
|
// Phase 2 AST optimization: Skip processment of ConditionalTerm
|
|
// if only one ConditionalFactor is defined
|
|
return ( ! ($condTerm instanceof AST\ConditionalTerm))
|
|
? $this->walkConditionalFactor($condTerm)
|
|
: implode(
|
|
' AND ', array_map(array($this, 'walkConditionalFactor'), $condTerm->conditionalFactors)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Walks down a ConditionalFactor AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param ConditionalFactor
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkConditionalFactor($factor)
|
|
{
|
|
// Phase 2 AST optimization: Skip processment of ConditionalFactor
|
|
// if only one ConditionalPrimary is defined
|
|
return ( ! ($factor instanceof AST\ConditionalFactor))
|
|
? $this->walkConditionalPrimary($factor)
|
|
: ($factor->not ? 'NOT ' : '') . $this->walkConditionalPrimary($factor->conditionalPrimary);
|
|
}
|
|
|
|
/**
|
|
* Walks down a ConditionalPrimary AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param ConditionalPrimary
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkConditionalPrimary($primary)
|
|
{
|
|
if ($primary->isSimpleConditionalExpression()) {
|
|
return $primary->simpleConditionalExpression->dispatch($this);
|
|
} else if ($primary->isConditionalExpression()) {
|
|
$condExpr = $primary->conditionalExpression;
|
|
|
|
return '(' . $this->walkConditionalExpression($condExpr) . ')';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Walks down an ExistsExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param ExistsExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkExistsExpression($existsExpr)
|
|
{
|
|
$sql = ($existsExpr->not) ? 'NOT ' : '';
|
|
|
|
$sql .= 'EXISTS (' . $this->walkSubselect($existsExpr->subselect) . ')';
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down a CollectionMemberExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param CollectionMemberExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkCollectionMemberExpression($collMemberExpr)
|
|
{
|
|
$sql = $collMemberExpr->not ? 'NOT ' : '';
|
|
$sql .= 'EXISTS (SELECT 1 FROM ';
|
|
$entityExpr = $collMemberExpr->entityExpression;
|
|
$collPathExpr = $collMemberExpr->collectionValuedPathExpression;
|
|
|
|
$fieldName = $collPathExpr->field;
|
|
$dqlAlias = $collPathExpr->identificationVariable;
|
|
|
|
$class = $this->_queryComponents[$dqlAlias]['metadata'];
|
|
|
|
if ($entityExpr instanceof AST\InputParameter) {
|
|
$dqlParamKey = $entityExpr->name;
|
|
$entity = $this->_query->getParameter($dqlParamKey);
|
|
} else {
|
|
//TODO
|
|
throw new \BadMethodCallException("Not implemented");
|
|
}
|
|
|
|
$assoc = $class->associationMappings[$fieldName];
|
|
|
|
if ($assoc['type'] == ClassMetadata::ONE_TO_MANY) {
|
|
$targetClass = $this->_em->getClassMetadata($assoc['targetEntity']);
|
|
$targetTableAlias = $this->getSQLTableAlias($targetClass->table['name']);
|
|
$sourceTableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
|
|
|
|
$sql .= $targetClass->getQuotedTableName($this->_platform)
|
|
. ' ' . $targetTableAlias . ' WHERE ';
|
|
|
|
$owningAssoc = $targetClass->associationMappings[$assoc['mappedBy']];
|
|
|
|
$first = true;
|
|
|
|
foreach ($owningAssoc['targetToSourceKeyColumns'] as $targetColumn => $sourceColumn) {
|
|
if ($first) $first = false; else $sql .= ' AND ';
|
|
|
|
$sql .= $sourceTableAlias . '.' . $class->getQuotedColumnName($class->fieldNames[$targetColumn], $this->_platform)
|
|
. ' = '
|
|
. $targetTableAlias . '.' . $sourceColumn;
|
|
}
|
|
|
|
$sql .= ' AND ';
|
|
$first = true;
|
|
|
|
foreach ($targetClass->identifier as $idField) {
|
|
if ($first) $first = false; else $sql .= ' AND ';
|
|
|
|
$this->_parserResult->addParameterMapping($dqlParamKey, $this->_sqlParamIndex++);
|
|
$sql .= $targetTableAlias . '.'
|
|
. $targetClass->getQuotedColumnName($idField, $this->_platform) . ' = ?';
|
|
}
|
|
} else { // many-to-many
|
|
$targetClass = $this->_em->getClassMetadata($assoc['targetEntity']);
|
|
|
|
$owningAssoc = $assoc['isOwningSide'] ? $assoc : $targetClass->associationMappings[$assoc['mappedBy']];
|
|
$joinTable = $owningAssoc['joinTable'];
|
|
|
|
// SQL table aliases
|
|
$joinTableAlias = $this->getSQLTableAlias($joinTable['name']);
|
|
$targetTableAlias = $this->getSQLTableAlias($targetClass->table['name']);
|
|
$sourceTableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
|
|
|
|
// join to target table
|
|
$sql .= $targetClass->getQuotedJoinTableName($owningAssoc, $this->_platform)
|
|
. ' ' . $joinTableAlias . ' INNER JOIN '
|
|
. $targetClass->getQuotedTableName($this->_platform)
|
|
. ' ' . $targetTableAlias . ' ON ';
|
|
|
|
// join conditions
|
|
$joinColumns = $assoc['isOwningSide']
|
|
? $joinTable['inverseJoinColumns']
|
|
: $joinTable['joinColumns'];
|
|
|
|
$first = true;
|
|
foreach ($joinColumns as $joinColumn) {
|
|
if ($first) $first = false; else $sql .= ' AND ';
|
|
|
|
$sql .= $joinTableAlias . '.' . $joinColumn['name'] . ' = '
|
|
. $targetTableAlias . '.' . $targetClass->getQuotedColumnName(
|
|
$targetClass->fieldNames[$joinColumn['referencedColumnName']],
|
|
$this->_platform);
|
|
}
|
|
|
|
$sql .= ' WHERE ';
|
|
|
|
$joinColumns = $assoc['isOwningSide']
|
|
? $joinTable['joinColumns']
|
|
: $joinTable['inverseJoinColumns'];
|
|
|
|
$first = true;
|
|
foreach ($joinColumns as $joinColumn) {
|
|
if ($first) $first = false; else $sql .= ' AND ';
|
|
|
|
$sql .= $joinTableAlias . '.' . $joinColumn['name'] . ' = '
|
|
. $sourceTableAlias . '.' . $class->getQuotedColumnName(
|
|
$class->fieldNames[$joinColumn['referencedColumnName']],
|
|
$this->_platform);
|
|
}
|
|
|
|
$sql .= ' AND ';
|
|
$first = true;
|
|
|
|
foreach ($targetClass->identifier as $idField) {
|
|
if ($first) $first = false; else $sql .= ' AND ';
|
|
|
|
$this->_parserResult->addParameterMapping($dqlParamKey, $this->_sqlParamIndex++);
|
|
$sql .= $targetTableAlias . '.'
|
|
. $targetClass->getQuotedColumnName($idField, $this->_platform) . ' = ?';
|
|
}
|
|
}
|
|
|
|
return $sql . ')';
|
|
}
|
|
|
|
/**
|
|
* Walks down an EmptyCollectionComparisonExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param EmptyCollectionComparisonExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkEmptyCollectionComparisonExpression($emptyCollCompExpr)
|
|
{
|
|
$sizeFunc = new AST\Functions\SizeFunction('size');
|
|
$sizeFunc->collectionPathExpression = $emptyCollCompExpr->expression;
|
|
|
|
return $sizeFunc->getSql($this) . ($emptyCollCompExpr->not ? ' > 0' : ' = 0');
|
|
}
|
|
|
|
/**
|
|
* Walks down a NullComparisonExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param NullComparisonExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkNullComparisonExpression($nullCompExpr)
|
|
{
|
|
$sql = '';
|
|
$innerExpr = $nullCompExpr->expression;
|
|
|
|
if ($innerExpr instanceof AST\InputParameter) {
|
|
$dqlParamKey = $innerExpr->name;
|
|
$this->_parserResult->addParameterMapping($dqlParamKey, $this->_sqlParamIndex++);
|
|
$sql .= ' ?';
|
|
} else {
|
|
$sql .= $this->walkPathExpression($innerExpr);
|
|
}
|
|
|
|
$sql .= ' IS' . ($nullCompExpr->not ? ' NOT' : '') . ' NULL';
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down an InExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param InExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkInExpression($inExpr)
|
|
{
|
|
$sql = $this->walkPathExpression($inExpr->pathExpression)
|
|
. ($inExpr->not ? ' NOT' : '') . ' IN (';
|
|
|
|
if ($inExpr->subselect) {
|
|
$sql .= $this->walkSubselect($inExpr->subselect);
|
|
} else {
|
|
$sql .= implode(', ', array_map(array($this, 'walkInParameter'), $inExpr->literals));
|
|
}
|
|
|
|
$sql .= ')';
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down an InstanceOfExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param InstanceOfExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkInstanceOfExpression($instanceOfExpr)
|
|
{
|
|
$sql = '';
|
|
|
|
$dqlAlias = $instanceOfExpr->identificationVariable;
|
|
$discrClass = $class = $this->_queryComponents[$dqlAlias]['metadata'];
|
|
$fieldName = null;
|
|
|
|
if ($class->discriminatorColumn) {
|
|
$discrClass = $this->_em->getClassMetadata($class->rootEntityName);
|
|
}
|
|
|
|
if ($this->_useSqlTableAliases) {
|
|
$sql .= $this->getSQLTableAlias($discrClass->table['name'], $dqlAlias) . '.';
|
|
}
|
|
|
|
$sql .= $class->discriminatorColumn['name'] . ($instanceOfExpr->not ? ' NOT IN ' : ' IN ');
|
|
|
|
$sqlParameterList = array();
|
|
|
|
foreach ($instanceOfExpr->value as $parameter) {
|
|
if ($parameter instanceof AST\InputParameter) {
|
|
// We need to modify the parameter value to be its correspondent mapped value
|
|
$dqlParamKey = $parameter->name;
|
|
$paramValue = $this->_query->getParameter($dqlParamKey);
|
|
|
|
if ( ! ($paramValue instanceof \Doctrine\ORM\Mapping\ClassMetadata)) {
|
|
throw QueryException::invalidParameterType('ClassMetadata', get_class($paramValue));
|
|
}
|
|
|
|
$entityClassName = $paramValue->name;
|
|
} else {
|
|
// Get name from ClassMetadata to resolve aliases.
|
|
$entityClassName = $this->_em->getClassMetadata($parameter)->name;
|
|
}
|
|
|
|
if ($entityClassName == $class->name) {
|
|
$sqlParameterList[] = $this->_conn->quote($class->discriminatorValue);
|
|
} else {
|
|
$discrMap = array_flip($class->discriminatorMap);
|
|
|
|
if (!isset($discrMap[$entityClassName])) {
|
|
throw QueryException::instanceOfUnrelatedClass($entityClassName, $class->rootEntityName);
|
|
}
|
|
|
|
$sqlParameterList[] = $this->_conn->quote($discrMap[$entityClassName]);
|
|
}
|
|
}
|
|
|
|
$sql .= '(' . implode(', ', $sqlParameterList) . ')';
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down an InParameter AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param InParameter
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkInParameter($inParam)
|
|
{
|
|
return $inParam instanceof AST\InputParameter ?
|
|
$this->walkInputParameter($inParam) :
|
|
$this->walkLiteral($inParam);
|
|
}
|
|
|
|
/**
|
|
* Walks down a literal that represents an AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param mixed
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkLiteral($literal)
|
|
{
|
|
switch ($literal->type) {
|
|
case AST\Literal::STRING:
|
|
return $this->_conn->quote($literal->value);
|
|
case AST\Literal::BOOLEAN:
|
|
$bool = strtolower($literal->value) == 'true' ? true : false;
|
|
$boolVal = $this->_conn->getDatabasePlatform()->convertBooleans($bool);
|
|
return is_string($boolVal) ? $this->_conn->quote($boolVal) : $boolVal;
|
|
case AST\Literal::NUMERIC:
|
|
return $literal->value;
|
|
default:
|
|
throw QueryException::invalidLiteral($literal);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Walks down a BetweenExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param BetweenExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkBetweenExpression($betweenExpr)
|
|
{
|
|
$sql = $this->walkArithmeticExpression($betweenExpr->expression);
|
|
|
|
if ($betweenExpr->not) $sql .= ' NOT';
|
|
|
|
$sql .= ' BETWEEN ' . $this->walkArithmeticExpression($betweenExpr->leftBetweenExpression)
|
|
. ' AND ' . $this->walkArithmeticExpression($betweenExpr->rightBetweenExpression);
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down a LikeExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param LikeExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkLikeExpression($likeExpr)
|
|
{
|
|
$stringExpr = $likeExpr->stringExpression;
|
|
$sql = $stringExpr->dispatch($this) . ($likeExpr->not ? ' NOT' : '') . ' LIKE ';
|
|
|
|
if ($likeExpr->stringPattern instanceof AST\InputParameter) {
|
|
$inputParam = $likeExpr->stringPattern;
|
|
$dqlParamKey = $inputParam->name;
|
|
$this->_parserResult->addParameterMapping($dqlParamKey, $this->_sqlParamIndex++);
|
|
$sql .= '?';
|
|
} else {
|
|
$sql .= $this->_conn->quote($likeExpr->stringPattern);
|
|
}
|
|
|
|
if ($likeExpr->escapeChar) {
|
|
$sql .= ' ESCAPE ' . $this->_conn->quote($likeExpr->escapeChar);
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down a StateFieldPathExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param StateFieldPathExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkStateFieldPathExpression($stateFieldPathExpression)
|
|
{
|
|
return $this->walkPathExpression($stateFieldPathExpression);
|
|
}
|
|
|
|
/**
|
|
* Walks down a ComparisonExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param ComparisonExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkComparisonExpression($compExpr)
|
|
{
|
|
$sql = '';
|
|
$leftExpr = $compExpr->leftExpression;
|
|
$rightExpr = $compExpr->rightExpression;
|
|
|
|
if ($leftExpr instanceof AST\Node) {
|
|
$sql .= $leftExpr->dispatch($this);
|
|
} else {
|
|
$sql .= is_numeric($leftExpr) ? $leftExpr : $this->_conn->quote($leftExpr);
|
|
}
|
|
|
|
$sql .= ' ' . $compExpr->operator . ' ';
|
|
|
|
if ($rightExpr instanceof AST\Node) {
|
|
$sql .= $rightExpr->dispatch($this);
|
|
} else {
|
|
$sql .= is_numeric($rightExpr) ? $rightExpr : $this->_conn->quote($rightExpr);
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Walks down an InputParameter AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param InputParameter
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkInputParameter($inputParam)
|
|
{
|
|
$this->_parserResult->addParameterMapping($inputParam->name, $this->_sqlParamIndex++);
|
|
|
|
return '?';
|
|
}
|
|
|
|
/**
|
|
* Walks down an ArithmeticExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param ArithmeticExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkArithmeticExpression($arithmeticExpr)
|
|
{
|
|
return ($arithmeticExpr->isSimpleArithmeticExpression())
|
|
? $this->walkSimpleArithmeticExpression($arithmeticExpr->simpleArithmeticExpression)
|
|
: '(' . $this->walkSubselect($arithmeticExpr->subselect) . ')';
|
|
}
|
|
|
|
/**
|
|
* Walks down an SimpleArithmeticExpression AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param SimpleArithmeticExpression
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkSimpleArithmeticExpression($simpleArithmeticExpr)
|
|
{
|
|
return ( ! ($simpleArithmeticExpr instanceof AST\SimpleArithmeticExpression))
|
|
? $this->walkArithmeticTerm($simpleArithmeticExpr)
|
|
: implode(
|
|
' ', array_map(array($this, 'walkArithmeticTerm'), $simpleArithmeticExpr->arithmeticTerms)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Walks down an ArithmeticTerm AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param mixed
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkArithmeticTerm($term)
|
|
{
|
|
if (is_string($term)) {
|
|
return $term;
|
|
}
|
|
|
|
// Phase 2 AST optimization: Skip processment of ArithmeticTerm
|
|
// if only one ArithmeticFactor is defined
|
|
return ( ! ($term instanceof AST\ArithmeticTerm))
|
|
? $this->walkArithmeticFactor($term)
|
|
: implode(
|
|
' ', array_map(array($this, 'walkArithmeticFactor'), $term->arithmeticFactors)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Walks down an ArithmeticFactor that represents an AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param mixed
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkArithmeticFactor($factor)
|
|
{
|
|
if (is_string($factor)) {
|
|
return $factor;
|
|
}
|
|
|
|
// Phase 2 AST optimization: Skip processment of ArithmeticFactor
|
|
// if only one ArithmeticPrimary is defined
|
|
return ( ! ($factor instanceof AST\ArithmeticFactor))
|
|
? $this->walkArithmeticPrimary($factor)
|
|
: ($factor->isNegativeSigned() ? '-' : ($factor->isPositiveSigned() ? '+' : ''))
|
|
. $this->walkArithmeticPrimary($factor->arithmeticPrimary);
|
|
}
|
|
|
|
/**
|
|
* Walks down an ArithmeticPrimary that represents an AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param mixed
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkArithmeticPrimary($primary)
|
|
{
|
|
if ($primary instanceof AST\SimpleArithmeticExpression) {
|
|
return '(' . $this->walkSimpleArithmeticExpression($primary) . ')';
|
|
} else if ($primary instanceof AST\Node) {
|
|
return $primary->dispatch($this);
|
|
}
|
|
|
|
// TODO: We need to deal with IdentificationVariable here
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Walks down a StringPrimary that represents an AST node, thereby generating the appropriate SQL.
|
|
*
|
|
* @param mixed
|
|
* @return string The SQL.
|
|
*/
|
|
public function walkStringPrimary($stringPrimary)
|
|
{
|
|
return (is_string($stringPrimary))
|
|
? $this->_conn->quote($stringPrimary)
|
|
: $stringPrimary->dispatch($this);
|
|
}
|
|
}
|