1. <?php
3. declare(strict_types=1);
5. namespace Doctrine\ORM\Query;
7. use BadMethodCallException;
8. use Doctrine\DBAL\Connection;
9. use Doctrine\DBAL\LockMode;
10. use Doctrine\DBAL\Platforms\AbstractPlatform;
11. use Doctrine\DBAL\Types\Type;
12. use Doctrine\Deprecations\Deprecation;
13. use Doctrine\ORM\EntityManagerInterface;
14. use Doctrine\ORM\Mapping\ClassMetadata;
15. use Doctrine\ORM\Mapping\QuoteStrategy;
16. use Doctrine\ORM\OptimisticLockException;
17. use Doctrine\ORM\Query;
18. use Doctrine\ORM\Utility\HierarchyDiscriminatorResolver;
19. use Doctrine\ORM\Utility\PersisterHelper;
20. use InvalidArgumentException;
21. use LogicException;
23. use function array_diff;
24. use function array_filter;
25. use function array_keys;
26. use function array_map;
27. use function array_merge;
28. use function assert;
29. use function count;
30. use function implode;
31. use function in_array;
32. use function is_array;
33. use function is_float;
34. use function is_numeric;
35. use function is_string;
36. use function preg_match;
37. use function reset;
38. use function sprintf;
39. use function strtolower;
40. use function strtoupper;
41. use function trim;
43. /**
44.  * The SqlWalker walks over a DQL AST and constructs the corresponding SQL.
45.  *
46.  * @psalm-import-type QueryComponent from Parser
47.  * @psalm-consistent-constructor
48.  */
49. class SqlWalker implements TreeWalker
50. {
51.     public const HINT_DISTINCT = 'doctrine.distinct';
53.     /**
54.      * Used to mark a query as containing a PARTIAL expression, which needs to be known by SLC.
55.      */
56.     public const HINT_PARTIAL = 'doctrine.partial';
58.     /** @var ResultSetMapping */
59.     private $rsm;
61.     /**
62.      * Counter for generating unique column aliases.
63.      *
64.      * @var int
65.      */
66.     private $aliasCounter = 0;
68.     /**
69.      * Counter for generating unique table aliases.
70.      *
71.      * @var int
72.      */
73.     private $tableAliasCounter = 0;
75.     /**
76.      * Counter for generating unique scalar result.
77.      *
78.      * @var int
79.      */
80.     private $scalarResultCounter = 1;
82.     /**
83.      * Counter for generating unique parameter indexes.
84.      *
85.      * @var int
86.      */
87.     private $sqlParamIndex = 0;
89.     /**
90.      * Counter for generating indexes.
91.      *
92.      * @var int
93.      */
94.     private $newObjectCounter = 0;
96.     /** @var ParserResult */
97.     private $parserResult;
99.     /** @var EntityManagerInterface */
100.     private $em;
102.     /** @var Connection */
103.     private $conn;
105.     /** @var Query */
106.     private $query;
108.     /** @var mixed[] */
109.     private $tableAliasMap = [];
111.     /**
112.      * Map from result variable names to their SQL column alias names.
113.      *
114.      * @psalm-var array<string|int, string|list<string>>
115.      */
116.     private $scalarResultAliasMap = [];
118.     /**
119.      * Map from Table-Alias + Column-Name to OrderBy-Direction.
120.      *
121.      * @var array<string, string>
122.      */
123.     private $orderedColumnsMap = [];
125.     /**
126.      * Map from DQL-Alias + Field-Name to SQL Column Alias.
127.      *
128.      * @var array<string, array<string, string>>
129.      */
130.     private $scalarFields = [];
132.     /**
133.      * Map of all components/classes that appear in the DQL query.
134.      *
135.      * @psalm-var array<string, QueryComponent>
136.      */
137.     private $queryComponents;
139.     /**
140.      * A list of classes that appear in non-scalar SelectExpressions.
141.      *
142.      * @psalm-var array<string, array{class: ClassMetadata, dqlAlias: string, resultAlias: string|null}>
143.      */
144.     private $selectedClasses = [];
146.     /**
147.      * The DQL alias of the root class of the currently traversed query.
148.      *
149.      * @psalm-var list<string>
150.      */
151.     private $rootAliases = [];
153.     /**
154.      * Flag that indicates whether to generate SQL table aliases in the SQL.
155.      * These should only be generated for SELECT queries, not for UPDATE/DELETE.
156.      *
157.      * @var bool
158.      */
159.     private $useSqlTableAliases = true;
161.     /**
162.      * The database platform abstraction.
163.      *
164.      * @var AbstractPlatform
165.      */
166.     private $platform;
168.     /**
169.      * The quote strategy.
170.      *
171.      * @var QuoteStrategy
172.      */
173.     private $quoteStrategy;
175.     /**
176.      * @param Query        $query        The parsed Query.
177.      * @param ParserResult $parserResult The result of the parsing process.
178.      * @psalm-param array<string, QueryComponent> $queryComponents The query components (symbol table).
179.      */
180.     public function __construct($query, $parserResult, array $queryComponents)
181.     {
182.         $this->query           = $query;
183.         $this->parserResult    = $parserResult;
184.         $this->queryComponents = $queryComponents;
185.         $this->rsm             = $parserResult->getResultSetMapping();
186.         $this->em              = $query->getEntityManager();
187.         $this->conn            = $this->em->getConnection();
188.         $this->platform        = $this->conn->getDatabasePlatform();
189.         $this->quoteStrategy   = $this->em->getConfiguration()->getQuoteStrategy();
190.     }
192.     /**
193.      * Gets the Query instance used by the walker.
194.      *
195.      * @return Query
196.      */
197.     public function getQuery()
198.     {
199.         return $this->query;
200.     }
202.     /**
203.      * Gets the Connection used by the walker.
204.      *
205.      * @return Connection
206.      */
207.     public function getConnection()
208.     {
209.         return $this->conn;
210.     }
212.     /**
213.      * Gets the EntityManager used by the walker.
214.      *
215.      * @return EntityManagerInterface
216.      */
217.     public function getEntityManager()
218.     {
219.         return $this->em;
220.     }
222.     /**
223.      * Gets the information about a single query component.
224.      *
225.      * @param string $dqlAlias The DQL alias.
226.      *
227.      * @return mixed[]
228.      * @psalm-return QueryComponent
229.      */
230.     public function getQueryComponent($dqlAlias)
231.     {
232.         return $this->queryComponents[$dqlAlias];
233.     }
235.     public function getMetadataForDqlAlias(string $dqlAlias): ClassMetadata
236.     {
237.         if (! isset($this->queryComponents[$dqlAlias]['metadata'])) {
238.             throw new LogicException(sprintf('No metadata for DQL alias: %s', $dqlAlias));
239.         }
241.         return $this->queryComponents[$dqlAlias]['metadata'];
242.     }
244.     /**
245.      * Returns internal queryComponents array.
246.      *
247.      * @return array<string, QueryComponent>
248.      */
249.     public function getQueryComponents()
250.     {
251.         return $this->queryComponents;
252.     }
254.     /**
255.      * Sets or overrides a query component for a given dql alias.
256.      *
257.      * @param string $dqlAlias The DQL alias.
258.      * @psalm-param QueryComponent $queryComponent
259.      *
260.      * @return void
261.      *
262.      * @not-deprecated
263.      */
264.     public function setQueryComponent($dqlAlias, array $queryComponent)
265.     {
266.         $requiredKeys = ['metadata', 'parent', 'relation', 'map', 'nestingLevel', 'token'];
268.         if (array_diff($requiredKeys, array_keys($queryComponent))) {
269.             throw QueryException::invalidQueryComponent($dqlAlias);
270.         }
272.         $this->queryComponents[$dqlAlias] = $queryComponent;
273.     }
275.     /**
276.      * Gets an executor that can be used to execute the result of this walker.
277.      *
278.      * @param AST\DeleteStatement|AST\UpdateStatement|AST\SelectStatement $AST
279.      *
280.      * @return Exec\AbstractSqlExecutor
281.      *
282.      * @not-deprecated
283.      */
284.     public function getExecutor($AST)
285.     {
286.         switch (true) {
287.             case $AST instanceof AST\DeleteStatement:
288.                 $primaryClass = $this->em->getClassMetadata($AST->deleteClause->abstractSchemaName);
290.                 return $primaryClass->isInheritanceTypeJoined()
291.                     ? new Exec\MultiTableDeleteExecutor($AST, $this)
292.                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
294.             case $AST instanceof AST\UpdateStatement:
295.                 $primaryClass = $this->em->getClassMetadata($AST->updateClause->abstractSchemaName);
297.                 return $primaryClass->isInheritanceTypeJoined()
298.                     ? new Exec\MultiTableUpdateExecutor($AST, $this)
299.                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
301.             default:
302.                 return new Exec\SingleSelectExecutor($AST, $this);
303.         }
304.     }
306.     /**
307.      * Generates a unique, short SQL table alias.
308.      *
309.      * @param string $tableName Table name
310.      * @param string $dqlAlias  The DQL alias.
311.      *
312.      * @return string Generated table alias.
313.      */
314.     public function getSQLTableAlias($tableName, $dqlAlias = '')
315.     {
316.         $tableName .= $dqlAlias ? '@[' . $dqlAlias . ']' : '';
318.         if (! isset($this->tableAliasMap[$tableName])) {
319.             $this->tableAliasMap[$tableName] = (preg_match('/[a-z]/i', $tableName[0]) ? strtolower($tableName[0]) : 't')
320.                 . $this->tableAliasCounter++ . '_';
321.         }
323.         return $this->tableAliasMap[$tableName];
324.     }
326.     /**
327.      * Forces the SqlWalker to use a specific alias for a table name, rather than
328.      * generating an alias on its own.
329.      *
330.      * @param string $tableName
331.      * @param string $alias
332.      * @param string $dqlAlias
333.      *
334.      * @return string
335.      */
336.     public function setSQLTableAlias($tableName, $alias, $dqlAlias = '')
337.     {
338.         $tableName .= $dqlAlias ? '@[' . $dqlAlias . ']' : '';
340.         $this->tableAliasMap[$tableName] = $alias;
342.         return $alias;
343.     }
345.     /**
346.      * Gets an SQL column alias for a column name.
347.      *
348.      * @param string $columnName
349.      *
350.      * @return string
351.      */
352.     public function getSQLColumnAlias($columnName)
353.     {
354.         return $this->quoteStrategy->getColumnAlias($columnName, $this->aliasCounter++, $this->platform);
355.     }
357.     /**
358.      * Generates the SQL JOINs that are necessary for Class Table Inheritance
359.      * for the given class.
360.      *
361.      * @param ClassMetadata $class    The class for which to generate the joins.
362.      * @param string        $dqlAlias The DQL alias of the class.
363.      *
364.      * @return string The SQL.
365.      */
366.     private function generateClassTableInheritanceJoins(
367.         ClassMetadata $class,
368.         string $dqlAlias
369.     ): string {
370.         $sql = '';
372.         $baseTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
374.         // INNER JOIN parent class tables
375.         foreach ($class->parentClasses as $parentClassName) {
376.             $parentClass = $this->em->getClassMetadata($parentClassName);
377.             $tableAlias  = $this->getSQLTableAlias($parentClass->getTableName(), $dqlAlias);
379.             // If this is a joined association we must use left joins to preserve the correct result.
380.             $sql .= isset($this->queryComponents[$dqlAlias]['relation']) ? ' LEFT ' : ' INNER ';
381.             $sql .= 'JOIN ' . $this->quoteStrategy->getTableName($parentClass, $this->platform) . ' ' . $tableAlias . ' ON ';
383.             $sqlParts = [];
385.             foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
386.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
387.             }
389.             // Add filters on the root class
390.             $sqlParts[] = $this->generateFilterConditionSQL($parentClass, $tableAlias);
392.             $sql .= implode(' AND ', array_filter($sqlParts));
393.         }
395.         // Ignore subclassing inclusion if partial objects is disallowed
396.         if ($this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
397.             return $sql;
398.         }
400.         // LEFT JOIN child class tables
401.         foreach ($class->subClasses as $subClassName) {
402.             $subClass   = $this->em->getClassMetadata($subClassName);
403.             $tableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
405.             $sql .= ' LEFT JOIN ' . $this->quoteStrategy->getTableName($subClass, $this->platform) . ' ' . $tableAlias . ' ON ';
407.             $sqlParts = [];
409.             foreach ($this->quoteStrategy->getIdentifierColumnNames($subClass, $this->platform) as $columnName) {
410.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
411.             }
413.             $sql .= implode(' AND ', $sqlParts);
414.         }
416.         return $sql;
417.     }
419.     private function generateOrderedCollectionOrderByItems(): string
420.     {
421.         $orderedColumns = [];
423.         foreach ($this->selectedClasses as $selectedClass) {
424.             $dqlAlias = $selectedClass['dqlAlias'];
425.             $qComp    = $this->queryComponents[$dqlAlias];
427.             if (! isset($qComp['relation']['orderBy'])) {
428.                 continue;
429.             }
431.             assert(isset($qComp['metadata']));
432.             $persister = $this->em->getUnitOfWork()->getEntityPersister($qComp['metadata']->name);
434.             foreach ($qComp['relation']['orderBy'] as $fieldName => $orientation) {
435.                 $columnName = $this->quoteStrategy->getColumnName($fieldName, $qComp['metadata'], $this->platform);
436.                 $tableName  = $qComp['metadata']->isInheritanceTypeJoined()
437.                     ? $persister->getOwningTable($fieldName)
438.                     : $qComp['metadata']->getTableName();
440.                 $orderedColumn = $this->getSQLTableAlias($tableName, $dqlAlias) . '.' . $columnName;
442.                 // OrderByClause should replace an ordered relation. see - DDC-2475
443.                 if (isset($this->orderedColumnsMap[$orderedColumn])) {
444.                     continue;
445.                 }
447.                 $this->orderedColumnsMap[$orderedColumn] = $orientation;
448.                 $orderedColumns[]                        = $orderedColumn . ' ' . $orientation;
449.             }
450.         }
452.         return implode(', ', $orderedColumns);
453.     }
455.     /**
456.      * Generates a discriminator column SQL condition for the class with the given DQL alias.
457.      *
458.      * @psalm-param list<string> $dqlAliases List of root DQL aliases to inspect for discriminator restrictions.
459.      */
460.     private function generateDiscriminatorColumnConditionSQL(array $dqlAliases): string
461.     {
462.         $sqlParts = [];
464.         foreach ($dqlAliases as $dqlAlias) {
465.             $class = $this->getMetadataForDqlAlias($dqlAlias);
467.             if (! $class->isInheritanceTypeSingleTable()) {
468.                 continue;
469.             }
471.             $conn   = $this->em->getConnection();
472.             $values = [];
474.             if ($class->discriminatorValue !== null) { // discriminators can be 0
475.                 $values[] = $conn->quote($class->discriminatorValue);
476.             }
478.             foreach ($class->subClasses as $subclassName) {
479.                 $values[] = $conn->quote($this->em->getClassMetadata($subclassName)->discriminatorValue);
480.             }
482.             $sqlTableAlias = $this->useSqlTableAliases
483.                 ? $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.'
484.                 : '';
486.             $sqlParts[] = $sqlTableAlias . $class->getDiscriminatorColumn()['name'] . ' IN (' . implode(', ', $values) . ')';
487.         }
489.         $sql = implode(' AND ', $sqlParts);
491.         return count($sqlParts) > 1 ? '(' . $sql . ')' : $sql;
492.     }
494.     /**
495.      * Generates the filter SQL for a given entity and table alias.
496.      *
497.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
498.      * @param string        $targetTableAlias The table alias of the joined/selected table.
499.      *
500.      * @return string The SQL query part to add to a query.
501.      */
502.     private function generateFilterConditionSQL(
503.         ClassMetadata $targetEntity,
504.         string $targetTableAlias
505.     ): string {
506.         if (! $this->em->hasFilters()) {
507.             return '';
508.         }
510.         switch ($targetEntity->inheritanceType) {
511.             case ClassMetadata::INHERITANCE_TYPE_NONE:
512.                 break;
513.             case ClassMetadata::INHERITANCE_TYPE_JOINED:
514.                 // The classes in the inheritance will be added to the query one by one,
515.                 // but only the root node is getting filtered
516.                 if ($targetEntity->name !== $targetEntity->rootEntityName) {
517.                     return '';
518.                 }
520.                 break;
521.             case ClassMetadata::INHERITANCE_TYPE_SINGLE_TABLE:
522.                 // With STI the table will only be queried once, make sure that the filters
523.                 // are added to the root entity
524.                 $targetEntity = $this->em->getClassMetadata($targetEntity->rootEntityName);
525.                 break;
526.             default:
527.                 //@todo: throw exception?
528.                 return '';
529.         }
531.         $filterClauses = [];
532.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
533.             $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
534.             if ($filterExpr !== '') {
535.                 $filterClauses[] = '(' . $filterExpr . ')';
536.             }
537.         }
539.         return implode(' AND ', $filterClauses);
540.     }
542.     /**
543.      * Walks down a SelectStatement AST node, thereby generating the appropriate SQL.
544.      *
545.      * @return string
546.      */
547.     public function walkSelectStatement(AST\SelectStatement $AST)
548.     {
549.         $limit    = $this->query->getMaxResults();
550.         $offset   = $this->query->getFirstResult();
551.         $lockMode = $this->query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE;
552.         $sql      = $this->walkSelectClause($AST->selectClause)
553.             . $this->walkFromClause($AST->fromClause)
554.             . $this->walkWhereClause($AST->whereClause);
556.         if ($AST->groupByClause) {
557.             $sql .= $this->walkGroupByClause($AST->groupByClause);
558.         }
560.         if ($AST->havingClause) {
561.             $sql .= $this->walkHavingClause($AST->havingClause);
562.         }
564.         if ($AST->orderByClause) {
565.             $sql .= $this->walkOrderByClause($AST->orderByClause);
566.         }
568.         $orderBySql = $this->generateOrderedCollectionOrderByItems();
569.         if (! $AST->orderByClause && $orderBySql) {
570.             $sql .= ' ORDER BY ' . $orderBySql;
571.         }
573.         $sql = $this->platform->modifyLimitQuery($sql, $limit, $offset);
575.         if ($lockMode === LockMode::NONE) {
576.             return $sql;
577.         }
579.         if ($lockMode === LockMode::PESSIMISTIC_READ) {
580.             return $sql . ' ' . $this->platform->getReadLockSQL();
581.         }
583.         if ($lockMode === LockMode::PESSIMISTIC_WRITE) {
584.             return $sql . ' ' . $this->platform->getWriteLockSQL();
585.         }
587.         if ($lockMode !== LockMode::OPTIMISTIC) {
588.             throw QueryException::invalidLockMode();
589.         }
591.         foreach ($this->selectedClasses as $selectedClass) {
592.             if (! $selectedClass['class']->isVersioned) {
593.                 throw OptimisticLockException::lockFailed($selectedClass['class']->name);
594.             }
595.         }
597.         return $sql;
598.     }
600.     /**
601.      * Walks down an UpdateStatement AST node, thereby generating the appropriate SQL.
602.      *
603.      * @return string
604.      */
605.     public function walkUpdateStatement(AST\UpdateStatement $AST)
606.     {
607.         $this->useSqlTableAliases = false;
608.         $this->rsm->isSelect      = false;
610.         return $this->walkUpdateClause($AST->updateClause)
611.             . $this->walkWhereClause($AST->whereClause);
612.     }
614.     /**
615.      * Walks down a DeleteStatement AST node, thereby generating the appropriate SQL.
616.      *
617.      * @return string
618.      */
619.     public function walkDeleteStatement(AST\DeleteStatement $AST)
620.     {
621.         $this->useSqlTableAliases = false;
622.         $this->rsm->isSelect      = false;
624.         return $this->walkDeleteClause($AST->deleteClause)
625.             . $this->walkWhereClause($AST->whereClause);
626.     }
628.     /**
629.      * Walks down an IdentificationVariable AST node, thereby generating the appropriate SQL.
630.      * This one differs of ->walkIdentificationVariable() because it generates the entity identifiers.
631.      *
632.      * @param string $identVariable
633.      *
634.      * @return string
635.      *
636.      * @not-deprecated
637.      */
638.     public function walkEntityIdentificationVariable($identVariable)
639.     {
640.         $class      = $this->getMetadataForDqlAlias($identVariable);
641.         $tableAlias = $this->getSQLTableAlias($class->getTableName(), $identVariable);
642.         $sqlParts   = [];
644.         foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
645.             $sqlParts[] = $tableAlias . '.' . $columnName;
646.         }
648.         return implode(', ', $sqlParts);
649.     }
651.     /**
652.      * Walks down an IdentificationVariable (no AST node associated), thereby generating the SQL.
653.      *
654.      * @param string $identificationVariable
655.      * @param string $fieldName
656.      *
657.      * @return string The SQL.
658.      *
659.      * @not-deprecated
660.      */
661.     public function walkIdentificationVariable($identificationVariable, $fieldName = null)
662.     {
663.         $class = $this->getMetadataForDqlAlias($identificationVariable);
665.         if (
666.             $fieldName !== null && $class->isInheritanceTypeJoined() &&
667.             isset($class->fieldMappings[$fieldName]['inherited'])
668.         ) {
669.             $class = $this->em->getClassMetadata($class->fieldMappings[$fieldName]['inherited']);
670.         }
672.         return $this->getSQLTableAlias($class->getTableName(), $identificationVariable);
673.     }
675.     /**
676.      * Walks down a PathExpression AST node, thereby generating the appropriate SQL.
677.      *
678.      * @param AST\PathExpression $pathExpr
679.      *
680.      * @return string
681.      *
682.      * @not-deprecated
683.      */
684.     public function walkPathExpression($pathExpr)
685.     {
686.         $sql = '';
687.         assert($pathExpr->field !== null);
689.         switch ($pathExpr->type) {
690.             case AST\PathExpression::TYPE_STATE_FIELD:
691.                 $fieldName = $pathExpr->field;
692.                 $dqlAlias  = $pathExpr->identificationVariable;
693.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
695.                 if ($this->useSqlTableAliases) {
696.                     $sql .= $this->walkIdentificationVariable($dqlAlias, $fieldName) . '.';
697.                 }
699.                 $sql .= $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
700.                 break;
702.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
703.                 // 1- the owning side:
704.                 //    Just use the foreign key, i.e. u.group_id
705.                 $fieldName = $pathExpr->field;
706.                 $dqlAlias  = $pathExpr->identificationVariable;
707.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
709.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
710.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
711.                 }
713.                 $assoc = $class->associationMappings[$fieldName];
715.                 if (! $assoc['isOwningSide']) {
716.                     throw QueryException::associationPathInverseSideNotSupported($pathExpr);
717.                 }
719.                 // COMPOSITE KEYS NOT (YET?) SUPPORTED
720.                 if (count($assoc['sourceToTargetKeyColumns']) > 1) {
721.                     throw QueryException::associationPathCompositeKeyNotSupported();
722.                 }
724.                 if ($this->useSqlTableAliases) {
725.                     $sql .= $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.';
726.                 }
728.                 $sql .= reset($assoc['targetToSourceKeyColumns']);
729.                 break;
731.             default:
732.                 throw QueryException::invalidPathExpression($pathExpr);
733.         }
735.         return $sql;
736.     }
738.     /**
739.      * Walks down a SelectClause AST node, thereby generating the appropriate SQL.
740.      *
741.      * @param AST\SelectClause $selectClause
742.      *
743.      * @return string
744.      *
745.      * @not-deprecated
746.      */
747.     public function walkSelectClause($selectClause)
748.     {
749.         $sql                  = 'SELECT ' . ($selectClause->isDistinct ? 'DISTINCT ' : '');
750.         $sqlSelectExpressions = array_filter(array_map([$this, 'walkSelectExpression'], $selectClause->selectExpressions));
752.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) === true && $selectClause->isDistinct) {
753.             $this->query->setHint(self::HINT_DISTINCT, true);
754.         }
756.         $addMetaColumns = ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD) &&
757.             $this->query->getHydrationMode() === Query::HYDRATE_OBJECT
758.             || $this->query->getHint(Query::HINT_INCLUDE_META_COLUMNS);
760.         foreach ($this->selectedClasses as $selectedClass) {
761.             $class       = $selectedClass['class'];
762.             $dqlAlias    = $selectedClass['dqlAlias'];
763.             $resultAlias = $selectedClass['resultAlias'];
765.             // Register as entity or joined entity result
766.             if (! isset($this->queryComponents[$dqlAlias]['relation'])) {
767.                 $this->rsm->addEntityResult($class->name, $dqlAlias, $resultAlias);
768.             } else {
769.                 assert(isset($this->queryComponents[$dqlAlias]['parent']));
771.                 $this->rsm->addJoinedEntityResult(
772.                     $class->name,
773.                     $dqlAlias,
774.                     $this->queryComponents[$dqlAlias]['parent'],
775.                     $this->queryComponents[$dqlAlias]['relation']['fieldName']
776.                 );
777.             }
779.             if ($class->isInheritanceTypeSingleTable() || $class->isInheritanceTypeJoined()) {
780.                 // Add discriminator columns to SQL
781.                 $rootClass   = $this->em->getClassMetadata($class->rootEntityName);
782.                 $tblAlias    = $this->getSQLTableAlias($rootClass->getTableName(), $dqlAlias);
783.                 $discrColumn = $rootClass->getDiscriminatorColumn();
784.                 $columnAlias = $this->getSQLColumnAlias($discrColumn['name']);
786.                 $sqlSelectExpressions[] = $tblAlias . '.' . $discrColumn['name'] . ' AS ' . $columnAlias;
788.                 $this->rsm->setDiscriminatorColumn($dqlAlias, $columnAlias);
789.                 $this->rsm->addMetaResult($dqlAlias, $columnAlias, $discrColumn['fieldName'], false, $discrColumn['type']);
790.                 if (! empty($discrColumn['enumType'])) {
791.                     $this->rsm->addEnumResult($columnAlias, $discrColumn['enumType']);
792.                 }
793.             }
795.             // Add foreign key columns to SQL, if necessary
796.             if (! $addMetaColumns && ! $class->containsForeignIdentifier) {
797.                 continue;
798.             }
800.             // Add foreign key columns of class and also parent classes
801.             foreach ($class->associationMappings as $assoc) {
802.                 if (
803.                     ! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)
804.                     || ( ! $addMetaColumns && ! isset($assoc['id']))
805.                 ) {
806.                     continue;
807.                 }
809.                 $targetClass   = $this->em->getClassMetadata($assoc['targetEntity']);
810.                 $isIdentifier  = (isset($assoc['id']) && $assoc['id'] === true);
811.                 $owningClass   = isset($assoc['inherited']) ? $this->em->getClassMetadata($assoc['inherited']) : $class;
812.                 $sqlTableAlias = $this->getSQLTableAlias($owningClass->getTableName(), $dqlAlias);
814.                 foreach ($assoc['joinColumns'] as $joinColumn) {
815.                     $columnName  = $joinColumn['name'];
816.                     $columnAlias = $this->getSQLColumnAlias($columnName);
817.                     $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
819.                     $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
820.                     $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
822.                     $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $isIdentifier, $columnType);
823.                 }
824.             }
826.             // Add foreign key columns to SQL, if necessary
827.             if (! $addMetaColumns) {
828.                 continue;
829.             }
831.             // Add foreign key columns of subclasses
832.             foreach ($class->subClasses as $subClassName) {
833.                 $subClass      = $this->em->getClassMetadata($subClassName);
834.                 $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
836.                 foreach ($subClass->associationMappings as $assoc) {
837.                     // Skip if association is inherited
838.                     if (isset($assoc['inherited'])) {
839.                         continue;
840.                     }
842.                     if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
843.                         $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
845.                         foreach ($assoc['joinColumns'] as $joinColumn) {
846.                             $columnName  = $joinColumn['name'];
847.                             $columnAlias = $this->getSQLColumnAlias($columnName);
848.                             $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
850.                             $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $subClass, $this->platform);
851.                             $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
853.                             $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $subClass->isIdentifier($columnName), $columnType);
854.                         }
855.                     }
856.                 }
857.             }
858.         }
860.         return $sql . implode(', ', $sqlSelectExpressions);
861.     }
863.     /**
864.      * Walks down a FromClause AST node, thereby generating the appropriate SQL.
865.      *
866.      * @param AST\FromClause $fromClause
867.      *
868.      * @return string
869.      *
870.      * @not-deprecated
871.      */
872.     public function walkFromClause($fromClause)
873.     {
874.         $identificationVarDecls = $fromClause->identificationVariableDeclarations;
875.         $sqlParts               = [];
877.         foreach ($identificationVarDecls as $identificationVariableDecl) {
878.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($identificationVariableDecl);
879.         }
881.         return ' FROM ' . implode(', ', $sqlParts);
882.     }
884.     /**
885.      * Walks down a IdentificationVariableDeclaration AST node, thereby generating the appropriate SQL.
886.      *
887.      * @param AST\IdentificationVariableDeclaration $identificationVariableDecl
888.      *
889.      * @return string
890.      *
891.      * @not-deprecated
892.      */
893.     public function walkIdentificationVariableDeclaration($identificationVariableDecl)
894.     {
895.         $sql = $this->walkRangeVariableDeclaration($identificationVariableDecl->rangeVariableDeclaration);
897.         if ($identificationVariableDecl->indexBy) {
898.             $this->walkIndexBy($identificationVariableDecl->indexBy);
899.         }
901.         foreach ($identificationVariableDecl->joins as $join) {
902.             $sql .= $this->walkJoin($join);
903.         }
905.         return $sql;
906.     }
908.     /**
909.      * Walks down a IndexBy AST node.
910.      *
911.      * @param AST\IndexBy $indexBy
912.      *
913.      * @return void
914.      *
915.      * @not-deprecated
916.      */
917.     public function walkIndexBy($indexBy)
918.     {
919.         $pathExpression = $indexBy->singleValuedPathExpression;
920.         $alias          = $pathExpression->identificationVariable;
921.         assert($pathExpression->field !== null);
923.         switch ($pathExpression->type) {
924.             case AST\PathExpression::TYPE_STATE_FIELD:
925.                 $field = $pathExpression->field;
926.                 break;
928.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
929.                 // Just use the foreign key, i.e. u.group_id
930.                 $fieldName = $pathExpression->field;
931.                 $class     = $this->getMetadataForDqlAlias($alias);
933.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
934.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
935.                 }
937.                 $association = $class->associationMappings[$fieldName];
939.                 if (! $association['isOwningSide']) {
940.                     throw QueryException::associationPathInverseSideNotSupported($pathExpression);
941.                 }
943.                 if (count($association['sourceToTargetKeyColumns']) > 1) {
944.                     throw QueryException::associationPathCompositeKeyNotSupported();
945.                 }
947.                 $field = reset($association['targetToSourceKeyColumns']);
948.                 break;
950.             default:
951.                 throw QueryException::invalidPathExpression($pathExpression);
952.         }
954.         if (isset($this->scalarFields[$alias][$field])) {
955.             $this->rsm->addIndexByScalar($this->scalarFields[$alias][$field]);
957.             return;
958.         }
960.         $this->rsm->addIndexBy($alias, $field);
961.     }
963.     /**
964.      * Walks down a RangeVariableDeclaration AST node, thereby generating the appropriate SQL.
965.      *
966.      * @param AST\RangeVariableDeclaration $rangeVariableDeclaration
967.      *
968.      * @return string
969.      *
970.      * @not-deprecated
971.      */
972.     public function walkRangeVariableDeclaration($rangeVariableDeclaration)
973.     {
974.         return $this->generateRangeVariableDeclarationSQL($rangeVariableDeclaration, false);
975.     }
977.     /**
978.      * Generate appropriate SQL for RangeVariableDeclaration AST node
979.      */
980.     private function generateRangeVariableDeclarationSQL(
981.         AST\RangeVariableDeclaration $rangeVariableDeclaration,
982.         bool $buildNestedJoins
983.     ): string {
984.         $class    = $this->em->getClassMetadata($rangeVariableDeclaration->abstractSchemaName);
985.         $dqlAlias = $rangeVariableDeclaration->aliasIdentificationVariable;
987.         if ($rangeVariableDeclaration->isRoot) {
988.             $this->rootAliases[] = $dqlAlias;
989.         }
991.         $sql = $this->platform->appendLockHint(
992.             $this->quoteStrategy->getTableName($class, $this->platform) . ' ' .
993.             $this->getSQLTableAlias($class->getTableName(), $dqlAlias),
994.             $this->query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE
995.         );
997.         if (! $class->isInheritanceTypeJoined()) {
998.             return $sql;
999.         }
1001.         $classTableInheritanceJoins = $this->generateClassTableInheritanceJoins($class, $dqlAlias);
1003.         if (! $buildNestedJoins) {
1004.             return $sql . $classTableInheritanceJoins;
1005.         }
1007.         return $classTableInheritanceJoins === '' ? $sql : '(' . $sql . $classTableInheritanceJoins . ')';
1008.     }
1010.     /**
1011.      * Walks down a JoinAssociationDeclaration AST node, thereby generating the appropriate SQL.
1012.      *
1013.      * @param AST\JoinAssociationDeclaration $joinAssociationDeclaration
1014.      * @param int                            $joinType
1015.      * @param AST\ConditionalExpression      $condExpr
1016.      * @psalm-param AST\Join::JOIN_TYPE_* $joinType
1017.      *
1018.      * @return string
1019.      *
1020.      * @throws QueryException
1021.      *
1022.      * @not-deprecated
1023.      */
1024.     public function walkJoinAssociationDeclaration($joinAssociationDeclaration, $joinType = AST\Join::JOIN_TYPE_INNER, $condExpr = null)
1025.     {
1026.         $sql = '';
1028.         $associationPathExpression = $joinAssociationDeclaration->joinAssociationPathExpression;
1029.         $joinedDqlAlias            = $joinAssociationDeclaration->aliasIdentificationVariable;
1030.         $indexBy                   = $joinAssociationDeclaration->indexBy;
1032.         $relation = $this->queryComponents[$joinedDqlAlias]['relation'] ?? null;
1033.         assert($relation !== null);
1034.         $targetClass     = $this->em->getClassMetadata($relation['targetEntity']);
1035.         $sourceClass     = $this->em->getClassMetadata($relation['sourceEntity']);
1036.         $targetTableName = $this->quoteStrategy->getTableName($targetClass, $this->platform);
1038.         $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName(), $joinedDqlAlias);
1039.         $sourceTableAlias = $this->getSQLTableAlias($sourceClass->getTableName(), $associationPathExpression->identificationVariable);
1041.         // Ensure we got the owning side, since it has all mapping info
1042.         $assoc = ! $relation['isOwningSide'] ? $targetClass->associationMappings[$relation['mappedBy']] : $relation;
1044.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) === true && (! $this->query->getHint(self::HINT_DISTINCT) || isset($this->selectedClasses[$joinedDqlAlias]))) {
1045.             if ($relation['type'] === ClassMetadata::ONE_TO_MANY || $relation['type'] === ClassMetadata::MANY_TO_MANY) {
1046.                 throw QueryException::iterateWithFetchJoinNotAllowed($assoc);
1047.             }
1048.         }
1050.         $targetTableJoin = null;
1052.         // This condition is not checking ClassMetadata::MANY_TO_ONE, because by definition it cannot
1053.         // be the owning side and previously we ensured that $assoc is always the owning side of the associations.
1054.         // The owning side is necessary at this point because only it contains the JoinColumn information.
1055.         switch (true) {
1056.             case $assoc['type'] & ClassMetadata::TO_ONE:
1057.                 $conditions = [];
1059.                 foreach ($assoc['joinColumns'] as $joinColumn) {
1060.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
1061.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
1063.                     if ($relation['isOwningSide']) {
1064.                         $conditions[] = $sourceTableAlias . '.' . $quotedSourceColumn . ' = ' . $targetTableAlias . '.' . $quotedTargetColumn;
1066.                         continue;
1067.                     }
1069.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $targetTableAlias . '.' . $quotedSourceColumn;
1070.                 }
1072.                 // Apply remaining inheritance restrictions
1073.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
1075.                 if ($discrSql) {
1076.                     $conditions[] = $discrSql;
1077.                 }
1079.                 // Apply the filters
1080.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
1082.                 if ($filterExpr) {
1083.                     $conditions[] = $filterExpr;
1084.                 }
1086.                 $targetTableJoin = [
1087.                     'table' => $targetTableName . ' ' . $targetTableAlias,
1088.                     'condition' => implode(' AND ', $conditions),
1089.                 ];
1090.                 break;
1092.             case $assoc['type'] === ClassMetadata::MANY_TO_MANY:
1093.                 // Join relation table
1094.                 $joinTable      = $assoc['joinTable'];
1095.                 $joinTableAlias = $this->getSQLTableAlias($joinTable['name'], $joinedDqlAlias);
1096.                 $joinTableName  = $this->quoteStrategy->getJoinTableName($assoc, $sourceClass, $this->platform);
1098.                 $conditions      = [];
1099.                 $relationColumns = $relation['isOwningSide']
1100.                     ? $assoc['joinTable']['joinColumns']
1101.                     : $assoc['joinTable']['inverseJoinColumns'];
1103.                 foreach ($relationColumns as $joinColumn) {
1104.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
1105.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
1107.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
1108.                 }
1110.                 $sql .= $joinTableName . ' ' . $joinTableAlias . ' ON ' . implode(' AND ', $conditions);
1112.                 // Join target table
1113.                 $sql .= $joinType === AST\Join::JOIN_TYPE_LEFT || $joinType === AST\Join::JOIN_TYPE_LEFTOUTER ? ' LEFT JOIN ' : ' INNER JOIN ';
1115.                 $conditions      = [];
1116.                 $relationColumns = $relation['isOwningSide']
1117.                     ? $assoc['joinTable']['inverseJoinColumns']
1118.                     : $assoc['joinTable']['joinColumns'];
1120.                 foreach ($relationColumns as $joinColumn) {
1121.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
1122.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
1124.                     $conditions[] = $targetTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
1125.                 }
1127.                 // Apply remaining inheritance restrictions
1128.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
1130.                 if ($discrSql) {
1131.                     $conditions[] = $discrSql;
1132.                 }
1134.                 // Apply the filters
1135.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
1137.                 if ($filterExpr) {
1138.                     $conditions[] = $filterExpr;
1139.                 }
1141.                 $targetTableJoin = [
1142.                     'table' => $targetTableName . ' ' . $targetTableAlias,
1143.                     'condition' => implode(' AND ', $conditions),
1144.                 ];
1145.                 break;
1147.             default:
1148.                 throw new BadMethodCallException('Type of association must be one of *_TO_ONE or MANY_TO_MANY');
1149.         }
1151.         // Handle WITH clause
1152.         $withCondition = $condExpr === null ? '' : ('(' . $this->walkConditionalExpression($condExpr) . ')');
1154.         if ($targetClass->isInheritanceTypeJoined()) {
1155.             $ctiJoins = $this->generateClassTableInheritanceJoins($targetClass, $joinedDqlAlias);
1156.             // If we have WITH condition, we need to build nested joins for target class table and cti joins
1157.             if ($withCondition && $ctiJoins) {
1158.                 $sql .= '(' . $targetTableJoin['table'] . $ctiJoins . ') ON ' . $targetTableJoin['condition'];
1159.             } else {
1160.                 $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'] . $ctiJoins;
1161.             }
1162.         } else {
1163.             $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'];
1164.         }
1166.         if ($withCondition) {
1167.             $sql .= ' AND ' . $withCondition;
1168.         }
1170.         // Apply the indexes
1171.         if ($indexBy) {
1172.             // For Many-To-One or One-To-One associations this obviously makes no sense, but is ignored silently.
1173.             $this->walkIndexBy($indexBy);
1174.         } elseif (isset($relation['indexBy'])) {
1175.             $this->rsm->addIndexBy($joinedDqlAlias, $relation['indexBy']);
1176.         }
1178.         return $sql;
1179.     }
1181.     /**
1182.      * Walks down a FunctionNode AST node, thereby generating the appropriate SQL.
1183.      *
1184.      * @param AST\Functions\FunctionNode $function
1185.      *
1186.      * @return string
1187.      *
1188.      * @not-deprecated
1189.      */
1190.     public function walkFunction($function)
1191.     {
1192.         return $function->getSql($this);
1193.     }
1195.     /**
1196.      * Walks down an OrderByClause AST node, thereby generating the appropriate SQL.
1197.      *
1198.      * @param AST\OrderByClause $orderByClause
1199.      *
1200.      * @return string
1201.      *
1202.      * @not-deprecated
1203.      */
1204.     public function walkOrderByClause($orderByClause)
1205.     {
1206.         $orderByItems = array_map([$this, 'walkOrderByItem'], $orderByClause->orderByItems);
1208.         $collectionOrderByItems = $this->generateOrderedCollectionOrderByItems();
1209.         if ($collectionOrderByItems !== '') {
1210.             $orderByItems = array_merge($orderByItems, (array) $collectionOrderByItems);
1211.         }
1213.         return ' ORDER BY ' . implode(', ', $orderByItems);
1214.     }
1216.     /**
1217.      * Walks down an OrderByItem AST node, thereby generating the appropriate SQL.
1218.      *
1219.      * @param AST\OrderByItem $orderByItem
1220.      *
1221.      * @return string
1222.      *
1223.      * @not-deprecated
1224.      */
1225.     public function walkOrderByItem($orderByItem)
1226.     {
1227.         $type = strtoupper($orderByItem->type);
1228.         $expr = $orderByItem->expression;
1229.         $sql  = $expr instanceof AST\Node
1230.             ? $expr->dispatch($this)
1231.             : $this->walkResultVariable($this->queryComponents[$expr]['token']->value);
1233.         $this->orderedColumnsMap[$sql] = $type;
1235.         if ($expr instanceof AST\Subselect) {
1236.             return '(' . $sql . ') ' . $type;
1237.         }
1239.         return $sql . ' ' . $type;
1240.     }
1242.     /**
1243.      * Walks down a HavingClause AST node, thereby generating the appropriate SQL.
1244.      *
1245.      * @param AST\HavingClause $havingClause
1246.      *
1247.      * @return string The SQL.
1248.      *
1249.      * @not-deprecated
1250.      */
1251.     public function walkHavingClause($havingClause)
1252.     {
1253.         return ' HAVING ' . $this->walkConditionalExpression($havingClause->conditionalExpression);
1254.     }
1256.     /**
1257.      * Walks down a Join AST node and creates the corresponding SQL.
1258.      *
1259.      * @param AST\Join $join
1260.      *
1261.      * @return string
1262.      *
1263.      * @not-deprecated
1264.      */
1265.     public function walkJoin($join)
1266.     {
1267.         $joinType        = $join->joinType;
1268.         $joinDeclaration = $join->joinAssociationDeclaration;
1270.         $sql = $joinType === AST\Join::JOIN_TYPE_LEFT || $joinType === AST\Join::JOIN_TYPE_LEFTOUTER
1271.             ? ' LEFT JOIN '
1272.             : ' INNER JOIN ';
1274.         switch (true) {
1275.             case $joinDeclaration instanceof AST\RangeVariableDeclaration:
1276.                 $class      = $this->em->getClassMetadata($joinDeclaration->abstractSchemaName);
1277.                 $dqlAlias   = $joinDeclaration->aliasIdentificationVariable;
1278.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
1279.                 $conditions = [];
1281.                 if ($join->conditionalExpression) {
1282.                     $conditions[] = '(' . $this->walkConditionalExpression($join->conditionalExpression) . ')';
1283.                 }
1285.                 $isUnconditionalJoin = $conditions === [];
1286.                 $condExprConjunction = $class->isInheritanceTypeJoined() && $joinType !== AST\Join::JOIN_TYPE_LEFT && $joinType !== AST\Join::JOIN_TYPE_LEFTOUTER && $isUnconditionalJoin
1287.                     ? ' AND '
1288.                     : ' ON ';
1290.                 $sql .= $this->generateRangeVariableDeclarationSQL($joinDeclaration, ! $isUnconditionalJoin);
1292.                 // Apply remaining inheritance restrictions
1293.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$dqlAlias]);
1295.                 if ($discrSql) {
1296.                     $conditions[] = $discrSql;
1297.                 }
1299.                 // Apply the filters
1300.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
1302.                 if ($filterExpr) {
1303.                     $conditions[] = $filterExpr;
1304.                 }
1306.                 if ($conditions) {
1307.                     $sql .= $condExprConjunction . implode(' AND ', $conditions);
1308.                 }
1310.                 break;
1312.             case $joinDeclaration instanceof AST\JoinAssociationDeclaration:
1313.                 $sql .= $this->walkJoinAssociationDeclaration($joinDeclaration, $joinType, $join->conditionalExpression);
1314.                 break;
1315.         }
1317.         return $sql;
1318.     }
1320.     /**
1321.      * Walks down a CoalesceExpression AST node and generates the corresponding SQL.
1322.      *
1323.      * @param AST\CoalesceExpression $coalesceExpression
1324.      *
1325.      * @return string The SQL.
1326.      *
1327.      * @not-deprecated
1328.      */
1329.     public function walkCoalesceExpression($coalesceExpression)
1330.     {
1331.         $sql = 'COALESCE(';
1333.         $scalarExpressions = [];
1335.         foreach ($coalesceExpression->scalarExpressions as $scalarExpression) {
1336.             $scalarExpressions[] = $this->walkSimpleArithmeticExpression($scalarExpression);
1337.         }
1339.         return $sql . implode(', ', $scalarExpressions) . ')';
1340.     }
1342.     /**
1343.      * Walks down a NullIfExpression AST node and generates the corresponding SQL.
1344.      *
1345.      * @param AST\NullIfExpression $nullIfExpression
1346.      *
1347.      * @return string The SQL.
1348.      *
1349.      * @not-deprecated
1350.      */
1351.     public function walkNullIfExpression($nullIfExpression)
1352.     {
1353.         $firstExpression = is_string($nullIfExpression->firstExpression)
1354.             ? $this->conn->quote($nullIfExpression->firstExpression)
1355.             : $this->walkSimpleArithmeticExpression($nullIfExpression->firstExpression);
1357.         $secondExpression = is_string($nullIfExpression->secondExpression)
1358.             ? $this->conn->quote($nullIfExpression->secondExpression)
1359.             : $this->walkSimpleArithmeticExpression($nullIfExpression->secondExpression);
1361.         return 'NULLIF(' . $firstExpression . ', ' . $secondExpression . ')';
1362.     }
1364.     /**
1365.      * Walks down a GeneralCaseExpression AST node and generates the corresponding SQL.
1366.      *
1367.      * @return string The SQL.
1368.      *
1369.      * @not-deprecated
1370.      */
1371.     public function walkGeneralCaseExpression(AST\GeneralCaseExpression $generalCaseExpression)
1372.     {
1373.         $sql = 'CASE';
1375.         foreach ($generalCaseExpression->whenClauses as $whenClause) {
1376.             $sql .= ' WHEN ' . $this->walkConditionalExpression($whenClause->caseConditionExpression);
1377.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($whenClause->thenScalarExpression);
1378.         }
1380.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($generalCaseExpression->elseScalarExpression) . ' END';
1382.         return $sql;
1383.     }
1385.     /**
1386.      * Walks down a SimpleCaseExpression AST node and generates the corresponding SQL.
1387.      *
1388.      * @param AST\SimpleCaseExpression $simpleCaseExpression
1389.      *
1390.      * @return string The SQL.
1391.      *
1392.      * @not-deprecated
1393.      */
1394.     public function walkSimpleCaseExpression($simpleCaseExpression)
1395.     {
1396.         $sql = 'CASE ' . $this->walkStateFieldPathExpression($simpleCaseExpression->caseOperand);
1398.         foreach ($simpleCaseExpression->simpleWhenClauses as $simpleWhenClause) {
1399.             $sql .= ' WHEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->caseScalarExpression);
1400.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->thenScalarExpression);
1401.         }
1403.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($simpleCaseExpression->elseScalarExpression) . ' END';
1405.         return $sql;
1406.     }
1408.     /**
1409.      * Walks down a SelectExpression AST node and generates the corresponding SQL.
1410.      *
1411.      * @param AST\SelectExpression $selectExpression
1412.      *
1413.      * @return string
1414.      *
1415.      * @not-deprecated
1416.      */
1417.     public function walkSelectExpression($selectExpression)
1418.     {
1419.         $sql    = '';
1420.         $expr   = $selectExpression->expression;
1421.         $hidden = $selectExpression->hiddenAliasResultVariable;
1423.         switch (true) {
1424.             case $expr instanceof AST\PathExpression:
1425.                 if ($expr->type !== AST\PathExpression::TYPE_STATE_FIELD) {
1426.                     throw QueryException::invalidPathExpression($expr);
1427.                 }
1429.                 assert($expr->field !== null);
1430.                 $fieldName = $expr->field;
1431.                 $dqlAlias  = $expr->identificationVariable;
1432.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
1434.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $fieldName;
1435.                 $tableName   = $class->isInheritanceTypeJoined()
1436.                     ? $this->em->getUnitOfWork()->getEntityPersister($class->name)->getOwningTable($fieldName)
1437.                     : $class->getTableName();
1439.                 $sqlTableAlias = $this->getSQLTableAlias($tableName, $dqlAlias);
1440.                 $fieldMapping  = $class->fieldMappings[$fieldName];
1441.                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
1442.                 $columnAlias   = $this->getSQLColumnAlias($fieldMapping['columnName']);
1443.                 $col           = $sqlTableAlias . '.' . $columnName;
1445.                 if (isset($fieldMapping['requireSQLConversion'])) {
1446.                     $type = Type::getType($fieldMapping['type']);
1447.                     $col  = $type->convertToPHPValueSQL($col, $this->conn->getDatabasePlatform());
1448.                 }
1450.                 $sql .= $col . ' AS ' . $columnAlias;
1452.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
1454.                 if (! $hidden) {
1455.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldMapping['type']);
1456.                     $this->scalarFields[$dqlAlias][$fieldName] = $columnAlias;
1458.                     if (! empty($fieldMapping['enumType'])) {
1459.                         $this->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
1460.                     }
1461.                 }
1463.                 break;
1465.             case $expr instanceof AST\AggregateExpression:
1466.             case $expr instanceof AST\Functions\FunctionNode:
1467.             case $expr instanceof AST\SimpleArithmeticExpression:
1468.             case $expr instanceof AST\ArithmeticTerm:
1469.             case $expr instanceof AST\ArithmeticFactor:
1470.             case $expr instanceof AST\ParenthesisExpression:
1471.             case $expr instanceof AST\Literal:
1472.             case $expr instanceof AST\NullIfExpression:
1473.             case $expr instanceof AST\CoalesceExpression:
1474.             case $expr instanceof AST\GeneralCaseExpression:
1475.             case $expr instanceof AST\SimpleCaseExpression:
1476.                 $columnAlias = $this->getSQLColumnAlias('sclr');
1477.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
1479.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
1481.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
1483.                 if ($hidden) {
1484.                     break;
1485.                 }
1487.                 if (! $expr instanceof Query\AST\TypedExpression) {
1488.                     // Conceptually we could resolve field type here by traverse through AST to retrieve field type,
1489.                     // but this is not a feasible solution; assume 'string'.
1490.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
1492.                     break;
1493.                 }
1495.                 $this->rsm->addScalarResult($columnAlias, $resultAlias, Type::getTypeRegistry()->lookupName($expr->getReturnType()));
1497.                 break;
1499.             case $expr instanceof AST\Subselect:
1500.                 $columnAlias = $this->getSQLColumnAlias('sclr');
1501.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
1503.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
1505.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
1507.                 if (! $hidden) {
1508.                     // We cannot resolve field type here; assume 'string'.
1509.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
1510.                 }
1512.                 break;
1514.             case $expr instanceof AST\NewObjectExpression:
1515.                 $sql .= $this->walkNewObject($expr, $selectExpression->fieldIdentificationVariable);
1516.                 break;
1518.             default:
1519.                 // IdentificationVariable or PartialObjectExpression
1520.                 if ($expr instanceof AST\PartialObjectExpression) {
1521.                     $this->query->setHint(self::HINT_PARTIAL, true);
1523.                     $dqlAlias        = $expr->identificationVariable;
1524.                     $partialFieldSet = $expr->partialFieldSet;
1525.                 } else {
1526.                     $dqlAlias        = $expr;
1527.                     $partialFieldSet = [];
1528.                 }
1530.                 $class       = $this->getMetadataForDqlAlias($dqlAlias);
1531.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: null;
1533.                 if (! isset($this->selectedClasses[$dqlAlias])) {
1534.                     $this->selectedClasses[$dqlAlias] = [
1535.                         'class'       => $class,
1536.                         'dqlAlias'    => $dqlAlias,
1537.                         'resultAlias' => $resultAlias,
1538.                     ];
1539.                 }
1541.                 $sqlParts = [];
1543.                 // Select all fields from the queried class
1544.                 foreach ($class->fieldMappings as $fieldName => $mapping) {
1545.                     if ($partialFieldSet && ! in_array($fieldName, $partialFieldSet, true)) {
1546.                         continue;
1547.                     }
1549.                     $tableName = isset($mapping['inherited'])
1550.                         ? $this->em->getClassMetadata($mapping['inherited'])->getTableName()
1551.                         : $class->getTableName();
1553.                     $sqlTableAlias    = $this->getSQLTableAlias($tableName, $dqlAlias);
1554.                     $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
1555.                     $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
1557.                     $col = $sqlTableAlias . '.' . $quotedColumnName;
1559.                     if (isset($mapping['requireSQLConversion'])) {
1560.                         $type = Type::getType($mapping['type']);
1561.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
1562.                     }
1564.                     $sqlParts[] = $col . ' AS ' . $columnAlias;
1566.                     $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
1568.                     $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $class->name);
1570.                     if (! empty($mapping['enumType'])) {
1571.                         $this->rsm->addEnumResult($columnAlias, $mapping['enumType']);
1572.                     }
1573.                 }
1575.                 // Add any additional fields of subclasses (excluding inherited fields)
1576.                 // 1) on Single Table Inheritance: always, since its marginal overhead
1577.                 // 2) on Class Table Inheritance only if partial objects are disallowed,
1578.                 //    since it requires outer joining subtables.
1579.                 if ($class->isInheritanceTypeSingleTable() || ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
1580.                     foreach ($class->subClasses as $subClassName) {
1581.                         $subClass      = $this->em->getClassMetadata($subClassName);
1582.                         $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
1584.                         foreach ($subClass->fieldMappings as $fieldName => $mapping) {
1585.                             if (isset($mapping['inherited']) || ($partialFieldSet && ! in_array($fieldName, $partialFieldSet, true))) {
1586.                                 continue;
1587.                             }
1589.                             $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
1590.                             $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $subClass, $this->platform);
1592.                             $col = $sqlTableAlias . '.' . $quotedColumnName;
1594.                             if (isset($mapping['requireSQLConversion'])) {
1595.                                 $type = Type::getType($mapping['type']);
1596.                                 $col  = $type->convertToPHPValueSQL($col, $this->platform);
1597.                             }
1599.                             $sqlParts[] = $col . ' AS ' . $columnAlias;
1601.                             $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
1603.                             $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $subClassName);
1604.                         }
1605.                     }
1606.                 }
1608.                 $sql .= implode(', ', $sqlParts);
1609.         }
1611.         return $sql;
1612.     }
1614.     /**
1615.      * Walks down a QuantifiedExpression AST node, thereby generating the appropriate SQL.
1616.      *
1617.      * @param AST\QuantifiedExpression $qExpr
1618.      *
1619.      * @return string
1620.      *
1621.      * @not-deprecated
1622.      */
1623.     public function walkQuantifiedExpression($qExpr)
1624.     {
1625.         return ' ' . strtoupper($qExpr->type) . '(' . $this->walkSubselect($qExpr->subselect) . ')';
1626.     }
1628.     /**
1629.      * Walks down a Subselect AST node, thereby generating the appropriate SQL.
1630.      *
1631.      * @param AST\Subselect $subselect
1632.      *
1633.      * @return string
1634.      *
1635.      * @not-deprecated
1636.      */
1637.     public function walkSubselect($subselect)
1638.     {
1639.         $useAliasesBefore  = $this->useSqlTableAliases;
1640.         $rootAliasesBefore = $this->rootAliases;
1642.         $this->rootAliases        = []; // reset the rootAliases for the subselect
1643.         $this->useSqlTableAliases = true;
1645.         $sql  = $this->walkSimpleSelectClause($subselect->simpleSelectClause);
1646.         $sql .= $this->walkSubselectFromClause($subselect->subselectFromClause);
1647.         $sql .= $this->walkWhereClause($subselect->whereClause);
1649.         $sql .= $subselect->groupByClause ? $this->walkGroupByClause($subselect->groupByClause) : '';
1650.         $sql .= $subselect->havingClause ? $this->walkHavingClause($subselect->havingClause) : '';
1651.         $sql .= $subselect->orderByClause ? $this->walkOrderByClause($subselect->orderByClause) : '';
1653.         $this->rootAliases        = $rootAliasesBefore; // put the main aliases back
1654.         $this->useSqlTableAliases = $useAliasesBefore;
1656.         return $sql;
1657.     }
1659.     /**
1660.      * Walks down a SubselectFromClause AST node, thereby generating the appropriate SQL.
1661.      *
1662.      * @param AST\SubselectFromClause $subselectFromClause
1663.      *
1664.      * @return string
1665.      *
1666.      * @not-deprecated
1667.      */
1668.     public function walkSubselectFromClause($subselectFromClause)
1669.     {
1670.         $identificationVarDecls = $subselectFromClause->identificationVariableDeclarations;
1671.         $sqlParts               = [];
1673.         foreach ($identificationVarDecls as $subselectIdVarDecl) {
1674.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($subselectIdVarDecl);
1675.         }
1677.         return ' FROM ' . implode(', ', $sqlParts);
1678.     }
1680.     /**
1681.      * Walks down a SimpleSelectClause AST node, thereby generating the appropriate SQL.
1682.      *
1683.      * @param AST\SimpleSelectClause $simpleSelectClause
1684.      *
1685.      * @return string
1686.      *
1687.      * @not-deprecated
1688.      */
1689.     public function walkSimpleSelectClause($simpleSelectClause)
1690.     {
1691.         return 'SELECT' . ($simpleSelectClause->isDistinct ? ' DISTINCT' : '')
1692.             . $this->walkSimpleSelectExpression($simpleSelectClause->simpleSelectExpression);
1693.     }
1695.     /** @return string */
1696.     public function walkParenthesisExpression(AST\ParenthesisExpression $parenthesisExpression)
1697.     {
1698.         return sprintf('(%s)', $parenthesisExpression->expression->dispatch($this));
1699.     }
1701.     /**
1702.      * @param AST\NewObjectExpression $newObjectExpression
1703.      * @param string|null             $newObjectResultAlias
1704.      *
1705.      * @return string The SQL.
1706.      */
1707.     public function walkNewObject($newObjectExpression, $newObjectResultAlias = null)
1708.     {
1709.         $sqlSelectExpressions = [];
1710.         $objIndex             = $newObjectResultAlias ?: $this->newObjectCounter++;
1712.         foreach ($newObjectExpression->args as $argIndex => $e) {
1713.             $resultAlias = $this->scalarResultCounter++;
1714.             $columnAlias = $this->getSQLColumnAlias('sclr');
1715.             $fieldType   = 'string';
1717.             switch (true) {
1718.                 case $e instanceof AST\NewObjectExpression:
1719.                     $sqlSelectExpressions[] = $e->dispatch($this);
1720.                     break;
1722.                 case $e instanceof AST\Subselect:
1723.                     $sqlSelectExpressions[] = '(' . $e->dispatch($this) . ') AS ' . $columnAlias;
1724.                     break;
1726.                 case $e instanceof AST\PathExpression:
1727.                     assert($e->field !== null);
1728.                     $dqlAlias     = $e->identificationVariable;
1729.                     $class        = $this->getMetadataForDqlAlias($dqlAlias);
1730.                     $fieldName    = $e->field;
1731.                     $fieldMapping = $class->fieldMappings[$fieldName];
1732.                     $fieldType    = $fieldMapping['type'];
1733.                     $col          = trim($e->dispatch($this));
1735.                     if (isset($fieldMapping['requireSQLConversion'])) {
1736.                         $type = Type::getType($fieldType);
1737.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
1738.                     }
1740.                     $sqlSelectExpressions[] = $col . ' AS ' . $columnAlias;
1742.                     if (! empty($fieldMapping['enumType'])) {
1743.                         $this->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
1744.                     }
1746.                     break;
1748.                 case $e instanceof AST\Literal:
1749.                     switch ($e->type) {
1750.                         case AST\Literal::BOOLEAN:
1751.                             $fieldType = 'boolean';
1752.                             break;
1754.                         case AST\Literal::NUMERIC:
1755.                             $fieldType = is_float($e->value) ? 'float' : 'integer';
1756.                             break;
1757.                     }
1759.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
1760.                     break;
1762.                 default:
1763.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
1764.                     break;
1765.             }
1767.             $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
1768.             $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldType);
1770.             $this->rsm->newObjectMappings[$columnAlias] = [
1771.                 'className' => $newObjectExpression->className,
1772.                 'objIndex'  => $objIndex,
1773.                 'argIndex'  => $argIndex,
1774.             ];
1775.         }
1777.         return implode(', ', $sqlSelectExpressions);
1778.     }
1780.     /**
1781.      * Walks down a SimpleSelectExpression AST node, thereby generating the appropriate SQL.
1782.      *
1783.      * @param AST\SimpleSelectExpression $simpleSelectExpression
1784.      *
1785.      * @return string
1786.      *
1787.      * @not-deprecated
1788.      */
1789.     public function walkSimpleSelectExpression($simpleSelectExpression)
1790.     {
1791.         $expr = $simpleSelectExpression->expression;
1792.         $sql  = ' ';
1794.         switch (true) {
1795.             case $expr instanceof AST\PathExpression:
1796.                 $sql .= $this->walkPathExpression($expr);
1797.                 break;
1799.             case $expr instanceof AST\Subselect:
1800.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
1802.                 $columnAlias                        = 'sclr' . $this->aliasCounter++;
1803.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
1805.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
1806.                 break;
1808.             case $expr instanceof AST\Functions\FunctionNode:
1809.             case $expr instanceof AST\SimpleArithmeticExpression:
1810.             case $expr instanceof AST\ArithmeticTerm:
1811.             case $expr instanceof AST\ArithmeticFactor:
1812.             case $expr instanceof AST\Literal:
1813.             case $expr instanceof AST\NullIfExpression:
1814.             case $expr instanceof AST\CoalesceExpression:
1815.             case $expr instanceof AST\GeneralCaseExpression:
1816.             case $expr instanceof AST\SimpleCaseExpression:
1817.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
1819.                 $columnAlias                        = $this->getSQLColumnAlias('sclr');
1820.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
1822.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
1823.                 break;
1825.             case $expr instanceof AST\ParenthesisExpression:
1826.                 $sql .= $this->walkParenthesisExpression($expr);
1827.                 break;
1829.             default: // IdentificationVariable
1830.                 $sql .= $this->walkEntityIdentificationVariable($expr);
1831.                 break;
1832.         }
1834.         return $sql;
1835.     }
1837.     /**
1838.      * Walks down an AggregateExpression AST node, thereby generating the appropriate SQL.
1839.      *
1840.      * @param AST\AggregateExpression $aggExpression
1841.      *
1842.      * @return string
1843.      *
1844.      * @not-deprecated
1845.      */
1846.     public function walkAggregateExpression($aggExpression)
1847.     {
1848.         return $aggExpression->functionName . '(' . ($aggExpression->isDistinct ? 'DISTINCT ' : '')
1849.             . $this->walkSimpleArithmeticExpression($aggExpression->pathExpression) . ')';
1850.     }
1852.     /**
1853.      * Walks down a GroupByClause AST node, thereby generating the appropriate SQL.
1854.      *
1855.      * @param AST\GroupByClause $groupByClause
1856.      *
1857.      * @return string
1858.      *
1859.      * @not-deprecated
1860.      */
1861.     public function walkGroupByClause($groupByClause)
1862.     {
1863.         $sqlParts = [];
1865.         foreach ($groupByClause->groupByItems as $groupByItem) {
1866.             $sqlParts[] = $this->walkGroupByItem($groupByItem);
1867.         }
1869.         return ' GROUP BY ' . implode(', ', $sqlParts);
1870.     }
1872.     /**
1873.      * Walks down a GroupByItem AST node, thereby generating the appropriate SQL.
1874.      *
1875.      * @param AST\PathExpression|string $groupByItem
1876.      *
1877.      * @return string
1878.      *
1879.      * @not-deprecated
1880.      */
1881.     public function walkGroupByItem($groupByItem)
1882.     {
1883.         // StateFieldPathExpression
1884.         if (! is_string($groupByItem)) {
1885.             return $this->walkPathExpression($groupByItem);
1886.         }
1888.         // ResultVariable
1889.         if (isset($this->queryComponents[$groupByItem]['resultVariable'])) {
1890.             $resultVariable = $this->queryComponents[$groupByItem]['resultVariable'];
1892.             if ($resultVariable instanceof AST\PathExpression) {
1893.                 return $this->walkPathExpression($resultVariable);
1894.             }
1896.             if ($resultVariable instanceof AST\Node && isset($resultVariable->pathExpression)) {
1897.                 return $this->walkPathExpression($resultVariable->pathExpression);
1898.             }
1900.             return $this->walkResultVariable($groupByItem);
1901.         }
1903.         // IdentificationVariable
1904.         $sqlParts = [];
1906.         foreach ($this->getMetadataForDqlAlias($groupByItem)->fieldNames as $field) {
1907.             $item       = new AST\PathExpression(AST\PathExpression::TYPE_STATE_FIELD, $groupByItem, $field);
1908.             $item->type = AST\PathExpression::TYPE_STATE_FIELD;
1910.             $sqlParts[] = $this->walkPathExpression($item);
1911.         }
1913.         foreach ($this->getMetadataForDqlAlias($groupByItem)->associationMappings as $mapping) {
1914.             if ($mapping['isOwningSide'] && $mapping['type'] & ClassMetadata::TO_ONE) {
1915.                 $item       = new AST\PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION, $groupByItem, $mapping['fieldName']);
1916.                 $item->type = AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION;
1918.                 $sqlParts[] = $this->walkPathExpression($item);
1919.             }
1920.         }
1922.         return implode(', ', $sqlParts);
1923.     }
1925.     /**
1926.      * Walks down a DeleteClause AST node, thereby generating the appropriate SQL.
1927.      *
1928.      * @return string
1929.      *
1930.      * @not-deprecated
1931.      */
1932.     public function walkDeleteClause(AST\DeleteClause $deleteClause)
1933.     {
1934.         $class     = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
1935.         $tableName = $class->getTableName();
1936.         $sql       = 'DELETE FROM ' . $this->quoteStrategy->getTableName($class, $this->platform);
1938.         $this->setSQLTableAlias($tableName, $tableName, $deleteClause->aliasIdentificationVariable);
1939.         $this->rootAliases[] = $deleteClause->aliasIdentificationVariable;
1941.         return $sql;
1942.     }
1944.     /**
1945.      * Walks down an UpdateClause AST node, thereby generating the appropriate SQL.
1946.      *
1947.      * @param AST\UpdateClause $updateClause
1948.      *
1949.      * @return string
1950.      *
1951.      * @not-deprecated
1952.      */
1953.     public function walkUpdateClause($updateClause)
1954.     {
1955.         $class     = $this->em->getClassMetadata($updateClause->abstractSchemaName);
1956.         $tableName = $class->getTableName();
1957.         $sql       = 'UPDATE ' . $this->quoteStrategy->getTableName($class, $this->platform);
1959.         $this->setSQLTableAlias($tableName, $tableName, $updateClause->aliasIdentificationVariable);
1960.         $this->rootAliases[] = $updateClause->aliasIdentificationVariable;
1962.         return $sql . ' SET ' . implode(', ', array_map([$this, 'walkUpdateItem'], $updateClause->updateItems));
1963.     }
1965.     /**
1966.      * Walks down an UpdateItem AST node, thereby generating the appropriate SQL.
1967.      *
1968.      * @param AST\UpdateItem $updateItem
1969.      *
1970.      * @return string
1971.      *
1972.      * @not-deprecated
1973.      */
1974.     public function walkUpdateItem($updateItem)
1975.     {
1976.         $useTableAliasesBefore    = $this->useSqlTableAliases;
1977.         $this->useSqlTableAliases = false;
1979.         $sql      = $this->walkPathExpression($updateItem->pathExpression) . ' = ';
1980.         $newValue = $updateItem->newValue;
1982.         switch (true) {
1983.             case $newValue instanceof AST\Node:
1984.                 $sql .= $newValue->dispatch($this);
1985.                 break;
1987.             case $newValue === null:
1988.                 $sql .= 'NULL';
1989.                 break;
1991.             default:
1992.                 $sql .= $this->conn->quote($newValue);
1993.                 break;
1994.         }
1996.         $this->useSqlTableAliases = $useTableAliasesBefore;
1998.         return $sql;
1999.     }
2001.     /**
2002.      * Walks down a WhereClause AST node, thereby generating the appropriate SQL.
2003.      * WhereClause or not, the appropriate discriminator sql is added.
2004.      *
2005.      * @param AST\WhereClause $whereClause
2006.      *
2007.      * @return string
2008.      *
2009.      * @not-deprecated
2010.      */
2011.     public function walkWhereClause($whereClause)
2012.     {
2013.         $condSql  = $whereClause !== null ? $this->walkConditionalExpression($whereClause->conditionalExpression) : '';
2014.         $discrSql = $this->generateDiscriminatorColumnConditionSQL($this->rootAliases);
2016.         if ($this->em->hasFilters()) {
2017.             $filterClauses = [];
2018.             foreach ($this->rootAliases as $dqlAlias) {
2019.                 $class      = $this->getMetadataForDqlAlias($dqlAlias);
2020.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
2022.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
2023.                 if ($filterExpr) {
2024.                     $filterClauses[] = $filterExpr;
2025.                 }
2026.             }
2028.             if (count($filterClauses)) {
2029.                 if ($condSql) {
2030.                     $condSql = '(' . $condSql . ') AND ';
2031.                 }
2033.                 $condSql .= implode(' AND ', $filterClauses);
2034.             }
2035.         }
2037.         if ($condSql) {
2038.             return ' WHERE ' . (! $discrSql ? $condSql : '(' . $condSql . ') AND ' . $discrSql);
2039.         }
2041.         if ($discrSql) {
2042.             return ' WHERE ' . $discrSql;
2043.         }
2045.         return '';
2046.     }
2048.     /**
2049.      * Walk down a ConditionalExpression AST node, thereby generating the appropriate SQL.
2050.      *
2051.      * @param AST\ConditionalExpression $condExpr
2052.      *
2053.      * @return string
2054.      *
2055.      * @not-deprecated
2056.      */
2057.     public function walkConditionalExpression($condExpr)
2058.     {
2059.         // Phase 2 AST optimization: Skip processing of ConditionalExpression
2060.         // if only one ConditionalTerm is defined
2061.         if (! ($condExpr instanceof AST\ConditionalExpression)) {
2062.             return $this->walkConditionalTerm($condExpr);
2063.         }
2065.         return implode(' OR ', array_map([$this, 'walkConditionalTerm'], $condExpr->conditionalTerms));
2066.     }
2068.     /**
2069.      * Walks down a ConditionalTerm AST node, thereby generating the appropriate SQL.
2070.      *
2071.      * @param AST\ConditionalTerm $condTerm
2072.      *
2073.      * @return string
2074.      *
2075.      * @not-deprecated
2076.      */
2077.     public function walkConditionalTerm($condTerm)
2078.     {
2079.         // Phase 2 AST optimization: Skip processing of ConditionalTerm
2080.         // if only one ConditionalFactor is defined
2081.         if (! ($condTerm instanceof AST\ConditionalTerm)) {
2082.             return $this->walkConditionalFactor($condTerm);
2083.         }
2085.         return implode(' AND ', array_map([$this, 'walkConditionalFactor'], $condTerm->conditionalFactors));
2086.     }
2088.     /**
2089.      * Walks down a ConditionalFactor AST node, thereby generating the appropriate SQL.
2090.      *
2091.      * @param AST\ConditionalFactor $factor
2092.      *
2093.      * @return string The SQL.
2094.      *
2095.      * @not-deprecated
2096.      */
2097.     public function walkConditionalFactor($factor)
2098.     {
2099.         // Phase 2 AST optimization: Skip processing of ConditionalFactor
2100.         // if only one ConditionalPrimary is defined
2101.         return ! ($factor instanceof AST\ConditionalFactor)
2102.             ? $this->walkConditionalPrimary($factor)
2103.             : ($factor->not ? 'NOT ' : '') . $this->walkConditionalPrimary($factor->conditionalPrimary);
2104.     }
2106.     /**
2107.      * Walks down a ConditionalPrimary AST node, thereby generating the appropriate SQL.
2108.      *
2109.      * @param AST\ConditionalPrimary $primary
2110.      *
2111.      * @return string
2112.      *
2113.      * @not-deprecated
2114.      */
2115.     public function walkConditionalPrimary($primary)
2116.     {
2117.         if ($primary->isSimpleConditionalExpression()) {
2118.             return $primary->simpleConditionalExpression->dispatch($this);
2119.         }
2121.         if ($primary->isConditionalExpression()) {
2122.             $condExpr = $primary->conditionalExpression;
2124.             return '(' . $this->walkConditionalExpression($condExpr) . ')';
2125.         }
2126.     }
2128.     /**
2129.      * Walks down an ExistsExpression AST node, thereby generating the appropriate SQL.
2130.      *
2131.      * @param AST\ExistsExpression $existsExpr
2132.      *
2133.      * @return string
2134.      *
2135.      * @not-deprecated
2136.      */
2137.     public function walkExistsExpression($existsExpr)
2138.     {
2139.         $sql = $existsExpr->not ? 'NOT ' : '';
2141.         $sql .= 'EXISTS (' . $this->walkSubselect($existsExpr->subselect) . ')';
2143.         return $sql;
2144.     }
2146.     /**
2147.      * Walks down a CollectionMemberExpression AST node, thereby generating the appropriate SQL.
2148.      *
2149.      * @param AST\CollectionMemberExpression $collMemberExpr
2150.      *
2151.      * @return string
2152.      *
2153.      * @not-deprecated
2154.      */
2155.     public function walkCollectionMemberExpression($collMemberExpr)
2156.     {
2157.         $sql  = $collMemberExpr->not ? 'NOT ' : '';
2158.         $sql .= 'EXISTS (SELECT 1 FROM ';
2160.         $entityExpr   = $collMemberExpr->entityExpression;
2161.         $collPathExpr = $collMemberExpr->collectionValuedPathExpression;
2162.         assert($collPathExpr->field !== null);
2164.         $fieldName = $collPathExpr->field;
2165.         $dqlAlias  = $collPathExpr->identificationVariable;
2167.         $class = $this->getMetadataForDqlAlias($dqlAlias);
2169.         switch (true) {
2170.             // InputParameter
2171.             case $entityExpr instanceof AST\InputParameter:
2172.                 $dqlParamKey = $entityExpr->name;
2173.                 $entitySql   = '?';
2174.                 break;
2176.             // SingleValuedAssociationPathExpression | IdentificationVariable
2177.             case $entityExpr instanceof AST\PathExpression:
2178.                 $entitySql = $this->walkPathExpression($entityExpr);
2179.                 break;
2181.             default:
2182.                 throw new BadMethodCallException('Not implemented');
2183.         }
2185.         $assoc = $class->associationMappings[$fieldName];
2187.         if ($assoc['type'] === ClassMetadata::ONE_TO_MANY) {
2188.             $targetClass      = $this->em->getClassMetadata($assoc['targetEntity']);
2189.             $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName());
2190.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
2192.             $sql .= $this->quoteStrategy->getTableName($targetClass, $this->platform) . ' ' . $targetTableAlias . ' WHERE ';
2194.             $owningAssoc = $targetClass->associationMappings[$assoc['mappedBy']];
2195.             $sqlParts    = [];
2197.             foreach ($owningAssoc['targetToSourceKeyColumns'] as $targetColumn => $sourceColumn) {
2198.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$targetColumn], $class, $this->platform);
2200.                 $sqlParts[] = $sourceTableAlias . '.' . $targetColumn . ' = ' . $targetTableAlias . '.' . $sourceColumn;
2201.             }
2203.             foreach ($this->quoteStrategy->getIdentifierColumnNames($targetClass, $this->platform) as $targetColumnName) {
2204.                 if (isset($dqlParamKey)) {
2205.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
2206.                 }
2208.                 $sqlParts[] = $targetTableAlias . '.' . $targetColumnName . ' = ' . $entitySql;
2209.             }
2211.             $sql .= implode(' AND ', $sqlParts);
2212.         } else { // many-to-many
2213.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
2215.             $owningAssoc = $assoc['isOwningSide'] ? $assoc : $targetClass->associationMappings[$assoc['mappedBy']];
2216.             $joinTable   = $owningAssoc['joinTable'];
2218.             // SQL table aliases
2219.             $joinTableAlias   = $this->getSQLTableAlias($joinTable['name']);
2220.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
2222.             $sql .= $this->quoteStrategy->getJoinTableName($owningAssoc, $targetClass, $this->platform) . ' ' . $joinTableAlias . ' WHERE ';
2224.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['joinColumns'] : $joinTable['inverseJoinColumns'];
2225.             $sqlParts    = [];
2227.             foreach ($joinColumns as $joinColumn) {
2228.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$joinColumn['referencedColumnName']], $class, $this->platform);
2230.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' = ' . $sourceTableAlias . '.' . $targetColumn;
2231.             }
2233.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['inverseJoinColumns'] : $joinTable['joinColumns'];
2235.             foreach ($joinColumns as $joinColumn) {
2236.                 if (isset($dqlParamKey)) {
2237.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
2238.                 }
2240.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' IN (' . $entitySql . ')';
2241.             }
2243.             $sql .= implode(' AND ', $sqlParts);
2244.         }
2246.         return $sql . ')';
2247.     }
2249.     /**
2250.      * Walks down an EmptyCollectionComparisonExpression AST node, thereby generating the appropriate SQL.
2251.      *
2252.      * @param AST\EmptyCollectionComparisonExpression $emptyCollCompExpr
2253.      *
2254.      * @return string
2255.      *
2256.      * @not-deprecated
2257.      */
2258.     public function walkEmptyCollectionComparisonExpression($emptyCollCompExpr)
2259.     {
2260.         $sizeFunc                           = new AST\Functions\SizeFunction('size');
2261.         $sizeFunc->collectionPathExpression = $emptyCollCompExpr->expression;
2263.         return $sizeFunc->getSql($this) . ($emptyCollCompExpr->not ? ' > 0' : ' = 0');
2264.     }
2266.     /**
2267.      * Walks down a NullComparisonExpression AST node, thereby generating the appropriate SQL.
2268.      *
2269.      * @param AST\NullComparisonExpression $nullCompExpr
2270.      *
2271.      * @return string
2272.      *
2273.      * @not-deprecated
2274.      */
2275.     public function walkNullComparisonExpression($nullCompExpr)
2276.     {
2277.         $expression = $nullCompExpr->expression;
2278.         $comparison = ' IS' . ($nullCompExpr->not ? ' NOT' : '') . ' NULL';
2280.         // Handle ResultVariable
2281.         if (is_string($expression) && isset($this->queryComponents[$expression]['resultVariable'])) {
2282.             return $this->walkResultVariable($expression) . $comparison;
2283.         }
2285.         // Handle InputParameter mapping inclusion to ParserResult
2286.         if ($expression instanceof AST\InputParameter) {
2287.             return $this->walkInputParameter($expression) . $comparison;
2288.         }
2290.         return $expression->dispatch($this) . $comparison;
2291.     }
2293.     /**
2294.      * Walks down an InExpression AST node, thereby generating the appropriate SQL.
2295.      *
2296.      * @deprecated Use {@see walkInListExpression()} or {@see walkInSubselectExpression()} instead.
2297.      *
2298.      * @param AST\InExpression $inExpr
2299.      *
2300.      * @return string
2301.      */
2302.     public function walkInExpression($inExpr)
2303.     {
2304.         Deprecation::triggerIfCalledFromOutside(
2305.             'doctrine/orm',
2306.             'https://github.com/doctrine/orm/pull/10267',
2307.             '%s() is deprecated, call walkInListExpression() or walkInSubselectExpression() instead.',
2308.             __METHOD__
2309.         );
2311.         if ($inExpr instanceof AST\InListExpression) {
2312.             return $this->walkInListExpression($inExpr);
2313.         }
2315.         if ($inExpr instanceof AST\InSubselectExpression) {
2316.             return $this->walkInSubselectExpression($inExpr);
2317.         }
2319.         $sql = $this->walkArithmeticExpression($inExpr->expression) . ($inExpr->not ? ' NOT' : '') . ' IN (';
2321.         $sql .= $inExpr->subselect
2322.             ? $this->walkSubselect($inExpr->subselect)
2323.             : implode(', ', array_map([$this, 'walkInParameter'], $inExpr->literals));
2325.         $sql .= ')';
2327.         return $sql;
2328.     }
2330.     /**
2331.      * Walks down an InExpression AST node, thereby generating the appropriate SQL.
2332.      */
2333.     public function walkInListExpression(AST\InListExpression $inExpr): string
2334.     {
2335.         return $this->walkArithmeticExpression($inExpr->expression)
2336.             . ($inExpr->not ? ' NOT' : '') . ' IN ('
2337.             . implode(', ', array_map([$this, 'walkInParameter'], $inExpr->literals))
2338.             . ')';
2339.     }
2341.     /**
2342.      * Walks down an InExpression AST node, thereby generating the appropriate SQL.
2343.      */
2344.     public function walkInSubselectExpression(AST\InSubselectExpression $inExpr): string
2345.     {
2346.         return $this->walkArithmeticExpression($inExpr->expression)
2347.             . ($inExpr->not ? ' NOT' : '') . ' IN ('
2348.             . $this->walkSubselect($inExpr->subselect)
2349.             . ')';
2350.     }
2352.     /**
2353.      * Walks down an InstanceOfExpression AST node, thereby generating the appropriate SQL.
2354.      *
2355.      * @param AST\InstanceOfExpression $instanceOfExpr
2356.      *
2357.      * @return string
2358.      *
2359.      * @throws QueryException
2360.      *
2361.      * @not-deprecated
2362.      */
2363.     public function walkInstanceOfExpression($instanceOfExpr)
2364.     {
2365.         $sql = '';
2367.         $dqlAlias   = $instanceOfExpr->identificationVariable;
2368.         $discrClass = $class = $this->getMetadataForDqlAlias($dqlAlias);
2370.         if ($class->discriminatorColumn) {
2371.             $discrClass = $this->em->getClassMetadata($class->rootEntityName);
2372.         }
2374.         if ($this->useSqlTableAliases) {
2375.             $sql .= $this->getSQLTableAlias($discrClass->getTableName(), $dqlAlias) . '.';
2376.         }
2378.         $sql .= $class->getDiscriminatorColumn()['name'] . ($instanceOfExpr->not ? ' NOT IN ' : ' IN ');
2379.         $sql .= $this->getChildDiscriminatorsFromClassMetadata($discrClass, $instanceOfExpr);
2381.         return $sql;
2382.     }
2384.     /**
2385.      * @param mixed $inParam
2386.      *
2387.      * @return string
2388.      *
2389.      * @not-deprecated
2390.      */
2391.     public function walkInParameter($inParam)
2392.     {
2393.         return $inParam instanceof AST\InputParameter
2394.             ? $this->walkInputParameter($inParam)
2395.             : $this->walkArithmeticExpression($inParam);
2396.     }
2398.     /**
2399.      * Walks down a literal that represents an AST node, thereby generating the appropriate SQL.
2400.      *
2401.      * @param AST\Literal $literal
2402.      *
2403.      * @return string
2404.      *
2405.      * @not-deprecated
2406.      */
2407.     public function walkLiteral($literal)
2408.     {
2409.         switch ($literal->type) {
2410.             case AST\Literal::STRING:
2411.                 return $this->conn->quote($literal->value);
2413.             case AST\Literal::BOOLEAN:
2414.                 return (string) $this->conn->getDatabasePlatform()->convertBooleans(strtolower($literal->value) === 'true');
2416.             case AST\Literal::NUMERIC:
2417.                 return (string) $literal->value;
2419.             default:
2420.                 throw QueryException::invalidLiteral($literal);
2421.         }
2422.     }
2424.     /**
2425.      * Walks down a BetweenExpression AST node, thereby generating the appropriate SQL.
2426.      *
2427.      * @param AST\BetweenExpression $betweenExpr
2428.      *
2429.      * @return string
2430.      *
2431.      * @not-deprecated
2432.      */
2433.     public function walkBetweenExpression($betweenExpr)
2434.     {
2435.         $sql = $this->walkArithmeticExpression($betweenExpr->expression);
2437.         if ($betweenExpr->not) {
2438.             $sql .= ' NOT';
2439.         }
2441.         $sql .= ' BETWEEN ' . $this->walkArithmeticExpression($betweenExpr->leftBetweenExpression)
2442.             . ' AND ' . $this->walkArithmeticExpression($betweenExpr->rightBetweenExpression);
2444.         return $sql;
2445.     }
2447.     /**
2448.      * Walks down a LikeExpression AST node, thereby generating the appropriate SQL.
2449.      *
2450.      * @param AST\LikeExpression $likeExpr
2451.      *
2452.      * @return string
2453.      *
2454.      * @not-deprecated
2455.      */
2456.     public function walkLikeExpression($likeExpr)
2457.     {
2458.         $stringExpr = $likeExpr->stringExpression;
2459.         if (is_string($stringExpr)) {
2460.             if (! isset($this->queryComponents[$stringExpr]['resultVariable'])) {
2461.                 throw new LogicException(sprintf('No result variable found for string expression "%s".', $stringExpr));
2462.             }
2464.             $leftExpr = $this->walkResultVariable($stringExpr);
2465.         } else {
2466.             $leftExpr = $stringExpr->dispatch($this);
2467.         }
2469.         $sql = $leftExpr . ($likeExpr->not ? ' NOT' : '') . ' LIKE ';
2471.         if ($likeExpr->stringPattern instanceof AST\InputParameter) {
2472.             $sql .= $this->walkInputParameter($likeExpr->stringPattern);
2473.         } elseif ($likeExpr->stringPattern instanceof AST\Functions\FunctionNode) {
2474.             $sql .= $this->walkFunction($likeExpr->stringPattern);
2475.         } elseif ($likeExpr->stringPattern instanceof AST\PathExpression) {
2476.             $sql .= $this->walkPathExpression($likeExpr->stringPattern);
2477.         } else {
2478.             $sql .= $this->walkLiteral($likeExpr->stringPattern);
2479.         }
2481.         if ($likeExpr->escapeChar) {
2482.             $sql .= ' ESCAPE ' . $this->walkLiteral($likeExpr->escapeChar);
2483.         }
2485.         return $sql;
2486.     }
2488.     /**
2489.      * Walks down a StateFieldPathExpression AST node, thereby generating the appropriate SQL.
2490.      *
2491.      * @param AST\PathExpression $stateFieldPathExpression
2492.      *
2493.      * @return string
2494.      *
2495.      * @not-deprecated
2496.      */
2497.     public function walkStateFieldPathExpression($stateFieldPathExpression)
2498.     {
2499.         return $this->walkPathExpression($stateFieldPathExpression);
2500.     }
2502.     /**
2503.      * Walks down a ComparisonExpression AST node, thereby generating the appropriate SQL.
2504.      *
2505.      * @param AST\ComparisonExpression $compExpr
2506.      *
2507.      * @return string
2508.      *
2509.      * @not-deprecated
2510.      */
2511.     public function walkComparisonExpression($compExpr)
2512.     {
2513.         $leftExpr  = $compExpr->leftExpression;
2514.         $rightExpr = $compExpr->rightExpression;
2515.         $sql       = '';
2517.         $sql .= $leftExpr instanceof AST\Node
2518.             ? $leftExpr->dispatch($this)
2519.             : (is_numeric($leftExpr) ? $leftExpr : $this->conn->quote($leftExpr));
2521.         $sql .= ' ' . $compExpr->operator . ' ';
2523.         $sql .= $rightExpr instanceof AST\Node
2524.             ? $rightExpr->dispatch($this)
2525.             : (is_numeric($rightExpr) ? $rightExpr : $this->conn->quote($rightExpr));
2527.         return $sql;
2528.     }
2530.     /**
2531.      * Walks down an InputParameter AST node, thereby generating the appropriate SQL.
2532.      *
2533.      * @param AST\InputParameter $inputParam
2534.      *
2535.      * @return string
2536.      *
2537.      * @not-deprecated
2538.      */
2539.     public function walkInputParameter($inputParam)
2540.     {
2541.         $this->parserResult->addParameterMapping($inputParam->name, $this->sqlParamIndex++);
2543.         $parameter = $this->query->getParameter($inputParam->name);
2545.         if ($parameter) {
2546.             $type = $parameter->getType();
2547.             if (Type::hasType($type)) {
2548.                 return Type::getType($type)->convertToDatabaseValueSQL('?', $this->platform);
2549.             }
2550.         }
2552.         return '?';
2553.     }
2555.     /**
2556.      * Walks down an ArithmeticExpression AST node, thereby generating the appropriate SQL.
2557.      *
2558.      * @param AST\ArithmeticExpression $arithmeticExpr
2559.      *
2560.      * @return string
2561.      *
2562.      * @not-deprecated
2563.      */
2564.     public function walkArithmeticExpression($arithmeticExpr)
2565.     {
2566.         return $arithmeticExpr->isSimpleArithmeticExpression()
2567.             ? $this->walkSimpleArithmeticExpression($arithmeticExpr->simpleArithmeticExpression)
2568.             : '(' . $this->walkSubselect($arithmeticExpr->subselect) . ')';
2569.     }
2571.     /**
2572.      * Walks down an SimpleArithmeticExpression AST node, thereby generating the appropriate SQL.
2573.      *
2574.      * @param AST\SimpleArithmeticExpression $simpleArithmeticExpr
2575.      *
2576.      * @return string
2577.      *
2578.      * @not-deprecated
2579.      */
2580.     public function walkSimpleArithmeticExpression($simpleArithmeticExpr)
2581.     {
2582.         if (! ($simpleArithmeticExpr instanceof AST\SimpleArithmeticExpression)) {
2583.             return $this->walkArithmeticTerm($simpleArithmeticExpr);
2584.         }
2586.         return implode(' ', array_map([$this, 'walkArithmeticTerm'], $simpleArithmeticExpr->arithmeticTerms));
2587.     }
2589.     /**
2590.      * Walks down an ArithmeticTerm AST node, thereby generating the appropriate SQL.
2591.      *
2592.      * @param mixed $term
2593.      *
2594.      * @return string
2595.      *
2596.      * @not-deprecated
2597.      */
2598.     public function walkArithmeticTerm($term)
2599.     {
2600.         if (is_string($term)) {
2601.             return isset($this->queryComponents[$term])
2602.                 ? $this->walkResultVariable($this->queryComponents[$term]['token']->value)
2603.                 : $term;
2604.         }
2606.         // Phase 2 AST optimization: Skip processing of ArithmeticTerm
2607.         // if only one ArithmeticFactor is defined
2608.         if (! ($term instanceof AST\ArithmeticTerm)) {
2609.             return $this->walkArithmeticFactor($term);
2610.         }
2612.         return implode(' ', array_map([$this, 'walkArithmeticFactor'], $term->arithmeticFactors));
2613.     }
2615.     /**
2616.      * Walks down an ArithmeticFactor that represents an AST node, thereby generating the appropriate SQL.
2617.      *
2618.      * @param mixed $factor
2619.      *
2620.      * @return string
2621.      *
2622.      * @not-deprecated
2623.      */
2624.     public function walkArithmeticFactor($factor)
2625.     {
2626.         if (is_string($factor)) {
2627.             return isset($this->queryComponents[$factor])
2628.                 ? $this->walkResultVariable($this->queryComponents[$factor]['token']->value)
2629.                 : $factor;
2630.         }
2632.         // Phase 2 AST optimization: Skip processing of ArithmeticFactor
2633.         // if only one ArithmeticPrimary is defined
2634.         if (! ($factor instanceof AST\ArithmeticFactor)) {
2635.             return $this->walkArithmeticPrimary($factor);
2636.         }
2638.         $sign = $factor->isNegativeSigned() ? '-' : ($factor->isPositiveSigned() ? '+' : '');
2640.         return $sign . $this->walkArithmeticPrimary($factor->arithmeticPrimary);
2641.     }
2643.     /**
2644.      * Walks down an ArithmeticPrimary that represents an AST node, thereby generating the appropriate SQL.
2645.      *
2646.      * @param mixed $primary
2647.      *
2648.      * @return string The SQL.
2649.      *
2650.      * @not-deprecated
2651.      */
2652.     public function walkArithmeticPrimary($primary)
2653.     {
2654.         if ($primary instanceof AST\SimpleArithmeticExpression) {
2655.             return '(' . $this->walkSimpleArithmeticExpression($primary) . ')';
2656.         }
2658.         if ($primary instanceof AST\Node) {
2659.             return $primary->dispatch($this);
2660.         }
2662.         return $this->walkEntityIdentificationVariable($primary);
2663.     }
2665.     /**
2666.      * Walks down a StringPrimary that represents an AST node, thereby generating the appropriate SQL.
2667.      *
2668.      * @param mixed $stringPrimary
2669.      *
2670.      * @return string
2671.      *
2672.      * @not-deprecated
2673.      */
2674.     public function walkStringPrimary($stringPrimary)
2675.     {
2676.         return is_string($stringPrimary)
2677.             ? $this->conn->quote($stringPrimary)
2678.             : $stringPrimary->dispatch($this);
2679.     }
2681.     /**
2682.      * Walks down a ResultVariable that represents an AST node, thereby generating the appropriate SQL.
2683.      *
2684.      * @param string $resultVariable
2685.      *
2686.      * @return string
2687.      *
2688.      * @not-deprecated
2689.      */
2690.     public function walkResultVariable($resultVariable)
2691.     {
2692.         if (! isset($this->scalarResultAliasMap[$resultVariable])) {
2693.             throw new InvalidArgumentException(sprintf('Unknown result variable: %s', $resultVariable));
2694.         }
2696.         $resultAlias = $this->scalarResultAliasMap[$resultVariable];
2698.         if (is_array($resultAlias)) {
2699.             return implode(', ', $resultAlias);
2700.         }
2702.         return $resultAlias;
2703.     }
2705.     /**
2706.      * @return string The list in parentheses of valid child discriminators from the given class
2707.      *
2708.      * @throws QueryException
2709.      */
2710.     private function getChildDiscriminatorsFromClassMetadata(
2711.         ClassMetadata $rootClass,
2712.         AST\InstanceOfExpression $instanceOfExpr
2713.     ): string {
2714.         $sqlParameterList = [];
2715.         $discriminators   = [];
2716.         foreach ($instanceOfExpr->value as $parameter) {
2717.             if ($parameter instanceof AST\InputParameter) {
2718.                 $this->rsm->discriminatorParameters[$parameter->name] = $parameter->name;
2719.                 $sqlParameterList[]                                   = $this->walkInParameter($parameter);
2720.                 continue;
2721.             }
2723.             $metadata = $this->em->getClassMetadata($parameter);
2725.             if ($metadata->getName() !== $rootClass->name && ! $metadata->getReflectionClass()->isSubclassOf($rootClass->name)) {
2726.                 throw QueryException::instanceOfUnrelatedClass($parameter, $rootClass->name);
2727.             }
2729.             $discriminators += HierarchyDiscriminatorResolver::resolveDiscriminatorsForClass($metadata, $this->em);
2730.         }
2732.         foreach (array_keys($discriminators) as $dis) {
2733.             $sqlParameterList[] = $this->conn->quote($dis);
2734.         }
2736.         return '(' . implode(', ', $sqlParameterList) . ')';
2737.     }
2738. }