vendor/doctrine/orm/lib/Doctrine/ORM/Query/SqlWalker.php line 1795

Open in your IDE?
  1. <?php
  2. /*
  3.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  4.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  5.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  6.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  7.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  8.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  9.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  *
  15.  * This software consists of voluntary contributions made by many individuals
  16.  * and is licensed under the MIT license. For more information, see
  17.  * <http://www.doctrine-project.org>.
  18.  */
  20. namespace Doctrine\ORM\Query;
  22. use Doctrine\DBAL\LockMode;
  23. use Doctrine\DBAL\Types\Type;
  24. use Doctrine\ORM\Mapping\ClassMetadata;
  25. use Doctrine\ORM\Mapping\ClassMetadataInfo;
  26. use Doctrine\ORM\OptimisticLockException;
  27. use Doctrine\ORM\Query;
  28. use Doctrine\ORM\Utility\HierarchyDiscriminatorResolver;
  29. use Doctrine\ORM\Utility\PersisterHelper;
  30. use function trim;
  32. /**
  33.  * The SqlWalker is a TreeWalker that walks over a DQL AST and constructs
  34.  * the corresponding SQL.
  35.  *
  36.  * @author Guilherme Blanco <[email protected]>
  37.  * @author Roman Borschel <[email protected]>
  38.  * @author Benjamin Eberlei <[email protected]>
  39.  * @author Alexander <[email protected]>
  40.  * @author Fabio B. Silva <[email protected]>
  41.  * @since  2.0
  42.  */
  43. class SqlWalker implements TreeWalker
  44. {
  45.     /**
  46.      * @var string
  47.      */
  48.     const HINT_DISTINCT = 'doctrine.distinct';
  50.     /**
  51.      * Used to mark a query as containing a PARTIAL expression, which needs to be known by SLC.
  52.      */
  53.     public const HINT_PARTIAL = 'doctrine.partial';
  55.     /**
  56.      * @var ResultSetMapping
  57.      */
  58.     private $rsm;
  60.     /**
  61.      * Counter for generating unique column aliases.
  62.      *
  63.      * @var integer
  64.      */
  65.     private $aliasCounter = 0;
  67.     /**
  68.      * Counter for generating unique table aliases.
  69.      *
  70.      * @var integer
  71.      */
  72.     private $tableAliasCounter = 0;
  74.     /**
  75.      * Counter for generating unique scalar result.
  76.      *
  77.      * @var integer
  78.      */
  79.     private $scalarResultCounter = 1;
  81.     /**
  82.      * Counter for generating unique parameter indexes.
  83.      *
  84.      * @var integer
  85.      */
  86.     private $sqlParamIndex = 0;
  88.     /**
  89.      * Counter for generating indexes.
  90.      *
  91.      * @var integer
  92.      */
  93.     private $newObjectCounter = 0;
  95.     /**
  96.      * @var ParserResult
  97.      */
  98.     private $parserResult;
  100.     /**
  101.      * @var \Doctrine\ORM\EntityManager
  102.      */
  103.     private $em;
  105.     /**
  106.      * @var \Doctrine\DBAL\Connection
  107.      */
  108.     private $conn;
  110.     /**
  111.      * @var \Doctrine\ORM\AbstractQuery
  112.      */
  113.     private $query;
  115.     /**
  116.      * @var array
  117.      */
  118.     private $tableAliasMap = [];
  120.     /**
  121.      * Map from result variable names to their SQL column alias names.
  122.      *
  123.      * @var array
  124.      */
  125.     private $scalarResultAliasMap = [];
  127.     /**
  128.      * Map from Table-Alias + Column-Name to OrderBy-Direction.
  129.      *
  130.      * @var array
  131.      */
  132.     private $orderedColumnsMap = [];
  134.     /**
  135.      * Map from DQL-Alias + Field-Name to SQL Column Alias.
  136.      *
  137.      * @var array
  138.      */
  139.     private $scalarFields = [];
  141.     /**
  142.      * Map of all components/classes that appear in the DQL query.
  143.      *
  144.      * @var array
  145.      *
  146.      * @psalm-var array<string, array{metadata: ClassMetadata}>
  147.      */
  148.     private $queryComponents;
  150.     /**
  151.      * A list of classes that appear in non-scalar SelectExpressions.
  152.      *
  153.      * @var array
  154.      */
  155.     private $selectedClasses = [];
  157.     /**
  158.      * The DQL alias of the root class of the currently traversed query.
  159.      *
  160.      * @var array
  161.      */
  162.     private $rootAliases = [];
  164.     /**
  165.      * Flag that indicates whether to generate SQL table aliases in the SQL.
  166.      * These should only be generated for SELECT queries, not for UPDATE/DELETE.
  167.      *
  168.      * @var boolean
  169.      */
  170.     private $useSqlTableAliases = true;
  172.     /**
  173.      * The database platform abstraction.
  174.      *
  175.      * @var \Doctrine\DBAL\Platforms\AbstractPlatform
  176.      */
  177.     private $platform;
  179.     /**
  180.      * The quote strategy.
  181.      *
  182.      * @var \Doctrine\ORM\Mapping\QuoteStrategy
  183.      */
  184.     private $quoteStrategy;
  186.     /**
  187.      * {@inheritDoc}
  188.      */
  189.     public function __construct($query, $parserResult, array $queryComponents)
  190.     {
  191.         $this->query            = $query;
  192.         $this->parserResult     = $parserResult;
  193.         $this->queryComponents  = $queryComponents;
  194.         $this->rsm              = $parserResult->getResultSetMapping();
  195.         $this->em               = $query->getEntityManager();
  196.         $this->conn             = $this->em->getConnection();
  197.         $this->platform         = $this->conn->getDatabasePlatform();
  198.         $this->quoteStrategy    = $this->em->getConfiguration()->getQuoteStrategy();
  199.     }
  201.     /**
  202.      * Gets the Query instance used by the walker.
  203.      *
  204.      * @return Query
  205.      */
  206.     public function getQuery()
  207.     {
  208.         return $this->query;
  209.     }
  211.     /**
  212.      * Gets the Connection used by the walker.
  213.      *
  214.      * @return \Doctrine\DBAL\Connection
  215.      */
  216.     public function getConnection()
  217.     {
  218.         return $this->conn;
  219.     }
  221.     /**
  222.      * Gets the EntityManager used by the walker.
  223.      *
  224.      * @return \Doctrine\ORM\EntityManager
  225.      */
  226.     public function getEntityManager()
  227.     {
  228.         return $this->em;
  229.     }
  231.     /**
  232.      * Gets the information about a single query component.
  233.      *
  234.      * @param string $dqlAlias The DQL alias.
  235.      *
  236.      * @return array
  237.      *
  238.      * @psalm-return array{metadata: ClassMetadata}
  239.      */
  240.     public function getQueryComponent($dqlAlias)
  241.     {
  242.         return $this->queryComponents[$dqlAlias];
  243.     }
  245.     /**
  246.      * {@inheritdoc}
  247.      */
  248.     public function getQueryComponents()
  249.     {
  250.         return $this->queryComponents;
  251.     }
  253.     /**
  254.      * {@inheritdoc}
  255.      */
  256.     public function setQueryComponent($dqlAlias, array $queryComponent)
  257.     {
  258.         $requiredKeys = ['metadata', 'parent', 'relation', 'map', 'nestingLevel', 'token'];
  260.         if (array_diff($requiredKeys, array_keys($queryComponent))) {
  261.             throw QueryException::invalidQueryComponent($dqlAlias);
  262.         }
  264.         $this->queryComponents[$dqlAlias] = $queryComponent;
  265.     }
  267.     /**
  268.      * {@inheritdoc}
  269.      */
  270.     public function getExecutor($AST)
  271.     {
  272.         switch (true) {
  273.             case ($AST instanceof AST\DeleteStatement):
  274.                 $primaryClass = $this->em->getClassMetadata($AST->deleteClause->abstractSchemaName);
  276.                 return ($primaryClass->isInheritanceTypeJoined())
  277.                     ? new Exec\MultiTableDeleteExecutor($AST, $this)
  278.                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
  280.             case ($AST instanceof AST\UpdateStatement):
  281.                 $primaryClass = $this->em->getClassMetadata($AST->updateClause->abstractSchemaName);
  283.                 return ($primaryClass->isInheritanceTypeJoined())
  284.                     ? new Exec\MultiTableUpdateExecutor($AST, $this)
  285.                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
  287.             default:
  288.                 return new Exec\SingleSelectExecutor($AST, $this);
  289.         }
  290.     }
  292.     /**
  293.      * Generates a unique, short SQL table alias.
  294.      *
  295.      * @param string $tableName Table name
  296.      * @param string $dqlAlias  The DQL alias.
  297.      *
  298.      * @return string Generated table alias.
  299.      */
  300.     public function getSQLTableAlias($tableName, $dqlAlias = '')
  301.     {
  302.         $tableName .= ($dqlAlias) ? '@[' . $dqlAlias . ']' : '';
  304.         if ( ! isset($this->tableAliasMap[$tableName])) {
  305.             $this->tableAliasMap[$tableName] = (preg_match('/[a-z]/i', $tableName[0]) ? strtolower($tableName[0]) : 't')
  306.                 . $this->tableAliasCounter++ . '_';
  307.         }
  309.         return $this->tableAliasMap[$tableName];
  310.     }
  312.     /**
  313.      * Forces the SqlWalker to use a specific alias for a table name, rather than
  314.      * generating an alias on its own.
  315.      *
  316.      * @param string $tableName
  317.      * @param string $alias
  318.      * @param string $dqlAlias
  319.      *
  320.      * @return string
  321.      */
  322.     public function setSQLTableAlias($tableName, $alias, $dqlAlias = '')
  323.     {
  324.         $tableName .= ($dqlAlias) ? '@[' . $dqlAlias . ']' : '';
  326.         $this->tableAliasMap[$tableName] = $alias;
  328.         return $alias;
  329.     }
  331.     /**
  332.      * Gets an SQL column alias for a column name.
  333.      *
  334.      * @param string $columnName
  335.      *
  336.      * @return string
  337.      */
  338.     public function getSQLColumnAlias($columnName)
  339.     {
  340.         return $this->quoteStrategy->getColumnAlias($columnName, $this->aliasCounter++, $this->platform);
  341.     }
  343.     /**
  344.      * Generates the SQL JOINs that are necessary for Class Table Inheritance
  345.      * for the given class.
  346.      *
  347.      * @param ClassMetadata $class    The class for which to generate the joins.
  348.      * @param string        $dqlAlias The DQL alias of the class.
  349.      *
  350.      * @return string The SQL.
  351.      */
  352.     private function _generateClassTableInheritanceJoins($class, $dqlAlias)
  353.     {
  354.         $sql = '';
  356.         $baseTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  358.         // INNER JOIN parent class tables
  359.         foreach ($class->parentClasses as $parentClassName) {
  360.             $parentClass = $this->em->getClassMetadata($parentClassName);
  361.             $tableAlias  = $this->getSQLTableAlias($parentClass->getTableName(), $dqlAlias);
  363.             // If this is a joined association we must use left joins to preserve the correct result.
  364.             $sql .= isset($this->queryComponents[$dqlAlias]['relation']) ? ' LEFT ' : ' INNER ';
  365.             $sql .= 'JOIN ' . $this->quoteStrategy->getTableName($parentClass, $this->platform) . ' ' . $tableAlias . ' ON ';
  367.             $sqlParts = [];
  369.             foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
  370.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
  371.             }
  373.             // Add filters on the root class
  374.             if ($filterSql = $this->generateFilterConditionSQL($parentClass, $tableAlias)) {
  375.                 $sqlParts[] = $filterSql;
  376.             }
  378.             $sql .= implode(' AND ', $sqlParts);
  379.         }
  381.         // Ignore subclassing inclusion if partial objects is disallowed
  382.         if ($this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
  383.             return $sql;
  384.         }
  386.         // LEFT JOIN child class tables
  387.         foreach ($class->subClasses as $subClassName) {
  388.             $subClass   = $this->em->getClassMetadata($subClassName);
  389.             $tableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  391.             $sql .= ' LEFT JOIN ' . $this->quoteStrategy->getTableName($subClass, $this->platform) . ' ' . $tableAlias . ' ON ';
  393.             $sqlParts = [];
  395.             foreach ($this->quoteStrategy->getIdentifierColumnNames($subClass, $this->platform) as $columnName) {
  396.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
  397.             }
  399.             $sql .= implode(' AND ', $sqlParts);
  400.         }
  402.         return $sql;
  403.     }
  405.     /**
  406.      * @return string
  407.      */
  408.     private function _generateOrderedCollectionOrderByItems()
  409.     {
  410.         $orderedColumns = [];
  412.         foreach ($this->selectedClasses as $selectedClass) {
  413.             $dqlAlias  = $selectedClass['dqlAlias'];
  414.             $qComp     = $this->queryComponents[$dqlAlias];
  416.             if ( ! isset($qComp['relation']['orderBy'])) {
  417.                 continue;
  418.             }
  420.             $persister = $this->em->getUnitOfWork()->getEntityPersister($qComp['metadata']->name);
  422.             foreach ($qComp['relation']['orderBy'] as $fieldName => $orientation) {
  423.                 $columnName = $this->quoteStrategy->getColumnName($fieldName, $qComp['metadata'], $this->platform);
  424.                 $tableName  = ($qComp['metadata']->isInheritanceTypeJoined())
  425.                     ? $persister->getOwningTable($fieldName)
  426.                     : $qComp['metadata']->getTableName();
  428.                 $orderedColumn = $this->getSQLTableAlias($tableName, $dqlAlias) . '.' . $columnName;
  430.                 // OrderByClause should replace an ordered relation. see - DDC-2475
  431.                 if (isset($this->orderedColumnsMap[$orderedColumn])) {
  432.                     continue;
  433.                 }
  435.                 $this->orderedColumnsMap[$orderedColumn] = $orientation;
  436.                 $orderedColumns[] = $orderedColumn . ' ' . $orientation;
  437.             }
  438.         }
  440.         return implode(', ', $orderedColumns);
  441.     }
  443.     /**
  444.      * Generates a discriminator column SQL condition for the class with the given DQL alias.
  445.      *
  446.      * @param array $dqlAliases List of root DQL aliases to inspect for discriminator restrictions.
  447.      *
  448.      * @return string
  449.      */
  450.     private function _generateDiscriminatorColumnConditionSQL(array $dqlAliases)
  451.     {
  452.         $sqlParts = [];
  454.         foreach ($dqlAliases as $dqlAlias) {
  455.             $class = $this->queryComponents[$dqlAlias]['metadata'];
  457.             if ( ! $class->isInheritanceTypeSingleTable()) continue;
  459.             $conn   = $this->em->getConnection();
  460.             $values = [];
  462.             if ($class->discriminatorValue !== null) { // discriminators can be 0
  463.                 $values[] = $conn->quote($class->discriminatorValue);
  464.             }
  466.             foreach ($class->subClasses as $subclassName) {
  467.                 $values[] = $conn->quote($this->em->getClassMetadata($subclassName)->discriminatorValue);
  468.             }
  470.             $sqlTableAlias = ($this->useSqlTableAliases)
  471.                 ? $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.'
  472.                 : '';
  474.             $sqlParts[] = $sqlTableAlias . $class->discriminatorColumn['name'] . ' IN (' . implode(', ', $values) . ')';
  475.         }
  477.         $sql = implode(' AND ', $sqlParts);
  479.         return (count($sqlParts) > 1) ? '(' . $sql . ')' : $sql;
  480.     }
  482.     /**
  483.      * Generates the filter SQL for a given entity and table alias.
  484.      *
  485.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
  486.      * @param string        $targetTableAlias The table alias of the joined/selected table.
  487.      *
  488.      * @return string The SQL query part to add to a query.
  489.      */
  490.     private function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias)
  491.     {
  492.         if (!$this->em->hasFilters()) {
  493.             return '';
  494.         }
  496.         switch($targetEntity->inheritanceType) {
  497.             case ClassMetadata::INHERITANCE_TYPE_NONE:
  498.                 break;
  499.             case ClassMetadata::INHERITANCE_TYPE_JOINED:
  500.                 // The classes in the inheritance will be added to the query one by one,
  501.                 // but only the root node is getting filtered
  502.                 if ($targetEntity->name !== $targetEntity->rootEntityName) {
  503.                     return '';
  504.                 }
  505.                 break;
  506.             case ClassMetadata::INHERITANCE_TYPE_SINGLE_TABLE:
  507.                 // With STI the table will only be queried once, make sure that the filters
  508.                 // are added to the root entity
  509.                 $targetEntity = $this->em->getClassMetadata($targetEntity->rootEntityName);
  510.                 break;
  511.             default:
  512.                 //@todo: throw exception?
  513.                 return '';
  514.         }
  516.         $filterClauses = [];
  517.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  518.             if ('' !== $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias)) {
  519.                 $filterClauses[] = '(' . $filterExpr . ')';
  520.             }
  521.         }
  523.         return implode(' AND ', $filterClauses);
  524.     }
  526.     /**
  527.      * {@inheritdoc}
  528.      */
  529.     public function walkSelectStatement(AST\SelectStatement $AST)
  530.     {
  531.         $limit    = $this->query->getMaxResults();
  532.         $offset   = $this->query->getFirstResult();
  533.         $lockMode = $this->query->getHint(Query::HINT_LOCK_MODE);
  534.         $sql      = $this->walkSelectClause($AST->selectClause)
  535.             . $this->walkFromClause($AST->fromClause)
  536.             . $this->walkWhereClause($AST->whereClause);
  538.         if ($AST->groupByClause) {
  539.             $sql .= $this->walkGroupByClause($AST->groupByClause);
  540.         }
  542.         if ($AST->havingClause) {
  543.             $sql .= $this->walkHavingClause($AST->havingClause);
  544.         }
  546.         if ($AST->orderByClause) {
  547.             $sql .= $this->walkOrderByClause($AST->orderByClause);
  548.         }
  550.         if ( ! $AST->orderByClause && ($orderBySql = $this->_generateOrderedCollectionOrderByItems())) {
  551.             $sql .= ' ORDER BY ' . $orderBySql;
  552.         }
  554.         if ($limit !== null || $offset !== null) {
  555.             $sql = $this->platform->modifyLimitQuery($sql, $limit, $offset);
  556.         }
  558.         if ($lockMode === null || $lockMode === false || $lockMode === LockMode::NONE) {
  559.             return $sql;
  560.         }
  562.         if ($lockMode === LockMode::PESSIMISTIC_READ) {
  563.             return $sql . ' ' . $this->platform->getReadLockSQL();
  564.         }
  566.         if ($lockMode === LockMode::PESSIMISTIC_WRITE) {
  567.             return $sql . ' ' . $this->platform->getWriteLockSQL();
  568.         }
  570.         if ($lockMode !== LockMode::OPTIMISTIC) {
  571.             throw QueryException::invalidLockMode();
  572.         }
  574.         foreach ($this->selectedClasses as $selectedClass) {
  575.             if ( ! $selectedClass['class']->isVersioned) {
  576.                 throw OptimisticLockException::lockFailed($selectedClass['class']->name);
  577.             }
  578.         }
  580.         return $sql;
  581.     }
  583.     /**
  584.      * {@inheritdoc}
  585.      */
  586.     public function walkUpdateStatement(AST\UpdateStatement $AST)
  587.     {
  588.         $this->useSqlTableAliases = false;
  589.         $this->rsm->isSelect      = false;
  591.         return $this->walkUpdateClause($AST->updateClause)
  592.             . $this->walkWhereClause($AST->whereClause);
  593.     }
  595.     /**
  596.      * {@inheritdoc}
  597.      */
  598.     public function walkDeleteStatement(AST\DeleteStatement $AST)
  599.     {
  600.         $this->useSqlTableAliases = false;
  601.         $this->rsm->isSelect      = false;
  603.         return $this->walkDeleteClause($AST->deleteClause)
  604.             . $this->walkWhereClause($AST->whereClause);
  605.     }
  607.     /**
  608.      * Walks down an IdentificationVariable AST node, thereby generating the appropriate SQL.
  609.      * This one differs of ->walkIdentificationVariable() because it generates the entity identifiers.
  610.      *
  611.      * @param string $identVariable
  612.      *
  613.      * @return string
  614.      */
  615.     public function walkEntityIdentificationVariable($identVariable)
  616.     {
  617.         $class      = $this->queryComponents[$identVariable]['metadata'];
  618.         $tableAlias = $this->getSQLTableAlias($class->getTableName(), $identVariable);
  619.         $sqlParts   = [];
  621.         foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
  622.             $sqlParts[] = $tableAlias . '.' . $columnName;
  623.         }
  625.         return implode(', ', $sqlParts);
  626.     }
  628.     /**
  629.      * Walks down an IdentificationVariable (no AST node associated), thereby generating the SQL.
  630.      *
  631.      * @param string $identificationVariable
  632.      * @param string $fieldName
  633.      *
  634.      * @return string The SQL.
  635.      */
  636.     public function walkIdentificationVariable($identificationVariable, $fieldName = null)
  637.     {
  638.         $class = $this->queryComponents[$identificationVariable]['metadata'];
  640.         if (
  641.             $fieldName !== null && $class->isInheritanceTypeJoined() &&
  642.             isset($class->fieldMappings[$fieldName]['inherited'])
  643.         ) {
  644.             $class = $this->em->getClassMetadata($class->fieldMappings[$fieldName]['inherited']);
  645.         }
  647.         return $this->getSQLTableAlias($class->getTableName(), $identificationVariable);
  648.     }
  650.     /**
  651.      * {@inheritdoc}
  652.      */
  653.     public function walkPathExpression($pathExpr)
  654.     {
  655.         $sql = '';
  657.         /* @var $pathExpr Query\AST\PathExpression */
  658.         switch ($pathExpr->type) {
  659.             case AST\PathExpression::TYPE_STATE_FIELD:
  660.                 $fieldName = $pathExpr->field;
  661.                 $dqlAlias = $pathExpr->identificationVariable;
  662.                 $class = $this->queryComponents[$dqlAlias]['metadata'];
  664.                 if ($this->useSqlTableAliases) {
  665.                     $sql .= $this->walkIdentificationVariable($dqlAlias, $fieldName) . '.';
  666.                 }
  668.                 $sql .= $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  669.                 break;
  671.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
  672.                 // 1- the owning side:
  673.                 //    Just use the foreign key, i.e. u.group_id
  674.                 $fieldName = $pathExpr->field;
  675.                 $dqlAlias = $pathExpr->identificationVariable;
  676.                 $class = $this->queryComponents[$dqlAlias]['metadata'];
  678.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
  679.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
  680.                 }
  682.                 $assoc = $class->associationMappings[$fieldName];
  684.                 if ( ! $assoc['isOwningSide']) {
  685.                     throw QueryException::associationPathInverseSideNotSupported($pathExpr);
  686.                 }
  688.                 // COMPOSITE KEYS NOT (YET?) SUPPORTED
  689.                 if (count($assoc['sourceToTargetKeyColumns']) > 1) {
  690.                     throw QueryException::associationPathCompositeKeyNotSupported();
  691.                 }
  693.                 if ($this->useSqlTableAliases) {
  694.                     $sql .= $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.';
  695.                 }
  697.                 $sql .= reset($assoc['targetToSourceKeyColumns']);
  698.                 break;
  700.             default:
  701.                 throw QueryException::invalidPathExpression($pathExpr);
  702.         }
  704.         return $sql;
  705.     }
  707.     /**
  708.      * {@inheritdoc}
  709.      */
  710.     public function walkSelectClause($selectClause)
  711.     {
  712.         $sql = 'SELECT ' . (($selectClause->isDistinct) ? 'DISTINCT ' : '');
  713.         $sqlSelectExpressions = array_filter(array_map([$this, 'walkSelectExpression'], $selectClause->selectExpressions));
  715.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) == true && $selectClause->isDistinct) {
  716.             $this->query->setHint(self::HINT_DISTINCT, true);
  717.         }
  719.         $addMetaColumns = ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD) &&
  720.             $this->query->getHydrationMode() == Query::HYDRATE_OBJECT
  721.             ||
  722.             $this->query->getHydrationMode() != Query::HYDRATE_OBJECT &&
  723.             $this->query->getHint(Query::HINT_INCLUDE_META_COLUMNS);
  725.         foreach ($this->selectedClasses as $selectedClass) {
  726.             $class       = $selectedClass['class'];
  727.             $dqlAlias    = $selectedClass['dqlAlias'];
  728.             $resultAlias = $selectedClass['resultAlias'];
  730.             // Register as entity or joined entity result
  731.             if ($this->queryComponents[$dqlAlias]['relation'] === null) {
  732.                 $this->rsm->addEntityResult($class->name, $dqlAlias, $resultAlias);
  733.             } else {
  734.                 $this->rsm->addJoinedEntityResult(
  735.                     $class->name,
  736.                     $dqlAlias,
  737.                     $this->queryComponents[$dqlAlias]['parent'],
  738.                     $this->queryComponents[$dqlAlias]['relation']['fieldName']
  739.                 );
  740.             }
  742.             if ($class->isInheritanceTypeSingleTable() || $class->isInheritanceTypeJoined()) {
  743.                 // Add discriminator columns to SQL
  744.                 $rootClass   = $this->em->getClassMetadata($class->rootEntityName);
  745.                 $tblAlias    = $this->getSQLTableAlias($rootClass->getTableName(), $dqlAlias);
  746.                 $discrColumn = $rootClass->discriminatorColumn;
  747.                 $columnAlias = $this->getSQLColumnAlias($discrColumn['name']);
  749.                 $sqlSelectExpressions[] = $tblAlias . '.' . $discrColumn['name'] . ' AS ' . $columnAlias;
  751.                 $this->rsm->setDiscriminatorColumn($dqlAlias, $columnAlias);
  752.                 $this->rsm->addMetaResult($dqlAlias, $columnAlias, $discrColumn['fieldName'], false, $discrColumn['type']);
  753.             }
  755.             // Add foreign key columns to SQL, if necessary
  756.             if ( ! $addMetaColumns && ! $class->containsForeignIdentifier) {
  757.                 continue;
  758.             }
  760.             // Add foreign key columns of class and also parent classes
  761.             foreach ($class->associationMappings as $assoc) {
  762.                 if ( ! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)
  763.                     || ( ! $addMetaColumns && !isset($assoc['id']))) {
  764.                     continue;
  765.                 }
  767.                 $targetClass   = $this->em->getClassMetadata($assoc['targetEntity']);
  768.                 $isIdentifier  = (isset($assoc['id']) && $assoc['id'] === true);
  769.                 $owningClass   = (isset($assoc['inherited'])) ? $this->em->getClassMetadata($assoc['inherited']) : $class;
  770.                 $sqlTableAlias = $this->getSQLTableAlias($owningClass->getTableName(), $dqlAlias);
  772.                 foreach ($assoc['joinColumns'] as $joinColumn) {
  773.                     $columnName  = $joinColumn['name'];
  774.                     $columnAlias = $this->getSQLColumnAlias($columnName);
  775.                     $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  777.                     $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  778.                     $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
  780.                     $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $isIdentifier, $columnType);
  781.                 }
  782.             }
  784.             // Add foreign key columns to SQL, if necessary
  785.             if ( ! $addMetaColumns) {
  786.                 continue;
  787.             }
  789.             // Add foreign key columns of subclasses
  790.             foreach ($class->subClasses as $subClassName) {
  791.                 $subClass      = $this->em->getClassMetadata($subClassName);
  792.                 $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  794.                 foreach ($subClass->associationMappings as $assoc) {
  795.                     // Skip if association is inherited
  796.                     if (isset($assoc['inherited'])) continue;
  798.                     if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
  799.                         $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  801.                         foreach ($assoc['joinColumns'] as $joinColumn) {
  802.                             $columnName  = $joinColumn['name'];
  803.                             $columnAlias = $this->getSQLColumnAlias($columnName);
  804.                             $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  806.                             $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $subClass, $this->platform);
  807.                             $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
  809.                             $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $subClass->isIdentifier($columnName), $columnType);
  810.                         }
  811.                     }
  812.                 }
  813.             }
  814.         }
  816.         $sql .= implode(', ', $sqlSelectExpressions);
  818.         return $sql;
  819.     }
  821.     /**
  822.      * {@inheritdoc}
  823.      */
  824.     public function walkFromClause($fromClause)
  825.     {
  826.         $identificationVarDecls = $fromClause->identificationVariableDeclarations;
  827.         $sqlParts = [];
  829.         foreach ($identificationVarDecls as $identificationVariableDecl) {
  830.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($identificationVariableDecl);
  831.         }
  833.         return ' FROM ' . implode(', ', $sqlParts);
  834.     }
  836.     /**
  837.      * Walks down a IdentificationVariableDeclaration AST node, thereby generating the appropriate SQL.
  838.      *
  839.      * @param AST\IdentificationVariableDeclaration $identificationVariableDecl
  840.      *
  841.      * @return string
  842.      */
  843.     public function walkIdentificationVariableDeclaration($identificationVariableDecl)
  844.     {
  845.         $sql = $this->walkRangeVariableDeclaration($identificationVariableDecl->rangeVariableDeclaration);
  847.         if ($identificationVariableDecl->indexBy) {
  848.             $this->walkIndexBy($identificationVariableDecl->indexBy);
  849.         }
  851.         foreach ($identificationVariableDecl->joins as $join) {
  852.             $sql .= $this->walkJoin($join);
  853.         }
  855.         return $sql;
  856.     }
  858.     /**
  859.      * Walks down a IndexBy AST node.
  860.      *
  861.      * @param AST\IndexBy $indexBy
  862.      *
  863.      * @return void
  864.      */
  865.     public function walkIndexBy($indexBy)
  866.     {
  867.         $pathExpression = $indexBy->simpleStateFieldPathExpression;
  868.         $alias          = $pathExpression->identificationVariable;
  869.         $field          = $pathExpression->field;
  871.         if (isset($this->scalarFields[$alias][$field])) {
  872.             $this->rsm->addIndexByScalar($this->scalarFields[$alias][$field]);
  874.             return;
  875.         }
  877.         $this->rsm->addIndexBy($alias, $field);
  878.     }
  880.     /**
  881.      * Walks down a RangeVariableDeclaration AST node, thereby generating the appropriate SQL.
  882.      *
  883.      * @param AST\RangeVariableDeclaration $rangeVariableDeclaration
  884.      *
  885.      * @return string
  886.      */
  887.     public function walkRangeVariableDeclaration($rangeVariableDeclaration)
  888.     {
  889.         return $this->generateRangeVariableDeclarationSQL($rangeVariableDeclaration, false);
  890.     }
  892.     /**
  893.      * Generate appropriate SQL for RangeVariableDeclaration AST node
  894.      *
  895.      * @param AST\RangeVariableDeclaration $rangeVariableDeclaration
  896.      * @param bool $buildNestedJoins
  897.      *
  898.      * @return string
  899.      */
  900.     private function generateRangeVariableDeclarationSQL($rangeVariableDeclaration, bool $buildNestedJoins) : string
  901.     {
  902.         $class    = $this->em->getClassMetadata($rangeVariableDeclaration->abstractSchemaName);
  903.         $dqlAlias = $rangeVariableDeclaration->aliasIdentificationVariable;
  905.         if ($rangeVariableDeclaration->isRoot) {
  906.             $this->rootAliases[] = $dqlAlias;
  907.         }
  909.         $sql = $this->platform->appendLockHint(
  910.             $this->quoteStrategy->getTableName($class, $this->platform) . ' ' .
  911.             $this->getSQLTableAlias($class->getTableName(), $dqlAlias),
  912.             $this->query->getHint(Query::HINT_LOCK_MODE)
  913.         );
  915.         if ( ! $class->isInheritanceTypeJoined()) {
  916.             return $sql;
  917.         }
  919.         $classTableInheritanceJoins = $this->_generateClassTableInheritanceJoins($class, $dqlAlias);
  921.         if ( ! $buildNestedJoins) {
  922.             return $sql . $classTableInheritanceJoins;
  923.         }
  925.         return $classTableInheritanceJoins === '' ? $sql : '(' . $sql . $classTableInheritanceJoins . ')';
  926.     }
  928.     /**
  929.      * Walks down a JoinAssociationDeclaration AST node, thereby generating the appropriate SQL.
  930.      *
  931.      * @param AST\JoinAssociationDeclaration $joinAssociationDeclaration
  932.      * @param int                            $joinType
  933.      * @param AST\ConditionalExpression      $condExpr
  934.      *
  935.      * @return string
  936.      *
  937.      * @throws QueryException
  938.      */
  939.     public function walkJoinAssociationDeclaration($joinAssociationDeclaration, $joinType = AST\Join::JOIN_TYPE_INNER, $condExpr = null)
  940.     {
  941.         $sql = '';
  943.         $associationPathExpression = $joinAssociationDeclaration->joinAssociationPathExpression;
  944.         $joinedDqlAlias            = $joinAssociationDeclaration->aliasIdentificationVariable;
  945.         $indexBy                   = $joinAssociationDeclaration->indexBy;
  947.         $relation        = $this->queryComponents[$joinedDqlAlias]['relation'];
  948.         $targetClass     = $this->em->getClassMetadata($relation['targetEntity']);
  949.         $sourceClass     = $this->em->getClassMetadata($relation['sourceEntity']);
  950.         $targetTableName = $this->quoteStrategy->getTableName($targetClass, $this->platform);
  952.         $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName(), $joinedDqlAlias);
  953.         $sourceTableAlias = $this->getSQLTableAlias($sourceClass->getTableName(), $associationPathExpression->identificationVariable);
  955.         // Ensure we got the owning side, since it has all mapping info
  956.         $assoc = ( ! $relation['isOwningSide']) ? $targetClass->associationMappings[$relation['mappedBy']] : $relation;
  958.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) == true && (!$this->query->getHint(self::HINT_DISTINCT) || isset($this->selectedClasses[$joinedDqlAlias]))) {
  959.             if ($relation['type'] == ClassMetadata::ONE_TO_MANY || $relation['type'] == ClassMetadata::MANY_TO_MANY) {
  960.                 throw QueryException::iterateWithFetchJoinNotAllowed($assoc);
  961.             }
  962.         }
  964.         $targetTableJoin = null;
  966.         // This condition is not checking ClassMetadata::MANY_TO_ONE, because by definition it cannot
  967.         // be the owning side and previously we ensured that $assoc is always the owning side of the associations.
  968.         // The owning side is necessary at this point because only it contains the JoinColumn information.
  969.         switch (true) {
  970.             case ($assoc['type'] & ClassMetadata::TO_ONE):
  971.                 $conditions = [];
  973.                 foreach ($assoc['joinColumns'] as $joinColumn) {
  974.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  975.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  977.                     if ($relation['isOwningSide']) {
  978.                         $conditions[] = $sourceTableAlias . '.' . $quotedSourceColumn . ' = ' . $targetTableAlias . '.' . $quotedTargetColumn;
  980.                         continue;
  981.                     }
  983.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $targetTableAlias . '.' . $quotedSourceColumn;
  984.                 }
  986.                 // Apply remaining inheritance restrictions
  987.                 $discrSql = $this->_generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
  989.                 if ($discrSql) {
  990.                     $conditions[] = $discrSql;
  991.                 }
  993.                 // Apply the filters
  994.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
  996.                 if ($filterExpr) {
  997.                     $conditions[] = $filterExpr;
  998.                 }
  1000.                 $targetTableJoin = [
  1001.                     'table' => $targetTableName . ' ' . $targetTableAlias,
  1002.                     'condition' => implode(' AND ', $conditions),
  1003.                 ];
  1004.                 break;
  1006.             case ($assoc['type'] == ClassMetadata::MANY_TO_MANY):
  1007.                 // Join relation table
  1008.                 $joinTable      = $assoc['joinTable'];
  1009.                 $joinTableAlias = $this->getSQLTableAlias($joinTable['name'], $joinedDqlAlias);
  1010.                 $joinTableName  = $this->quoteStrategy->getJoinTableName($assoc, $sourceClass, $this->platform);
  1012.                 $conditions      = [];
  1013.                 $relationColumns = ($relation['isOwningSide'])
  1014.                     ? $assoc['joinTable']['joinColumns']
  1015.                     : $assoc['joinTable']['inverseJoinColumns'];
  1017.                 foreach ($relationColumns as $joinColumn) {
  1018.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  1019.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  1021.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
  1022.                 }
  1024.                 $sql .= $joinTableName . ' ' . $joinTableAlias . ' ON ' . implode(' AND ', $conditions);
  1026.                 // Join target table
  1027.                 $sql .= ($joinType == AST\Join::JOIN_TYPE_LEFT || $joinType == AST\Join::JOIN_TYPE_LEFTOUTER) ? ' LEFT JOIN ' : ' INNER JOIN ';
  1029.                 $conditions      = [];
  1030.                 $relationColumns = ($relation['isOwningSide'])
  1031.                     ? $assoc['joinTable']['inverseJoinColumns']
  1032.                     : $assoc['joinTable']['joinColumns'];
  1034.                 foreach ($relationColumns as $joinColumn) {
  1035.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  1036.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  1038.                     $conditions[] = $targetTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
  1039.                 }
  1041.                 // Apply remaining inheritance restrictions
  1042.                 $discrSql = $this->_generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
  1044.                 if ($discrSql) {
  1045.                     $conditions[] = $discrSql;
  1046.                 }
  1048.                 // Apply the filters
  1049.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
  1051.                 if ($filterExpr) {
  1052.                     $conditions[] = $filterExpr;
  1053.                 }
  1055.                 $targetTableJoin = [
  1056.                     'table' => $targetTableName . ' ' . $targetTableAlias,
  1057.                     'condition' => implode(' AND ', $conditions),
  1058.                 ];
  1059.                 break;
  1061.             default:
  1062.                 throw new \BadMethodCallException('Type of association must be one of *_TO_ONE or MANY_TO_MANY');
  1063.         }
  1065.         // Handle WITH clause
  1066.         $withCondition = (null === $condExpr) ? '' : ('(' . $this->walkConditionalExpression($condExpr) . ')');
  1068.         if ($targetClass->isInheritanceTypeJoined()) {
  1069.             $ctiJoins = $this->_generateClassTableInheritanceJoins($targetClass, $joinedDqlAlias);
  1070.             // If we have WITH condition, we need to build nested joins for target class table and cti joins
  1071.             if ($withCondition) {
  1072.                 $sql .= '(' . $targetTableJoin['table'] . $ctiJoins . ') ON ' . $targetTableJoin['condition'];
  1073.             } else {
  1074.                 $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'] . $ctiJoins;
  1075.             }
  1076.         } else {
  1077.             $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'];
  1078.         }
  1080.         if ($withCondition) {
  1081.             $sql .= ' AND ' . $withCondition;
  1082.         }
  1084.         // Apply the indexes
  1085.         if ($indexBy) {
  1086.             // For Many-To-One or One-To-One associations this obviously makes no sense, but is ignored silently.
  1087.             $this->walkIndexBy($indexBy);
  1088.         } else if (isset($relation['indexBy'])) {
  1089.             $this->rsm->addIndexBy($joinedDqlAlias, $relation['indexBy']);
  1090.         }
  1092.         return $sql;
  1093.     }
  1095.     /**
  1096.      * {@inheritdoc}
  1097.      */
  1098.     public function walkFunction($function)
  1099.     {
  1100.         return $function->getSql($this);
  1101.     }
  1103.     /**
  1104.      * {@inheritdoc}
  1105.      */
  1106.     public function walkOrderByClause($orderByClause)
  1107.     {
  1108.         $orderByItems = array_map([$this, 'walkOrderByItem'], $orderByClause->orderByItems);
  1110.         if (($collectionOrderByItems = $this->_generateOrderedCollectionOrderByItems()) !== '') {
  1111.             $orderByItems = array_merge($orderByItems, (array) $collectionOrderByItems);
  1112.         }
  1114.         return ' ORDER BY ' . implode(', ', $orderByItems);
  1115.     }
  1117.     /**
  1118.      * {@inheritdoc}
  1119.      */
  1120.     public function walkOrderByItem($orderByItem)
  1121.     {
  1122.         $type = strtoupper($orderByItem->type);
  1123.         $expr = $orderByItem->expression;
  1124.         $sql  = ($expr instanceof AST\Node)
  1125.             ? $expr->dispatch($this)
  1126.             : $this->walkResultVariable($this->queryComponents[$expr]['token']['value']);
  1128.         $this->orderedColumnsMap[$sql] = $type;
  1130.         if ($expr instanceof AST\Subselect) {
  1131.             return '(' . $sql . ') ' . $type;
  1132.         }
  1134.         return $sql . ' ' . $type;
  1135.     }
  1137.     /**
  1138.      * {@inheritdoc}
  1139.      */
  1140.     public function walkHavingClause($havingClause)
  1141.     {
  1142.         return ' HAVING ' . $this->walkConditionalExpression($havingClause->conditionalExpression);
  1143.     }
  1145.     /**
  1146.      * {@inheritdoc}
  1147.      */
  1148.     public function walkJoin($join)
  1149.     {
  1150.         $joinType        = $join->joinType;
  1151.         $joinDeclaration = $join->joinAssociationDeclaration;
  1153.         $sql = ($joinType == AST\Join::JOIN_TYPE_LEFT || $joinType == AST\Join::JOIN_TYPE_LEFTOUTER)
  1154.             ? ' LEFT JOIN '
  1155.             : ' INNER JOIN ';
  1157.         switch (true) {
  1158.             case ($joinDeclaration instanceof AST\RangeVariableDeclaration):
  1159.                 $class      = $this->em->getClassMetadata($joinDeclaration->abstractSchemaName);
  1160.                 $dqlAlias   = $joinDeclaration->aliasIdentificationVariable;
  1161.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
  1162.                 $conditions = [];
  1164.                 if ($join->conditionalExpression) {
  1165.                     $conditions[] = '(' . $this->walkConditionalExpression($join->conditionalExpression) . ')';
  1166.                 }
  1168.                 $isUnconditionalJoin = empty($conditions);
  1169.                 $condExprConjunction = ($class->isInheritanceTypeJoined() && $joinType != AST\Join::JOIN_TYPE_LEFT && $joinType != AST\Join::JOIN_TYPE_LEFTOUTER && $isUnconditionalJoin)
  1170.                     ? ' AND '
  1171.                     : ' ON ';
  1173.                 $sql .= $this->generateRangeVariableDeclarationSQL($joinDeclaration, !$isUnconditionalJoin);
  1175.                 // Apply remaining inheritance restrictions
  1176.                 $discrSql = $this->_generateDiscriminatorColumnConditionSQL([$dqlAlias]);
  1178.                 if ($discrSql) {
  1179.                     $conditions[] = $discrSql;
  1180.                 }
  1182.                 // Apply the filters
  1183.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
  1185.                 if ($filterExpr) {
  1186.                     $conditions[] = $filterExpr;
  1187.                 }
  1189.                 if ($conditions) {
  1190.                     $sql .= $condExprConjunction . implode(' AND ', $conditions);
  1191.                 }
  1193.                 break;
  1195.             case ($joinDeclaration instanceof AST\JoinAssociationDeclaration):
  1196.                 $sql .= $this->walkJoinAssociationDeclaration($joinDeclaration, $joinType, $join->conditionalExpression);
  1197.                 break;
  1198.         }
  1200.         return $sql;
  1201.     }
  1203.     /**
  1204.      * Walks down a CoalesceExpression AST node and generates the corresponding SQL.
  1205.      *
  1206.      * @param AST\CoalesceExpression $coalesceExpression
  1207.      *
  1208.      * @return string The SQL.
  1209.      */
  1210.     public function walkCoalesceExpression($coalesceExpression)
  1211.     {
  1212.         $sql = 'COALESCE(';
  1214.         $scalarExpressions = [];
  1216.         foreach ($coalesceExpression->scalarExpressions as $scalarExpression) {
  1217.             $scalarExpressions[] = $this->walkSimpleArithmeticExpression($scalarExpression);
  1218.         }
  1220.         $sql .= implode(', ', $scalarExpressions) . ')';
  1222.         return $sql;
  1223.     }
  1225.     /**
  1226.      * Walks down a NullIfExpression AST node and generates the corresponding SQL.
  1227.      *
  1228.      * @param AST\NullIfExpression $nullIfExpression
  1229.      *
  1230.      * @return string The SQL.
  1231.      */
  1232.     public function walkNullIfExpression($nullIfExpression)
  1233.     {
  1234.         $firstExpression = is_string($nullIfExpression->firstExpression)
  1235.             ? $this->conn->quote($nullIfExpression->firstExpression)
  1236.             : $this->walkSimpleArithmeticExpression($nullIfExpression->firstExpression);
  1238.         $secondExpression = is_string($nullIfExpression->secondExpression)
  1239.             ? $this->conn->quote($nullIfExpression->secondExpression)
  1240.             : $this->walkSimpleArithmeticExpression($nullIfExpression->secondExpression);
  1242.         return 'NULLIF(' . $firstExpression . ', ' . $secondExpression . ')';
  1243.     }
  1245.     /**
  1246.      * Walks down a GeneralCaseExpression AST node and generates the corresponding SQL.
  1247.      *
  1248.      * @param AST\GeneralCaseExpression $generalCaseExpression
  1249.      *
  1250.      * @return string The SQL.
  1251.      */
  1252.     public function walkGeneralCaseExpression(AST\GeneralCaseExpression $generalCaseExpression)
  1253.     {
  1254.         $sql = 'CASE';
  1256.         foreach ($generalCaseExpression->whenClauses as $whenClause) {
  1257.             $sql .= ' WHEN ' . $this->walkConditionalExpression($whenClause->caseConditionExpression);
  1258.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($whenClause->thenScalarExpression);
  1259.         }
  1261.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($generalCaseExpression->elseScalarExpression) . ' END';
  1263.         return $sql;
  1264.     }
  1266.     /**
  1267.      * Walks down a SimpleCaseExpression AST node and generates the corresponding SQL.
  1268.      *
  1269.      * @param AST\SimpleCaseExpression $simpleCaseExpression
  1270.      *
  1271.      * @return string The SQL.
  1272.      */
  1273.     public function walkSimpleCaseExpression($simpleCaseExpression)
  1274.     {
  1275.         $sql = 'CASE ' . $this->walkStateFieldPathExpression($simpleCaseExpression->caseOperand);
  1277.         foreach ($simpleCaseExpression->simpleWhenClauses as $simpleWhenClause) {
  1278.             $sql .= ' WHEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->caseScalarExpression);
  1279.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->thenScalarExpression);
  1280.         }
  1282.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($simpleCaseExpression->elseScalarExpression) . ' END';
  1284.         return $sql;
  1285.     }
  1287.     /**
  1288.      * {@inheritdoc}
  1289.      */
  1290.     public function walkSelectExpression($selectExpression)
  1291.     {
  1292.         $sql    = '';
  1293.         $expr   = $selectExpression->expression;
  1294.         $hidden = $selectExpression->hiddenAliasResultVariable;
  1296.         switch (true) {
  1297.             case ($expr instanceof AST\PathExpression):
  1298.                 if ($expr->type !== AST\PathExpression::TYPE_STATE_FIELD) {
  1299.                     throw QueryException::invalidPathExpression($expr);
  1300.                 }
  1302.                 $fieldName = $expr->field;
  1303.                 $dqlAlias  = $expr->identificationVariable;
  1304.                 $qComp     = $this->queryComponents[$dqlAlias];
  1305.                 $class     = $qComp['metadata'];
  1307.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $fieldName;
  1308.                 $tableName   = ($class->isInheritanceTypeJoined())
  1309.                     ? $this->em->getUnitOfWork()->getEntityPersister($class->name)->getOwningTable($fieldName)
  1310.                     : $class->getTableName();
  1312.                 $sqlTableAlias = $this->getSQLTableAlias($tableName, $dqlAlias);
  1313.                 $fieldMapping  = $class->fieldMappings[$fieldName];
  1314.                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  1315.                 $columnAlias   = $this->getSQLColumnAlias($fieldMapping['columnName']);
  1316.                 $col           = $sqlTableAlias . '.' . $columnName;
  1318.                 if (isset($fieldMapping['requireSQLConversion'])) {
  1319.                     $type = Type::getType($fieldMapping['type']);
  1320.                     $col  = $type->convertToPHPValueSQL($col, $this->conn->getDatabasePlatform());
  1321.                 }
  1323.                 $sql .= $col . ' AS ' . $columnAlias;
  1325.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1327.                 if ( ! $hidden) {
  1328.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldMapping['type']);
  1329.                     $this->scalarFields[$dqlAlias][$fieldName] = $columnAlias;
  1330.                 }
  1332.                 break;
  1334.             case ($expr instanceof AST\AggregateExpression):
  1335.             case ($expr instanceof AST\Functions\FunctionNode):
  1336.             case ($expr instanceof AST\SimpleArithmeticExpression):
  1337.             case ($expr instanceof AST\ArithmeticTerm):
  1338.             case ($expr instanceof AST\ArithmeticFactor):
  1339.             case ($expr instanceof AST\ParenthesisExpression):
  1340.             case ($expr instanceof AST\Literal):
  1341.             case ($expr instanceof AST\NullIfExpression):
  1342.             case ($expr instanceof AST\CoalesceExpression):
  1343.             case ($expr instanceof AST\GeneralCaseExpression):
  1344.             case ($expr instanceof AST\SimpleCaseExpression):
  1345.                 $columnAlias = $this->getSQLColumnAlias('sclr');
  1346.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1348.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
  1350.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1352.                 if ( ! $hidden) {
  1353.                     // We cannot resolve field type here; assume 'string'.
  1354.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
  1355.                 }
  1356.                 break;
  1358.             case ($expr instanceof AST\Subselect):
  1359.                 $columnAlias = $this->getSQLColumnAlias('sclr');
  1360.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1362.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
  1364.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1366.                 if ( ! $hidden) {
  1367.                     // We cannot resolve field type here; assume 'string'.
  1368.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
  1369.                 }
  1370.                 break;
  1372.             case ($expr instanceof AST\NewObjectExpression):
  1373.                 $sql .= $this->walkNewObject($expr,$selectExpression->fieldIdentificationVariable);
  1374.                 break;
  1376.             default:
  1377.                 // IdentificationVariable or PartialObjectExpression
  1378.                 if ($expr instanceof AST\PartialObjectExpression) {
  1379.                     $this->query->setHint(self::HINT_PARTIAL, true);
  1381.                     $dqlAlias = $expr->identificationVariable;
  1382.                     $partialFieldSet = $expr->partialFieldSet;
  1383.                 } else {
  1384.                     $dqlAlias = $expr;
  1385.                     $partialFieldSet = [];
  1386.                 }
  1388.                 $queryComp   = $this->queryComponents[$dqlAlias];
  1389.                 $class       = $queryComp['metadata'];
  1390.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: null;
  1392.                 if ( ! isset($this->selectedClasses[$dqlAlias])) {
  1393.                     $this->selectedClasses[$dqlAlias] = [
  1394.                         'class'       => $class,
  1395.                         'dqlAlias'    => $dqlAlias,
  1396.                         'resultAlias' => $resultAlias
  1397.                     ];
  1398.                 }
  1400.                 $sqlParts = [];
  1402.                 // Select all fields from the queried class
  1403.                 foreach ($class->fieldMappings as $fieldName => $mapping) {
  1404.                     if ($partialFieldSet && ! in_array($fieldName, $partialFieldSet)) {
  1405.                         continue;
  1406.                     }
  1408.                     $tableName = (isset($mapping['inherited']))
  1409.                         ? $this->em->getClassMetadata($mapping['inherited'])->getTableName()
  1410.                         : $class->getTableName();
  1412.                     $sqlTableAlias    = $this->getSQLTableAlias($tableName, $dqlAlias);
  1413.                     $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
  1414.                     $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  1416.                     $col = $sqlTableAlias . '.' . $quotedColumnName;
  1418.                     if (isset($mapping['requireSQLConversion'])) {
  1419.                         $type = Type::getType($mapping['type']);
  1420.                         $col = $type->convertToPHPValueSQL($col, $this->platform);
  1421.                     }
  1423.                     $sqlParts[] = $col . ' AS '. $columnAlias;
  1425.                     $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
  1427.                     $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $class->name);
  1428.                 }
  1430.                 // Add any additional fields of subclasses (excluding inherited fields)
  1431.                 // 1) on Single Table Inheritance: always, since its marginal overhead
  1432.                 // 2) on Class Table Inheritance only if partial objects are disallowed,
  1433.                 //    since it requires outer joining subtables.
  1434.                 if ($class->isInheritanceTypeSingleTable() || ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
  1435.                     foreach ($class->subClasses as $subClassName) {
  1436.                         $subClass      = $this->em->getClassMetadata($subClassName);
  1437.                         $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  1439.                         foreach ($subClass->fieldMappings as $fieldName => $mapping) {
  1440.                             if (isset($mapping['inherited']) || ($partialFieldSet && !in_array($fieldName, $partialFieldSet))) {
  1441.                                 continue;
  1442.                             }
  1444.                             $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
  1445.                             $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $subClass, $this->platform);
  1447.                             $col = $sqlTableAlias . '.' . $quotedColumnName;
  1449.                             if (isset($mapping['requireSQLConversion'])) {
  1450.                                 $type = Type::getType($mapping['type']);
  1451.                                 $col = $type->convertToPHPValueSQL($col, $this->platform);
  1452.                             }
  1454.                             $sqlParts[] = $col . ' AS ' . $columnAlias;
  1456.                             $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
  1458.                             $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $subClassName);
  1459.                         }
  1460.                     }
  1461.                 }
  1463.                 $sql .= implode(', ', $sqlParts);
  1464.         }
  1466.         return $sql;
  1467.     }
  1469.     /**
  1470.      * {@inheritdoc}
  1471.      */
  1472.     public function walkQuantifiedExpression($qExpr)
  1473.     {
  1474.         return ' ' . strtoupper($qExpr->type) . '(' . $this->walkSubselect($qExpr->subselect) . ')';
  1475.     }
  1477.     /**
  1478.      * {@inheritdoc}
  1479.      */
  1480.     public function walkSubselect($subselect)
  1481.     {
  1482.         $useAliasesBefore  = $this->useSqlTableAliases;
  1483.         $rootAliasesBefore = $this->rootAliases;
  1485.         $this->rootAliases = []; // reset the rootAliases for the subselect
  1486.         $this->useSqlTableAliases = true;
  1488.         $sql  = $this->walkSimpleSelectClause($subselect->simpleSelectClause);
  1489.         $sql .= $this->walkSubselectFromClause($subselect->subselectFromClause);
  1490.         $sql .= $this->walkWhereClause($subselect->whereClause);
  1492.         $sql .= $subselect->groupByClause ? $this->walkGroupByClause($subselect->groupByClause) : '';
  1493.         $sql .= $subselect->havingClause ? $this->walkHavingClause($subselect->havingClause) : '';
  1494.         $sql .= $subselect->orderByClause ? $this->walkOrderByClause($subselect->orderByClause) : '';
  1496.         $this->rootAliases        = $rootAliasesBefore; // put the main aliases back
  1497.         $this->useSqlTableAliases = $useAliasesBefore;
  1499.         return $sql;
  1500.     }
  1502.     /**
  1503.      * {@inheritdoc}
  1504.      */
  1505.     public function walkSubselectFromClause($subselectFromClause)
  1506.     {
  1507.         $identificationVarDecls = $subselectFromClause->identificationVariableDeclarations;
  1508.         $sqlParts               = [];
  1510.         foreach ($identificationVarDecls as $subselectIdVarDecl) {
  1511.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($subselectIdVarDecl);
  1512.         }
  1514.         return ' FROM ' . implode(', ', $sqlParts);
  1515.     }
  1517.     /**
  1518.      * {@inheritdoc}
  1519.      */
  1520.     public function walkSimpleSelectClause($simpleSelectClause)
  1521.     {
  1522.         return 'SELECT' . ($simpleSelectClause->isDistinct ? ' DISTINCT' : '')
  1523.             . $this->walkSimpleSelectExpression($simpleSelectClause->simpleSelectExpression);
  1524.     }
  1526.     /**
  1527.      * @param \Doctrine\ORM\Query\AST\ParenthesisExpression $parenthesisExpression
  1528.      *
  1529.      * @return string
  1530.      */
  1531.     public function walkParenthesisExpression(AST\ParenthesisExpression $parenthesisExpression)
  1532.     {
  1533.         return sprintf('(%s)', $parenthesisExpression->expression->dispatch($this));
  1534.     }
  1536.     /**
  1537.      * @param AST\NewObjectExpression   $newObjectExpression
  1538.      * @param null|string               $newObjectResultAlias
  1539.      * @return string The SQL.
  1540.      */
  1541.     public function walkNewObject($newObjectExpression, $newObjectResultAlias=null)
  1542.     {
  1543.         $sqlSelectExpressions = [];
  1544.         $objIndex             = $newObjectResultAlias?:$this->newObjectCounter++;
  1546.         foreach ($newObjectExpression->args as $argIndex => $e) {
  1547.             $resultAlias = $this->scalarResultCounter++;
  1548.             $columnAlias = $this->getSQLColumnAlias('sclr');
  1549.             $fieldType   = 'string';
  1551.             switch (true) {
  1552.                 case ($e instanceof AST\NewObjectExpression):
  1553.                     $sqlSelectExpressions[] = $e->dispatch($this);
  1554.                     break;
  1556.                 case ($e instanceof AST\Subselect):
  1557.                     $sqlSelectExpressions[] = '(' . $e->dispatch($this) . ') AS ' . $columnAlias;
  1558.                     break;
  1560.                 case ($e instanceof AST\PathExpression):
  1561.                     $dqlAlias     = $e->identificationVariable;
  1562.                     $qComp        = $this->queryComponents[$dqlAlias];
  1563.                     $class        = $qComp['metadata'];
  1564.                     $fieldType    = $class->fieldMappings[$e->field]['type'];
  1565.                     $fieldName    = $e->field;
  1566.                     $fieldMapping = $class->fieldMappings[$fieldName];
  1567.                     $col          = trim($e->dispatch($this));
  1569.                     if (isset($fieldMapping['requireSQLConversion'])) {
  1570.                         $type = Type::getType($fieldType);
  1571.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
  1572.                     }
  1574.                     $sqlSelectExpressions[] = $col . ' AS ' . $columnAlias;
  1575.                     break;
  1577.                 case ($e instanceof AST\Literal):
  1578.                     switch ($e->type) {
  1579.                         case AST\Literal::BOOLEAN:
  1580.                             $fieldType = 'boolean';
  1581.                             break;
  1583.                         case AST\Literal::NUMERIC:
  1584.                             $fieldType = is_float($e->value) ? 'float' : 'integer';
  1585.                             break;
  1586.                     }
  1588.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
  1589.                     break;
  1591.                 default:
  1592.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
  1593.                     break;
  1594.             }
  1596.             $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1597.             $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldType);
  1599.             $this->rsm->newObjectMappings[$columnAlias] = [
  1600.                 'className' => $newObjectExpression->className,
  1601.                 'objIndex'  => $objIndex,
  1602.                 'argIndex'  => $argIndex
  1603.             ];
  1604.         }
  1606.         return implode(', ', $sqlSelectExpressions);
  1607.     }
  1609.     /**
  1610.      * {@inheritdoc}
  1611.      */
  1612.     public function walkSimpleSelectExpression($simpleSelectExpression)
  1613.     {
  1614.         $expr = $simpleSelectExpression->expression;
  1615.         $sql  = ' ';
  1617.         switch (true) {
  1618.             case ($expr instanceof AST\PathExpression):
  1619.                 $sql .= $this->walkPathExpression($expr);
  1620.                 break;
  1622.             case ($expr instanceof AST\Subselect):
  1623.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1625.                 $columnAlias = 'sclr' . $this->aliasCounter++;
  1626.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
  1628.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
  1629.                 break;
  1631.             case ($expr instanceof AST\Functions\FunctionNode):
  1632.             case ($expr instanceof AST\SimpleArithmeticExpression):
  1633.             case ($expr instanceof AST\ArithmeticTerm):
  1634.             case ($expr instanceof AST\ArithmeticFactor):
  1635.             case ($expr instanceof AST\Literal):
  1636.             case ($expr instanceof AST\NullIfExpression):
  1637.             case ($expr instanceof AST\CoalesceExpression):
  1638.             case ($expr instanceof AST\GeneralCaseExpression):
  1639.             case ($expr instanceof AST\SimpleCaseExpression):
  1640.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1642.                 $columnAlias = $this->getSQLColumnAlias('sclr');
  1643.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
  1645.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
  1646.                 break;
  1648.             case ($expr instanceof AST\ParenthesisExpression):
  1649.                 $sql .= $this->walkParenthesisExpression($expr);
  1650.                 break;
  1652.             default: // IdentificationVariable
  1653.                 $sql .= $this->walkEntityIdentificationVariable($expr);
  1654.                 break;
  1655.         }
  1657.         return $sql;
  1658.     }
  1660.     /**
  1661.      * {@inheritdoc}
  1662.      */
  1663.     public function walkAggregateExpression($aggExpression)
  1664.     {
  1665.         return $aggExpression->functionName . '(' . ($aggExpression->isDistinct ? 'DISTINCT ' : '')
  1666.             . $this->walkSimpleArithmeticExpression($aggExpression->pathExpression) . ')';
  1667.     }
  1669.     /**
  1670.      * {@inheritdoc}
  1671.      */
  1672.     public function walkGroupByClause($groupByClause)
  1673.     {
  1674.         $sqlParts = [];
  1676.         foreach ($groupByClause->groupByItems as $groupByItem) {
  1677.             $sqlParts[] = $this->walkGroupByItem($groupByItem);
  1678.         }
  1680.         return ' GROUP BY ' . implode(', ', $sqlParts);
  1681.     }
  1683.     /**
  1684.      * {@inheritdoc}
  1685.      */
  1686.     public function walkGroupByItem($groupByItem)
  1687.     {
  1688.         // StateFieldPathExpression
  1689.         if ( ! is_string($groupByItem)) {
  1690.             return $this->walkPathExpression($groupByItem);
  1691.         }
  1693.         // ResultVariable
  1694.         if (isset($this->queryComponents[$groupByItem]['resultVariable'])) {
  1695.             $resultVariable = $this->queryComponents[$groupByItem]['resultVariable'];
  1697.             if ($resultVariable instanceof AST\PathExpression) {
  1698.                 return $this->walkPathExpression($resultVariable);
  1699.             }
  1701.             if (isset($resultVariable->pathExpression)) {
  1702.                 return $this->walkPathExpression($resultVariable->pathExpression);
  1703.             }
  1705.             return $this->walkResultVariable($groupByItem);
  1706.         }
  1708.         // IdentificationVariable
  1709.         $sqlParts = [];
  1711.         foreach ($this->queryComponents[$groupByItem]['metadata']->fieldNames as $field) {
  1712.             $item       = new AST\PathExpression(AST\PathExpression::TYPE_STATE_FIELD, $groupByItem, $field);
  1713.             $item->type = AST\PathExpression::TYPE_STATE_FIELD;
  1715.             $sqlParts[] = $this->walkPathExpression($item);
  1716.         }
  1718.         foreach ($this->queryComponents[$groupByItem]['metadata']->associationMappings as $mapping) {
  1719.             if ($mapping['isOwningSide'] && $mapping['type'] & ClassMetadataInfo::TO_ONE) {
  1720.                 $item       = new AST\PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION, $groupByItem, $mapping['fieldName']);
  1721.                 $item->type = AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION;
  1723.                 $sqlParts[] = $this->walkPathExpression($item);
  1724.             }
  1725.         }
  1727.         return implode(', ', $sqlParts);
  1728.     }
  1730.     /**
  1731.      * {@inheritdoc}
  1732.      */
  1733.     public function walkDeleteClause(AST\DeleteClause $deleteClause)
  1734.     {
  1735.         $class     = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1736.         $tableName = $class->getTableName();
  1737.         $sql       = 'DELETE FROM ' . $this->quoteStrategy->getTableName($class, $this->platform);
  1739.         $this->setSQLTableAlias($tableName, $tableName, $deleteClause->aliasIdentificationVariable);
  1740.         $this->rootAliases[] = $deleteClause->aliasIdentificationVariable;
  1742.         return $sql;
  1743.     }
  1745.     /**
  1746.      * {@inheritdoc}
  1747.      */
  1748.     public function walkUpdateClause($updateClause)
  1749.     {
  1750.         $class     = $this->em->getClassMetadata($updateClause->abstractSchemaName);
  1751.         $tableName = $class->getTableName();
  1752.         $sql       = 'UPDATE ' . $this->quoteStrategy->getTableName($class, $this->platform);
  1754.         $this->setSQLTableAlias($tableName, $tableName, $updateClause->aliasIdentificationVariable);
  1755.         $this->rootAliases[] = $updateClause->aliasIdentificationVariable;
  1757.         $sql .= ' SET ' . implode(', ', array_map([$this, 'walkUpdateItem'], $updateClause->updateItems));
  1759.         return $sql;
  1760.     }
  1762.     /**
  1763.      * {@inheritdoc}
  1764.      */
  1765.     public function walkUpdateItem($updateItem)
  1766.     {
  1767.         $useTableAliasesBefore = $this->useSqlTableAliases;
  1768.         $this->useSqlTableAliases = false;
  1770.         $sql      = $this->walkPathExpression($updateItem->pathExpression) . ' = ';
  1771.         $newValue = $updateItem->newValue;
  1773.         switch (true) {
  1774.             case ($newValue instanceof AST\Node):
  1775.                 $sql .= $newValue->dispatch($this);
  1776.                 break;
  1778.             case ($newValue === null):
  1779.                 $sql .= 'NULL';
  1780.                 break;
  1782.             default:
  1783.                 $sql .= $this->conn->quote($newValue);
  1784.                 break;
  1785.         }
  1787.         $this->useSqlTableAliases = $useTableAliasesBefore;
  1789.         return $sql;
  1790.     }
  1792.     /**
  1793.      * {@inheritdoc}
  1794.      */
  1795.     public function walkWhereClause($whereClause)
  1796.     {
  1797.         $condSql  = null !== $whereClause ? $this->walkConditionalExpression($whereClause->conditionalExpression) : '';
  1798.         $discrSql = $this->_generateDiscriminatorColumnConditionSQL($this->rootAliases);
  1800.         if ($this->em->hasFilters()) {
  1801.             $filterClauses = [];
  1802.             foreach ($this->rootAliases as $dqlAlias) {
  1803.                 $class = $this->queryComponents[$dqlAlias]['metadata'];
  1804.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
  1806.                 if ($filterExpr = $this->generateFilterConditionSQL($class, $tableAlias)) {
  1807.                     $filterClauses[] = $filterExpr;
  1808.                 }
  1809.             }
  1811.             if (count($filterClauses)) {
  1812.                 if ($condSql) {
  1813.                     $condSql = '(' . $condSql . ') AND ';
  1814.                 }
  1816.                 $condSql .= implode(' AND ', $filterClauses);
  1817.             }
  1818.         }
  1820.         if ($condSql) {
  1821.             return ' WHERE ' . (( ! $discrSql) ? $condSql : '(' . $condSql . ') AND ' . $discrSql);
  1822.         }
  1824.         if ($discrSql) {
  1825.             return ' WHERE ' . $discrSql;
  1826.         }
  1828.         return '';
  1829.     }
  1831.     /**
  1832.      * {@inheritdoc}
  1833.      */
  1834.     public function walkConditionalExpression($condExpr)
  1835.     {
  1836.         // Phase 2 AST optimization: Skip processing of ConditionalExpression
  1837.         // if only one ConditionalTerm is defined
  1838.         if ( ! ($condExpr instanceof AST\ConditionalExpression)) {
  1839.             return $this->walkConditionalTerm($condExpr);
  1840.         }
  1842.         return implode(' OR ', array_map([$this, 'walkConditionalTerm'], $condExpr->conditionalTerms));
  1843.     }
  1845.     /**
  1846.      * {@inheritdoc}
  1847.      */
  1848.     public function walkConditionalTerm($condTerm)
  1849.     {
  1850.         // Phase 2 AST optimization: Skip processing of ConditionalTerm
  1851.         // if only one ConditionalFactor is defined
  1852.         if ( ! ($condTerm instanceof AST\ConditionalTerm)) {
  1853.             return $this->walkConditionalFactor($condTerm);
  1854.         }
  1856.         return implode(' AND ', array_map([$this, 'walkConditionalFactor'], $condTerm->conditionalFactors));
  1857.     }
  1859.     /**
  1860.      * {@inheritdoc}
  1861.      */
  1862.     public function walkConditionalFactor($factor)
  1863.     {
  1864.         // Phase 2 AST optimization: Skip processing of ConditionalFactor
  1865.         // if only one ConditionalPrimary is defined
  1866.         return ( ! ($factor instanceof AST\ConditionalFactor))
  1867.             ? $this->walkConditionalPrimary($factor)
  1868.             : ($factor->not ? 'NOT ' : '') . $this->walkConditionalPrimary($factor->conditionalPrimary);
  1869.     }
  1871.     /**
  1872.      * {@inheritdoc}
  1873.      */
  1874.     public function walkConditionalPrimary($primary)
  1875.     {
  1876.         if ($primary->isSimpleConditionalExpression()) {
  1877.             return $primary->simpleConditionalExpression->dispatch($this);
  1878.         }
  1880.         if ($primary->isConditionalExpression()) {
  1881.             $condExpr = $primary->conditionalExpression;
  1883.             return '(' . $this->walkConditionalExpression($condExpr) . ')';
  1884.         }
  1885.     }
  1887.     /**
  1888.      * {@inheritdoc}
  1889.      */
  1890.     public function walkExistsExpression($existsExpr)
  1891.     {
  1892.         $sql = ($existsExpr->not) ? 'NOT ' : '';
  1894.         $sql .= 'EXISTS (' . $this->walkSubselect($existsExpr->subselect) . ')';
  1896.         return $sql;
  1897.     }
  1899.     /**
  1900.      * {@inheritdoc}
  1901.      */
  1902.     public function walkCollectionMemberExpression($collMemberExpr)
  1903.     {
  1904.         $sql = $collMemberExpr->not ? 'NOT ' : '';
  1905.         $sql .= 'EXISTS (SELECT 1 FROM ';
  1907.         $entityExpr   = $collMemberExpr->entityExpression;
  1908.         $collPathExpr = $collMemberExpr->collectionValuedPathExpression;
  1910.         $fieldName = $collPathExpr->field;
  1911.         $dqlAlias  = $collPathExpr->identificationVariable;
  1913.         $class = $this->queryComponents[$dqlAlias]['metadata'];
  1915.         switch (true) {
  1916.             // InputParameter
  1917.             case ($entityExpr instanceof AST\InputParameter):
  1918.                 $dqlParamKey = $entityExpr->name;
  1919.                 $entitySql   = '?';
  1920.                 break;
  1922.             // SingleValuedAssociationPathExpression | IdentificationVariable
  1923.             case ($entityExpr instanceof AST\PathExpression):
  1924.                 $entitySql = $this->walkPathExpression($entityExpr);
  1925.                 break;
  1927.             default:
  1928.                 throw new \BadMethodCallException("Not implemented");
  1929.         }
  1931.         $assoc = $class->associationMappings[$fieldName];
  1933.         if ($assoc['type'] == ClassMetadata::ONE_TO_MANY) {
  1934.             $targetClass      = $this->em->getClassMetadata($assoc['targetEntity']);
  1935.             $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName());
  1936.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  1938.             $sql .= $this->quoteStrategy->getTableName($targetClass, $this->platform) . ' ' . $targetTableAlias . ' WHERE ';
  1940.             $owningAssoc = $targetClass->associationMappings[$assoc['mappedBy']];
  1941.             $sqlParts    = [];
  1943.             foreach ($owningAssoc['targetToSourceKeyColumns'] as $targetColumn => $sourceColumn) {
  1944.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$targetColumn], $class, $this->platform);
  1946.                 $sqlParts[] = $sourceTableAlias . '.' . $targetColumn . ' = ' . $targetTableAlias . '.' . $sourceColumn;
  1947.             }
  1949.             foreach ($this->quoteStrategy->getIdentifierColumnNames($targetClass, $this->platform) as $targetColumnName) {
  1950.                 if (isset($dqlParamKey)) {
  1951.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
  1952.                 }
  1954.                 $sqlParts[] = $targetTableAlias . '.'  . $targetColumnName . ' = ' . $entitySql;
  1955.             }
  1957.             $sql .= implode(' AND ', $sqlParts);
  1958.         } else { // many-to-many
  1959.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  1961.             $owningAssoc = $assoc['isOwningSide'] ? $assoc : $targetClass->associationMappings[$assoc['mappedBy']];
  1962.             $joinTable = $owningAssoc['joinTable'];
  1964.             // SQL table aliases
  1965.             $joinTableAlias   = $this->getSQLTableAlias($joinTable['name']);
  1966.             $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName());
  1967.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  1969.             // join to target table
  1970.             $sql .= $this->quoteStrategy->getJoinTableName($owningAssoc, $targetClass, $this->platform) . ' ' . $joinTableAlias
  1971.                 . ' INNER JOIN ' . $this->quoteStrategy->getTableName($targetClass, $this->platform) . ' ' . $targetTableAlias . ' ON ';
  1973.             // join conditions
  1974.             $joinColumns  = $assoc['isOwningSide'] ? $joinTable['inverseJoinColumns'] : $joinTable['joinColumns'];
  1975.             $joinSqlParts = [];
  1977.             foreach ($joinColumns as $joinColumn) {
  1978.                 $targetColumn = $this->quoteStrategy->getColumnName($targetClass->fieldNames[$joinColumn['referencedColumnName']], $targetClass, $this->platform);
  1980.                 $joinSqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' = ' . $targetTableAlias . '.' . $targetColumn;
  1981.             }
  1983.             $sql .= implode(' AND ', $joinSqlParts);
  1984.             $sql .= ' WHERE ';
  1986.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['joinColumns'] : $joinTable['inverseJoinColumns'];
  1987.             $sqlParts    = [];
  1989.             foreach ($joinColumns as $joinColumn) {
  1990.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$joinColumn['referencedColumnName']], $class, $this->platform);
  1992.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' = ' . $sourceTableAlias . '.' . $targetColumn;
  1993.             }
  1995.             foreach ($this->quoteStrategy->getIdentifierColumnNames($targetClass, $this->platform) as $targetColumnName) {
  1996.                 if (isset($dqlParamKey)) {
  1997.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
  1998.                 }
  2000.                 $sqlParts[] = $targetTableAlias . '.' . $targetColumnName . ' IN (' . $entitySql . ')';
  2001.             }
  2003.             $sql .= implode(' AND ', $sqlParts);
  2004.         }
  2006.         return $sql . ')';
  2007.     }
  2009.     /**
  2010.      * {@inheritdoc}
  2011.      */
  2012.     public function walkEmptyCollectionComparisonExpression($emptyCollCompExpr)
  2013.     {
  2014.         $sizeFunc = new AST\Functions\SizeFunction('size');
  2015.         $sizeFunc->collectionPathExpression = $emptyCollCompExpr->expression;
  2017.         return $sizeFunc->getSql($this) . ($emptyCollCompExpr->not ? ' > 0' : ' = 0');
  2018.     }
  2020.     /**
  2021.      * {@inheritdoc}
  2022.      */
  2023.     public function walkNullComparisonExpression($nullCompExpr)
  2024.     {
  2025.         $expression = $nullCompExpr->expression;
  2026.         $comparison = ' IS' . ($nullCompExpr->not ? ' NOT' : '') . ' NULL';
  2028.         // Handle ResultVariable
  2029.         if (is_string($expression) && isset($this->queryComponents[$expression]['resultVariable'])) {
  2030.             return $this->walkResultVariable($expression) . $comparison;
  2031.         }
  2033.         // Handle InputParameter mapping inclusion to ParserResult
  2034.         if ($expression instanceof AST\InputParameter) {
  2035.             return $this->walkInputParameter($expression) . $comparison;
  2036.         }
  2038.         return $expression->dispatch($this) . $comparison;
  2039.     }
  2041.     /**
  2042.      * {@inheritdoc}
  2043.      */
  2044.     public function walkInExpression($inExpr)
  2045.     {
  2046.         $sql = $this->walkArithmeticExpression($inExpr->expression) . ($inExpr->not ? ' NOT' : '') . ' IN (';
  2048.         $sql .= ($inExpr->subselect)
  2049.             ? $this->walkSubselect($inExpr->subselect)
  2050.             : implode(', ', array_map([$this, 'walkInParameter'], $inExpr->literals));
  2052.         $sql .= ')';
  2054.         return $sql;
  2055.     }
  2057.     /**
  2058.      * {@inheritdoc}
  2059.      * @throws \Doctrine\ORM\Query\QueryException
  2060.      */
  2061.     public function walkInstanceOfExpression($instanceOfExpr)
  2062.     {
  2063.         $sql = '';
  2065.         $dqlAlias = $instanceOfExpr->identificationVariable;
  2066.         $discrClass = $class = $this->queryComponents[$dqlAlias]['metadata'];
  2068.         if ($class->discriminatorColumn) {
  2069.             $discrClass = $this->em->getClassMetadata($class->rootEntityName);
  2070.         }
  2072.         if ($this->useSqlTableAliases) {
  2073.             $sql .= $this->getSQLTableAlias($discrClass->getTableName(), $dqlAlias) . '.';
  2074.         }
  2076.         $sql .= $class->discriminatorColumn['name'] . ($instanceOfExpr->not ? ' NOT IN ' : ' IN ');
  2077.         $sql .= $this->getChildDiscriminatorsFromClassMetadata($discrClass, $instanceOfExpr);
  2079.         return $sql;
  2080.     }
  2082.     /**
  2083.      * {@inheritdoc}
  2084.      */
  2085.     public function walkInParameter($inParam)
  2086.     {
  2087.         return $inParam instanceof AST\InputParameter
  2088.             ? $this->walkInputParameter($inParam)
  2089.             : $this->walkLiteral($inParam);
  2090.     }
  2092.     /**
  2093.      * {@inheritdoc}
  2094.      */
  2095.     public function walkLiteral($literal)
  2096.     {
  2097.         switch ($literal->type) {
  2098.             case AST\Literal::STRING:
  2099.                 return $this->conn->quote($literal->value);
  2101.             case AST\Literal::BOOLEAN:
  2102.                 return $this->conn->getDatabasePlatform()->convertBooleans('true' === strtolower($literal->value));
  2104.             case AST\Literal::NUMERIC:
  2105.                 return $literal->value;
  2107.             default:
  2108.                 throw QueryException::invalidLiteral($literal);
  2109.         }
  2110.     }
  2112.     /**
  2113.      * {@inheritdoc}
  2114.      */
  2115.     public function walkBetweenExpression($betweenExpr)
  2116.     {
  2117.         $sql = $this->walkArithmeticExpression($betweenExpr->expression);
  2119.         if ($betweenExpr->not) {
  2120.             $sql .= ' NOT';
  2121.         }
  2123.         $sql .= ' BETWEEN ' . $this->walkArithmeticExpression($betweenExpr->leftBetweenExpression)
  2124.             . ' AND ' . $this->walkArithmeticExpression($betweenExpr->rightBetweenExpression);
  2126.         return $sql;
  2127.     }
  2129.     /**
  2130.      * {@inheritdoc}
  2131.      */
  2132.     public function walkLikeExpression($likeExpr)
  2133.     {
  2134.         $stringExpr = $likeExpr->stringExpression;
  2135.         $leftExpr   = (is_string($stringExpr) && isset($this->queryComponents[$stringExpr]['resultVariable']))
  2136.             ? $this->walkResultVariable($stringExpr)
  2137.             : $stringExpr->dispatch($this);
  2139.         $sql = $leftExpr . ($likeExpr->not ? ' NOT' : '') . ' LIKE ';
  2141.         if ($likeExpr->stringPattern instanceof AST\InputParameter) {
  2142.             $sql .= $this->walkInputParameter($likeExpr->stringPattern);
  2143.         } elseif ($likeExpr->stringPattern instanceof AST\Functions\FunctionNode) {
  2144.             $sql .= $this->walkFunction($likeExpr->stringPattern);
  2145.         } elseif ($likeExpr->stringPattern instanceof AST\PathExpression) {
  2146.             $sql .= $this->walkPathExpression($likeExpr->stringPattern);
  2147.         } else {
  2148.             $sql .= $this->walkLiteral($likeExpr->stringPattern);
  2149.         }
  2151.         if ($likeExpr->escapeChar) {
  2152.             $sql .= ' ESCAPE ' . $this->walkLiteral($likeExpr->escapeChar);
  2153.         }
  2155.         return $sql;
  2156.     }
  2158.     /**
  2159.      * {@inheritdoc}
  2160.      */
  2161.     public function walkStateFieldPathExpression($stateFieldPathExpression)
  2162.     {
  2163.         return $this->walkPathExpression($stateFieldPathExpression);
  2164.     }
  2166.     /**
  2167.      * {@inheritdoc}
  2168.      */
  2169.     public function walkComparisonExpression($compExpr)
  2170.     {
  2171.         $leftExpr  = $compExpr->leftExpression;
  2172.         $rightExpr = $compExpr->rightExpression;
  2173.         $sql       = '';
  2175.         $sql .= ($leftExpr instanceof AST\Node)
  2176.             ? $leftExpr->dispatch($this)
  2177.             : (is_numeric($leftExpr) ? $leftExpr : $this->conn->quote($leftExpr));
  2179.         $sql .= ' ' . $compExpr->operator . ' ';
  2181.         $sql .= ($rightExpr instanceof AST\Node)
  2182.             ? $rightExpr->dispatch($this)
  2183.             : (is_numeric($rightExpr) ? $rightExpr : $this->conn->quote($rightExpr));
  2185.         return $sql;
  2186.     }
  2188.     /**
  2189.      * {@inheritdoc}
  2190.      */
  2191.     public function walkInputParameter($inputParam)
  2192.     {
  2193.         $this->parserResult->addParameterMapping($inputParam->name, $this->sqlParamIndex++);
  2195.         $parameter = $this->query->getParameter($inputParam->name);
  2197.         if ($parameter && Type::hasType($type = $parameter->getType())) {
  2198.             return Type::getType($type)->convertToDatabaseValueSQL('?', $this->platform);
  2199.         }
  2201.         return '?';
  2202.     }
  2204.     /**
  2205.      * {@inheritdoc}
  2206.      */
  2207.     public function walkArithmeticExpression($arithmeticExpr)
  2208.     {
  2209.         return ($arithmeticExpr->isSimpleArithmeticExpression())
  2210.             ? $this->walkSimpleArithmeticExpression($arithmeticExpr->simpleArithmeticExpression)
  2211.             : '(' . $this->walkSubselect($arithmeticExpr->subselect) . ')';
  2212.     }
  2214.     /**
  2215.      * {@inheritdoc}
  2216.      */
  2217.     public function walkSimpleArithmeticExpression($simpleArithmeticExpr)
  2218.     {
  2219.         if ( ! ($simpleArithmeticExpr instanceof AST\SimpleArithmeticExpression)) {
  2220.             return $this->walkArithmeticTerm($simpleArithmeticExpr);
  2221.         }
  2223.         return implode(' ', array_map([$this, 'walkArithmeticTerm'], $simpleArithmeticExpr->arithmeticTerms));
  2224.     }
  2226.     /**
  2227.      * {@inheritdoc}
  2228.      */
  2229.     public function walkArithmeticTerm($term)
  2230.     {
  2231.         if (is_string($term)) {
  2232.             return (isset($this->queryComponents[$term]))
  2233.                 ? $this->walkResultVariable($this->queryComponents[$term]['token']['value'])
  2234.                 : $term;
  2235.         }
  2237.         // Phase 2 AST optimization: Skip processing of ArithmeticTerm
  2238.         // if only one ArithmeticFactor is defined
  2239.         if ( ! ($term instanceof AST\ArithmeticTerm)) {
  2240.             return $this->walkArithmeticFactor($term);
  2241.         }
  2243.         return implode(' ', array_map([$this, 'walkArithmeticFactor'], $term->arithmeticFactors));
  2244.     }
  2246.     /**
  2247.      * {@inheritdoc}
  2248.      */
  2249.     public function walkArithmeticFactor($factor)
  2250.     {
  2251.         if (is_string($factor)) {
  2252.             return (isset($this->queryComponents[$factor]))
  2253.                 ? $this->walkResultVariable($this->queryComponents[$factor]['token']['value'])
  2254.                 : $factor;
  2255.         }
  2257.         // Phase 2 AST optimization: Skip processing of ArithmeticFactor
  2258.         // if only one ArithmeticPrimary is defined
  2259.         if ( ! ($factor instanceof AST\ArithmeticFactor)) {
  2260.             return $this->walkArithmeticPrimary($factor);
  2261.         }
  2263.         $sign = $factor->isNegativeSigned() ? '-' : ($factor->isPositiveSigned() ? '+' : '');
  2265.         return $sign . $this->walkArithmeticPrimary($factor->arithmeticPrimary);
  2266.     }
  2268.     /**
  2269.      * Walks down an ArithmeticPrimary that represents an AST node, thereby generating the appropriate SQL.
  2270.      *
  2271.      * @param mixed $primary
  2272.      *
  2273.      * @return string The SQL.
  2274.      */
  2275.     public function walkArithmeticPrimary($primary)
  2276.     {
  2277.         if ($primary instanceof AST\SimpleArithmeticExpression) {
  2278.             return '(' . $this->walkSimpleArithmeticExpression($primary) . ')';
  2279.         }
  2281.         if ($primary instanceof AST\Node) {
  2282.             return $primary->dispatch($this);
  2283.         }
  2285.         return $this->walkEntityIdentificationVariable($primary);
  2286.     }
  2288.     /**
  2289.      * {@inheritdoc}
  2290.      */
  2291.     public function walkStringPrimary($stringPrimary)
  2292.     {
  2293.         return (is_string($stringPrimary))
  2294.             ? $this->conn->quote($stringPrimary)
  2295.             : $stringPrimary->dispatch($this);
  2296.     }
  2298.     /**
  2299.      * {@inheritdoc}
  2300.      */
  2301.     public function walkResultVariable($resultVariable)
  2302.     {
  2303.         $resultAlias = $this->scalarResultAliasMap[$resultVariable];
  2305.         if (is_array($resultAlias)) {
  2306.             return implode(', ', $resultAlias);
  2307.         }
  2309.         return $resultAlias;
  2310.     }
  2312.     /**
  2313.      * @param ClassMetadataInfo $rootClass
  2314.      * @param AST\InstanceOfExpression $instanceOfExpr
  2315.      * @return string The list in parentheses of valid child discriminators from the given class
  2316.      * @throws QueryException
  2317.      */
  2318.     private function getChildDiscriminatorsFromClassMetadata(ClassMetadataInfo $rootClass, AST\InstanceOfExpression $instanceOfExpr): string
  2319.     {
  2320.         $sqlParameterList = [];
  2321.         $discriminators = [];
  2322.         foreach ($instanceOfExpr->value as $parameter) {
  2323.             if ($parameter instanceof AST\InputParameter) {
  2324.                 $this->rsm->discriminatorParameters[$parameter->name] = $parameter->name;
  2325.                 $sqlParameterList[] = $this->walkInParameter($parameter);
  2326.                 continue;
  2327.             }
  2329.             $metadata = $this->em->getClassMetadata($parameter);
  2331.             if ($metadata->getName() !== $rootClass->name && ! $metadata->getReflectionClass()->isSubclassOf($rootClass->name)) {
  2332.                 throw QueryException::instanceOfUnrelatedClass($parameter, $rootClass->name);
  2333.             }
  2335.             $discriminators += HierarchyDiscriminatorResolver::resolveDiscriminatorsForClass($metadata, $this->em);
  2336.         }
  2338.         foreach (array_keys($discriminators) as $dis) {
  2339.             $sqlParameterList[] = $this->conn->quote($dis);
  2340.         }
  2342.         return '(' . implode(', ', $sqlParameterList) . ')';
  2343.     }
  2344. }