1. <?php
3. declare(strict_types=1);
5. namespace Doctrine\ORM\Query;
7. use BadMethodCallException;
8. use Doctrine\DBAL\Connection;
9. use Doctrine\DBAL\LockMode;
10. use Doctrine\DBAL\Platforms\AbstractPlatform;
11. use Doctrine\DBAL\Types\Type;
12. use Doctrine\Deprecations\Deprecation;
13. use Doctrine\ORM\EntityManagerInterface;
14. use Doctrine\ORM\Mapping\ClassMetadata;
15. use Doctrine\ORM\Mapping\QuoteStrategy;
16. use Doctrine\ORM\OptimisticLockException;
17. use Doctrine\ORM\Query;
18. use Doctrine\ORM\Utility\HierarchyDiscriminatorResolver;
19. use Doctrine\ORM\Utility\PersisterHelper;
20. use InvalidArgumentException;
21. use LogicException;
23. use function array_diff;
24. use function array_filter;
25. use function array_keys;
26. use function array_map;
27. use function array_merge;
28. use function assert;
29. use function count;
30. use function implode;
31. use function in_array;
32. use function is_array;
33. use function is_float;
34. use function is_numeric;
35. use function is_string;
36. use function preg_match;
37. use function reset;
38. use function sprintf;
39. use function strtolower;
40. use function strtoupper;
41. use function trim;
43. /**
44.  * The SqlWalker walks over a DQL AST and constructs the corresponding SQL.
45.  *
46.  * @psalm-import-type QueryComponent from Parser
47.  * @psalm-consistent-constructor
48.  */
49. class SqlWalker implements TreeWalker
50. {
51.     public const HINT_DISTINCT = 'doctrine.distinct';
53.     /**
54.      * Used to mark a query as containing a PARTIAL expression, which needs to be known by SLC.
55.      */
56.     public const HINT_PARTIAL = 'doctrine.partial';
58.     /** @var ResultSetMapping */
59.     private $rsm;
61.     /**
62.      * Counter for generating unique column aliases.
63.      *
64.      * @var int
65.      */
66.     private $aliasCounter = 0;
68.     /**
69.      * Counter for generating unique table aliases.
70.      *
71.      * @var int
72.      */
73.     private $tableAliasCounter = 0;
75.     /**
76.      * Counter for generating unique scalar result.
77.      *
78.      * @var int
79.      */
80.     private $scalarResultCounter = 1;
82.     /**
83.      * Counter for generating unique parameter indexes.
84.      *
85.      * @var int
86.      */
87.     private $sqlParamIndex = 0;
89.     /**
90.      * Counter for generating indexes.
91.      *
92.      * @var int
93.      */
94.     private $newObjectCounter = 0;
96.     /** @var ParserResult */
97.     private $parserResult;
99.     /** @var EntityManagerInterface */
100.     private $em;
102.     /** @var Connection */
103.     private $conn;
105.     /** @var Query */
106.     private $query;
108.     /** @var mixed[] */
109.     private $tableAliasMap = [];
111.     /**
112.      * Map from result variable names to their SQL column alias names.
113.      *
114.      * @psalm-var array<string|int, string|list<string>>
115.      */
116.     private $scalarResultAliasMap = [];
118.     /**
119.      * Map from Table-Alias + Column-Name to OrderBy-Direction.
120.      *
121.      * @var array<string, string>
122.      */
123.     private $orderedColumnsMap = [];
125.     /**
126.      * Map from DQL-Alias + Field-Name to SQL Column Alias.
127.      *
128.      * @var array<string, array<string, string>>
129.      */
130.     private $scalarFields = [];
132.     /**
133.      * Map of all components/classes that appear in the DQL query.
134.      *
135.      * @psalm-var array<string, QueryComponent>
136.      */
137.     private $queryComponents;
139.     /**
140.      * A list of classes that appear in non-scalar SelectExpressions.
141.      *
142.      * @psalm-var array<string, array{class: ClassMetadata, dqlAlias: string, resultAlias: string|null}>
143.      */
144.     private $selectedClasses = [];
146.     /**
147.      * The DQL alias of the root class of the currently traversed query.
148.      *
149.      * @psalm-var list<string>
150.      */
151.     private $rootAliases = [];
153.     /**
154.      * Flag that indicates whether to generate SQL table aliases in the SQL.
155.      * These should only be generated for SELECT queries, not for UPDATE/DELETE.
156.      *
157.      * @var bool
158.      */
159.     private $useSqlTableAliases = true;
161.     /**
162.      * The database platform abstraction.
163.      *
164.      * @var AbstractPlatform
165.      */
166.     private $platform;
168.     /**
169.      * The quote strategy.
170.      *
171.      * @var QuoteStrategy
172.      */
173.     private $quoteStrategy;
175.     /**
176.      * @param Query        $query        The parsed Query.
177.      * @param ParserResult $parserResult The result of the parsing process.
178.      * @psalm-param array<string, QueryComponent> $queryComponents The query components (symbol table).
179.      */
180.     public function __construct($query, $parserResult, array $queryComponents)
181.     {
182.         $this->query           = $query;
183.         $this->parserResult    = $parserResult;
184.         $this->queryComponents = $queryComponents;
185.         $this->rsm             = $parserResult->getResultSetMapping();
186.         $this->em              = $query->getEntityManager();
187.         $this->conn            = $this->em->getConnection();
188.         $this->platform        = $this->conn->getDatabasePlatform();
189.         $this->quoteStrategy   = $this->em->getConfiguration()->getQuoteStrategy();
190.     }
192.     /**
193.      * Gets the Query instance used by the walker.
194.      *
195.      * @return Query
196.      */
197.     public function getQuery()
198.     {
199.         return $this->query;
200.     }
202.     /**
203.      * Gets the Connection used by the walker.
204.      *
205.      * @return Connection
206.      */
207.     public function getConnection()
208.     {
209.         return $this->conn;
210.     }
212.     /**
213.      * Gets the EntityManager used by the walker.
214.      *
215.      * @return EntityManagerInterface
216.      */
217.     public function getEntityManager()
218.     {
219.         return $this->em;
220.     }
222.     /**
223.      * Gets the information about a single query component.
224.      *
225.      * @param string $dqlAlias The DQL alias.
226.      *
227.      * @return mixed[]
228.      * @psalm-return QueryComponent
229.      */
230.     public function getQueryComponent($dqlAlias)
231.     {
232.         return $this->queryComponents[$dqlAlias];
233.     }
235.     public function getMetadataForDqlAlias(string $dqlAlias): ClassMetadata
236.     {
237.         if (! isset($this->queryComponents[$dqlAlias]['metadata'])) {
238.             throw new LogicException(sprintf('No metadata for DQL alias: %s', $dqlAlias));
239.         }
241.         return $this->queryComponents[$dqlAlias]['metadata'];
242.     }
244.     /**
245.      * Returns internal queryComponents array.
246.      *
247.      * @return array<string, QueryComponent>
248.      */
249.     public function getQueryComponents()
250.     {
251.         return $this->queryComponents;
252.     }
254.     /**
255.      * Sets or overrides a query component for a given dql alias.
256.      *
257.      * @param string $dqlAlias The DQL alias.
258.      * @psalm-param QueryComponent $queryComponent
259.      *
260.      * @return void
261.      */
262.     public function setQueryComponent($dqlAlias, array $queryComponent)
263.     {
264.         $requiredKeys = ['metadata', 'parent', 'relation', 'map', 'nestingLevel', 'token'];
266.         if (array_diff($requiredKeys, array_keys($queryComponent))) {
267.             throw QueryException::invalidQueryComponent($dqlAlias);
268.         }
270.         $this->queryComponents[$dqlAlias] = $queryComponent;
271.     }
273.     /**
274.      * Gets an executor that can be used to execute the result of this walker.
275.      *
276.      * @param AST\DeleteStatement|AST\UpdateStatement|AST\SelectStatement $AST
277.      *
278.      * @return Exec\AbstractSqlExecutor
279.      */
280.     public function getExecutor($AST)
281.     {
282.         switch (true) {
283.             case $AST instanceof AST\DeleteStatement:
284.                 $primaryClass = $this->em->getClassMetadata($AST->deleteClause->abstractSchemaName);
286.                 return $primaryClass->isInheritanceTypeJoined()
287.                     ? new Exec\MultiTableDeleteExecutor($AST, $this)
288.                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
290.             case $AST instanceof AST\UpdateStatement:
291.                 $primaryClass = $this->em->getClassMetadata($AST->updateClause->abstractSchemaName);
293.                 return $primaryClass->isInheritanceTypeJoined()
294.                     ? new Exec\MultiTableUpdateExecutor($AST, $this)
295.                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
297.             default:
298.                 return new Exec\SingleSelectExecutor($AST, $this);
299.         }
300.     }
302.     /**
303.      * Generates a unique, short SQL table alias.
304.      *
305.      * @param string $tableName Table name
306.      * @param string $dqlAlias  The DQL alias.
307.      *
308.      * @return string Generated table alias.
309.      */
310.     public function getSQLTableAlias($tableName, $dqlAlias = '')
311.     {
312.         $tableName .= $dqlAlias ? '@[' . $dqlAlias . ']' : '';
314.         if (! isset($this->tableAliasMap[$tableName])) {
315.             $this->tableAliasMap[$tableName] = (preg_match('/[a-z]/i', $tableName[0]) ? strtolower($tableName[0]) : 't')
316.                 . $this->tableAliasCounter++ . '_';
317.         }
319.         return $this->tableAliasMap[$tableName];
320.     }
322.     /**
323.      * Forces the SqlWalker to use a specific alias for a table name, rather than
324.      * generating an alias on its own.
325.      *
326.      * @param string $tableName
327.      * @param string $alias
328.      * @param string $dqlAlias
329.      *
330.      * @return string
331.      */
332.     public function setSQLTableAlias($tableName, $alias, $dqlAlias = '')
333.     {
334.         $tableName .= $dqlAlias ? '@[' . $dqlAlias . ']' : '';
336.         $this->tableAliasMap[$tableName] = $alias;
338.         return $alias;
339.     }
341.     /**
342.      * Gets an SQL column alias for a column name.
343.      *
344.      * @param string $columnName
345.      *
346.      * @return string
347.      */
348.     public function getSQLColumnAlias($columnName)
349.     {
350.         return $this->quoteStrategy->getColumnAlias($columnName, $this->aliasCounter++, $this->platform);
351.     }
353.     /**
354.      * Generates the SQL JOINs that are necessary for Class Table Inheritance
355.      * for the given class.
356.      *
357.      * @param ClassMetadata $class    The class for which to generate the joins.
358.      * @param string        $dqlAlias The DQL alias of the class.
359.      *
360.      * @return string The SQL.
361.      */
362.     private function generateClassTableInheritanceJoins(
363.         ClassMetadata $class,
364.         string $dqlAlias
365.     ): string {
366.         $sql = '';
368.         $baseTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
370.         // INNER JOIN parent class tables
371.         foreach ($class->parentClasses as $parentClassName) {
372.             $parentClass = $this->em->getClassMetadata($parentClassName);
373.             $tableAlias  = $this->getSQLTableAlias($parentClass->getTableName(), $dqlAlias);
375.             // If this is a joined association we must use left joins to preserve the correct result.
376.             $sql .= isset($this->queryComponents[$dqlAlias]['relation']) ? ' LEFT ' : ' INNER ';
377.             $sql .= 'JOIN ' . $this->quoteStrategy->getTableName($parentClass, $this->platform) . ' ' . $tableAlias . ' ON ';
379.             $sqlParts = [];
381.             foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
382.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
383.             }
385.             // Add filters on the root class
386.             $sqlParts[] = $this->generateFilterConditionSQL($parentClass, $tableAlias);
388.             $sql .= implode(' AND ', array_filter($sqlParts));
389.         }
391.         // Ignore subclassing inclusion if partial objects is disallowed
392.         if ($this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
393.             return $sql;
394.         }
396.         // LEFT JOIN child class tables
397.         foreach ($class->subClasses as $subClassName) {
398.             $subClass   = $this->em->getClassMetadata($subClassName);
399.             $tableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
401.             $sql .= ' LEFT JOIN ' . $this->quoteStrategy->getTableName($subClass, $this->platform) . ' ' . $tableAlias . ' ON ';
403.             $sqlParts = [];
405.             foreach ($this->quoteStrategy->getIdentifierColumnNames($subClass, $this->platform) as $columnName) {
406.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
407.             }
409.             $sql .= implode(' AND ', $sqlParts);
410.         }
412.         return $sql;
413.     }
415.     private function generateOrderedCollectionOrderByItems(): string
416.     {
417.         $orderedColumns = [];
419.         foreach ($this->selectedClasses as $selectedClass) {
420.             $dqlAlias = $selectedClass['dqlAlias'];
421.             $qComp    = $this->queryComponents[$dqlAlias];
423.             if (! isset($qComp['relation']['orderBy'])) {
424.                 continue;
425.             }
427.             assert(isset($qComp['metadata']));
428.             $persister = $this->em->getUnitOfWork()->getEntityPersister($qComp['metadata']->name);
430.             foreach ($qComp['relation']['orderBy'] as $fieldName => $orientation) {
431.                 $columnName = $this->quoteStrategy->getColumnName($fieldName, $qComp['metadata'], $this->platform);
432.                 $tableName  = $qComp['metadata']->isInheritanceTypeJoined()
433.                     ? $persister->getOwningTable($fieldName)
434.                     : $qComp['metadata']->getTableName();
436.                 $orderedColumn = $this->getSQLTableAlias($tableName, $dqlAlias) . '.' . $columnName;
438.                 // OrderByClause should replace an ordered relation. see - DDC-2475
439.                 if (isset($this->orderedColumnsMap[$orderedColumn])) {
440.                     continue;
441.                 }
443.                 $this->orderedColumnsMap[$orderedColumn] = $orientation;
444.                 $orderedColumns[]                        = $orderedColumn . ' ' . $orientation;
445.             }
446.         }
448.         return implode(', ', $orderedColumns);
449.     }
451.     /**
452.      * Generates a discriminator column SQL condition for the class with the given DQL alias.
453.      *
454.      * @psalm-param list<string> $dqlAliases List of root DQL aliases to inspect for discriminator restrictions.
455.      */
456.     private function generateDiscriminatorColumnConditionSQL(array $dqlAliases): string
457.     {
458.         $sqlParts = [];
460.         foreach ($dqlAliases as $dqlAlias) {
461.             $class = $this->getMetadataForDqlAlias($dqlAlias);
463.             if (! $class->isInheritanceTypeSingleTable()) {
464.                 continue;
465.             }
467.             $conn   = $this->em->getConnection();
468.             $values = [];
470.             if ($class->discriminatorValue !== null) { // discriminators can be 0
471.                 $values[] = $conn->quote($class->discriminatorValue);
472.             }
474.             foreach ($class->subClasses as $subclassName) {
475.                 $values[] = $conn->quote($this->em->getClassMetadata($subclassName)->discriminatorValue);
476.             }
478.             $sqlTableAlias = $this->useSqlTableAliases
479.                 ? $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.'
480.                 : '';
482.             $sqlParts[] = $sqlTableAlias . $class->getDiscriminatorColumn()['name'] . ' IN (' . implode(', ', $values) . ')';
483.         }
485.         $sql = implode(' AND ', $sqlParts);
487.         return count($sqlParts) > 1 ? '(' . $sql . ')' : $sql;
488.     }
490.     /**
491.      * Generates the filter SQL for a given entity and table alias.
492.      *
493.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
494.      * @param string        $targetTableAlias The table alias of the joined/selected table.
495.      *
496.      * @return string The SQL query part to add to a query.
497.      */
498.     private function generateFilterConditionSQL(
499.         ClassMetadata $targetEntity,
500.         string $targetTableAlias
501.     ): string {
502.         if (! $this->em->hasFilters()) {
503.             return '';
504.         }
506.         switch ($targetEntity->inheritanceType) {
507.             case ClassMetadata::INHERITANCE_TYPE_NONE:
508.                 break;
509.             case ClassMetadata::INHERITANCE_TYPE_JOINED:
510.                 // The classes in the inheritance will be added to the query one by one,
511.                 // but only the root node is getting filtered
512.                 if ($targetEntity->name !== $targetEntity->rootEntityName) {
513.                     return '';
514.                 }
516.                 break;
517.             case ClassMetadata::INHERITANCE_TYPE_SINGLE_TABLE:
518.                 // With STI the table will only be queried once, make sure that the filters
519.                 // are added to the root entity
520.                 $targetEntity = $this->em->getClassMetadata($targetEntity->rootEntityName);
521.                 break;
522.             default:
523.                 //@todo: throw exception?
524.                 return '';
525.         }
527.         $filterClauses = [];
528.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
529.             $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
530.             if ($filterExpr !== '') {
531.                 $filterClauses[] = '(' . $filterExpr . ')';
532.             }
533.         }
535.         return implode(' AND ', $filterClauses);
536.     }
538.     /**
539.      * Walks down a SelectStatement AST node, thereby generating the appropriate SQL.
540.      *
541.      * @return string
542.      */
543.     public function walkSelectStatement(AST\SelectStatement $AST)
544.     {
545.         $limit    = $this->query->getMaxResults();
546.         $offset   = $this->query->getFirstResult();
547.         $lockMode = $this->query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE;
548.         $sql      = $this->walkSelectClause($AST->selectClause)
549.             . $this->walkFromClause($AST->fromClause)
550.             . $this->walkWhereClause($AST->whereClause);
552.         if ($AST->groupByClause) {
553.             $sql .= $this->walkGroupByClause($AST->groupByClause);
554.         }
556.         if ($AST->havingClause) {
557.             $sql .= $this->walkHavingClause($AST->havingClause);
558.         }
560.         if ($AST->orderByClause) {
561.             $sql .= $this->walkOrderByClause($AST->orderByClause);
562.         }
564.         $orderBySql = $this->generateOrderedCollectionOrderByItems();
565.         if (! $AST->orderByClause && $orderBySql) {
566.             $sql .= ' ORDER BY ' . $orderBySql;
567.         }
569.         $sql = $this->platform->modifyLimitQuery($sql, $limit, $offset ?? 0);
571.         if ($lockMode === LockMode::NONE) {
572.             return $sql;
573.         }
575.         if ($lockMode === LockMode::PESSIMISTIC_READ) {
576.             return $sql . ' ' . $this->platform->getReadLockSQL();
577.         }
579.         if ($lockMode === LockMode::PESSIMISTIC_WRITE) {
580.             return $sql . ' ' . $this->platform->getWriteLockSQL();
581.         }
583.         if ($lockMode !== LockMode::OPTIMISTIC) {
584.             throw QueryException::invalidLockMode();
585.         }
587.         foreach ($this->selectedClasses as $selectedClass) {
588.             if (! $selectedClass['class']->isVersioned) {
589.                 throw OptimisticLockException::lockFailed($selectedClass['class']->name);
590.             }
591.         }
593.         return $sql;
594.     }
596.     /**
597.      * Walks down an UpdateStatement AST node, thereby generating the appropriate SQL.
598.      *
599.      * @return string
600.      */
601.     public function walkUpdateStatement(AST\UpdateStatement $AST)
602.     {
603.         $this->useSqlTableAliases = false;
604.         $this->rsm->isSelect      = false;
606.         return $this->walkUpdateClause($AST->updateClause)
607.             . $this->walkWhereClause($AST->whereClause);
608.     }
610.     /**
611.      * Walks down a DeleteStatement AST node, thereby generating the appropriate SQL.
612.      *
613.      * @return string
614.      */
615.     public function walkDeleteStatement(AST\DeleteStatement $AST)
616.     {
617.         $this->useSqlTableAliases = false;
618.         $this->rsm->isSelect      = false;
620.         return $this->walkDeleteClause($AST->deleteClause)
621.             . $this->walkWhereClause($AST->whereClause);
622.     }
624.     /**
625.      * Walks down an IdentificationVariable AST node, thereby generating the appropriate SQL.
626.      * This one differs of ->walkIdentificationVariable() because it generates the entity identifiers.
627.      *
628.      * @param string $identVariable
629.      *
630.      * @return string
631.      */
632.     public function walkEntityIdentificationVariable($identVariable)
633.     {
634.         $class      = $this->getMetadataForDqlAlias($identVariable);
635.         $tableAlias = $this->getSQLTableAlias($class->getTableName(), $identVariable);
636.         $sqlParts   = [];
638.         foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
639.             $sqlParts[] = $tableAlias . '.' . $columnName;
640.         }
642.         return implode(', ', $sqlParts);
643.     }
645.     /**
646.      * Walks down an IdentificationVariable (no AST node associated), thereby generating the SQL.
647.      *
648.      * @param string $identificationVariable
649.      * @param string $fieldName
650.      *
651.      * @return string The SQL.
652.      */
653.     public function walkIdentificationVariable($identificationVariable, $fieldName = null)
654.     {
655.         $class = $this->getMetadataForDqlAlias($identificationVariable);
657.         if (
658.             $fieldName !== null && $class->isInheritanceTypeJoined() &&
659.             isset($class->fieldMappings[$fieldName]['inherited'])
660.         ) {
661.             $class = $this->em->getClassMetadata($class->fieldMappings[$fieldName]['inherited']);
662.         }
664.         return $this->getSQLTableAlias($class->getTableName(), $identificationVariable);
665.     }
667.     /**
668.      * Walks down a PathExpression AST node, thereby generating the appropriate SQL.
669.      *
670.      * @param AST\PathExpression $pathExpr
671.      *
672.      * @return string
673.      */
674.     public function walkPathExpression($pathExpr)
675.     {
676.         $sql = '';
677.         assert($pathExpr->field !== null);
679.         switch ($pathExpr->type) {
680.             case AST\PathExpression::TYPE_STATE_FIELD:
681.                 $fieldName = $pathExpr->field;
682.                 $dqlAlias  = $pathExpr->identificationVariable;
683.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
685.                 if ($this->useSqlTableAliases) {
686.                     $sql .= $this->walkIdentificationVariable($dqlAlias, $fieldName) . '.';
687.                 }
689.                 $sql .= $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
690.                 break;
692.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
693.                 // 1- the owning side:
694.                 //    Just use the foreign key, i.e. u.group_id
695.                 $fieldName = $pathExpr->field;
696.                 $dqlAlias  = $pathExpr->identificationVariable;
697.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
699.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
700.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
701.                 }
703.                 $assoc = $class->associationMappings[$fieldName];
705.                 if (! $assoc['isOwningSide']) {
706.                     throw QueryException::associationPathInverseSideNotSupported($pathExpr);
707.                 }
709.                 // COMPOSITE KEYS NOT (YET?) SUPPORTED
710.                 if (count($assoc['sourceToTargetKeyColumns']) > 1) {
711.                     throw QueryException::associationPathCompositeKeyNotSupported();
712.                 }
714.                 if ($this->useSqlTableAliases) {
715.                     $sql .= $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.';
716.                 }
718.                 $sql .= reset($assoc['targetToSourceKeyColumns']);
719.                 break;
721.             default:
722.                 throw QueryException::invalidPathExpression($pathExpr);
723.         }
725.         return $sql;
726.     }
728.     /**
729.      * Walks down a SelectClause AST node, thereby generating the appropriate SQL.
730.      *
731.      * @param AST\SelectClause $selectClause
732.      *
733.      * @return string
734.      */
735.     public function walkSelectClause($selectClause)
736.     {
737.         $sql                  = 'SELECT ' . ($selectClause->isDistinct ? 'DISTINCT ' : '');
738.         $sqlSelectExpressions = array_filter(array_map([$this, 'walkSelectExpression'], $selectClause->selectExpressions));
740.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) === true && $selectClause->isDistinct) {
741.             $this->query->setHint(self::HINT_DISTINCT, true);
742.         }
744.         $addMetaColumns = ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD) &&
745.             $this->query->getHydrationMode() === Query::HYDRATE_OBJECT
746.             || $this->query->getHint(Query::HINT_INCLUDE_META_COLUMNS);
748.         foreach ($this->selectedClasses as $selectedClass) {
749.             $class       = $selectedClass['class'];
750.             $dqlAlias    = $selectedClass['dqlAlias'];
751.             $resultAlias = $selectedClass['resultAlias'];
753.             // Register as entity or joined entity result
754.             if (! isset($this->queryComponents[$dqlAlias]['relation'])) {
755.                 $this->rsm->addEntityResult($class->name, $dqlAlias, $resultAlias);
756.             } else {
757.                 assert(isset($this->queryComponents[$dqlAlias]['parent']));
759.                 $this->rsm->addJoinedEntityResult(
760.                     $class->name,
761.                     $dqlAlias,
762.                     $this->queryComponents[$dqlAlias]['parent'],
763.                     $this->queryComponents[$dqlAlias]['relation']['fieldName']
764.                 );
765.             }
767.             if ($class->isInheritanceTypeSingleTable() || $class->isInheritanceTypeJoined()) {
768.                 // Add discriminator columns to SQL
769.                 $rootClass   = $this->em->getClassMetadata($class->rootEntityName);
770.                 $tblAlias    = $this->getSQLTableAlias($rootClass->getTableName(), $dqlAlias);
771.                 $discrColumn = $rootClass->getDiscriminatorColumn();
772.                 $columnAlias = $this->getSQLColumnAlias($discrColumn['name']);
774.                 $sqlSelectExpressions[] = $tblAlias . '.' . $discrColumn['name'] . ' AS ' . $columnAlias;
776.                 $this->rsm->setDiscriminatorColumn($dqlAlias, $columnAlias);
777.                 $this->rsm->addMetaResult($dqlAlias, $columnAlias, $discrColumn['fieldName'], false, $discrColumn['type']);
778.                 if (! empty($discrColumn['enumType'])) {
779.                     $this->rsm->addEnumResult($columnAlias, $discrColumn['enumType']);
780.                 }
781.             }
783.             // Add foreign key columns to SQL, if necessary
784.             if (! $addMetaColumns && ! $class->containsForeignIdentifier) {
785.                 continue;
786.             }
788.             // Add foreign key columns of class and also parent classes
789.             foreach ($class->associationMappings as $assoc) {
790.                 if (
791.                     ! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)
792.                     || ( ! $addMetaColumns && ! isset($assoc['id']))
793.                 ) {
794.                     continue;
795.                 }
797.                 $targetClass   = $this->em->getClassMetadata($assoc['targetEntity']);
798.                 $isIdentifier  = (isset($assoc['id']) && $assoc['id'] === true);
799.                 $owningClass   = isset($assoc['inherited']) ? $this->em->getClassMetadata($assoc['inherited']) : $class;
800.                 $sqlTableAlias = $this->getSQLTableAlias($owningClass->getTableName(), $dqlAlias);
802.                 foreach ($assoc['joinColumns'] as $joinColumn) {
803.                     $columnName  = $joinColumn['name'];
804.                     $columnAlias = $this->getSQLColumnAlias($columnName);
805.                     $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
807.                     $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
808.                     $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
810.                     $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $isIdentifier, $columnType);
811.                 }
812.             }
814.             // Add foreign key columns to SQL, if necessary
815.             if (! $addMetaColumns) {
816.                 continue;
817.             }
819.             // Add foreign key columns of subclasses
820.             foreach ($class->subClasses as $subClassName) {
821.                 $subClass      = $this->em->getClassMetadata($subClassName);
822.                 $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
824.                 foreach ($subClass->associationMappings as $assoc) {
825.                     // Skip if association is inherited
826.                     if (isset($assoc['inherited'])) {
827.                         continue;
828.                     }
830.                     if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
831.                         $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
833.                         foreach ($assoc['joinColumns'] as $joinColumn) {
834.                             $columnName  = $joinColumn['name'];
835.                             $columnAlias = $this->getSQLColumnAlias($columnName);
836.                             $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
838.                             $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $subClass, $this->platform);
839.                             $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
841.                             $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $subClass->isIdentifier($columnName), $columnType);
842.                         }
843.                     }
844.                 }
845.             }
846.         }
848.         return $sql . implode(', ', $sqlSelectExpressions);
849.     }
851.     /**
852.      * Walks down a FromClause AST node, thereby generating the appropriate SQL.
853.      *
854.      * @param AST\FromClause $fromClause
855.      *
856.      * @return string
857.      */
858.     public function walkFromClause($fromClause)
859.     {
860.         $identificationVarDecls = $fromClause->identificationVariableDeclarations;
861.         $sqlParts               = [];
863.         foreach ($identificationVarDecls as $identificationVariableDecl) {
864.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($identificationVariableDecl);
865.         }
867.         return ' FROM ' . implode(', ', $sqlParts);
868.     }
870.     /**
871.      * Walks down a IdentificationVariableDeclaration AST node, thereby generating the appropriate SQL.
872.      *
873.      * @param AST\IdentificationVariableDeclaration $identificationVariableDecl
874.      *
875.      * @return string
876.      */
877.     public function walkIdentificationVariableDeclaration($identificationVariableDecl)
878.     {
879.         $sql = $this->walkRangeVariableDeclaration($identificationVariableDecl->rangeVariableDeclaration);
881.         if ($identificationVariableDecl->indexBy) {
882.             $this->walkIndexBy($identificationVariableDecl->indexBy);
883.         }
885.         foreach ($identificationVariableDecl->joins as $join) {
886.             $sql .= $this->walkJoin($join);
887.         }
889.         return $sql;
890.     }
892.     /**
893.      * Walks down a IndexBy AST node.
894.      *
895.      * @param AST\IndexBy $indexBy
896.      *
897.      * @return void
898.      */
899.     public function walkIndexBy($indexBy)
900.     {
901.         $pathExpression = $indexBy->singleValuedPathExpression;
902.         $alias          = $pathExpression->identificationVariable;
903.         assert($pathExpression->field !== null);
905.         switch ($pathExpression->type) {
906.             case AST\PathExpression::TYPE_STATE_FIELD:
907.                 $field = $pathExpression->field;
908.                 break;
910.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
911.                 // Just use the foreign key, i.e. u.group_id
912.                 $fieldName = $pathExpression->field;
913.                 $class     = $this->getMetadataForDqlAlias($alias);
915.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
916.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
917.                 }
919.                 $association = $class->associationMappings[$fieldName];
921.                 if (! $association['isOwningSide']) {
922.                     throw QueryException::associationPathInverseSideNotSupported($pathExpression);
923.                 }
925.                 if (count($association['sourceToTargetKeyColumns']) > 1) {
926.                     throw QueryException::associationPathCompositeKeyNotSupported();
927.                 }
929.                 $field = reset($association['targetToSourceKeyColumns']);
930.                 break;
932.             default:
933.                 throw QueryException::invalidPathExpression($pathExpression);
934.         }
936.         if (isset($this->scalarFields[$alias][$field])) {
937.             $this->rsm->addIndexByScalar($this->scalarFields[$alias][$field]);
939.             return;
940.         }
942.         $this->rsm->addIndexBy($alias, $field);
943.     }
945.     /**
946.      * Walks down a RangeVariableDeclaration AST node, thereby generating the appropriate SQL.
947.      *
948.      * @param AST\RangeVariableDeclaration $rangeVariableDeclaration
949.      *
950.      * @return string
951.      */
952.     public function walkRangeVariableDeclaration($rangeVariableDeclaration)
953.     {
954.         return $this->generateRangeVariableDeclarationSQL($rangeVariableDeclaration, false);
955.     }
957.     /**
958.      * Generate appropriate SQL for RangeVariableDeclaration AST node
959.      */
960.     private function generateRangeVariableDeclarationSQL(
961.         AST\RangeVariableDeclaration $rangeVariableDeclaration,
962.         bool $buildNestedJoins
963.     ): string {
964.         $class    = $this->em->getClassMetadata($rangeVariableDeclaration->abstractSchemaName);
965.         $dqlAlias = $rangeVariableDeclaration->aliasIdentificationVariable;
967.         if ($rangeVariableDeclaration->isRoot) {
968.             $this->rootAliases[] = $dqlAlias;
969.         }
971.         $sql = $this->platform->appendLockHint(
972.             $this->quoteStrategy->getTableName($class, $this->platform) . ' ' .
973.             $this->getSQLTableAlias($class->getTableName(), $dqlAlias),
974.             $this->query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE
975.         );
977.         if (! $class->isInheritanceTypeJoined()) {
978.             return $sql;
979.         }
981.         $classTableInheritanceJoins = $this->generateClassTableInheritanceJoins($class, $dqlAlias);
983.         if (! $buildNestedJoins) {
984.             return $sql . $classTableInheritanceJoins;
985.         }
987.         return $classTableInheritanceJoins === '' ? $sql : '(' . $sql . $classTableInheritanceJoins . ')';
988.     }
990.     /**
991.      * Walks down a JoinAssociationDeclaration AST node, thereby generating the appropriate SQL.
992.      *
993.      * @param AST\JoinAssociationDeclaration $joinAssociationDeclaration
994.      * @param int                            $joinType
995.      * @param AST\ConditionalExpression      $condExpr
996.      * @psalm-param AST\Join::JOIN_TYPE_* $joinType
997.      *
998.      * @return string
999.      *
1000.      * @throws QueryException
1001.      */
1002.     public function walkJoinAssociationDeclaration($joinAssociationDeclaration, $joinType = AST\Join::JOIN_TYPE_INNER, $condExpr = null)
1003.     {
1004.         $sql = '';
1006.         $associationPathExpression = $joinAssociationDeclaration->joinAssociationPathExpression;
1007.         $joinedDqlAlias            = $joinAssociationDeclaration->aliasIdentificationVariable;
1008.         $indexBy                   = $joinAssociationDeclaration->indexBy;
1010.         $relation = $this->queryComponents[$joinedDqlAlias]['relation'] ?? null;
1011.         assert($relation !== null);
1012.         $targetClass     = $this->em->getClassMetadata($relation['targetEntity']);
1013.         $sourceClass     = $this->em->getClassMetadata($relation['sourceEntity']);
1014.         $targetTableName = $this->quoteStrategy->getTableName($targetClass, $this->platform);
1016.         $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName(), $joinedDqlAlias);
1017.         $sourceTableAlias = $this->getSQLTableAlias($sourceClass->getTableName(), $associationPathExpression->identificationVariable);
1019.         // Ensure we got the owning side, since it has all mapping info
1020.         $assoc = ! $relation['isOwningSide'] ? $targetClass->associationMappings[$relation['mappedBy']] : $relation;
1022.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) === true && (! $this->query->getHint(self::HINT_DISTINCT) || isset($this->selectedClasses[$joinedDqlAlias]))) {
1023.             if ($relation['type'] === ClassMetadata::ONE_TO_MANY || $relation['type'] === ClassMetadata::MANY_TO_MANY) {
1024.                 throw QueryException::iterateWithFetchJoinNotAllowed($assoc);
1025.             }
1026.         }
1028.         $targetTableJoin = null;
1030.         // This condition is not checking ClassMetadata::MANY_TO_ONE, because by definition it cannot
1031.         // be the owning side and previously we ensured that $assoc is always the owning side of the associations.
1032.         // The owning side is necessary at this point because only it contains the JoinColumn information.
1033.         switch (true) {
1034.             case $assoc['type'] & ClassMetadata::TO_ONE:
1035.                 $conditions = [];
1037.                 foreach ($assoc['joinColumns'] as $joinColumn) {
1038.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
1039.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
1041.                     if ($relation['isOwningSide']) {
1042.                         $conditions[] = $sourceTableAlias . '.' . $quotedSourceColumn . ' = ' . $targetTableAlias . '.' . $quotedTargetColumn;
1044.                         continue;
1045.                     }
1047.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $targetTableAlias . '.' . $quotedSourceColumn;
1048.                 }
1050.                 // Apply remaining inheritance restrictions
1051.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
1053.                 if ($discrSql) {
1054.                     $conditions[] = $discrSql;
1055.                 }
1057.                 // Apply the filters
1058.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
1060.                 if ($filterExpr) {
1061.                     $conditions[] = $filterExpr;
1062.                 }
1064.                 $targetTableJoin = [
1065.                     'table' => $targetTableName . ' ' . $targetTableAlias,
1066.                     'condition' => implode(' AND ', $conditions),
1067.                 ];
1068.                 break;
1070.             case $assoc['type'] === ClassMetadata::MANY_TO_MANY:
1071.                 // Join relation table
1072.                 $joinTable      = $assoc['joinTable'];
1073.                 $joinTableAlias = $this->getSQLTableAlias($joinTable['name'], $joinedDqlAlias);
1074.                 $joinTableName  = $this->quoteStrategy->getJoinTableName($assoc, $sourceClass, $this->platform);
1076.                 $conditions      = [];
1077.                 $relationColumns = $relation['isOwningSide']
1078.                     ? $assoc['joinTable']['joinColumns']
1079.                     : $assoc['joinTable']['inverseJoinColumns'];
1081.                 foreach ($relationColumns as $joinColumn) {
1082.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
1083.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
1085.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
1086.                 }
1088.                 $sql .= $joinTableName . ' ' . $joinTableAlias . ' ON ' . implode(' AND ', $conditions);
1090.                 // Join target table
1091.                 $sql .= $joinType === AST\Join::JOIN_TYPE_LEFT || $joinType === AST\Join::JOIN_TYPE_LEFTOUTER ? ' LEFT JOIN ' : ' INNER JOIN ';
1093.                 $conditions      = [];
1094.                 $relationColumns = $relation['isOwningSide']
1095.                     ? $assoc['joinTable']['inverseJoinColumns']
1096.                     : $assoc['joinTable']['joinColumns'];
1098.                 foreach ($relationColumns as $joinColumn) {
1099.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
1100.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
1102.                     $conditions[] = $targetTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
1103.                 }
1105.                 // Apply remaining inheritance restrictions
1106.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
1108.                 if ($discrSql) {
1109.                     $conditions[] = $discrSql;
1110.                 }
1112.                 // Apply the filters
1113.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
1115.                 if ($filterExpr) {
1116.                     $conditions[] = $filterExpr;
1117.                 }
1119.                 $targetTableJoin = [
1120.                     'table' => $targetTableName . ' ' . $targetTableAlias,
1121.                     'condition' => implode(' AND ', $conditions),
1122.                 ];
1123.                 break;
1125.             default:
1126.                 throw new BadMethodCallException('Type of association must be one of *_TO_ONE or MANY_TO_MANY');
1127.         }
1129.         // Handle WITH clause
1130.         $withCondition = $condExpr === null ? '' : ('(' . $this->walkConditionalExpression($condExpr) . ')');
1132.         if ($targetClass->isInheritanceTypeJoined()) {
1133.             $ctiJoins = $this->generateClassTableInheritanceJoins($targetClass, $joinedDqlAlias);
1134.             // If we have WITH condition, we need to build nested joins for target class table and cti joins
1135.             if ($withCondition && $ctiJoins) {
1136.                 $sql .= '(' . $targetTableJoin['table'] . $ctiJoins . ') ON ' . $targetTableJoin['condition'];
1137.             } else {
1138.                 $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'] . $ctiJoins;
1139.             }
1140.         } else {
1141.             $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'];
1142.         }
1144.         if ($withCondition) {
1145.             $sql .= ' AND ' . $withCondition;
1146.         }
1148.         // Apply the indexes
1149.         if ($indexBy) {
1150.             // For Many-To-One or One-To-One associations this obviously makes no sense, but is ignored silently.
1151.             $this->walkIndexBy($indexBy);
1152.         } elseif (isset($relation['indexBy'])) {
1153.             $this->rsm->addIndexBy($joinedDqlAlias, $relation['indexBy']);
1154.         }
1156.         return $sql;
1157.     }
1159.     /**
1160.      * Walks down a FunctionNode AST node, thereby generating the appropriate SQL.
1161.      *
1162.      * @param AST\Functions\FunctionNode $function
1163.      *
1164.      * @return string
1165.      */
1166.     public function walkFunction($function)
1167.     {
1168.         return $function->getSql($this);
1169.     }
1171.     /**
1172.      * Walks down an OrderByClause AST node, thereby generating the appropriate SQL.
1173.      *
1174.      * @param AST\OrderByClause $orderByClause
1175.      *
1176.      * @return string
1177.      */
1178.     public function walkOrderByClause($orderByClause)
1179.     {
1180.         $orderByItems = array_map([$this, 'walkOrderByItem'], $orderByClause->orderByItems);
1182.         $collectionOrderByItems = $this->generateOrderedCollectionOrderByItems();
1183.         if ($collectionOrderByItems !== '') {
1184.             $orderByItems = array_merge($orderByItems, (array) $collectionOrderByItems);
1185.         }
1187.         return ' ORDER BY ' . implode(', ', $orderByItems);
1188.     }
1190.     /**
1191.      * Walks down an OrderByItem AST node, thereby generating the appropriate SQL.
1192.      *
1193.      * @param AST\OrderByItem $orderByItem
1194.      *
1195.      * @return string
1196.      */
1197.     public function walkOrderByItem($orderByItem)
1198.     {
1199.         $type = strtoupper($orderByItem->type);
1200.         $expr = $orderByItem->expression;
1201.         $sql  = $expr instanceof AST\Node
1202.             ? $expr->dispatch($this)
1203.             : $this->walkResultVariable($this->queryComponents[$expr]['token']['value']);
1205.         $this->orderedColumnsMap[$sql] = $type;
1207.         if ($expr instanceof AST\Subselect) {
1208.             return '(' . $sql . ') ' . $type;
1209.         }
1211.         return $sql . ' ' . $type;
1212.     }
1214.     /**
1215.      * Walks down a HavingClause AST node, thereby generating the appropriate SQL.
1216.      *
1217.      * @param AST\HavingClause $havingClause
1218.      *
1219.      * @return string The SQL.
1220.      */
1221.     public function walkHavingClause($havingClause)
1222.     {
1223.         return ' HAVING ' . $this->walkConditionalExpression($havingClause->conditionalExpression);
1224.     }
1226.     /**
1227.      * Walks down a Join AST node and creates the corresponding SQL.
1228.      *
1229.      * @param AST\Join $join
1230.      *
1231.      * @return string
1232.      */
1233.     public function walkJoin($join)
1234.     {
1235.         $joinType        = $join->joinType;
1236.         $joinDeclaration = $join->joinAssociationDeclaration;
1238.         $sql = $joinType === AST\Join::JOIN_TYPE_LEFT || $joinType === AST\Join::JOIN_TYPE_LEFTOUTER
1239.             ? ' LEFT JOIN '
1240.             : ' INNER JOIN ';
1242.         switch (true) {
1243.             case $joinDeclaration instanceof AST\RangeVariableDeclaration:
1244.                 $class      = $this->em->getClassMetadata($joinDeclaration->abstractSchemaName);
1245.                 $dqlAlias   = $joinDeclaration->aliasIdentificationVariable;
1246.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
1247.                 $conditions = [];
1249.                 if ($join->conditionalExpression) {
1250.                     $conditions[] = '(' . $this->walkConditionalExpression($join->conditionalExpression) . ')';
1251.                 }
1253.                 $isUnconditionalJoin = $conditions === [];
1254.                 $condExprConjunction = $class->isInheritanceTypeJoined() && $joinType !== AST\Join::JOIN_TYPE_LEFT && $joinType !== AST\Join::JOIN_TYPE_LEFTOUTER && $isUnconditionalJoin
1255.                     ? ' AND '
1256.                     : ' ON ';
1258.                 $sql .= $this->generateRangeVariableDeclarationSQL($joinDeclaration, ! $isUnconditionalJoin);
1260.                 // Apply remaining inheritance restrictions
1261.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$dqlAlias]);
1263.                 if ($discrSql) {
1264.                     $conditions[] = $discrSql;
1265.                 }
1267.                 // Apply the filters
1268.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
1270.                 if ($filterExpr) {
1271.                     $conditions[] = $filterExpr;
1272.                 }
1274.                 if ($conditions) {
1275.                     $sql .= $condExprConjunction . implode(' AND ', $conditions);
1276.                 }
1278.                 break;
1280.             case $joinDeclaration instanceof AST\JoinAssociationDeclaration:
1281.                 $sql .= $this->walkJoinAssociationDeclaration($joinDeclaration, $joinType, $join->conditionalExpression);
1282.                 break;
1283.         }
1285.         return $sql;
1286.     }
1288.     /**
1289.      * Walks down a CoalesceExpression AST node and generates the corresponding SQL.
1290.      *
1291.      * @param AST\CoalesceExpression $coalesceExpression
1292.      *
1293.      * @return string The SQL.
1294.      */
1295.     public function walkCoalesceExpression($coalesceExpression)
1296.     {
1297.         $sql = 'COALESCE(';
1299.         $scalarExpressions = [];
1301.         foreach ($coalesceExpression->scalarExpressions as $scalarExpression) {
1302.             $scalarExpressions[] = $this->walkSimpleArithmeticExpression($scalarExpression);
1303.         }
1305.         return $sql . implode(', ', $scalarExpressions) . ')';
1306.     }
1308.     /**
1309.      * Walks down a NullIfExpression AST node and generates the corresponding SQL.
1310.      *
1311.      * @param AST\NullIfExpression $nullIfExpression
1312.      *
1313.      * @return string The SQL.
1314.      */
1315.     public function walkNullIfExpression($nullIfExpression)
1316.     {
1317.         $firstExpression = is_string($nullIfExpression->firstExpression)
1318.             ? $this->conn->quote($nullIfExpression->firstExpression)
1319.             : $this->walkSimpleArithmeticExpression($nullIfExpression->firstExpression);
1321.         $secondExpression = is_string($nullIfExpression->secondExpression)
1322.             ? $this->conn->quote($nullIfExpression->secondExpression)
1323.             : $this->walkSimpleArithmeticExpression($nullIfExpression->secondExpression);
1325.         return 'NULLIF(' . $firstExpression . ', ' . $secondExpression . ')';
1326.     }
1328.     /**
1329.      * Walks down a GeneralCaseExpression AST node and generates the corresponding SQL.
1330.      *
1331.      * @return string The SQL.
1332.      */
1333.     public function walkGeneralCaseExpression(AST\GeneralCaseExpression $generalCaseExpression)
1334.     {
1335.         $sql = 'CASE';
1337.         foreach ($generalCaseExpression->whenClauses as $whenClause) {
1338.             $sql .= ' WHEN ' . $this->walkConditionalExpression($whenClause->caseConditionExpression);
1339.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($whenClause->thenScalarExpression);
1340.         }
1342.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($generalCaseExpression->elseScalarExpression) . ' END';
1344.         return $sql;
1345.     }
1347.     /**
1348.      * Walks down a SimpleCaseExpression AST node and generates the corresponding SQL.
1349.      *
1350.      * @param AST\SimpleCaseExpression $simpleCaseExpression
1351.      *
1352.      * @return string The SQL.
1353.      */
1354.     public function walkSimpleCaseExpression($simpleCaseExpression)
1355.     {
1356.         $sql = 'CASE ' . $this->walkStateFieldPathExpression($simpleCaseExpression->caseOperand);
1358.         foreach ($simpleCaseExpression->simpleWhenClauses as $simpleWhenClause) {
1359.             $sql .= ' WHEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->caseScalarExpression);
1360.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->thenScalarExpression);
1361.         }
1363.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($simpleCaseExpression->elseScalarExpression) . ' END';
1365.         return $sql;
1366.     }
1368.     /**
1369.      * Walks down a SelectExpression AST node and generates the corresponding SQL.
1370.      *
1371.      * @param AST\SelectExpression $selectExpression
1372.      *
1373.      * @return string
1374.      */
1375.     public function walkSelectExpression($selectExpression)
1376.     {
1377.         $sql    = '';
1378.         $expr   = $selectExpression->expression;
1379.         $hidden = $selectExpression->hiddenAliasResultVariable;
1381.         switch (true) {
1382.             case $expr instanceof AST\PathExpression:
1383.                 if ($expr->type !== AST\PathExpression::TYPE_STATE_FIELD) {
1384.                     throw QueryException::invalidPathExpression($expr);
1385.                 }
1387.                 assert($expr->field !== null);
1388.                 $fieldName = $expr->field;
1389.                 $dqlAlias  = $expr->identificationVariable;
1390.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
1392.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $fieldName;
1393.                 $tableName   = $class->isInheritanceTypeJoined()
1394.                     ? $this->em->getUnitOfWork()->getEntityPersister($class->name)->getOwningTable($fieldName)
1395.                     : $class->getTableName();
1397.                 $sqlTableAlias = $this->getSQLTableAlias($tableName, $dqlAlias);
1398.                 $fieldMapping  = $class->fieldMappings[$fieldName];
1399.                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
1400.                 $columnAlias   = $this->getSQLColumnAlias($fieldMapping['columnName']);
1401.                 $col           = $sqlTableAlias . '.' . $columnName;
1403.                 if (isset($fieldMapping['requireSQLConversion'])) {
1404.                     $type = Type::getType($fieldMapping['type']);
1405.                     $col  = $type->convertToPHPValueSQL($col, $this->conn->getDatabasePlatform());
1406.                 }
1408.                 $sql .= $col . ' AS ' . $columnAlias;
1410.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
1412.                 if (! $hidden) {
1413.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldMapping['type']);
1414.                     $this->scalarFields[$dqlAlias][$fieldName] = $columnAlias;
1416.                     if (! empty($fieldMapping['enumType'])) {
1417.                         $this->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
1418.                     }
1419.                 }
1421.                 break;
1423.             case $expr instanceof AST\AggregateExpression:
1424.             case $expr instanceof AST\Functions\FunctionNode:
1425.             case $expr instanceof AST\SimpleArithmeticExpression:
1426.             case $expr instanceof AST\ArithmeticTerm:
1427.             case $expr instanceof AST\ArithmeticFactor:
1428.             case $expr instanceof AST\ParenthesisExpression:
1429.             case $expr instanceof AST\Literal:
1430.             case $expr instanceof AST\NullIfExpression:
1431.             case $expr instanceof AST\CoalesceExpression:
1432.             case $expr instanceof AST\GeneralCaseExpression:
1433.             case $expr instanceof AST\SimpleCaseExpression:
1434.                 $columnAlias = $this->getSQLColumnAlias('sclr');
1435.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
1437.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
1439.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
1441.                 if ($hidden) {
1442.                     break;
1443.                 }
1445.                 if (! $expr instanceof Query\AST\TypedExpression) {
1446.                     // Conceptually we could resolve field type here by traverse through AST to retrieve field type,
1447.                     // but this is not a feasible solution; assume 'string'.
1448.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
1450.                     break;
1451.                 }
1453.                 $this->rsm->addScalarResult($columnAlias, $resultAlias, Type::getTypeRegistry()->lookupName($expr->getReturnType()));
1455.                 break;
1457.             case $expr instanceof AST\Subselect:
1458.                 $columnAlias = $this->getSQLColumnAlias('sclr');
1459.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
1461.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
1463.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
1465.                 if (! $hidden) {
1466.                     // We cannot resolve field type here; assume 'string'.
1467.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
1468.                 }
1470.                 break;
1472.             case $expr instanceof AST\NewObjectExpression:
1473.                 $sql .= $this->walkNewObject($expr, $selectExpression->fieldIdentificationVariable);
1474.                 break;
1476.             default:
1477.                 // IdentificationVariable or PartialObjectExpression
1478.                 if ($expr instanceof AST\PartialObjectExpression) {
1479.                     $this->query->setHint(self::HINT_PARTIAL, true);
1481.                     $dqlAlias        = $expr->identificationVariable;
1482.                     $partialFieldSet = $expr->partialFieldSet;
1483.                 } else {
1484.                     $dqlAlias        = $expr;
1485.                     $partialFieldSet = [];
1486.                 }
1488.                 $class       = $this->getMetadataForDqlAlias($dqlAlias);
1489.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: null;
1491.                 if (! isset($this->selectedClasses[$dqlAlias])) {
1492.                     $this->selectedClasses[$dqlAlias] = [
1493.                         'class'       => $class,
1494.                         'dqlAlias'    => $dqlAlias,
1495.                         'resultAlias' => $resultAlias,
1496.                     ];
1497.                 }
1499.                 $sqlParts = [];
1501.                 // Select all fields from the queried class
1502.                 foreach ($class->fieldMappings as $fieldName => $mapping) {
1503.                     if ($partialFieldSet && ! in_array($fieldName, $partialFieldSet, true)) {
1504.                         continue;
1505.                     }
1507.                     $tableName = isset($mapping['inherited'])
1508.                         ? $this->em->getClassMetadata($mapping['inherited'])->getTableName()
1509.                         : $class->getTableName();
1511.                     $sqlTableAlias    = $this->getSQLTableAlias($tableName, $dqlAlias);
1512.                     $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
1513.                     $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
1515.                     $col = $sqlTableAlias . '.' . $quotedColumnName;
1517.                     if (isset($mapping['requireSQLConversion'])) {
1518.                         $type = Type::getType($mapping['type']);
1519.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
1520.                     }
1522.                     $sqlParts[] = $col . ' AS ' . $columnAlias;
1524.                     $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
1526.                     $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $class->name);
1528.                     if (! empty($mapping['enumType'])) {
1529.                         $this->rsm->addEnumResult($columnAlias, $mapping['enumType']);
1530.                     }
1531.                 }
1533.                 // Add any additional fields of subclasses (excluding inherited fields)
1534.                 // 1) on Single Table Inheritance: always, since its marginal overhead
1535.                 // 2) on Class Table Inheritance only if partial objects are disallowed,
1536.                 //    since it requires outer joining subtables.
1537.                 if ($class->isInheritanceTypeSingleTable() || ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
1538.                     foreach ($class->subClasses as $subClassName) {
1539.                         $subClass      = $this->em->getClassMetadata($subClassName);
1540.                         $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
1542.                         foreach ($subClass->fieldMappings as $fieldName => $mapping) {
1543.                             if (isset($mapping['inherited']) || ($partialFieldSet && ! in_array($fieldName, $partialFieldSet, true))) {
1544.                                 continue;
1545.                             }
1547.                             $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
1548.                             $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $subClass, $this->platform);
1550.                             $col = $sqlTableAlias . '.' . $quotedColumnName;
1552.                             if (isset($mapping['requireSQLConversion'])) {
1553.                                 $type = Type::getType($mapping['type']);
1554.                                 $col  = $type->convertToPHPValueSQL($col, $this->platform);
1555.                             }
1557.                             $sqlParts[] = $col . ' AS ' . $columnAlias;
1559.                             $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
1561.                             $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $subClassName);
1562.                         }
1563.                     }
1564.                 }
1566.                 $sql .= implode(', ', $sqlParts);
1567.         }
1569.         return $sql;
1570.     }
1572.     /**
1573.      * Walks down a QuantifiedExpression AST node, thereby generating the appropriate SQL.
1574.      *
1575.      * @param AST\QuantifiedExpression $qExpr
1576.      *
1577.      * @return string
1578.      */
1579.     public function walkQuantifiedExpression($qExpr)
1580.     {
1581.         return ' ' . strtoupper($qExpr->type) . '(' . $this->walkSubselect($qExpr->subselect) . ')';
1582.     }
1584.     /**
1585.      * Walks down a Subselect AST node, thereby generating the appropriate SQL.
1586.      *
1587.      * @param AST\Subselect $subselect
1588.      *
1589.      * @return string
1590.      */
1591.     public function walkSubselect($subselect)
1592.     {
1593.         $useAliasesBefore  = $this->useSqlTableAliases;
1594.         $rootAliasesBefore = $this->rootAliases;
1596.         $this->rootAliases        = []; // reset the rootAliases for the subselect
1597.         $this->useSqlTableAliases = true;
1599.         $sql  = $this->walkSimpleSelectClause($subselect->simpleSelectClause);
1600.         $sql .= $this->walkSubselectFromClause($subselect->subselectFromClause);
1601.         $sql .= $this->walkWhereClause($subselect->whereClause);
1603.         $sql .= $subselect->groupByClause ? $this->walkGroupByClause($subselect->groupByClause) : '';
1604.         $sql .= $subselect->havingClause ? $this->walkHavingClause($subselect->havingClause) : '';
1605.         $sql .= $subselect->orderByClause ? $this->walkOrderByClause($subselect->orderByClause) : '';
1607.         $this->rootAliases        = $rootAliasesBefore; // put the main aliases back
1608.         $this->useSqlTableAliases = $useAliasesBefore;
1610.         return $sql;
1611.     }
1613.     /**
1614.      * Walks down a SubselectFromClause AST node, thereby generating the appropriate SQL.
1615.      *
1616.      * @param AST\SubselectFromClause $subselectFromClause
1617.      *
1618.      * @return string
1619.      */
1620.     public function walkSubselectFromClause($subselectFromClause)
1621.     {
1622.         $identificationVarDecls = $subselectFromClause->identificationVariableDeclarations;
1623.         $sqlParts               = [];
1625.         foreach ($identificationVarDecls as $subselectIdVarDecl) {
1626.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($subselectIdVarDecl);
1627.         }
1629.         return ' FROM ' . implode(', ', $sqlParts);
1630.     }
1632.     /**
1633.      * Walks down a SimpleSelectClause AST node, thereby generating the appropriate SQL.
1634.      *
1635.      * @param AST\SimpleSelectClause $simpleSelectClause
1636.      *
1637.      * @return string
1638.      */
1639.     public function walkSimpleSelectClause($simpleSelectClause)
1640.     {
1641.         return 'SELECT' . ($simpleSelectClause->isDistinct ? ' DISTINCT' : '')
1642.             . $this->walkSimpleSelectExpression($simpleSelectClause->simpleSelectExpression);
1643.     }
1645.     /** @return string */
1646.     public function walkParenthesisExpression(AST\ParenthesisExpression $parenthesisExpression)
1647.     {
1648.         return sprintf('(%s)', $parenthesisExpression->expression->dispatch($this));
1649.     }
1651.     /**
1652.      * @param AST\NewObjectExpression $newObjectExpression
1653.      * @param string|null             $newObjectResultAlias
1654.      *
1655.      * @return string The SQL.
1656.      */
1657.     public function walkNewObject($newObjectExpression, $newObjectResultAlias = null)
1658.     {
1659.         $sqlSelectExpressions = [];
1660.         $objIndex             = $newObjectResultAlias ?: $this->newObjectCounter++;
1662.         foreach ($newObjectExpression->args as $argIndex => $e) {
1663.             $resultAlias = $this->scalarResultCounter++;
1664.             $columnAlias = $this->getSQLColumnAlias('sclr');
1665.             $fieldType   = 'string';
1667.             switch (true) {
1668.                 case $e instanceof AST\NewObjectExpression:
1669.                     $sqlSelectExpressions[] = $e->dispatch($this);
1670.                     break;
1672.                 case $e instanceof AST\Subselect:
1673.                     $sqlSelectExpressions[] = '(' . $e->dispatch($this) . ') AS ' . $columnAlias;
1674.                     break;
1676.                 case $e instanceof AST\PathExpression:
1677.                     assert($e->field !== null);
1678.                     $dqlAlias     = $e->identificationVariable;
1679.                     $class        = $this->getMetadataForDqlAlias($dqlAlias);
1680.                     $fieldName    = $e->field;
1681.                     $fieldMapping = $class->fieldMappings[$fieldName];
1682.                     $fieldType    = $fieldMapping['type'];
1683.                     $col          = trim($e->dispatch($this));
1685.                     if (isset($fieldMapping['requireSQLConversion'])) {
1686.                         $type = Type::getType($fieldType);
1687.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
1688.                     }
1690.                     $sqlSelectExpressions[] = $col . ' AS ' . $columnAlias;
1692.                     if (! empty($fieldMapping['enumType'])) {
1693.                         $this->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
1694.                     }
1696.                     break;
1698.                 case $e instanceof AST\Literal:
1699.                     switch ($e->type) {
1700.                         case AST\Literal::BOOLEAN:
1701.                             $fieldType = 'boolean';
1702.                             break;
1704.                         case AST\Literal::NUMERIC:
1705.                             $fieldType = is_float($e->value) ? 'float' : 'integer';
1706.                             break;
1707.                     }
1709.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
1710.                     break;
1712.                 default:
1713.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
1714.                     break;
1715.             }
1717.             $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
1718.             $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldType);
1720.             $this->rsm->newObjectMappings[$columnAlias] = [
1721.                 'className' => $newObjectExpression->className,
1722.                 'objIndex'  => $objIndex,
1723.                 'argIndex'  => $argIndex,
1724.             ];
1725.         }
1727.         return implode(', ', $sqlSelectExpressions);
1728.     }
1730.     /**
1731.      * Walks down a SimpleSelectExpression AST node, thereby generating the appropriate SQL.
1732.      *
1733.      * @param AST\SimpleSelectExpression $simpleSelectExpression
1734.      *
1735.      * @return string
1736.      */
1737.     public function walkSimpleSelectExpression($simpleSelectExpression)
1738.     {
1739.         $expr = $simpleSelectExpression->expression;
1740.         $sql  = ' ';
1742.         switch (true) {
1743.             case $expr instanceof AST\PathExpression:
1744.                 $sql .= $this->walkPathExpression($expr);
1745.                 break;
1747.             case $expr instanceof AST\Subselect:
1748.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
1750.                 $columnAlias                        = 'sclr' . $this->aliasCounter++;
1751.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
1753.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
1754.                 break;
1756.             case $expr instanceof AST\Functions\FunctionNode:
1757.             case $expr instanceof AST\SimpleArithmeticExpression:
1758.             case $expr instanceof AST\ArithmeticTerm:
1759.             case $expr instanceof AST\ArithmeticFactor:
1760.             case $expr instanceof AST\Literal:
1761.             case $expr instanceof AST\NullIfExpression:
1762.             case $expr instanceof AST\CoalesceExpression:
1763.             case $expr instanceof AST\GeneralCaseExpression:
1764.             case $expr instanceof AST\SimpleCaseExpression:
1765.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
1767.                 $columnAlias                        = $this->getSQLColumnAlias('sclr');
1768.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
1770.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
1771.                 break;
1773.             case $expr instanceof AST\ParenthesisExpression:
1774.                 $sql .= $this->walkParenthesisExpression($expr);
1775.                 break;
1777.             default: // IdentificationVariable
1778.                 $sql .= $this->walkEntityIdentificationVariable($expr);
1779.                 break;
1780.         }
1782.         return $sql;
1783.     }
1785.     /**
1786.      * Walks down an AggregateExpression AST node, thereby generating the appropriate SQL.
1787.      *
1788.      * @param AST\AggregateExpression $aggExpression
1789.      *
1790.      * @return string
1791.      */
1792.     public function walkAggregateExpression($aggExpression)
1793.     {
1794.         return $aggExpression->functionName . '(' . ($aggExpression->isDistinct ? 'DISTINCT ' : '')
1795.             . $this->walkSimpleArithmeticExpression($aggExpression->pathExpression) . ')';
1796.     }
1798.     /**
1799.      * Walks down a GroupByClause AST node, thereby generating the appropriate SQL.
1800.      *
1801.      * @param AST\GroupByClause $groupByClause
1802.      *
1803.      * @return string
1804.      */
1805.     public function walkGroupByClause($groupByClause)
1806.     {
1807.         $sqlParts = [];
1809.         foreach ($groupByClause->groupByItems as $groupByItem) {
1810.             $sqlParts[] = $this->walkGroupByItem($groupByItem);
1811.         }
1813.         return ' GROUP BY ' . implode(', ', $sqlParts);
1814.     }
1816.     /**
1817.      * Walks down a GroupByItem AST node, thereby generating the appropriate SQL.
1818.      *
1819.      * @param AST\PathExpression|string $groupByItem
1820.      *
1821.      * @return string
1822.      */
1823.     public function walkGroupByItem($groupByItem)
1824.     {
1825.         // StateFieldPathExpression
1826.         if (! is_string($groupByItem)) {
1827.             return $this->walkPathExpression($groupByItem);
1828.         }
1830.         // ResultVariable
1831.         if (isset($this->queryComponents[$groupByItem]['resultVariable'])) {
1832.             $resultVariable = $this->queryComponents[$groupByItem]['resultVariable'];
1834.             if ($resultVariable instanceof AST\PathExpression) {
1835.                 return $this->walkPathExpression($resultVariable);
1836.             }
1838.             if ($resultVariable instanceof AST\Node && isset($resultVariable->pathExpression)) {
1839.                 return $this->walkPathExpression($resultVariable->pathExpression);
1840.             }
1842.             return $this->walkResultVariable($groupByItem);
1843.         }
1845.         // IdentificationVariable
1846.         $sqlParts = [];
1848.         foreach ($this->getMetadataForDqlAlias($groupByItem)->fieldNames as $field) {
1849.             $item       = new AST\PathExpression(AST\PathExpression::TYPE_STATE_FIELD, $groupByItem, $field);
1850.             $item->type = AST\PathExpression::TYPE_STATE_FIELD;
1852.             $sqlParts[] = $this->walkPathExpression($item);
1853.         }
1855.         foreach ($this->getMetadataForDqlAlias($groupByItem)->associationMappings as $mapping) {
1856.             if ($mapping['isOwningSide'] && $mapping['type'] & ClassMetadata::TO_ONE) {
1857.                 $item       = new AST\PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION, $groupByItem, $mapping['fieldName']);
1858.                 $item->type = AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION;
1860.                 $sqlParts[] = $this->walkPathExpression($item);
1861.             }
1862.         }
1864.         return implode(', ', $sqlParts);
1865.     }
1867.     /**
1868.      * Walks down a DeleteClause AST node, thereby generating the appropriate SQL.
1869.      *
1870.      * @return string
1871.      */
1872.     public function walkDeleteClause(AST\DeleteClause $deleteClause)
1873.     {
1874.         $class     = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
1875.         $tableName = $class->getTableName();
1876.         $sql       = 'DELETE FROM ' . $this->quoteStrategy->getTableName($class, $this->platform);
1878.         $this->setSQLTableAlias($tableName, $tableName, $deleteClause->aliasIdentificationVariable);
1879.         $this->rootAliases[] = $deleteClause->aliasIdentificationVariable;
1881.         return $sql;
1882.     }
1884.     /**
1885.      * Walks down an UpdateClause AST node, thereby generating the appropriate SQL.
1886.      *
1887.      * @param AST\UpdateClause $updateClause
1888.      *
1889.      * @return string
1890.      */
1891.     public function walkUpdateClause($updateClause)
1892.     {
1893.         $class     = $this->em->getClassMetadata($updateClause->abstractSchemaName);
1894.         $tableName = $class->getTableName();
1895.         $sql       = 'UPDATE ' . $this->quoteStrategy->getTableName($class, $this->platform);
1897.         $this->setSQLTableAlias($tableName, $tableName, $updateClause->aliasIdentificationVariable);
1898.         $this->rootAliases[] = $updateClause->aliasIdentificationVariable;
1900.         return $sql . ' SET ' . implode(', ', array_map([$this, 'walkUpdateItem'], $updateClause->updateItems));
1901.     }
1903.     /**
1904.      * Walks down an UpdateItem AST node, thereby generating the appropriate SQL.
1905.      *
1906.      * @param AST\UpdateItem $updateItem
1907.      *
1908.      * @return string
1909.      */
1910.     public function walkUpdateItem($updateItem)
1911.     {
1912.         $useTableAliasesBefore    = $this->useSqlTableAliases;
1913.         $this->useSqlTableAliases = false;
1915.         $sql      = $this->walkPathExpression($updateItem->pathExpression) . ' = ';
1916.         $newValue = $updateItem->newValue;
1918.         switch (true) {
1919.             case $newValue instanceof AST\Node:
1920.                 $sql .= $newValue->dispatch($this);
1921.                 break;
1923.             case $newValue === null:
1924.                 $sql .= 'NULL';
1925.                 break;
1927.             default:
1928.                 $sql .= $this->conn->quote($newValue);
1929.                 break;
1930.         }
1932.         $this->useSqlTableAliases = $useTableAliasesBefore;
1934.         return $sql;
1935.     }
1937.     /**
1938.      * Walks down a WhereClause AST node, thereby generating the appropriate SQL.
1939.      * WhereClause or not, the appropriate discriminator sql is added.
1940.      *
1941.      * @param AST\WhereClause $whereClause
1942.      *
1943.      * @return string
1944.      */
1945.     public function walkWhereClause($whereClause)
1946.     {
1947.         $condSql  = $whereClause !== null ? $this->walkConditionalExpression($whereClause->conditionalExpression) : '';
1948.         $discrSql = $this->generateDiscriminatorColumnConditionSQL($this->rootAliases);
1950.         if ($this->em->hasFilters()) {
1951.             $filterClauses = [];
1952.             foreach ($this->rootAliases as $dqlAlias) {
1953.                 $class      = $this->getMetadataForDqlAlias($dqlAlias);
1954.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
1956.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
1957.                 if ($filterExpr) {
1958.                     $filterClauses[] = $filterExpr;
1959.                 }
1960.             }
1962.             if (count($filterClauses)) {
1963.                 if ($condSql) {
1964.                     $condSql = '(' . $condSql . ') AND ';
1965.                 }
1967.                 $condSql .= implode(' AND ', $filterClauses);
1968.             }
1969.         }
1971.         if ($condSql) {
1972.             return ' WHERE ' . (! $discrSql ? $condSql : '(' . $condSql . ') AND ' . $discrSql);
1973.         }
1975.         if ($discrSql) {
1976.             return ' WHERE ' . $discrSql;
1977.         }
1979.         return '';
1980.     }
1982.     /**
1983.      * Walk down a ConditionalExpression AST node, thereby generating the appropriate SQL.
1984.      *
1985.      * @param AST\ConditionalExpression $condExpr
1986.      *
1987.      * @return string
1988.      */
1989.     public function walkConditionalExpression($condExpr)
1990.     {
1991.         // Phase 2 AST optimization: Skip processing of ConditionalExpression
1992.         // if only one ConditionalTerm is defined
1993.         if (! ($condExpr instanceof AST\ConditionalExpression)) {
1994.             return $this->walkConditionalTerm($condExpr);
1995.         }
1997.         return implode(' OR ', array_map([$this, 'walkConditionalTerm'], $condExpr->conditionalTerms));
1998.     }
2000.     /**
2001.      * Walks down a ConditionalTerm AST node, thereby generating the appropriate SQL.
2002.      *
2003.      * @param AST\ConditionalTerm $condTerm
2004.      *
2005.      * @return string
2006.      */
2007.     public function walkConditionalTerm($condTerm)
2008.     {
2009.         // Phase 2 AST optimization: Skip processing of ConditionalTerm
2010.         // if only one ConditionalFactor is defined
2011.         if (! ($condTerm instanceof AST\ConditionalTerm)) {
2012.             return $this->walkConditionalFactor($condTerm);
2013.         }
2015.         return implode(' AND ', array_map([$this, 'walkConditionalFactor'], $condTerm->conditionalFactors));
2016.     }
2018.     /**
2019.      * Walks down a ConditionalFactor AST node, thereby generating the appropriate SQL.
2020.      *
2021.      * @param AST\ConditionalFactor $factor
2022.      *
2023.      * @return string The SQL.
2024.      */
2025.     public function walkConditionalFactor($factor)
2026.     {
2027.         // Phase 2 AST optimization: Skip processing of ConditionalFactor
2028.         // if only one ConditionalPrimary is defined
2029.         return ! ($factor instanceof AST\ConditionalFactor)
2030.             ? $this->walkConditionalPrimary($factor)
2031.             : ($factor->not ? 'NOT ' : '') . $this->walkConditionalPrimary($factor->conditionalPrimary);
2032.     }
2034.     /**
2035.      * Walks down a ConditionalPrimary AST node, thereby generating the appropriate SQL.
2036.      *
2037.      * @param AST\ConditionalPrimary $primary
2038.      *
2039.      * @return string
2040.      */
2041.     public function walkConditionalPrimary($primary)
2042.     {
2043.         if ($primary->isSimpleConditionalExpression()) {
2044.             return $primary->simpleConditionalExpression->dispatch($this);
2045.         }
2047.         if ($primary->isConditionalExpression()) {
2048.             $condExpr = $primary->conditionalExpression;
2050.             return '(' . $this->walkConditionalExpression($condExpr) . ')';
2051.         }
2052.     }
2054.     /**
2055.      * Walks down an ExistsExpression AST node, thereby generating the appropriate SQL.
2056.      *
2057.      * @param AST\ExistsExpression $existsExpr
2058.      *
2059.      * @return string
2060.      */
2061.     public function walkExistsExpression($existsExpr)
2062.     {
2063.         $sql = $existsExpr->not ? 'NOT ' : '';
2065.         $sql .= 'EXISTS (' . $this->walkSubselect($existsExpr->subselect) . ')';
2067.         return $sql;
2068.     }
2070.     /**
2071.      * Walks down a CollectionMemberExpression AST node, thereby generating the appropriate SQL.
2072.      *
2073.      * @param AST\CollectionMemberExpression $collMemberExpr
2074.      *
2075.      * @return string
2076.      */
2077.     public function walkCollectionMemberExpression($collMemberExpr)
2078.     {
2079.         $sql  = $collMemberExpr->not ? 'NOT ' : '';
2080.         $sql .= 'EXISTS (SELECT 1 FROM ';
2082.         $entityExpr   = $collMemberExpr->entityExpression;
2083.         $collPathExpr = $collMemberExpr->collectionValuedPathExpression;
2084.         assert($collPathExpr->field !== null);
2086.         $fieldName = $collPathExpr->field;
2087.         $dqlAlias  = $collPathExpr->identificationVariable;
2089.         $class = $this->getMetadataForDqlAlias($dqlAlias);
2091.         switch (true) {
2092.             // InputParameter
2093.             case $entityExpr instanceof AST\InputParameter:
2094.                 $dqlParamKey = $entityExpr->name;
2095.                 $entitySql   = '?';
2096.                 break;
2098.             // SingleValuedAssociationPathExpression | IdentificationVariable
2099.             case $entityExpr instanceof AST\PathExpression:
2100.                 $entitySql = $this->walkPathExpression($entityExpr);
2101.                 break;
2103.             default:
2104.                 throw new BadMethodCallException('Not implemented');
2105.         }
2107.         $assoc = $class->associationMappings[$fieldName];
2109.         if ($assoc['type'] === ClassMetadata::ONE_TO_MANY) {
2110.             $targetClass      = $this->em->getClassMetadata($assoc['targetEntity']);
2111.             $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName());
2112.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
2114.             $sql .= $this->quoteStrategy->getTableName($targetClass, $this->platform) . ' ' . $targetTableAlias . ' WHERE ';
2116.             $owningAssoc = $targetClass->associationMappings[$assoc['mappedBy']];
2117.             $sqlParts    = [];
2119.             foreach ($owningAssoc['targetToSourceKeyColumns'] as $targetColumn => $sourceColumn) {
2120.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$targetColumn], $class, $this->platform);
2122.                 $sqlParts[] = $sourceTableAlias . '.' . $targetColumn . ' = ' . $targetTableAlias . '.' . $sourceColumn;
2123.             }
2125.             foreach ($this->quoteStrategy->getIdentifierColumnNames($targetClass, $this->platform) as $targetColumnName) {
2126.                 if (isset($dqlParamKey)) {
2127.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
2128.                 }
2130.                 $sqlParts[] = $targetTableAlias . '.' . $targetColumnName . ' = ' . $entitySql;
2131.             }
2133.             $sql .= implode(' AND ', $sqlParts);
2134.         } else { // many-to-many
2135.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
2137.             $owningAssoc = $assoc['isOwningSide'] ? $assoc : $targetClass->associationMappings[$assoc['mappedBy']];
2138.             $joinTable   = $owningAssoc['joinTable'];
2140.             // SQL table aliases
2141.             $joinTableAlias   = $this->getSQLTableAlias($joinTable['name']);
2142.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
2144.             $sql .= $this->quoteStrategy->getJoinTableName($owningAssoc, $targetClass, $this->platform) . ' ' . $joinTableAlias . ' WHERE ';
2146.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['joinColumns'] : $joinTable['inverseJoinColumns'];
2147.             $sqlParts    = [];
2149.             foreach ($joinColumns as $joinColumn) {
2150.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$joinColumn['referencedColumnName']], $class, $this->platform);
2152.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' = ' . $sourceTableAlias . '.' . $targetColumn;
2153.             }
2155.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['inverseJoinColumns'] : $joinTable['joinColumns'];
2157.             foreach ($joinColumns as $joinColumn) {
2158.                 if (isset($dqlParamKey)) {
2159.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
2160.                 }
2162.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' IN (' . $entitySql . ')';
2163.             }
2165.             $sql .= implode(' AND ', $sqlParts);
2166.         }
2168.         return $sql . ')';
2169.     }
2171.     /**
2172.      * Walks down an EmptyCollectionComparisonExpression AST node, thereby generating the appropriate SQL.
2173.      *
2174.      * @param AST\EmptyCollectionComparisonExpression $emptyCollCompExpr
2175.      *
2176.      * @return string
2177.      */
2178.     public function walkEmptyCollectionComparisonExpression($emptyCollCompExpr)
2179.     {
2180.         $sizeFunc                           = new AST\Functions\SizeFunction('size');
2181.         $sizeFunc->collectionPathExpression = $emptyCollCompExpr->expression;
2183.         return $sizeFunc->getSql($this) . ($emptyCollCompExpr->not ? ' > 0' : ' = 0');
2184.     }
2186.     /**
2187.      * Walks down a NullComparisonExpression AST node, thereby generating the appropriate SQL.
2188.      *
2189.      * @param AST\NullComparisonExpression $nullCompExpr
2190.      *
2191.      * @return string
2192.      */
2193.     public function walkNullComparisonExpression($nullCompExpr)
2194.     {
2195.         $expression = $nullCompExpr->expression;
2196.         $comparison = ' IS' . ($nullCompExpr->not ? ' NOT' : '') . ' NULL';
2198.         // Handle ResultVariable
2199.         if (is_string($expression) && isset($this->queryComponents[$expression]['resultVariable'])) {
2200.             return $this->walkResultVariable($expression) . $comparison;
2201.         }
2203.         // Handle InputParameter mapping inclusion to ParserResult
2204.         if ($expression instanceof AST\InputParameter) {
2205.             return $this->walkInputParameter($expression) . $comparison;
2206.         }
2208.         return $expression->dispatch($this) . $comparison;
2209.     }
2211.     /**
2212.      * Walks down an InExpression AST node, thereby generating the appropriate SQL.
2213.      *
2214.      * @deprecated Use {@see walkInListExpression()} or {@see walkInSubselectExpression()} instead.
2215.      *
2216.      * @param AST\InExpression $inExpr
2217.      *
2218.      * @return string
2219.      */
2220.     public function walkInExpression($inExpr)
2221.     {
2222.         Deprecation::triggerIfCalledFromOutside(
2223.             'doctrine/orm',
2224.             'https://github.com/doctrine/orm/pull/10267',
2225.             '%s() is deprecated, call walkInListExpression() or walkInSubselectExpression() instead.',
2226.             __METHOD__
2227.         );
2229.         if ($inExpr instanceof AST\InListExpression) {
2230.             return $this->walkInListExpression($inExpr);
2231.         }
2233.         if ($inExpr instanceof AST\InSubselectExpression) {
2234.             return $this->walkInSubselectExpression($inExpr);
2235.         }
2237.         $sql = $this->walkArithmeticExpression($inExpr->expression) . ($inExpr->not ? ' NOT' : '') . ' IN (';
2239.         $sql .= $inExpr->subselect
2240.             ? $this->walkSubselect($inExpr->subselect)
2241.             : implode(', ', array_map([$this, 'walkInParameter'], $inExpr->literals));
2243.         $sql .= ')';
2245.         return $sql;
2246.     }
2248.     /**
2249.      * Walks down an InExpression AST node, thereby generating the appropriate SQL.
2250.      */
2251.     public function walkInListExpression(AST\InListExpression $inExpr): string
2252.     {
2253.         return $this->walkArithmeticExpression($inExpr->expression)
2254.             . ($inExpr->not ? ' NOT' : '') . ' IN ('
2255.             . implode(', ', array_map([$this, 'walkInParameter'], $inExpr->literals))
2256.             . ')';
2257.     }
2259.     /**
2260.      * Walks down an InExpression AST node, thereby generating the appropriate SQL.
2261.      */
2262.     public function walkInSubselectExpression(AST\InSubselectExpression $inExpr): string
2263.     {
2264.         return $this->walkArithmeticExpression($inExpr->expression)
2265.             . ($inExpr->not ? ' NOT' : '') . ' IN ('
2266.             . $this->walkSubselect($inExpr->subselect)
2267.             . ')';
2268.     }
2270.     /**
2271.      * Walks down an InstanceOfExpression AST node, thereby generating the appropriate SQL.
2272.      *
2273.      * @param AST\InstanceOfExpression $instanceOfExpr
2274.      *
2275.      * @return string
2276.      *
2277.      * @throws QueryException
2278.      */
2279.     public function walkInstanceOfExpression($instanceOfExpr)
2280.     {
2281.         $sql = '';
2283.         $dqlAlias   = $instanceOfExpr->identificationVariable;
2284.         $discrClass = $class = $this->getMetadataForDqlAlias($dqlAlias);
2286.         if ($class->discriminatorColumn) {
2287.             $discrClass = $this->em->getClassMetadata($class->rootEntityName);
2288.         }
2290.         if ($this->useSqlTableAliases) {
2291.             $sql .= $this->getSQLTableAlias($discrClass->getTableName(), $dqlAlias) . '.';
2292.         }
2294.         $sql .= $class->getDiscriminatorColumn()['name'] . ($instanceOfExpr->not ? ' NOT IN ' : ' IN ');
2295.         $sql .= $this->getChildDiscriminatorsFromClassMetadata($discrClass, $instanceOfExpr);
2297.         return $sql;
2298.     }
2300.     /**
2301.      * @param mixed $inParam
2302.      *
2303.      * @return string
2304.      */
2305.     public function walkInParameter($inParam)
2306.     {
2307.         return $inParam instanceof AST\InputParameter
2308.             ? $this->walkInputParameter($inParam)
2309.             : $this->walkArithmeticExpression($inParam);
2310.     }
2312.     /**
2313.      * Walks down a literal that represents an AST node, thereby generating the appropriate SQL.
2314.      *
2315.      * @param AST\Literal $literal
2316.      *
2317.      * @return string
2318.      */
2319.     public function walkLiteral($literal)
2320.     {
2321.         switch ($literal->type) {
2322.             case AST\Literal::STRING:
2323.                 return $this->conn->quote($literal->value);
2325.             case AST\Literal::BOOLEAN:
2326.                 return (string) $this->conn->getDatabasePlatform()->convertBooleans(strtolower($literal->value) === 'true');
2328.             case AST\Literal::NUMERIC:
2329.                 return (string) $literal->value;
2331.             default:
2332.                 throw QueryException::invalidLiteral($literal);
2333.         }
2334.     }
2336.     /**
2337.      * Walks down a BetweenExpression AST node, thereby generating the appropriate SQL.
2338.      *
2339.      * @param AST\BetweenExpression $betweenExpr
2340.      *
2341.      * @return string
2342.      */
2343.     public function walkBetweenExpression($betweenExpr)
2344.     {
2345.         $sql = $this->walkArithmeticExpression($betweenExpr->expression);
2347.         if ($betweenExpr->not) {
2348.             $sql .= ' NOT';
2349.         }
2351.         $sql .= ' BETWEEN ' . $this->walkArithmeticExpression($betweenExpr->leftBetweenExpression)
2352.             . ' AND ' . $this->walkArithmeticExpression($betweenExpr->rightBetweenExpression);
2354.         return $sql;
2355.     }
2357.     /**
2358.      * Walks down a LikeExpression AST node, thereby generating the appropriate SQL.
2359.      *
2360.      * @param AST\LikeExpression $likeExpr
2361.      *
2362.      * @return string
2363.      */
2364.     public function walkLikeExpression($likeExpr)
2365.     {
2366.         $stringExpr = $likeExpr->stringExpression;
2367.         if (is_string($stringExpr)) {
2368.             if (! isset($this->queryComponents[$stringExpr]['resultVariable'])) {
2369.                 throw new LogicException(sprintf('No result variable found for string expression "%s".', $stringExpr));
2370.             }
2372.             $leftExpr = $this->walkResultVariable($stringExpr);
2373.         } else {
2374.             $leftExpr = $stringExpr->dispatch($this);
2375.         }
2377.         $sql = $leftExpr . ($likeExpr->not ? ' NOT' : '') . ' LIKE ';
2379.         if ($likeExpr->stringPattern instanceof AST\InputParameter) {
2380.             $sql .= $this->walkInputParameter($likeExpr->stringPattern);
2381.         } elseif ($likeExpr->stringPattern instanceof AST\Functions\FunctionNode) {
2382.             $sql .= $this->walkFunction($likeExpr->stringPattern);
2383.         } elseif ($likeExpr->stringPattern instanceof AST\PathExpression) {
2384.             $sql .= $this->walkPathExpression($likeExpr->stringPattern);
2385.         } else {
2386.             $sql .= $this->walkLiteral($likeExpr->stringPattern);
2387.         }
2389.         if ($likeExpr->escapeChar) {
2390.             $sql .= ' ESCAPE ' . $this->walkLiteral($likeExpr->escapeChar);
2391.         }
2393.         return $sql;
2394.     }
2396.     /**
2397.      * Walks down a StateFieldPathExpression AST node, thereby generating the appropriate SQL.
2398.      *
2399.      * @param AST\PathExpression $stateFieldPathExpression
2400.      *
2401.      * @return string
2402.      */
2403.     public function walkStateFieldPathExpression($stateFieldPathExpression)
2404.     {
2405.         return $this->walkPathExpression($stateFieldPathExpression);
2406.     }
2408.     /**
2409.      * Walks down a ComparisonExpression AST node, thereby generating the appropriate SQL.
2410.      *
2411.      * @param AST\ComparisonExpression $compExpr
2412.      *
2413.      * @return string
2414.      */
2415.     public function walkComparisonExpression($compExpr)
2416.     {
2417.         $leftExpr  = $compExpr->leftExpression;
2418.         $rightExpr = $compExpr->rightExpression;
2419.         $sql       = '';
2421.         $sql .= $leftExpr instanceof AST\Node
2422.             ? $leftExpr->dispatch($this)
2423.             : (is_numeric($leftExpr) ? $leftExpr : $this->conn->quote($leftExpr));
2425.         $sql .= ' ' . $compExpr->operator . ' ';
2427.         $sql .= $rightExpr instanceof AST\Node
2428.             ? $rightExpr->dispatch($this)
2429.             : (is_numeric($rightExpr) ? $rightExpr : $this->conn->quote($rightExpr));
2431.         return $sql;
2432.     }
2434.     /**
2435.      * Walks down an InputParameter AST node, thereby generating the appropriate SQL.
2436.      *
2437.      * @param AST\InputParameter $inputParam
2438.      *
2439.      * @return string
2440.      */
2441.     public function walkInputParameter($inputParam)
2442.     {
2443.         $this->parserResult->addParameterMapping($inputParam->name, $this->sqlParamIndex++);
2445.         $parameter = $this->query->getParameter($inputParam->name);
2447.         if ($parameter) {
2448.             $type = $parameter->getType();
2449.             if (Type::hasType($type)) {
2450.                 return Type::getType($type)->convertToDatabaseValueSQL('?', $this->platform);
2451.             }
2452.         }
2454.         return '?';
2455.     }
2457.     /**
2458.      * Walks down an ArithmeticExpression AST node, thereby generating the appropriate SQL.
2459.      *
2460.      * @param AST\ArithmeticExpression $arithmeticExpr
2461.      *
2462.      * @return string
2463.      */
2464.     public function walkArithmeticExpression($arithmeticExpr)
2465.     {
2466.         return $arithmeticExpr->isSimpleArithmeticExpression()
2467.             ? $this->walkSimpleArithmeticExpression($arithmeticExpr->simpleArithmeticExpression)
2468.             : '(' . $this->walkSubselect($arithmeticExpr->subselect) . ')';
2469.     }
2471.     /**
2472.      * Walks down an SimpleArithmeticExpression AST node, thereby generating the appropriate SQL.
2473.      *
2474.      * @param AST\SimpleArithmeticExpression $simpleArithmeticExpr
2475.      *
2476.      * @return string
2477.      */
2478.     public function walkSimpleArithmeticExpression($simpleArithmeticExpr)
2479.     {
2480.         if (! ($simpleArithmeticExpr instanceof AST\SimpleArithmeticExpression)) {
2481.             return $this->walkArithmeticTerm($simpleArithmeticExpr);
2482.         }
2484.         return implode(' ', array_map([$this, 'walkArithmeticTerm'], $simpleArithmeticExpr->arithmeticTerms));
2485.     }
2487.     /**
2488.      * Walks down an ArithmeticTerm AST node, thereby generating the appropriate SQL.
2489.      *
2490.      * @param mixed $term
2491.      *
2492.      * @return string
2493.      */
2494.     public function walkArithmeticTerm($term)
2495.     {
2496.         if (is_string($term)) {
2497.             return isset($this->queryComponents[$term])
2498.                 ? $this->walkResultVariable($this->queryComponents[$term]['token']['value'])
2499.                 : $term;
2500.         }
2502.         // Phase 2 AST optimization: Skip processing of ArithmeticTerm
2503.         // if only one ArithmeticFactor is defined
2504.         if (! ($term instanceof AST\ArithmeticTerm)) {
2505.             return $this->walkArithmeticFactor($term);
2506.         }
2508.         return implode(' ', array_map([$this, 'walkArithmeticFactor'], $term->arithmeticFactors));
2509.     }
2511.     /**
2512.      * Walks down an ArithmeticFactor that represents an AST node, thereby generating the appropriate SQL.
2513.      *
2514.      * @param mixed $factor
2515.      *
2516.      * @return string
2517.      */
2518.     public function walkArithmeticFactor($factor)
2519.     {
2520.         if (is_string($factor)) {
2521.             return isset($this->queryComponents[$factor])
2522.                 ? $this->walkResultVariable($this->queryComponents[$factor]['token']['value'])
2523.                 : $factor;
2524.         }
2526.         // Phase 2 AST optimization: Skip processing of ArithmeticFactor
2527.         // if only one ArithmeticPrimary is defined
2528.         if (! ($factor instanceof AST\ArithmeticFactor)) {
2529.             return $this->walkArithmeticPrimary($factor);
2530.         }
2532.         $sign = $factor->isNegativeSigned() ? '-' : ($factor->isPositiveSigned() ? '+' : '');
2534.         return $sign . $this->walkArithmeticPrimary($factor->arithmeticPrimary);
2535.     }
2537.     /**
2538.      * Walks down an ArithmeticPrimary that represents an AST node, thereby generating the appropriate SQL.
2539.      *
2540.      * @param mixed $primary
2541.      *
2542.      * @return string The SQL.
2543.      */
2544.     public function walkArithmeticPrimary($primary)
2545.     {
2546.         if ($primary instanceof AST\SimpleArithmeticExpression) {
2547.             return '(' . $this->walkSimpleArithmeticExpression($primary) . ')';
2548.         }
2550.         if ($primary instanceof AST\Node) {
2551.             return $primary->dispatch($this);
2552.         }
2554.         return $this->walkEntityIdentificationVariable($primary);
2555.     }
2557.     /**
2558.      * Walks down a StringPrimary that represents an AST node, thereby generating the appropriate SQL.
2559.      *
2560.      * @param mixed $stringPrimary
2561.      *
2562.      * @return string
2563.      */
2564.     public function walkStringPrimary($stringPrimary)
2565.     {
2566.         return is_string($stringPrimary)
2567.             ? $this->conn->quote($stringPrimary)
2568.             : $stringPrimary->dispatch($this);
2569.     }
2571.     /**
2572.      * Walks down a ResultVariable that represents an AST node, thereby generating the appropriate SQL.
2573.      *
2574.      * @param string $resultVariable
2575.      *
2576.      * @return string
2577.      */
2578.     public function walkResultVariable($resultVariable)
2579.     {
2580.         if (! isset($this->scalarResultAliasMap[$resultVariable])) {
2581.             throw new InvalidArgumentException(sprintf('Unknown result variable: %s', $resultVariable));
2582.         }
2584.         $resultAlias = $this->scalarResultAliasMap[$resultVariable];
2586.         if (is_array($resultAlias)) {
2587.             return implode(', ', $resultAlias);
2588.         }
2590.         return $resultAlias;
2591.     }
2593.     /**
2594.      * @return string The list in parentheses of valid child discriminators from the given class
2595.      *
2596.      * @throws QueryException
2597.      */
2598.     private function getChildDiscriminatorsFromClassMetadata(
2599.         ClassMetadata $rootClass,
2600.         AST\InstanceOfExpression $instanceOfExpr
2601.     ): string {
2602.         $sqlParameterList = [];
2603.         $discriminators   = [];
2604.         foreach ($instanceOfExpr->value as $parameter) {
2605.             if ($parameter instanceof AST\InputParameter) {
2606.                 $this->rsm->discriminatorParameters[$parameter->name] = $parameter->name;
2607.                 $sqlParameterList[]                                   = $this->walkInParameter($parameter);
2608.                 continue;
2609.             }
2611.             $metadata = $this->em->getClassMetadata($parameter);
2613.             if ($metadata->getName() !== $rootClass->name && ! $metadata->getReflectionClass()->isSubclassOf($rootClass->name)) {
2614.                 throw QueryException::instanceOfUnrelatedClass($parameter, $rootClass->name);
2615.             }
2617.             $discriminators += HierarchyDiscriminatorResolver::resolveDiscriminatorsForClass($metadata, $this->em);
2618.         }
2620.         foreach (array_keys($discriminators) as $dis) {
2621.             $sqlParameterList[] = $this->conn->quote($dis);
2622.         }
2624.         return '(' . implode(', ', $sqlParameterList) . ')';
2625.     }
2626. }