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\LockSqlHelper;
20. use Doctrine\ORM\Utility\PersisterHelper;
21. use InvalidArgumentException;
22. use LogicException;
24. use function array_diff;
25. use function array_filter;
26. use function array_keys;
27. use function array_map;
28. use function array_merge;
29. use function assert;
30. use function count;
31. use function implode;
32. use function in_array;
33. use function is_array;
34. use function is_float;
35. use function is_numeric;
36. use function is_string;
37. use function preg_match;
38. use function reset;
39. use function sprintf;
40. use function strtolower;
41. use function strtoupper;
42. use function trim;
44. /**
45.  * The SqlWalker walks over a DQL AST and constructs the corresponding SQL.
46.  *
47.  * @psalm-import-type QueryComponent from Parser
48.  * @psalm-consistent-constructor
49.  */
50. class SqlWalker implements TreeWalker
51. {
52.     use LockSqlHelper;
54.     public const HINT_DISTINCT = 'doctrine.distinct';
56.     /**
57.      * Used to mark a query as containing a PARTIAL expression, which needs to be known by SLC.
58.      */
59.     public const HINT_PARTIAL = 'doctrine.partial';
61.     /** @var ResultSetMapping */
62.     private $rsm;
64.     /**
65.      * Counter for generating unique column aliases.
66.      *
67.      * @var int
68.      */
69.     private $aliasCounter = 0;
71.     /**
72.      * Counter for generating unique table aliases.
73.      *
74.      * @var int
75.      */
76.     private $tableAliasCounter = 0;
78.     /**
79.      * Counter for generating unique scalar result.
80.      *
81.      * @var int
82.      */
83.     private $scalarResultCounter = 1;
85.     /**
86.      * Counter for generating unique parameter indexes.
87.      *
88.      * @var int
89.      */
90.     private $sqlParamIndex = 0;
92.     /**
93.      * Counter for generating indexes.
94.      *
95.      * @var int
96.      */
97.     private $newObjectCounter = 0;
99.     /** @var ParserResult */
100.     private $parserResult;
102.     /** @var EntityManagerInterface */
103.     private $em;
105.     /** @var Connection */
106.     private $conn;
108.     /** @var Query */
109.     private $query;
111.     /** @var mixed[] */
112.     private $tableAliasMap = [];
114.     /**
115.      * Map from result variable names to their SQL column alias names.
116.      *
117.      * @psalm-var array<string|int, string|list<string>>
118.      */
119.     private $scalarResultAliasMap = [];
121.     /**
122.      * Map from Table-Alias + Column-Name to OrderBy-Direction.
123.      *
124.      * @var array<string, string>
125.      */
126.     private $orderedColumnsMap = [];
128.     /**
129.      * Map from DQL-Alias + Field-Name to SQL Column Alias.
130.      *
131.      * @var array<string, array<string, string>>
132.      */
133.     private $scalarFields = [];
135.     /**
136.      * Map of all components/classes that appear in the DQL query.
137.      *
138.      * @psalm-var array<string, QueryComponent>
139.      */
140.     private $queryComponents;
142.     /**
143.      * A list of classes that appear in non-scalar SelectExpressions.
144.      *
145.      * @psalm-var array<string, array{class: ClassMetadata, dqlAlias: string, resultAlias: string|null}>
146.      */
147.     private $selectedClasses = [];
149.     /**
150.      * The DQL alias of the root class of the currently traversed query.
151.      *
152.      * @psalm-var list<string>
153.      */
154.     private $rootAliases = [];
156.     /**
157.      * Flag that indicates whether to generate SQL table aliases in the SQL.
158.      * These should only be generated for SELECT queries, not for UPDATE/DELETE.
159.      *
160.      * @var bool
161.      */
162.     private $useSqlTableAliases = true;
164.     /**
165.      * The database platform abstraction.
166.      *
167.      * @var AbstractPlatform
168.      */
169.     private $platform;
171.     /**
172.      * The quote strategy.
173.      *
174.      * @var QuoteStrategy
175.      */
176.     private $quoteStrategy;
178.     /**
179.      * @param Query        $query        The parsed Query.
180.      * @param ParserResult $parserResult The result of the parsing process.
181.      * @psalm-param array<string, QueryComponent> $queryComponents The query components (symbol table).
182.      */
183.     public function __construct($query, $parserResult, array $queryComponents)
184.     {
185.         $this->query           = $query;
186.         $this->parserResult    = $parserResult;
187.         $this->queryComponents = $queryComponents;
188.         $this->rsm             = $parserResult->getResultSetMapping();
189.         $this->em              = $query->getEntityManager();
190.         $this->conn            = $this->em->getConnection();
191.         $this->platform        = $this->conn->getDatabasePlatform();
192.         $this->quoteStrategy   = $this->em->getConfiguration()->getQuoteStrategy();
193.     }
195.     /**
196.      * Gets the Query instance used by the walker.
197.      *
198.      * @return Query
199.      */
200.     public function getQuery()
201.     {
202.         return $this->query;
203.     }
205.     /**
206.      * Gets the Connection used by the walker.
207.      *
208.      * @return Connection
209.      */
210.     public function getConnection()
211.     {
212.         return $this->conn;
213.     }
215.     /**
216.      * Gets the EntityManager used by the walker.
217.      *
218.      * @return EntityManagerInterface
219.      */
220.     public function getEntityManager()
221.     {
222.         return $this->em;
223.     }
225.     /**
226.      * Gets the information about a single query component.
227.      *
228.      * @param string $dqlAlias The DQL alias.
229.      *
230.      * @return mixed[]
231.      * @psalm-return QueryComponent
232.      */
233.     public function getQueryComponent($dqlAlias)
234.     {
235.         return $this->queryComponents[$dqlAlias];
236.     }
238.     public function getMetadataForDqlAlias(string $dqlAlias): ClassMetadata
239.     {
240.         if (! isset($this->queryComponents[$dqlAlias]['metadata'])) {
241.             throw new LogicException(sprintf('No metadata for DQL alias: %s', $dqlAlias));
242.         }
244.         return $this->queryComponents[$dqlAlias]['metadata'];
245.     }
247.     /**
248.      * Returns internal queryComponents array.
249.      *
250.      * @return array<string, QueryComponent>
251.      */
252.     public function getQueryComponents()
253.     {
254.         return $this->queryComponents;
255.     }
257.     /**
258.      * Sets or overrides a query component for a given dql alias.
259.      *
260.      * @param string $dqlAlias The DQL alias.
261.      * @psalm-param QueryComponent $queryComponent
262.      *
263.      * @return void
264.      *
265.      * @not-deprecated
266.      */
267.     public function setQueryComponent($dqlAlias, array $queryComponent)
268.     {
269.         $requiredKeys = ['metadata', 'parent', 'relation', 'map', 'nestingLevel', 'token'];
271.         if (array_diff($requiredKeys, array_keys($queryComponent))) {
272.             throw QueryException::invalidQueryComponent($dqlAlias);
273.         }
275.         $this->queryComponents[$dqlAlias] = $queryComponent;
276.     }
278.     /**
279.      * Gets an executor that can be used to execute the result of this walker.
280.      *
281.      * @param AST\DeleteStatement|AST\UpdateStatement|AST\SelectStatement $AST
282.      *
283.      * @return Exec\AbstractSqlExecutor
284.      *
285.      * @not-deprecated
286.      */
287.     public function getExecutor($AST)
288.     {
289.         switch (true) {
290.             case $AST instanceof AST\DeleteStatement:
291.                 $primaryClass = $this->em->getClassMetadata($AST->deleteClause->abstractSchemaName);
293.                 return $primaryClass->isInheritanceTypeJoined()
294.                     ? new Exec\MultiTableDeleteExecutor($AST, $this)
295.                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
297.             case $AST instanceof AST\UpdateStatement:
298.                 $primaryClass = $this->em->getClassMetadata($AST->updateClause->abstractSchemaName);
300.                 return $primaryClass->isInheritanceTypeJoined()
301.                     ? new Exec\MultiTableUpdateExecutor($AST, $this)
302.                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
304.             default:
305.                 return new Exec\SingleSelectExecutor($AST, $this);
306.         }
307.     }
309.     /**
310.      * Generates a unique, short SQL table alias.
311.      *
312.      * @param string $tableName Table name
313.      * @param string $dqlAlias  The DQL alias.
314.      *
315.      * @return string Generated table alias.
316.      */
317.     public function getSQLTableAlias($tableName, $dqlAlias = '')
318.     {
319.         $tableName .= $dqlAlias ? '@[' . $dqlAlias . ']' : '';
321.         if (! isset($this->tableAliasMap[$tableName])) {
322.             $this->tableAliasMap[$tableName] = (preg_match('/[a-z]/i', $tableName[0]) ? strtolower($tableName[0]) : 't')
323.                 . $this->tableAliasCounter++ . '_';
324.         }
326.         return $this->tableAliasMap[$tableName];
327.     }
329.     /**
330.      * Forces the SqlWalker to use a specific alias for a table name, rather than
331.      * generating an alias on its own.
332.      *
333.      * @param string $tableName
334.      * @param string $alias
335.      * @param string $dqlAlias
336.      *
337.      * @return string
338.      */
339.     public function setSQLTableAlias($tableName, $alias, $dqlAlias = '')
340.     {
341.         $tableName .= $dqlAlias ? '@[' . $dqlAlias . ']' : '';
343.         $this->tableAliasMap[$tableName] = $alias;
345.         return $alias;
346.     }
348.     /**
349.      * Gets an SQL column alias for a column name.
350.      *
351.      * @param string $columnName
352.      *
353.      * @return string
354.      */
355.     public function getSQLColumnAlias($columnName)
356.     {
357.         return $this->quoteStrategy->getColumnAlias($columnName, $this->aliasCounter++, $this->platform);
358.     }
360.     /**
361.      * Generates the SQL JOINs that are necessary for Class Table Inheritance
362.      * for the given class.
363.      *
364.      * @param ClassMetadata $class    The class for which to generate the joins.
365.      * @param string        $dqlAlias The DQL alias of the class.
366.      *
367.      * @return string The SQL.
368.      */
369.     private function generateClassTableInheritanceJoins(
370.         ClassMetadata $class,
371.         string $dqlAlias
372.     ): string {
373.         $sql = '';
375.         $baseTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
377.         // INNER JOIN parent class tables
378.         foreach ($class->parentClasses as $parentClassName) {
379.             $parentClass = $this->em->getClassMetadata($parentClassName);
380.             $tableAlias  = $this->getSQLTableAlias($parentClass->getTableName(), $dqlAlias);
382.             // If this is a joined association we must use left joins to preserve the correct result.
383.             $sql .= isset($this->queryComponents[$dqlAlias]['relation']) ? ' LEFT ' : ' INNER ';
384.             $sql .= 'JOIN ' . $this->quoteStrategy->getTableName($parentClass, $this->platform) . ' ' . $tableAlias . ' ON ';
386.             $sqlParts = [];
388.             foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
389.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
390.             }
392.             // Add filters on the root class
393.             $sqlParts[] = $this->generateFilterConditionSQL($parentClass, $tableAlias);
395.             $sql .= implode(' AND ', array_filter($sqlParts));
396.         }
398.         // Ignore subclassing inclusion if partial objects is disallowed
399.         if ($this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
400.             return $sql;
401.         }
403.         // LEFT JOIN child class tables
404.         foreach ($class->subClasses as $subClassName) {
405.             $subClass   = $this->em->getClassMetadata($subClassName);
406.             $tableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
408.             $sql .= ' LEFT JOIN ' . $this->quoteStrategy->getTableName($subClass, $this->platform) . ' ' . $tableAlias . ' ON ';
410.             $sqlParts = [];
412.             foreach ($this->quoteStrategy->getIdentifierColumnNames($subClass, $this->platform) as $columnName) {
413.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
414.             }
416.             $sql .= implode(' AND ', $sqlParts);
417.         }
419.         return $sql;
420.     }
422.     private function generateOrderedCollectionOrderByItems(): string
423.     {
424.         $orderedColumns = [];
426.         foreach ($this->selectedClasses as $selectedClass) {
427.             $dqlAlias = $selectedClass['dqlAlias'];
428.             $qComp    = $this->queryComponents[$dqlAlias];
430.             if (! isset($qComp['relation']['orderBy'])) {
431.                 continue;
432.             }
434.             assert(isset($qComp['metadata']));
435.             $persister = $this->em->getUnitOfWork()->getEntityPersister($qComp['metadata']->name);
437.             foreach ($qComp['relation']['orderBy'] as $fieldName => $orientation) {
438.                 $columnName = $this->quoteStrategy->getColumnName($fieldName, $qComp['metadata'], $this->platform);
439.                 $tableName  = $qComp['metadata']->isInheritanceTypeJoined()
440.                     ? $persister->getOwningTable($fieldName)
441.                     : $qComp['metadata']->getTableName();
443.                 $orderedColumn = $this->getSQLTableAlias($tableName, $dqlAlias) . '.' . $columnName;
445.                 // OrderByClause should replace an ordered relation. see - DDC-2475
446.                 if (isset($this->orderedColumnsMap[$orderedColumn])) {
447.                     continue;
448.                 }
450.                 $this->orderedColumnsMap[$orderedColumn] = $orientation;
451.                 $orderedColumns[]                        = $orderedColumn . ' ' . $orientation;
452.             }
453.         }
455.         return implode(', ', $orderedColumns);
456.     }
458.     /**
459.      * Generates a discriminator column SQL condition for the class with the given DQL alias.
460.      *
461.      * @psalm-param list<string> $dqlAliases List of root DQL aliases to inspect for discriminator restrictions.
462.      */
463.     private function generateDiscriminatorColumnConditionSQL(array $dqlAliases): string
464.     {
465.         $sqlParts = [];
467.         foreach ($dqlAliases as $dqlAlias) {
468.             $class = $this->getMetadataForDqlAlias($dqlAlias);
470.             if (! $class->isInheritanceTypeSingleTable()) {
471.                 continue;
472.             }
474.             $sqlTableAlias = $this->useSqlTableAliases
475.                 ? $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.'
476.                 : '';
478.             $conn   = $this->em->getConnection();
479.             $values = [];
481.             if ($class->discriminatorValue !== null) { // discriminators can be 0
482.                 $values[] = $conn->quote($class->discriminatorValue);
483.             }
485.             foreach ($class->subClasses as $subclassName) {
486.                 $subclassMetadata = $this->em->getClassMetadata($subclassName);
488.                 // Abstract entity classes show up in the list of subClasses, but may be omitted
489.                 // from the discriminator map. In that case, they have a null discriminator value.
490.                 if ($subclassMetadata->discriminatorValue === null) {
491.                     continue;
492.                 }
494.                 $values[] = $conn->quote($subclassMetadata->discriminatorValue);
495.             }
497.             if ($values !== []) {
498.                 $sqlParts[] = $sqlTableAlias . $class->getDiscriminatorColumn()['name'] . ' IN (' . implode(', ', $values) . ')';
499.             } else {
500.                 $sqlParts[] = '1=0'; // impossible condition
501.             }
502.         }
504.         $sql = implode(' AND ', $sqlParts);
506.         return count($sqlParts) > 1 ? '(' . $sql . ')' : $sql;
507.     }
509.     /**
510.      * Generates the filter SQL for a given entity and table alias.
511.      *
512.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
513.      * @param string        $targetTableAlias The table alias of the joined/selected table.
514.      *
515.      * @return string The SQL query part to add to a query.
516.      */
517.     private function generateFilterConditionSQL(
518.         ClassMetadata $targetEntity,
519.         string $targetTableAlias
520.     ): string {
521.         if (! $this->em->hasFilters()) {
522.             return '';
523.         }
525.         switch ($targetEntity->inheritanceType) {
526.             case ClassMetadata::INHERITANCE_TYPE_NONE:
527.                 break;
528.             case ClassMetadata::INHERITANCE_TYPE_JOINED:
529.                 // The classes in the inheritance will be added to the query one by one,
530.                 // but only the root node is getting filtered
531.                 if ($targetEntity->name !== $targetEntity->rootEntityName) {
532.                     return '';
533.                 }
535.                 break;
536.             case ClassMetadata::INHERITANCE_TYPE_SINGLE_TABLE:
537.                 // With STI the table will only be queried once, make sure that the filters
538.                 // are added to the root entity
539.                 $targetEntity = $this->em->getClassMetadata($targetEntity->rootEntityName);
540.                 break;
541.             default:
542.                 //@todo: throw exception?
543.                 return '';
544.         }
546.         $filterClauses = [];
547.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
548.             $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
549.             if ($filterExpr !== '') {
550.                 $filterClauses[] = '(' . $filterExpr . ')';
551.             }
552.         }
554.         return implode(' AND ', $filterClauses);
555.     }
557.     /**
558.      * Walks down a SelectStatement AST node, thereby generating the appropriate SQL.
559.      *
560.      * @return string
561.      */
562.     public function walkSelectStatement(AST\SelectStatement $AST)
563.     {
564.         $limit    = $this->query->getMaxResults();
565.         $offset   = $this->query->getFirstResult();
566.         $lockMode = $this->query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE;
567.         $sql      = $this->walkSelectClause($AST->selectClause)
568.             . $this->walkFromClause($AST->fromClause)
569.             . $this->walkWhereClause($AST->whereClause);
571.         if ($AST->groupByClause) {
572.             $sql .= $this->walkGroupByClause($AST->groupByClause);
573.         }
575.         if ($AST->havingClause) {
576.             $sql .= $this->walkHavingClause($AST->havingClause);
577.         }
579.         if ($AST->orderByClause) {
580.             $sql .= $this->walkOrderByClause($AST->orderByClause);
581.         }
583.         $orderBySql = $this->generateOrderedCollectionOrderByItems();
584.         if (! $AST->orderByClause && $orderBySql) {
585.             $sql .= ' ORDER BY ' . $orderBySql;
586.         }
588.         $sql = $this->platform->modifyLimitQuery($sql, $limit, $offset);
590.         if ($lockMode === LockMode::NONE) {
591.             return $sql;
592.         }
594.         if ($lockMode === LockMode::PESSIMISTIC_READ) {
595.             return $sql . ' ' . $this->getReadLockSQL($this->platform);
596.         }
598.         if ($lockMode === LockMode::PESSIMISTIC_WRITE) {
599.             return $sql . ' ' . $this->getWriteLockSQL($this->platform);
600.         }
602.         if ($lockMode !== LockMode::OPTIMISTIC) {
603.             throw QueryException::invalidLockMode();
604.         }
606.         foreach ($this->selectedClasses as $selectedClass) {
607.             if (! $selectedClass['class']->isVersioned) {
608.                 throw OptimisticLockException::lockFailed($selectedClass['class']->name);
609.             }
610.         }
612.         return $sql;
613.     }
615.     /**
616.      * Walks down an UpdateStatement AST node, thereby generating the appropriate SQL.
617.      *
618.      * @return string
619.      */
620.     public function walkUpdateStatement(AST\UpdateStatement $AST)
621.     {
622.         $this->useSqlTableAliases = false;
623.         $this->rsm->isSelect      = false;
625.         return $this->walkUpdateClause($AST->updateClause)
626.             . $this->walkWhereClause($AST->whereClause);
627.     }
629.     /**
630.      * Walks down a DeleteStatement AST node, thereby generating the appropriate SQL.
631.      *
632.      * @return string
633.      */
634.     public function walkDeleteStatement(AST\DeleteStatement $AST)
635.     {
636.         $this->useSqlTableAliases = false;
637.         $this->rsm->isSelect      = false;
639.         return $this->walkDeleteClause($AST->deleteClause)
640.             . $this->walkWhereClause($AST->whereClause);
641.     }
643.     /**
644.      * Walks down an IdentificationVariable AST node, thereby generating the appropriate SQL.
645.      * This one differs of ->walkIdentificationVariable() because it generates the entity identifiers.
646.      *
647.      * @param string $identVariable
648.      *
649.      * @return string
650.      *
651.      * @not-deprecated
652.      */
653.     public function walkEntityIdentificationVariable($identVariable)
654.     {
655.         $class      = $this->getMetadataForDqlAlias($identVariable);
656.         $tableAlias = $this->getSQLTableAlias($class->getTableName(), $identVariable);
657.         $sqlParts   = [];
659.         foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
660.             $sqlParts[] = $tableAlias . '.' . $columnName;
661.         }
663.         return implode(', ', $sqlParts);
664.     }
666.     /**
667.      * Walks down an IdentificationVariable (no AST node associated), thereby generating the SQL.
668.      *
669.      * @param string $identificationVariable
670.      * @param string $fieldName
671.      *
672.      * @return string The SQL.
673.      *
674.      * @not-deprecated
675.      */
676.     public function walkIdentificationVariable($identificationVariable, $fieldName = null)
677.     {
678.         $class = $this->getMetadataForDqlAlias($identificationVariable);
680.         if (
681.             $fieldName !== null && $class->isInheritanceTypeJoined() &&
682.             isset($class->fieldMappings[$fieldName]['inherited'])
683.         ) {
684.             $class = $this->em->getClassMetadata($class->fieldMappings[$fieldName]['inherited']);
685.         }
687.         return $this->getSQLTableAlias($class->getTableName(), $identificationVariable);
688.     }
690.     /**
691.      * Walks down a PathExpression AST node, thereby generating the appropriate SQL.
692.      *
693.      * @param AST\PathExpression $pathExpr
694.      *
695.      * @return string
696.      *
697.      * @not-deprecated
698.      */
699.     public function walkPathExpression($pathExpr)
700.     {
701.         $sql = '';
702.         assert($pathExpr->field !== null);
704.         switch ($pathExpr->type) {
705.             case AST\PathExpression::TYPE_STATE_FIELD:
706.                 $fieldName = $pathExpr->field;
707.                 $dqlAlias  = $pathExpr->identificationVariable;
708.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
710.                 if ($this->useSqlTableAliases) {
711.                     $sql .= $this->walkIdentificationVariable($dqlAlias, $fieldName) . '.';
712.                 }
714.                 $sql .= $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
715.                 break;
717.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
718.                 // 1- the owning side:
719.                 //    Just use the foreign key, i.e. u.group_id
720.                 $fieldName = $pathExpr->field;
721.                 $dqlAlias  = $pathExpr->identificationVariable;
722.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
724.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
725.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
726.                 }
728.                 $assoc = $class->associationMappings[$fieldName];
730.                 if (! $assoc['isOwningSide']) {
731.                     throw QueryException::associationPathInverseSideNotSupported($pathExpr);
732.                 }
734.                 // COMPOSITE KEYS NOT (YET?) SUPPORTED
735.                 if (count($assoc['sourceToTargetKeyColumns']) > 1) {
736.                     throw QueryException::associationPathCompositeKeyNotSupported();
737.                 }
739.                 if ($this->useSqlTableAliases) {
740.                     $sql .= $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.';
741.                 }
743.                 $sql .= reset($assoc['targetToSourceKeyColumns']);
744.                 break;
746.             default:
747.                 throw QueryException::invalidPathExpression($pathExpr);
748.         }
750.         return $sql;
751.     }
753.     /**
754.      * Walks down a SelectClause AST node, thereby generating the appropriate SQL.
755.      *
756.      * @param AST\SelectClause $selectClause
757.      *
758.      * @return string
759.      *
760.      * @not-deprecated
761.      */
762.     public function walkSelectClause($selectClause)
763.     {
764.         $sql                  = 'SELECT ' . ($selectClause->isDistinct ? 'DISTINCT ' : '');
765.         $sqlSelectExpressions = array_filter(array_map([$this, 'walkSelectExpression'], $selectClause->selectExpressions));
767.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) === true && $selectClause->isDistinct) {
768.             $this->query->setHint(self::HINT_DISTINCT, true);
769.         }
771.         $addMetaColumns = ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD) &&
772.             $this->query->getHydrationMode() === Query::HYDRATE_OBJECT
773.             || $this->query->getHint(Query::HINT_INCLUDE_META_COLUMNS);
775.         foreach ($this->selectedClasses as $selectedClass) {
776.             $class       = $selectedClass['class'];
777.             $dqlAlias    = $selectedClass['dqlAlias'];
778.             $resultAlias = $selectedClass['resultAlias'];
780.             // Register as entity or joined entity result
781.             if (! isset($this->queryComponents[$dqlAlias]['relation'])) {
782.                 $this->rsm->addEntityResult($class->name, $dqlAlias, $resultAlias);
783.             } else {
784.                 assert(isset($this->queryComponents[$dqlAlias]['parent']));
786.                 $this->rsm->addJoinedEntityResult(
787.                     $class->name,
788.                     $dqlAlias,
789.                     $this->queryComponents[$dqlAlias]['parent'],
790.                     $this->queryComponents[$dqlAlias]['relation']['fieldName']
791.                 );
792.             }
794.             if ($class->isInheritanceTypeSingleTable() || $class->isInheritanceTypeJoined()) {
795.                 // Add discriminator columns to SQL
796.                 $rootClass   = $this->em->getClassMetadata($class->rootEntityName);
797.                 $tblAlias    = $this->getSQLTableAlias($rootClass->getTableName(), $dqlAlias);
798.                 $discrColumn = $rootClass->getDiscriminatorColumn();
799.                 $columnAlias = $this->getSQLColumnAlias($discrColumn['name']);
801.                 $sqlSelectExpressions[] = $tblAlias . '.' . $discrColumn['name'] . ' AS ' . $columnAlias;
803.                 $this->rsm->setDiscriminatorColumn($dqlAlias, $columnAlias);
804.                 $this->rsm->addMetaResult($dqlAlias, $columnAlias, $discrColumn['fieldName'], false, $discrColumn['type']);
805.                 if (! empty($discrColumn['enumType'])) {
806.                     $this->rsm->addEnumResult($columnAlias, $discrColumn['enumType']);
807.                 }
808.             }
810.             // Add foreign key columns to SQL, if necessary
811.             if (! $addMetaColumns && ! $class->containsForeignIdentifier) {
812.                 continue;
813.             }
815.             // Add foreign key columns of class and also parent classes
816.             foreach ($class->associationMappings as $assoc) {
817.                 if (
818.                     ! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)
819.                     || ( ! $addMetaColumns && ! isset($assoc['id']))
820.                 ) {
821.                     continue;
822.                 }
824.                 $targetClass   = $this->em->getClassMetadata($assoc['targetEntity']);
825.                 $isIdentifier  = (isset($assoc['id']) && $assoc['id'] === true);
826.                 $owningClass   = isset($assoc['inherited']) ? $this->em->getClassMetadata($assoc['inherited']) : $class;
827.                 $sqlTableAlias = $this->getSQLTableAlias($owningClass->getTableName(), $dqlAlias);
829.                 foreach ($assoc['joinColumns'] as $joinColumn) {
830.                     $columnName  = $joinColumn['name'];
831.                     $columnAlias = $this->getSQLColumnAlias($columnName);
832.                     $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
834.                     $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
835.                     $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
837.                     $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $isIdentifier, $columnType);
838.                 }
839.             }
841.             // Add foreign key columns to SQL, if necessary
842.             if (! $addMetaColumns) {
843.                 continue;
844.             }
846.             // Add foreign key columns of subclasses
847.             foreach ($class->subClasses as $subClassName) {
848.                 $subClass      = $this->em->getClassMetadata($subClassName);
849.                 $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
851.                 foreach ($subClass->associationMappings as $assoc) {
852.                     // Skip if association is inherited
853.                     if (isset($assoc['inherited'])) {
854.                         continue;
855.                     }
857.                     if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
858.                         $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
860.                         foreach ($assoc['joinColumns'] as $joinColumn) {
861.                             $columnName  = $joinColumn['name'];
862.                             $columnAlias = $this->getSQLColumnAlias($columnName);
863.                             $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
865.                             $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $subClass, $this->platform);
866.                             $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
868.                             $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $subClass->isIdentifier($columnName), $columnType);
869.                         }
870.                     }
871.                 }
872.             }
873.         }
875.         return $sql . implode(', ', $sqlSelectExpressions);
876.     }
878.     /**
879.      * Walks down a FromClause AST node, thereby generating the appropriate SQL.
880.      *
881.      * @param AST\FromClause $fromClause
882.      *
883.      * @return string
884.      *
885.      * @not-deprecated
886.      */
887.     public function walkFromClause($fromClause)
888.     {
889.         $identificationVarDecls = $fromClause->identificationVariableDeclarations;
890.         $sqlParts               = [];
892.         foreach ($identificationVarDecls as $identificationVariableDecl) {
893.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($identificationVariableDecl);
894.         }
896.         return ' FROM ' . implode(', ', $sqlParts);
897.     }
899.     /**
900.      * Walks down a IdentificationVariableDeclaration AST node, thereby generating the appropriate SQL.
901.      *
902.      * @param AST\IdentificationVariableDeclaration $identificationVariableDecl
903.      *
904.      * @return string
905.      *
906.      * @not-deprecated
907.      */
908.     public function walkIdentificationVariableDeclaration($identificationVariableDecl)
909.     {
910.         $sql = $this->walkRangeVariableDeclaration($identificationVariableDecl->rangeVariableDeclaration);
912.         if ($identificationVariableDecl->indexBy) {
913.             $this->walkIndexBy($identificationVariableDecl->indexBy);
914.         }
916.         foreach ($identificationVariableDecl->joins as $join) {
917.             $sql .= $this->walkJoin($join);
918.         }
920.         return $sql;
921.     }
923.     /**
924.      * Walks down a IndexBy AST node.
925.      *
926.      * @param AST\IndexBy $indexBy
927.      *
928.      * @return void
929.      *
930.      * @not-deprecated
931.      */
932.     public function walkIndexBy($indexBy)
933.     {
934.         $pathExpression = $indexBy->singleValuedPathExpression;
935.         $alias          = $pathExpression->identificationVariable;
936.         assert($pathExpression->field !== null);
938.         switch ($pathExpression->type) {
939.             case AST\PathExpression::TYPE_STATE_FIELD:
940.                 $field = $pathExpression->field;
941.                 break;
943.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
944.                 // Just use the foreign key, i.e. u.group_id
945.                 $fieldName = $pathExpression->field;
946.                 $class     = $this->getMetadataForDqlAlias($alias);
948.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
949.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
950.                 }
952.                 $association = $class->associationMappings[$fieldName];
954.                 if (! $association['isOwningSide']) {
955.                     throw QueryException::associationPathInverseSideNotSupported($pathExpression);
956.                 }
958.                 if (count($association['sourceToTargetKeyColumns']) > 1) {
959.                     throw QueryException::associationPathCompositeKeyNotSupported();
960.                 }
962.                 $field = reset($association['targetToSourceKeyColumns']);
963.                 break;
965.             default:
966.                 throw QueryException::invalidPathExpression($pathExpression);
967.         }
969.         if (isset($this->scalarFields[$alias][$field])) {
970.             $this->rsm->addIndexByScalar($this->scalarFields[$alias][$field]);
972.             return;
973.         }
975.         $this->rsm->addIndexBy($alias, $field);
976.     }
978.     /**
979.      * Walks down a RangeVariableDeclaration AST node, thereby generating the appropriate SQL.
980.      *
981.      * @param AST\RangeVariableDeclaration $rangeVariableDeclaration
982.      *
983.      * @return string
984.      *
985.      * @not-deprecated
986.      */
987.     public function walkRangeVariableDeclaration($rangeVariableDeclaration)
988.     {
989.         return $this->generateRangeVariableDeclarationSQL($rangeVariableDeclaration, false);
990.     }
992.     /**
993.      * Generate appropriate SQL for RangeVariableDeclaration AST node
994.      */
995.     private function generateRangeVariableDeclarationSQL(
996.         AST\RangeVariableDeclaration $rangeVariableDeclaration,
997.         bool $buildNestedJoins
998.     ): string {
999.         $class    = $this->em->getClassMetadata($rangeVariableDeclaration->abstractSchemaName);
1000.         $dqlAlias = $rangeVariableDeclaration->aliasIdentificationVariable;
1002.         if ($rangeVariableDeclaration->isRoot) {
1003.             $this->rootAliases[] = $dqlAlias;
1004.         }
1006.         $sql = $this->platform->appendLockHint(
1007.             $this->quoteStrategy->getTableName($class, $this->platform) . ' ' .
1008.             $this->getSQLTableAlias($class->getTableName(), $dqlAlias),
1009.             $this->query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE
1010.         );
1012.         if (! $class->isInheritanceTypeJoined()) {
1013.             return $sql;
1014.         }
1016.         $classTableInheritanceJoins = $this->generateClassTableInheritanceJoins($class, $dqlAlias);
1018.         if (! $buildNestedJoins) {
1019.             return $sql . $classTableInheritanceJoins;
1020.         }
1022.         return $classTableInheritanceJoins === '' ? $sql : '(' . $sql . $classTableInheritanceJoins . ')';
1023.     }
1025.     /**
1026.      * Walks down a JoinAssociationDeclaration AST node, thereby generating the appropriate SQL.
1027.      *
1028.      * @param AST\JoinAssociationDeclaration                             $joinAssociationDeclaration
1029.      * @param int                                                        $joinType
1030.      * @param AST\ConditionalExpression|AST\Phase2OptimizableConditional $condExpr
1031.      * @psalm-param AST\Join::JOIN_TYPE_* $joinType
1032.      *
1033.      * @return string
1034.      *
1035.      * @throws QueryException
1036.      *
1037.      * @not-deprecated
1038.      */
1039.     public function walkJoinAssociationDeclaration($joinAssociationDeclaration, $joinType = AST\Join::JOIN_TYPE_INNER, $condExpr = null)
1040.     {
1041.         $sql = '';
1043.         $associationPathExpression = $joinAssociationDeclaration->joinAssociationPathExpression;
1044.         $joinedDqlAlias            = $joinAssociationDeclaration->aliasIdentificationVariable;
1045.         $indexBy                   = $joinAssociationDeclaration->indexBy;
1047.         $relation = $this->queryComponents[$joinedDqlAlias]['relation'] ?? null;
1048.         assert($relation !== null);
1049.         $targetClass     = $this->em->getClassMetadata($relation['targetEntity']);
1050.         $sourceClass     = $this->em->getClassMetadata($relation['sourceEntity']);
1051.         $targetTableName = $this->quoteStrategy->getTableName($targetClass, $this->platform);
1053.         $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName(), $joinedDqlAlias);
1054.         $sourceTableAlias = $this->getSQLTableAlias($sourceClass->getTableName(), $associationPathExpression->identificationVariable);
1056.         // Ensure we got the owning side, since it has all mapping info
1057.         $assoc = ! $relation['isOwningSide'] ? $targetClass->associationMappings[$relation['mappedBy']] : $relation;
1059.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) === true && (! $this->query->getHint(self::HINT_DISTINCT) || isset($this->selectedClasses[$joinedDqlAlias]))) {
1060.             if ($relation['type'] === ClassMetadata::ONE_TO_MANY || $relation['type'] === ClassMetadata::MANY_TO_MANY) {
1061.                 throw QueryException::iterateWithFetchJoinNotAllowed($assoc);
1062.             }
1063.         }
1065.         $fetchMode = $this->query->getHint('fetchMode')[$assoc['sourceEntity']][$assoc['fieldName']] ?? $relation['fetch'];
1067.         if ($fetchMode === ClassMetadata::FETCH_EAGER && $condExpr !== null) {
1068.             throw QueryException::eagerFetchJoinWithNotAllowed($assoc['sourceEntity'], $assoc['fieldName']);
1069.         }
1071.         // This condition is not checking ClassMetadata::MANY_TO_ONE, because by definition it cannot
1072.         // be the owning side and previously we ensured that $assoc is always the owning side of the associations.
1073.         // The owning side is necessary at this point because only it contains the JoinColumn information.
1074.         switch (true) {
1075.             case $assoc['type'] & ClassMetadata::TO_ONE:
1076.                 $conditions = [];
1078.                 foreach ($assoc['joinColumns'] as $joinColumn) {
1079.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
1080.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
1082.                     if ($relation['isOwningSide']) {
1083.                         $conditions[] = $sourceTableAlias . '.' . $quotedSourceColumn . ' = ' . $targetTableAlias . '.' . $quotedTargetColumn;
1085.                         continue;
1086.                     }
1088.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $targetTableAlias . '.' . $quotedSourceColumn;
1089.                 }
1091.                 // Apply remaining inheritance restrictions
1092.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
1094.                 if ($discrSql) {
1095.                     $conditions[] = $discrSql;
1096.                 }
1098.                 // Apply the filters
1099.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
1101.                 if ($filterExpr) {
1102.                     $conditions[] = $filterExpr;
1103.                 }
1105.                 $targetTableJoin = [
1106.                     'table' => $targetTableName . ' ' . $targetTableAlias,
1107.                     'condition' => implode(' AND ', $conditions),
1108.                 ];
1109.                 break;
1111.             case $assoc['type'] === ClassMetadata::MANY_TO_MANY:
1112.                 // Join relation table
1113.                 $joinTable      = $assoc['joinTable'];
1114.                 $joinTableAlias = $this->getSQLTableAlias($joinTable['name'], $joinedDqlAlias);
1115.                 $joinTableName  = $this->quoteStrategy->getJoinTableName($assoc, $sourceClass, $this->platform);
1117.                 $conditions      = [];
1118.                 $relationColumns = $relation['isOwningSide']
1119.                     ? $assoc['joinTable']['joinColumns']
1120.                     : $assoc['joinTable']['inverseJoinColumns'];
1122.                 foreach ($relationColumns as $joinColumn) {
1123.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
1124.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
1126.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
1127.                 }
1129.                 $sql .= $joinTableName . ' ' . $joinTableAlias . ' ON ' . implode(' AND ', $conditions);
1131.                 // Join target table
1132.                 $sql .= $joinType === AST\Join::JOIN_TYPE_LEFT || $joinType === AST\Join::JOIN_TYPE_LEFTOUTER ? ' LEFT JOIN ' : ' INNER JOIN ';
1134.                 $conditions      = [];
1135.                 $relationColumns = $relation['isOwningSide']
1136.                     ? $assoc['joinTable']['inverseJoinColumns']
1137.                     : $assoc['joinTable']['joinColumns'];
1139.                 foreach ($relationColumns as $joinColumn) {
1140.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
1141.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
1143.                     $conditions[] = $targetTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
1144.                 }
1146.                 // Apply remaining inheritance restrictions
1147.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
1149.                 if ($discrSql) {
1150.                     $conditions[] = $discrSql;
1151.                 }
1153.                 // Apply the filters
1154.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
1156.                 if ($filterExpr) {
1157.                     $conditions[] = $filterExpr;
1158.                 }
1160.                 $targetTableJoin = [
1161.                     'table' => $targetTableName . ' ' . $targetTableAlias,
1162.                     'condition' => implode(' AND ', $conditions),
1163.                 ];
1164.                 break;
1166.             default:
1167.                 throw new BadMethodCallException('Type of association must be one of *_TO_ONE or MANY_TO_MANY');
1168.         }
1170.         // Handle WITH clause
1171.         $withCondition = $condExpr === null ? '' : ('(' . $this->walkConditionalExpression($condExpr) . ')');
1173.         if ($targetClass->isInheritanceTypeJoined()) {
1174.             $ctiJoins = $this->generateClassTableInheritanceJoins($targetClass, $joinedDqlAlias);
1175.             // If we have WITH condition, we need to build nested joins for target class table and cti joins
1176.             if ($withCondition && $ctiJoins) {
1177.                 $sql .= '(' . $targetTableJoin['table'] . $ctiJoins . ') ON ' . $targetTableJoin['condition'];
1178.             } else {
1179.                 $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'] . $ctiJoins;
1180.             }
1181.         } else {
1182.             $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'];
1183.         }
1185.         if ($withCondition) {
1186.             $sql .= ' AND ' . $withCondition;
1187.         }
1189.         // Apply the indexes
1190.         if ($indexBy) {
1191.             // For Many-To-One or One-To-One associations this obviously makes no sense, but is ignored silently.
1192.             $this->walkIndexBy($indexBy);
1193.         } elseif (isset($relation['indexBy'])) {
1194.             $this->rsm->addIndexBy($joinedDqlAlias, $relation['indexBy']);
1195.         }
1197.         return $sql;
1198.     }
1200.     /**
1201.      * Walks down a FunctionNode AST node, thereby generating the appropriate SQL.
1202.      *
1203.      * @param AST\Functions\FunctionNode $function
1204.      *
1205.      * @return string
1206.      *
1207.      * @not-deprecated
1208.      */
1209.     public function walkFunction($function)
1210.     {
1211.         return $function->getSql($this);
1212.     }
1214.     /**
1215.      * Walks down an OrderByClause AST node, thereby generating the appropriate SQL.
1216.      *
1217.      * @param AST\OrderByClause $orderByClause
1218.      *
1219.      * @return string
1220.      *
1221.      * @not-deprecated
1222.      */
1223.     public function walkOrderByClause($orderByClause)
1224.     {
1225.         $orderByItems = array_map([$this, 'walkOrderByItem'], $orderByClause->orderByItems);
1227.         $collectionOrderByItems = $this->generateOrderedCollectionOrderByItems();
1228.         if ($collectionOrderByItems !== '') {
1229.             $orderByItems = array_merge($orderByItems, (array) $collectionOrderByItems);
1230.         }
1232.         return ' ORDER BY ' . implode(', ', $orderByItems);
1233.     }
1235.     /**
1236.      * Walks down an OrderByItem AST node, thereby generating the appropriate SQL.
1237.      *
1238.      * @param AST\OrderByItem $orderByItem
1239.      *
1240.      * @return string
1241.      *
1242.      * @not-deprecated
1243.      */
1244.     public function walkOrderByItem($orderByItem)
1245.     {
1246.         $type = strtoupper($orderByItem->type);
1247.         $expr = $orderByItem->expression;
1248.         $sql  = $expr instanceof AST\Node
1249.             ? $expr->dispatch($this)
1250.             : $this->walkResultVariable($this->queryComponents[$expr]['token']->value);
1252.         $this->orderedColumnsMap[$sql] = $type;
1254.         if ($expr instanceof AST\Subselect) {
1255.             return '(' . $sql . ') ' . $type;
1256.         }
1258.         return $sql . ' ' . $type;
1259.     }
1261.     /**
1262.      * Walks down a HavingClause AST node, thereby generating the appropriate SQL.
1263.      *
1264.      * @param AST\HavingClause $havingClause
1265.      *
1266.      * @return string The SQL.
1267.      *
1268.      * @not-deprecated
1269.      */
1270.     public function walkHavingClause($havingClause)
1271.     {
1272.         return ' HAVING ' . $this->walkConditionalExpression($havingClause->conditionalExpression);
1273.     }
1275.     /**
1276.      * Walks down a Join AST node and creates the corresponding SQL.
1277.      *
1278.      * @param AST\Join $join
1279.      *
1280.      * @return string
1281.      *
1282.      * @not-deprecated
1283.      */
1284.     public function walkJoin($join)
1285.     {
1286.         $joinType        = $join->joinType;
1287.         $joinDeclaration = $join->joinAssociationDeclaration;
1289.         $sql = $joinType === AST\Join::JOIN_TYPE_LEFT || $joinType === AST\Join::JOIN_TYPE_LEFTOUTER
1290.             ? ' LEFT JOIN '
1291.             : ' INNER JOIN ';
1293.         switch (true) {
1294.             case $joinDeclaration instanceof AST\RangeVariableDeclaration:
1295.                 $class      = $this->em->getClassMetadata($joinDeclaration->abstractSchemaName);
1296.                 $dqlAlias   = $joinDeclaration->aliasIdentificationVariable;
1297.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
1298.                 $conditions = [];
1300.                 if ($join->conditionalExpression) {
1301.                     $conditions[] = '(' . $this->walkConditionalExpression($join->conditionalExpression) . ')';
1302.                 }
1304.                 $isUnconditionalJoin = $conditions === [];
1305.                 $condExprConjunction = $class->isInheritanceTypeJoined() && $joinType !== AST\Join::JOIN_TYPE_LEFT && $joinType !== AST\Join::JOIN_TYPE_LEFTOUTER && $isUnconditionalJoin
1306.                     ? ' AND '
1307.                     : ' ON ';
1309.                 $sql .= $this->generateRangeVariableDeclarationSQL($joinDeclaration, ! $isUnconditionalJoin);
1311.                 // Apply remaining inheritance restrictions
1312.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$dqlAlias]);
1314.                 if ($discrSql) {
1315.                     $conditions[] = $discrSql;
1316.                 }
1318.                 // Apply the filters
1319.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
1321.                 if ($filterExpr) {
1322.                     $conditions[] = $filterExpr;
1323.                 }
1325.                 if ($conditions) {
1326.                     $sql .= $condExprConjunction . implode(' AND ', $conditions);
1327.                 }
1329.                 break;
1331.             case $joinDeclaration instanceof AST\JoinAssociationDeclaration:
1332.                 $sql .= $this->walkJoinAssociationDeclaration($joinDeclaration, $joinType, $join->conditionalExpression);
1333.                 break;
1334.         }
1336.         return $sql;
1337.     }
1339.     /**
1340.      * Walks down a CoalesceExpression AST node and generates the corresponding SQL.
1341.      *
1342.      * @param AST\CoalesceExpression $coalesceExpression
1343.      *
1344.      * @return string The SQL.
1345.      *
1346.      * @not-deprecated
1347.      */
1348.     public function walkCoalesceExpression($coalesceExpression)
1349.     {
1350.         $sql = 'COALESCE(';
1352.         $scalarExpressions = [];
1354.         foreach ($coalesceExpression->scalarExpressions as $scalarExpression) {
1355.             $scalarExpressions[] = $this->walkSimpleArithmeticExpression($scalarExpression);
1356.         }
1358.         return $sql . implode(', ', $scalarExpressions) . ')';
1359.     }
1361.     /**
1362.      * Walks down a NullIfExpression AST node and generates the corresponding SQL.
1363.      *
1364.      * @param AST\NullIfExpression $nullIfExpression
1365.      *
1366.      * @return string The SQL.
1367.      *
1368.      * @not-deprecated
1369.      */
1370.     public function walkNullIfExpression($nullIfExpression)
1371.     {
1372.         $firstExpression = is_string($nullIfExpression->firstExpression)
1373.             ? $this->conn->quote($nullIfExpression->firstExpression)
1374.             : $this->walkSimpleArithmeticExpression($nullIfExpression->firstExpression);
1376.         $secondExpression = is_string($nullIfExpression->secondExpression)
1377.             ? $this->conn->quote($nullIfExpression->secondExpression)
1378.             : $this->walkSimpleArithmeticExpression($nullIfExpression->secondExpression);
1380.         return 'NULLIF(' . $firstExpression . ', ' . $secondExpression . ')';
1381.     }
1383.     /**
1384.      * Walks down a GeneralCaseExpression AST node and generates the corresponding SQL.
1385.      *
1386.      * @return string The SQL.
1387.      *
1388.      * @not-deprecated
1389.      */
1390.     public function walkGeneralCaseExpression(AST\GeneralCaseExpression $generalCaseExpression)
1391.     {
1392.         $sql = 'CASE';
1394.         foreach ($generalCaseExpression->whenClauses as $whenClause) {
1395.             $sql .= ' WHEN ' . $this->walkConditionalExpression($whenClause->caseConditionExpression);
1396.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($whenClause->thenScalarExpression);
1397.         }
1399.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($generalCaseExpression->elseScalarExpression) . ' END';
1401.         return $sql;
1402.     }
1404.     /**
1405.      * Walks down a SimpleCaseExpression AST node and generates the corresponding SQL.
1406.      *
1407.      * @param AST\SimpleCaseExpression $simpleCaseExpression
1408.      *
1409.      * @return string The SQL.
1410.      *
1411.      * @not-deprecated
1412.      */
1413.     public function walkSimpleCaseExpression($simpleCaseExpression)
1414.     {
1415.         $sql = 'CASE ' . $this->walkStateFieldPathExpression($simpleCaseExpression->caseOperand);
1417.         foreach ($simpleCaseExpression->simpleWhenClauses as $simpleWhenClause) {
1418.             $sql .= ' WHEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->caseScalarExpression);
1419.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->thenScalarExpression);
1420.         }
1422.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($simpleCaseExpression->elseScalarExpression) . ' END';
1424.         return $sql;
1425.     }
1427.     /**
1428.      * Walks down a SelectExpression AST node and generates the corresponding SQL.
1429.      *
1430.      * @param AST\SelectExpression $selectExpression
1431.      *
1432.      * @return string
1433.      *
1434.      * @not-deprecated
1435.      */
1436.     public function walkSelectExpression($selectExpression)
1437.     {
1438.         $sql    = '';
1439.         $expr   = $selectExpression->expression;
1440.         $hidden = $selectExpression->hiddenAliasResultVariable;
1442.         switch (true) {
1443.             case $expr instanceof AST\PathExpression:
1444.                 if ($expr->type !== AST\PathExpression::TYPE_STATE_FIELD) {
1445.                     throw QueryException::invalidPathExpression($expr);
1446.                 }
1448.                 assert($expr->field !== null);
1449.                 $fieldName = $expr->field;
1450.                 $dqlAlias  = $expr->identificationVariable;
1451.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
1453.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $fieldName;
1454.                 $tableName   = $class->isInheritanceTypeJoined()
1455.                     ? $this->em->getUnitOfWork()->getEntityPersister($class->name)->getOwningTable($fieldName)
1456.                     : $class->getTableName();
1458.                 $sqlTableAlias = $this->getSQLTableAlias($tableName, $dqlAlias);
1459.                 $fieldMapping  = $class->fieldMappings[$fieldName];
1460.                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
1461.                 $columnAlias   = $this->getSQLColumnAlias($fieldMapping['columnName']);
1462.                 $col           = $sqlTableAlias . '.' . $columnName;
1464.                 if (isset($fieldMapping['requireSQLConversion'])) {
1465.                     $type = Type::getType($fieldMapping['type']);
1466.                     $col  = $type->convertToPHPValueSQL($col, $this->conn->getDatabasePlatform());
1467.                 }
1469.                 $sql .= $col . ' AS ' . $columnAlias;
1471.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
1473.                 if (! $hidden) {
1474.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldMapping['type']);
1475.                     $this->scalarFields[$dqlAlias][$fieldName] = $columnAlias;
1477.                     if (! empty($fieldMapping['enumType'])) {
1478.                         $this->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
1479.                     }
1480.                 }
1482.                 break;
1484.             case $expr instanceof AST\AggregateExpression:
1485.             case $expr instanceof AST\Functions\FunctionNode:
1486.             case $expr instanceof AST\SimpleArithmeticExpression:
1487.             case $expr instanceof AST\ArithmeticTerm:
1488.             case $expr instanceof AST\ArithmeticFactor:
1489.             case $expr instanceof AST\ParenthesisExpression:
1490.             case $expr instanceof AST\Literal:
1491.             case $expr instanceof AST\NullIfExpression:
1492.             case $expr instanceof AST\CoalesceExpression:
1493.             case $expr instanceof AST\GeneralCaseExpression:
1494.             case $expr instanceof AST\SimpleCaseExpression:
1495.                 $columnAlias = $this->getSQLColumnAlias('sclr');
1496.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
1498.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
1500.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
1502.                 if ($hidden) {
1503.                     break;
1504.                 }
1506.                 if (! $expr instanceof Query\AST\TypedExpression) {
1507.                     // Conceptually we could resolve field type here by traverse through AST to retrieve field type,
1508.                     // but this is not a feasible solution; assume 'string'.
1509.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
1511.                     break;
1512.                 }
1514.                 $this->rsm->addScalarResult($columnAlias, $resultAlias, Type::getTypeRegistry()->lookupName($expr->getReturnType()));
1516.                 break;
1518.             case $expr instanceof AST\Subselect:
1519.                 $columnAlias = $this->getSQLColumnAlias('sclr');
1520.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
1522.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
1524.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
1526.                 if (! $hidden) {
1527.                     // We cannot resolve field type here; assume 'string'.
1528.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
1529.                 }
1531.                 break;
1533.             case $expr instanceof AST\NewObjectExpression:
1534.                 $sql .= $this->walkNewObject($expr, $selectExpression->fieldIdentificationVariable);
1535.                 break;
1537.             default:
1538.                 // IdentificationVariable or PartialObjectExpression
1539.                 if ($expr instanceof AST\PartialObjectExpression) {
1540.                     $this->query->setHint(self::HINT_PARTIAL, true);
1542.                     $dqlAlias        = $expr->identificationVariable;
1543.                     $partialFieldSet = $expr->partialFieldSet;
1544.                 } else {
1545.                     $dqlAlias        = $expr;
1546.                     $partialFieldSet = [];
1547.                 }
1549.                 $class       = $this->getMetadataForDqlAlias($dqlAlias);
1550.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: null;
1552.                 if (! isset($this->selectedClasses[$dqlAlias])) {
1553.                     $this->selectedClasses[$dqlAlias] = [
1554.                         'class'       => $class,
1555.                         'dqlAlias'    => $dqlAlias,
1556.                         'resultAlias' => $resultAlias,
1557.                     ];
1558.                 }
1560.                 $sqlParts = [];
1562.                 // Select all fields from the queried class
1563.                 foreach ($class->fieldMappings as $fieldName => $mapping) {
1564.                     if ($partialFieldSet && ! in_array($fieldName, $partialFieldSet, true)) {
1565.                         continue;
1566.                     }
1568.                     $tableName = isset($mapping['inherited'])
1569.                         ? $this->em->getClassMetadata($mapping['inherited'])->getTableName()
1570.                         : $class->getTableName();
1572.                     $sqlTableAlias    = $this->getSQLTableAlias($tableName, $dqlAlias);
1573.                     $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
1574.                     $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
1576.                     $col = $sqlTableAlias . '.' . $quotedColumnName;
1578.                     if (isset($mapping['requireSQLConversion'])) {
1579.                         $type = Type::getType($mapping['type']);
1580.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
1581.                     }
1583.                     $sqlParts[] = $col . ' AS ' . $columnAlias;
1585.                     $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
1587.                     $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $class->name);
1589.                     if (! empty($mapping['enumType'])) {
1590.                         $this->rsm->addEnumResult($columnAlias, $mapping['enumType']);
1591.                     }
1592.                 }
1594.                 // Add any additional fields of subclasses (excluding inherited fields)
1595.                 // 1) on Single Table Inheritance: always, since its marginal overhead
1596.                 // 2) on Class Table Inheritance only if partial objects are disallowed,
1597.                 //    since it requires outer joining subtables.
1598.                 if ($class->isInheritanceTypeSingleTable() || ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
1599.                     foreach ($class->subClasses as $subClassName) {
1600.                         $subClass      = $this->em->getClassMetadata($subClassName);
1601.                         $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
1603.                         foreach ($subClass->fieldMappings as $fieldName => $mapping) {
1604.                             if (isset($mapping['inherited']) || ($partialFieldSet && ! in_array($fieldName, $partialFieldSet, true))) {
1605.                                 continue;
1606.                             }
1608.                             $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
1609.                             $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $subClass, $this->platform);
1611.                             $col = $sqlTableAlias . '.' . $quotedColumnName;
1613.                             if (isset($mapping['requireSQLConversion'])) {
1614.                                 $type = Type::getType($mapping['type']);
1615.                                 $col  = $type->convertToPHPValueSQL($col, $this->platform);
1616.                             }
1618.                             $sqlParts[] = $col . ' AS ' . $columnAlias;
1620.                             $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
1622.                             $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $subClassName);
1623.                         }
1624.                     }
1625.                 }
1627.                 $sql .= implode(', ', $sqlParts);
1628.         }
1630.         return $sql;
1631.     }
1633.     /**
1634.      * Walks down a QuantifiedExpression AST node, thereby generating the appropriate SQL.
1635.      *
1636.      * @param AST\QuantifiedExpression $qExpr
1637.      *
1638.      * @return string
1639.      *
1640.      * @not-deprecated
1641.      */
1642.     public function walkQuantifiedExpression($qExpr)
1643.     {
1644.         return ' ' . strtoupper($qExpr->type) . '(' . $this->walkSubselect($qExpr->subselect) . ')';
1645.     }
1647.     /**
1648.      * Walks down a Subselect AST node, thereby generating the appropriate SQL.
1649.      *
1650.      * @param AST\Subselect $subselect
1651.      *
1652.      * @return string
1653.      *
1654.      * @not-deprecated
1655.      */
1656.     public function walkSubselect($subselect)
1657.     {
1658.         $useAliasesBefore  = $this->useSqlTableAliases;
1659.         $rootAliasesBefore = $this->rootAliases;
1661.         $this->rootAliases        = []; // reset the rootAliases for the subselect
1662.         $this->useSqlTableAliases = true;
1664.         $sql  = $this->walkSimpleSelectClause($subselect->simpleSelectClause);
1665.         $sql .= $this->walkSubselectFromClause($subselect->subselectFromClause);
1666.         $sql .= $this->walkWhereClause($subselect->whereClause);
1668.         $sql .= $subselect->groupByClause ? $this->walkGroupByClause($subselect->groupByClause) : '';
1669.         $sql .= $subselect->havingClause ? $this->walkHavingClause($subselect->havingClause) : '';
1670.         $sql .= $subselect->orderByClause ? $this->walkOrderByClause($subselect->orderByClause) : '';
1672.         $this->rootAliases        = $rootAliasesBefore; // put the main aliases back
1673.         $this->useSqlTableAliases = $useAliasesBefore;
1675.         return $sql;
1676.     }
1678.     /**
1679.      * Walks down a SubselectFromClause AST node, thereby generating the appropriate SQL.
1680.      *
1681.      * @param AST\SubselectFromClause $subselectFromClause
1682.      *
1683.      * @return string
1684.      *
1685.      * @not-deprecated
1686.      */
1687.     public function walkSubselectFromClause($subselectFromClause)
1688.     {
1689.         $identificationVarDecls = $subselectFromClause->identificationVariableDeclarations;
1690.         $sqlParts               = [];
1692.         foreach ($identificationVarDecls as $subselectIdVarDecl) {
1693.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($subselectIdVarDecl);
1694.         }
1696.         return ' FROM ' . implode(', ', $sqlParts);
1697.     }
1699.     /**
1700.      * Walks down a SimpleSelectClause AST node, thereby generating the appropriate SQL.
1701.      *
1702.      * @param AST\SimpleSelectClause $simpleSelectClause
1703.      *
1704.      * @return string
1705.      *
1706.      * @not-deprecated
1707.      */
1708.     public function walkSimpleSelectClause($simpleSelectClause)
1709.     {
1710.         return 'SELECT' . ($simpleSelectClause->isDistinct ? ' DISTINCT' : '')
1711.             . $this->walkSimpleSelectExpression($simpleSelectClause->simpleSelectExpression);
1712.     }
1714.     /** @return string */
1715.     public function walkParenthesisExpression(AST\ParenthesisExpression $parenthesisExpression)
1716.     {
1717.         return sprintf('(%s)', $parenthesisExpression->expression->dispatch($this));
1718.     }
1720.     /**
1721.      * @param AST\NewObjectExpression $newObjectExpression
1722.      * @param string|null             $newObjectResultAlias
1723.      *
1724.      * @return string The SQL.
1725.      */
1726.     public function walkNewObject($newObjectExpression, $newObjectResultAlias = null)
1727.     {
1728.         $sqlSelectExpressions = [];
1729.         $objIndex             = $newObjectResultAlias ?: $this->newObjectCounter++;
1731.         foreach ($newObjectExpression->args as $argIndex => $e) {
1732.             $resultAlias = $this->scalarResultCounter++;
1733.             $columnAlias = $this->getSQLColumnAlias('sclr');
1734.             $fieldType   = 'string';
1736.             switch (true) {
1737.                 case $e instanceof AST\NewObjectExpression:
1738.                     $sqlSelectExpressions[] = $e->dispatch($this);
1739.                     break;
1741.                 case $e instanceof AST\Subselect:
1742.                     $sqlSelectExpressions[] = '(' . $e->dispatch($this) . ') AS ' . $columnAlias;
1743.                     break;
1745.                 case $e instanceof AST\PathExpression:
1746.                     assert($e->field !== null);
1747.                     $dqlAlias     = $e->identificationVariable;
1748.                     $class        = $this->getMetadataForDqlAlias($dqlAlias);
1749.                     $fieldName    = $e->field;
1750.                     $fieldMapping = $class->fieldMappings[$fieldName];
1751.                     $fieldType    = $fieldMapping['type'];
1752.                     $col          = trim($e->dispatch($this));
1754.                     if (isset($fieldMapping['requireSQLConversion'])) {
1755.                         $type = Type::getType($fieldType);
1756.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
1757.                     }
1759.                     $sqlSelectExpressions[] = $col . ' AS ' . $columnAlias;
1761.                     if (! empty($fieldMapping['enumType'])) {
1762.                         $this->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
1763.                     }
1765.                     break;
1767.                 case $e instanceof AST\Literal:
1768.                     switch ($e->type) {
1769.                         case AST\Literal::BOOLEAN:
1770.                             $fieldType = 'boolean';
1771.                             break;
1773.                         case AST\Literal::NUMERIC:
1774.                             $fieldType = is_float($e->value) ? 'float' : 'integer';
1775.                             break;
1776.                     }
1778.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
1779.                     break;
1781.                 default:
1782.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
1783.                     break;
1784.             }
1786.             $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
1787.             $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldType);
1789.             $this->rsm->newObjectMappings[$columnAlias] = [
1790.                 'className' => $newObjectExpression->className,
1791.                 'objIndex'  => $objIndex,
1792.                 'argIndex'  => $argIndex,
1793.             ];
1794.         }
1796.         return implode(', ', $sqlSelectExpressions);
1797.     }
1799.     /**
1800.      * Walks down a SimpleSelectExpression AST node, thereby generating the appropriate SQL.
1801.      *
1802.      * @param AST\SimpleSelectExpression $simpleSelectExpression
1803.      *
1804.      * @return string
1805.      *
1806.      * @not-deprecated
1807.      */
1808.     public function walkSimpleSelectExpression($simpleSelectExpression)
1809.     {
1810.         $expr = $simpleSelectExpression->expression;
1811.         $sql  = ' ';
1813.         switch (true) {
1814.             case $expr instanceof AST\PathExpression:
1815.                 $sql .= $this->walkPathExpression($expr);
1816.                 break;
1818.             case $expr instanceof AST\Subselect:
1819.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
1821.                 $columnAlias                        = 'sclr' . $this->aliasCounter++;
1822.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
1824.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
1825.                 break;
1827.             case $expr instanceof AST\Functions\FunctionNode:
1828.             case $expr instanceof AST\SimpleArithmeticExpression:
1829.             case $expr instanceof AST\ArithmeticTerm:
1830.             case $expr instanceof AST\ArithmeticFactor:
1831.             case $expr instanceof AST\Literal:
1832.             case $expr instanceof AST\NullIfExpression:
1833.             case $expr instanceof AST\CoalesceExpression:
1834.             case $expr instanceof AST\GeneralCaseExpression:
1835.             case $expr instanceof AST\SimpleCaseExpression:
1836.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
1838.                 $columnAlias                        = $this->getSQLColumnAlias('sclr');
1839.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
1841.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
1842.                 break;
1844.             case $expr instanceof AST\ParenthesisExpression:
1845.                 $sql .= $this->walkParenthesisExpression($expr);
1846.                 break;
1848.             default: // IdentificationVariable
1849.                 $sql .= $this->walkEntityIdentificationVariable($expr);
1850.                 break;
1851.         }
1853.         return $sql;
1854.     }
1856.     /**
1857.      * Walks down an AggregateExpression AST node, thereby generating the appropriate SQL.
1858.      *
1859.      * @param AST\AggregateExpression $aggExpression
1860.      *
1861.      * @return string
1862.      *
1863.      * @not-deprecated
1864.      */
1865.     public function walkAggregateExpression($aggExpression)
1866.     {
1867.         return $aggExpression->functionName . '(' . ($aggExpression->isDistinct ? 'DISTINCT ' : '')
1868.             . $this->walkSimpleArithmeticExpression($aggExpression->pathExpression) . ')';
1869.     }
1871.     /**
1872.      * Walks down a GroupByClause AST node, thereby generating the appropriate SQL.
1873.      *
1874.      * @param AST\GroupByClause $groupByClause
1875.      *
1876.      * @return string
1877.      *
1878.      * @not-deprecated
1879.      */
1880.     public function walkGroupByClause($groupByClause)
1881.     {
1882.         $sqlParts = [];
1884.         foreach ($groupByClause->groupByItems as $groupByItem) {
1885.             $sqlParts[] = $this->walkGroupByItem($groupByItem);
1886.         }
1888.         return ' GROUP BY ' . implode(', ', $sqlParts);
1889.     }
1891.     /**
1892.      * Walks down a GroupByItem AST node, thereby generating the appropriate SQL.
1893.      *
1894.      * @param AST\PathExpression|string $groupByItem
1895.      *
1896.      * @return string
1897.      *
1898.      * @not-deprecated
1899.      */
1900.     public function walkGroupByItem($groupByItem)
1901.     {
1902.         // StateFieldPathExpression
1903.         if (! is_string($groupByItem)) {
1904.             return $this->walkPathExpression($groupByItem);
1905.         }
1907.         // ResultVariable
1908.         if (isset($this->queryComponents[$groupByItem]['resultVariable'])) {
1909.             $resultVariable = $this->queryComponents[$groupByItem]['resultVariable'];
1911.             if ($resultVariable instanceof AST\PathExpression) {
1912.                 return $this->walkPathExpression($resultVariable);
1913.             }
1915.             if ($resultVariable instanceof AST\Node && isset($resultVariable->pathExpression)) {
1916.                 return $this->walkPathExpression($resultVariable->pathExpression);
1917.             }
1919.             return $this->walkResultVariable($groupByItem);
1920.         }
1922.         // IdentificationVariable
1923.         $sqlParts = [];
1925.         foreach ($this->getMetadataForDqlAlias($groupByItem)->fieldNames as $field) {
1926.             $item       = new AST\PathExpression(AST\PathExpression::TYPE_STATE_FIELD, $groupByItem, $field);
1927.             $item->type = AST\PathExpression::TYPE_STATE_FIELD;
1929.             $sqlParts[] = $this->walkPathExpression($item);
1930.         }
1932.         foreach ($this->getMetadataForDqlAlias($groupByItem)->associationMappings as $mapping) {
1933.             if ($mapping['isOwningSide'] && $mapping['type'] & ClassMetadata::TO_ONE) {
1934.                 $item       = new AST\PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION, $groupByItem, $mapping['fieldName']);
1935.                 $item->type = AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION;
1937.                 $sqlParts[] = $this->walkPathExpression($item);
1938.             }
1939.         }
1941.         return implode(', ', $sqlParts);
1942.     }
1944.     /**
1945.      * Walks down a DeleteClause AST node, thereby generating the appropriate SQL.
1946.      *
1947.      * @return string
1948.      *
1949.      * @not-deprecated
1950.      */
1951.     public function walkDeleteClause(AST\DeleteClause $deleteClause)
1952.     {
1953.         $class     = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
1954.         $tableName = $class->getTableName();
1955.         $sql       = 'DELETE FROM ' . $this->quoteStrategy->getTableName($class, $this->platform);
1957.         $this->setSQLTableAlias($tableName, $tableName, $deleteClause->aliasIdentificationVariable);
1958.         $this->rootAliases[] = $deleteClause->aliasIdentificationVariable;
1960.         return $sql;
1961.     }
1963.     /**
1964.      * Walks down an UpdateClause AST node, thereby generating the appropriate SQL.
1965.      *
1966.      * @param AST\UpdateClause $updateClause
1967.      *
1968.      * @return string
1969.      *
1970.      * @not-deprecated
1971.      */
1972.     public function walkUpdateClause($updateClause)
1973.     {
1974.         $class     = $this->em->getClassMetadata($updateClause->abstractSchemaName);
1975.         $tableName = $class->getTableName();
1976.         $sql       = 'UPDATE ' . $this->quoteStrategy->getTableName($class, $this->platform);
1978.         $this->setSQLTableAlias($tableName, $tableName, $updateClause->aliasIdentificationVariable);
1979.         $this->rootAliases[] = $updateClause->aliasIdentificationVariable;
1981.         return $sql . ' SET ' . implode(', ', array_map([$this, 'walkUpdateItem'], $updateClause->updateItems));
1982.     }
1984.     /**
1985.      * Walks down an UpdateItem AST node, thereby generating the appropriate SQL.
1986.      *
1987.      * @param AST\UpdateItem $updateItem
1988.      *
1989.      * @return string
1990.      *
1991.      * @not-deprecated
1992.      */
1993.     public function walkUpdateItem($updateItem)
1994.     {
1995.         $useTableAliasesBefore    = $this->useSqlTableAliases;
1996.         $this->useSqlTableAliases = false;
1998.         $sql      = $this->walkPathExpression($updateItem->pathExpression) . ' = ';
1999.         $newValue = $updateItem->newValue;
2001.         switch (true) {
2002.             case $newValue instanceof AST\Node:
2003.                 $sql .= $newValue->dispatch($this);
2004.                 break;
2006.             case $newValue === null:
2007.                 $sql .= 'NULL';
2008.                 break;
2010.             default:
2011.                 $sql .= $this->conn->quote($newValue);
2012.                 break;
2013.         }
2015.         $this->useSqlTableAliases = $useTableAliasesBefore;
2017.         return $sql;
2018.     }
2020.     /**
2021.      * Walks down a WhereClause AST node, thereby generating the appropriate SQL.
2022.      * WhereClause or not, the appropriate discriminator sql is added.
2023.      *
2024.      * @param AST\WhereClause $whereClause
2025.      *
2026.      * @return string
2027.      *
2028.      * @not-deprecated
2029.      */
2030.     public function walkWhereClause($whereClause)
2031.     {
2032.         $condSql  = $whereClause !== null ? $this->walkConditionalExpression($whereClause->conditionalExpression) : '';
2033.         $discrSql = $this->generateDiscriminatorColumnConditionSQL($this->rootAliases);
2035.         if ($this->em->hasFilters()) {
2036.             $filterClauses = [];
2037.             foreach ($this->rootAliases as $dqlAlias) {
2038.                 $class      = $this->getMetadataForDqlAlias($dqlAlias);
2039.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
2041.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
2042.                 if ($filterExpr) {
2043.                     $filterClauses[] = $filterExpr;
2044.                 }
2045.             }
2047.             if (count($filterClauses)) {
2048.                 if ($condSql) {
2049.                     $condSql = '(' . $condSql . ') AND ';
2050.                 }
2052.                 $condSql .= implode(' AND ', $filterClauses);
2053.             }
2054.         }
2056.         if ($condSql) {
2057.             return ' WHERE ' . (! $discrSql ? $condSql : '(' . $condSql . ') AND ' . $discrSql);
2058.         }
2060.         if ($discrSql) {
2061.             return ' WHERE ' . $discrSql;
2062.         }
2064.         return '';
2065.     }
2067.     /**
2068.      * Walk down a ConditionalExpression AST node, thereby generating the appropriate SQL.
2069.      *
2070.      * @param AST\ConditionalExpression|AST\Phase2OptimizableConditional $condExpr
2071.      *
2072.      * @return string
2073.      *
2074.      * @not-deprecated
2075.      */
2076.     public function walkConditionalExpression($condExpr)
2077.     {
2078.         // Phase 2 AST optimization: Skip processing of ConditionalExpression
2079.         // if only one ConditionalTerm is defined
2080.         if (! ($condExpr instanceof AST\ConditionalExpression)) {
2081.             return $this->walkConditionalTerm($condExpr);
2082.         }
2084.         return implode(' OR ', array_map([$this, 'walkConditionalTerm'], $condExpr->conditionalTerms));
2085.     }
2087.     /**
2088.      * Walks down a ConditionalTerm AST node, thereby generating the appropriate SQL.
2089.      *
2090.      * @param AST\ConditionalTerm|AST\ConditionalFactor|AST\ConditionalPrimary $condTerm
2091.      *
2092.      * @return string
2093.      *
2094.      * @not-deprecated
2095.      */
2096.     public function walkConditionalTerm($condTerm)
2097.     {
2098.         // Phase 2 AST optimization: Skip processing of ConditionalTerm
2099.         // if only one ConditionalFactor is defined
2100.         if (! ($condTerm instanceof AST\ConditionalTerm)) {
2101.             return $this->walkConditionalFactor($condTerm);
2102.         }
2104.         return implode(' AND ', array_map([$this, 'walkConditionalFactor'], $condTerm->conditionalFactors));
2105.     }
2107.     /**
2108.      * Walks down a ConditionalFactor AST node, thereby generating the appropriate SQL.
2109.      *
2110.      * @param AST\ConditionalFactor|AST\ConditionalPrimary $factor
2111.      *
2112.      * @return string The SQL.
2113.      *
2114.      * @not-deprecated
2115.      */
2116.     public function walkConditionalFactor($factor)
2117.     {
2118.         // Phase 2 AST optimization: Skip processing of ConditionalFactor
2119.         // if only one ConditionalPrimary is defined
2120.         return ! ($factor instanceof AST\ConditionalFactor)
2121.             ? $this->walkConditionalPrimary($factor)
2122.             : ($factor->not ? 'NOT ' : '') . $this->walkConditionalPrimary($factor->conditionalPrimary);
2123.     }
2125.     /**
2126.      * Walks down a ConditionalPrimary AST node, thereby generating the appropriate SQL.
2127.      *
2128.      * @param AST\ConditionalPrimary $primary
2129.      *
2130.      * @return string
2131.      *
2132.      * @not-deprecated
2133.      */
2134.     public function walkConditionalPrimary($primary)
2135.     {
2136.         if ($primary->isSimpleConditionalExpression()) {
2137.             return $primary->simpleConditionalExpression->dispatch($this);
2138.         }
2140.         if ($primary->isConditionalExpression()) {
2141.             $condExpr = $primary->conditionalExpression;
2143.             return '(' . $this->walkConditionalExpression($condExpr) . ')';
2144.         }
2145.     }
2147.     /**
2148.      * Walks down an ExistsExpression AST node, thereby generating the appropriate SQL.
2149.      *
2150.      * @param AST\ExistsExpression $existsExpr
2151.      *
2152.      * @return string
2153.      *
2154.      * @not-deprecated
2155.      */
2156.     public function walkExistsExpression($existsExpr)
2157.     {
2158.         $sql = $existsExpr->not ? 'NOT ' : '';
2160.         $sql .= 'EXISTS (' . $this->walkSubselect($existsExpr->subselect) . ')';
2162.         return $sql;
2163.     }
2165.     /**
2166.      * Walks down a CollectionMemberExpression AST node, thereby generating the appropriate SQL.
2167.      *
2168.      * @param AST\CollectionMemberExpression $collMemberExpr
2169.      *
2170.      * @return string
2171.      *
2172.      * @not-deprecated
2173.      */
2174.     public function walkCollectionMemberExpression($collMemberExpr)
2175.     {
2176.         $sql  = $collMemberExpr->not ? 'NOT ' : '';
2177.         $sql .= 'EXISTS (SELECT 1 FROM ';
2179.         $entityExpr   = $collMemberExpr->entityExpression;
2180.         $collPathExpr = $collMemberExpr->collectionValuedPathExpression;
2181.         assert($collPathExpr->field !== null);
2183.         $fieldName = $collPathExpr->field;
2184.         $dqlAlias  = $collPathExpr->identificationVariable;
2186.         $class = $this->getMetadataForDqlAlias($dqlAlias);
2188.         switch (true) {
2189.             // InputParameter
2190.             case $entityExpr instanceof AST\InputParameter:
2191.                 $dqlParamKey = $entityExpr->name;
2192.                 $entitySql   = '?';
2193.                 break;
2195.             // SingleValuedAssociationPathExpression | IdentificationVariable
2196.             case $entityExpr instanceof AST\PathExpression:
2197.                 $entitySql = $this->walkPathExpression($entityExpr);
2198.                 break;
2200.             default:
2201.                 throw new BadMethodCallException('Not implemented');
2202.         }
2204.         $assoc = $class->associationMappings[$fieldName];
2206.         if ($assoc['type'] === ClassMetadata::ONE_TO_MANY) {
2207.             $targetClass      = $this->em->getClassMetadata($assoc['targetEntity']);
2208.             $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName());
2209.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
2211.             $sql .= $this->quoteStrategy->getTableName($targetClass, $this->platform) . ' ' . $targetTableAlias . ' WHERE ';
2213.             $owningAssoc = $targetClass->associationMappings[$assoc['mappedBy']];
2214.             $sqlParts    = [];
2216.             foreach ($owningAssoc['targetToSourceKeyColumns'] as $targetColumn => $sourceColumn) {
2217.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$targetColumn], $class, $this->platform);
2219.                 $sqlParts[] = $sourceTableAlias . '.' . $targetColumn . ' = ' . $targetTableAlias . '.' . $sourceColumn;
2220.             }
2222.             foreach ($this->quoteStrategy->getIdentifierColumnNames($targetClass, $this->platform) as $targetColumnName) {
2223.                 if (isset($dqlParamKey)) {
2224.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
2225.                 }
2227.                 $sqlParts[] = $targetTableAlias . '.' . $targetColumnName . ' = ' . $entitySql;
2228.             }
2230.             $sql .= implode(' AND ', $sqlParts);
2231.         } else { // many-to-many
2232.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
2234.             $owningAssoc = $assoc['isOwningSide'] ? $assoc : $targetClass->associationMappings[$assoc['mappedBy']];
2235.             $joinTable   = $owningAssoc['joinTable'];
2237.             // SQL table aliases
2238.             $joinTableAlias   = $this->getSQLTableAlias($joinTable['name']);
2239.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
2241.             $sql .= $this->quoteStrategy->getJoinTableName($owningAssoc, $targetClass, $this->platform) . ' ' . $joinTableAlias . ' WHERE ';
2243.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['joinColumns'] : $joinTable['inverseJoinColumns'];
2244.             $sqlParts    = [];
2246.             foreach ($joinColumns as $joinColumn) {
2247.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$joinColumn['referencedColumnName']], $class, $this->platform);
2249.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' = ' . $sourceTableAlias . '.' . $targetColumn;
2250.             }
2252.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['inverseJoinColumns'] : $joinTable['joinColumns'];
2254.             foreach ($joinColumns as $joinColumn) {
2255.                 if (isset($dqlParamKey)) {
2256.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
2257.                 }
2259.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' IN (' . $entitySql . ')';
2260.             }
2262.             $sql .= implode(' AND ', $sqlParts);
2263.         }
2265.         return $sql . ')';
2266.     }
2268.     /**
2269.      * Walks down an EmptyCollectionComparisonExpression AST node, thereby generating the appropriate SQL.
2270.      *
2271.      * @param AST\EmptyCollectionComparisonExpression $emptyCollCompExpr
2272.      *
2273.      * @return string
2274.      *
2275.      * @not-deprecated
2276.      */
2277.     public function walkEmptyCollectionComparisonExpression($emptyCollCompExpr)
2278.     {
2279.         $sizeFunc                           = new AST\Functions\SizeFunction('size');
2280.         $sizeFunc->collectionPathExpression = $emptyCollCompExpr->expression;
2282.         return $sizeFunc->getSql($this) . ($emptyCollCompExpr->not ? ' > 0' : ' = 0');
2283.     }
2285.     /**
2286.      * Walks down a NullComparisonExpression AST node, thereby generating the appropriate SQL.
2287.      *
2288.      * @param AST\NullComparisonExpression $nullCompExpr
2289.      *
2290.      * @return string
2291.      *
2292.      * @not-deprecated
2293.      */
2294.     public function walkNullComparisonExpression($nullCompExpr)
2295.     {
2296.         $expression = $nullCompExpr->expression;
2297.         $comparison = ' IS' . ($nullCompExpr->not ? ' NOT' : '') . ' NULL';
2299.         // Handle ResultVariable
2300.         if (is_string($expression) && isset($this->queryComponents[$expression]['resultVariable'])) {
2301.             return $this->walkResultVariable($expression) . $comparison;
2302.         }
2304.         // Handle InputParameter mapping inclusion to ParserResult
2305.         if ($expression instanceof AST\InputParameter) {
2306.             return $this->walkInputParameter($expression) . $comparison;
2307.         }
2309.         return $expression->dispatch($this) . $comparison;
2310.     }
2312.     /**
2313.      * Walks down an InExpression AST node, thereby generating the appropriate SQL.
2314.      *
2315.      * @deprecated Use {@see walkInListExpression()} or {@see walkInSubselectExpression()} instead.
2316.      *
2317.      * @param AST\InExpression $inExpr
2318.      *
2319.      * @return string
2320.      */
2321.     public function walkInExpression($inExpr)
2322.     {
2323.         Deprecation::triggerIfCalledFromOutside(
2324.             'doctrine/orm',
2325.             'https://github.com/doctrine/orm/pull/10267',
2326.             '%s() is deprecated, call walkInListExpression() or walkInSubselectExpression() instead.',
2327.             __METHOD__
2328.         );
2330.         if ($inExpr instanceof AST\InListExpression) {
2331.             return $this->walkInListExpression($inExpr);
2332.         }
2334.         if ($inExpr instanceof AST\InSubselectExpression) {
2335.             return $this->walkInSubselectExpression($inExpr);
2336.         }
2338.         $sql = $this->walkArithmeticExpression($inExpr->expression) . ($inExpr->not ? ' NOT' : '') . ' IN (';
2340.         $sql .= $inExpr->subselect
2341.             ? $this->walkSubselect($inExpr->subselect)
2342.             : implode(', ', array_map([$this, 'walkInParameter'], $inExpr->literals));
2344.         $sql .= ')';
2346.         return $sql;
2347.     }
2349.     /**
2350.      * Walks down an InExpression AST node, thereby generating the appropriate SQL.
2351.      */
2352.     public function walkInListExpression(AST\InListExpression $inExpr): string
2353.     {
2354.         return $this->walkArithmeticExpression($inExpr->expression)
2355.             . ($inExpr->not ? ' NOT' : '') . ' IN ('
2356.             . implode(', ', array_map([$this, 'walkInParameter'], $inExpr->literals))
2357.             . ')';
2358.     }
2360.     /**
2361.      * Walks down an InExpression AST node, thereby generating the appropriate SQL.
2362.      */
2363.     public function walkInSubselectExpression(AST\InSubselectExpression $inExpr): string
2364.     {
2365.         return $this->walkArithmeticExpression($inExpr->expression)
2366.             . ($inExpr->not ? ' NOT' : '') . ' IN ('
2367.             . $this->walkSubselect($inExpr->subselect)
2368.             . ')';
2369.     }
2371.     /**
2372.      * Walks down an InstanceOfExpression AST node, thereby generating the appropriate SQL.
2373.      *
2374.      * @param AST\InstanceOfExpression $instanceOfExpr
2375.      *
2376.      * @return string
2377.      *
2378.      * @throws QueryException
2379.      *
2380.      * @not-deprecated
2381.      */
2382.     public function walkInstanceOfExpression($instanceOfExpr)
2383.     {
2384.         $sql = '';
2386.         $dqlAlias   = $instanceOfExpr->identificationVariable;
2387.         $discrClass = $class = $this->getMetadataForDqlAlias($dqlAlias);
2389.         if ($class->discriminatorColumn) {
2390.             $discrClass = $this->em->getClassMetadata($class->rootEntityName);
2391.         }
2393.         if ($this->useSqlTableAliases) {
2394.             $sql .= $this->getSQLTableAlias($discrClass->getTableName(), $dqlAlias) . '.';
2395.         }
2397.         $sql .= $class->getDiscriminatorColumn()['name'] . ($instanceOfExpr->not ? ' NOT IN ' : ' IN ');
2398.         $sql .= $this->getChildDiscriminatorsFromClassMetadata($discrClass, $instanceOfExpr);
2400.         return $sql;
2401.     }
2403.     /**
2404.      * @param mixed $inParam
2405.      *
2406.      * @return string
2407.      *
2408.      * @not-deprecated
2409.      */
2410.     public function walkInParameter($inParam)
2411.     {
2412.         return $inParam instanceof AST\InputParameter
2413.             ? $this->walkInputParameter($inParam)
2414.             : $this->walkArithmeticExpression($inParam);
2415.     }
2417.     /**
2418.      * Walks down a literal that represents an AST node, thereby generating the appropriate SQL.
2419.      *
2420.      * @param AST\Literal $literal
2421.      *
2422.      * @return string
2423.      *
2424.      * @not-deprecated
2425.      */
2426.     public function walkLiteral($literal)
2427.     {
2428.         switch ($literal->type) {
2429.             case AST\Literal::STRING:
2430.                 return $this->conn->quote($literal->value);
2432.             case AST\Literal::BOOLEAN:
2433.                 return (string) $this->conn->getDatabasePlatform()->convertBooleans(strtolower($literal->value) === 'true');
2435.             case AST\Literal::NUMERIC:
2436.                 return (string) $literal->value;
2438.             default:
2439.                 throw QueryException::invalidLiteral($literal);
2440.         }
2441.     }
2443.     /**
2444.      * Walks down a BetweenExpression AST node, thereby generating the appropriate SQL.
2445.      *
2446.      * @param AST\BetweenExpression $betweenExpr
2447.      *
2448.      * @return string
2449.      *
2450.      * @not-deprecated
2451.      */
2452.     public function walkBetweenExpression($betweenExpr)
2453.     {
2454.         $sql = $this->walkArithmeticExpression($betweenExpr->expression);
2456.         if ($betweenExpr->not) {
2457.             $sql .= ' NOT';
2458.         }
2460.         $sql .= ' BETWEEN ' . $this->walkArithmeticExpression($betweenExpr->leftBetweenExpression)
2461.             . ' AND ' . $this->walkArithmeticExpression($betweenExpr->rightBetweenExpression);
2463.         return $sql;
2464.     }
2466.     /**
2467.      * Walks down a LikeExpression AST node, thereby generating the appropriate SQL.
2468.      *
2469.      * @param AST\LikeExpression $likeExpr
2470.      *
2471.      * @return string
2472.      *
2473.      * @not-deprecated
2474.      */
2475.     public function walkLikeExpression($likeExpr)
2476.     {
2477.         $stringExpr = $likeExpr->stringExpression;
2478.         if (is_string($stringExpr)) {
2479.             if (! isset($this->queryComponents[$stringExpr]['resultVariable'])) {
2480.                 throw new LogicException(sprintf('No result variable found for string expression "%s".', $stringExpr));
2481.             }
2483.             $leftExpr = $this->walkResultVariable($stringExpr);
2484.         } else {
2485.             $leftExpr = $stringExpr->dispatch($this);
2486.         }
2488.         $sql = $leftExpr . ($likeExpr->not ? ' NOT' : '') . ' LIKE ';
2490.         if ($likeExpr->stringPattern instanceof AST\InputParameter) {
2491.             $sql .= $this->walkInputParameter($likeExpr->stringPattern);
2492.         } elseif ($likeExpr->stringPattern instanceof AST\Functions\FunctionNode) {
2493.             $sql .= $this->walkFunction($likeExpr->stringPattern);
2494.         } elseif ($likeExpr->stringPattern instanceof AST\PathExpression) {
2495.             $sql .= $this->walkPathExpression($likeExpr->stringPattern);
2496.         } else {
2497.             $sql .= $this->walkLiteral($likeExpr->stringPattern);
2498.         }
2500.         if ($likeExpr->escapeChar) {
2501.             $sql .= ' ESCAPE ' . $this->walkLiteral($likeExpr->escapeChar);
2502.         }
2504.         return $sql;
2505.     }
2507.     /**
2508.      * Walks down a StateFieldPathExpression AST node, thereby generating the appropriate SQL.
2509.      *
2510.      * @param AST\PathExpression $stateFieldPathExpression
2511.      *
2512.      * @return string
2513.      *
2514.      * @not-deprecated
2515.      */
2516.     public function walkStateFieldPathExpression($stateFieldPathExpression)
2517.     {
2518.         return $this->walkPathExpression($stateFieldPathExpression);
2519.     }
2521.     /**
2522.      * Walks down a ComparisonExpression AST node, thereby generating the appropriate SQL.
2523.      *
2524.      * @param AST\ComparisonExpression $compExpr
2525.      *
2526.      * @return string
2527.      *
2528.      * @not-deprecated
2529.      */
2530.     public function walkComparisonExpression($compExpr)
2531.     {
2532.         $leftExpr  = $compExpr->leftExpression;
2533.         $rightExpr = $compExpr->rightExpression;
2534.         $sql       = '';
2536.         $sql .= $leftExpr instanceof AST\Node
2537.             ? $leftExpr->dispatch($this)
2538.             : (is_numeric($leftExpr) ? $leftExpr : $this->conn->quote($leftExpr));
2540.         $sql .= ' ' . $compExpr->operator . ' ';
2542.         $sql .= $rightExpr instanceof AST\Node
2543.             ? $rightExpr->dispatch($this)
2544.             : (is_numeric($rightExpr) ? $rightExpr : $this->conn->quote($rightExpr));
2546.         return $sql;
2547.     }
2549.     /**
2550.      * Walks down an InputParameter AST node, thereby generating the appropriate SQL.
2551.      *
2552.      * @param AST\InputParameter $inputParam
2553.      *
2554.      * @return string
2555.      *
2556.      * @not-deprecated
2557.      */
2558.     public function walkInputParameter($inputParam)
2559.     {
2560.         $this->parserResult->addParameterMapping($inputParam->name, $this->sqlParamIndex++);
2562.         $parameter = $this->query->getParameter($inputParam->name);
2564.         if ($parameter) {
2565.             $type = $parameter->getType();
2566.             if (Type::hasType($type)) {
2567.                 return Type::getType($type)->convertToDatabaseValueSQL('?', $this->platform);
2568.             }
2569.         }
2571.         return '?';
2572.     }
2574.     /**
2575.      * Walks down an ArithmeticExpression AST node, thereby generating the appropriate SQL.
2576.      *
2577.      * @param AST\ArithmeticExpression $arithmeticExpr
2578.      *
2579.      * @return string
2580.      *
2581.      * @not-deprecated
2582.      */
2583.     public function walkArithmeticExpression($arithmeticExpr)
2584.     {
2585.         return $arithmeticExpr->isSimpleArithmeticExpression()
2586.             ? $this->walkSimpleArithmeticExpression($arithmeticExpr->simpleArithmeticExpression)
2587.             : '(' . $this->walkSubselect($arithmeticExpr->subselect) . ')';
2588.     }
2590.     /**
2591.      * Walks down an SimpleArithmeticExpression AST node, thereby generating the appropriate SQL.
2592.      *
2593.      * @param AST\Node|string $simpleArithmeticExpr
2594.      *
2595.      * @return string
2596.      *
2597.      * @not-deprecated
2598.      */
2599.     public function walkSimpleArithmeticExpression($simpleArithmeticExpr)
2600.     {
2601.         if (! ($simpleArithmeticExpr instanceof AST\SimpleArithmeticExpression)) {
2602.             return $this->walkArithmeticTerm($simpleArithmeticExpr);
2603.         }
2605.         return implode(' ', array_map([$this, 'walkArithmeticTerm'], $simpleArithmeticExpr->arithmeticTerms));
2606.     }
2608.     /**
2609.      * Walks down an ArithmeticTerm AST node, thereby generating the appropriate SQL.
2610.      *
2611.      * @param mixed $term
2612.      *
2613.      * @return string
2614.      *
2615.      * @not-deprecated
2616.      */
2617.     public function walkArithmeticTerm($term)
2618.     {
2619.         if (is_string($term)) {
2620.             return isset($this->queryComponents[$term])
2621.                 ? $this->walkResultVariable($this->queryComponents[$term]['token']->value)
2622.                 : $term;
2623.         }
2625.         // Phase 2 AST optimization: Skip processing of ArithmeticTerm
2626.         // if only one ArithmeticFactor is defined
2627.         if (! ($term instanceof AST\ArithmeticTerm)) {
2628.             return $this->walkArithmeticFactor($term);
2629.         }
2631.         return implode(' ', array_map([$this, 'walkArithmeticFactor'], $term->arithmeticFactors));
2632.     }
2634.     /**
2635.      * Walks down an ArithmeticFactor that represents an AST node, thereby generating the appropriate SQL.
2636.      *
2637.      * @param mixed $factor
2638.      *
2639.      * @return string
2640.      *
2641.      * @not-deprecated
2642.      */
2643.     public function walkArithmeticFactor($factor)
2644.     {
2645.         if (is_string($factor)) {
2646.             return isset($this->queryComponents[$factor])
2647.                 ? $this->walkResultVariable($this->queryComponents[$factor]['token']->value)
2648.                 : $factor;
2649.         }
2651.         // Phase 2 AST optimization: Skip processing of ArithmeticFactor
2652.         // if only one ArithmeticPrimary is defined
2653.         if (! ($factor instanceof AST\ArithmeticFactor)) {
2654.             return $this->walkArithmeticPrimary($factor);
2655.         }
2657.         $sign = $factor->isNegativeSigned() ? '-' : ($factor->isPositiveSigned() ? '+' : '');
2659.         return $sign . $this->walkArithmeticPrimary($factor->arithmeticPrimary);
2660.     }
2662.     /**
2663.      * Walks down an ArithmeticPrimary that represents an AST node, thereby generating the appropriate SQL.
2664.      *
2665.      * @param mixed $primary
2666.      *
2667.      * @return string The SQL.
2668.      *
2669.      * @not-deprecated
2670.      */
2671.     public function walkArithmeticPrimary($primary)
2672.     {
2673.         if ($primary instanceof AST\SimpleArithmeticExpression) {
2674.             return '(' . $this->walkSimpleArithmeticExpression($primary) . ')';
2675.         }
2677.         if ($primary instanceof AST\Node) {
2678.             return $primary->dispatch($this);
2679.         }
2681.         return $this->walkEntityIdentificationVariable($primary);
2682.     }
2684.     /**
2685.      * Walks down a StringPrimary that represents an AST node, thereby generating the appropriate SQL.
2686.      *
2687.      * @param mixed $stringPrimary
2688.      *
2689.      * @return string
2690.      *
2691.      * @not-deprecated
2692.      */
2693.     public function walkStringPrimary($stringPrimary)
2694.     {
2695.         return is_string($stringPrimary)
2696.             ? $this->conn->quote($stringPrimary)
2697.             : $stringPrimary->dispatch($this);
2698.     }
2700.     /**
2701.      * Walks down a ResultVariable that represents an AST node, thereby generating the appropriate SQL.
2702.      *
2703.      * @param string $resultVariable
2704.      *
2705.      * @return string
2706.      *
2707.      * @not-deprecated
2708.      */
2709.     public function walkResultVariable($resultVariable)
2710.     {
2711.         if (! isset($this->scalarResultAliasMap[$resultVariable])) {
2712.             throw new InvalidArgumentException(sprintf('Unknown result variable: %s', $resultVariable));
2713.         }
2715.         $resultAlias = $this->scalarResultAliasMap[$resultVariable];
2717.         if (is_array($resultAlias)) {
2718.             return implode(', ', $resultAlias);
2719.         }
2721.         return $resultAlias;
2722.     }
2724.     /**
2725.      * @return string The list in parentheses of valid child discriminators from the given class
2726.      *
2727.      * @throws QueryException
2728.      */
2729.     private function getChildDiscriminatorsFromClassMetadata(
2730.         ClassMetadata $rootClass,
2731.         AST\InstanceOfExpression $instanceOfExpr
2732.     ): string {
2733.         $sqlParameterList = [];
2734.         $discriminators   = [];
2735.         foreach ($instanceOfExpr->value as $parameter) {
2736.             if ($parameter instanceof AST\InputParameter) {
2737.                 $this->rsm->discriminatorParameters[$parameter->name] = $parameter->name;
2738.                 $sqlParameterList[]                                   = $this->walkInParameter($parameter);
2739.                 continue;
2740.             }
2742.             $metadata = $this->em->getClassMetadata($parameter);
2744.             if ($metadata->getName() !== $rootClass->name && ! $metadata->getReflectionClass()->isSubclassOf($rootClass->name)) {
2745.                 throw QueryException::instanceOfUnrelatedClass($parameter, $rootClass->name);
2746.             }
2748.             $discriminators += HierarchyDiscriminatorResolver::resolveDiscriminatorsForClass($metadata, $this->em);
2749.         }
2751.         foreach (array_keys($discriminators) as $dis) {
2752.             $sqlParameterList[] = $this->conn->quote($dis);
2753.         }
2755.         return '(' . implode(', ', $sqlParameterList) . ')';
2756.     }
2757. }