vendor/doctrine/orm/src/Query/SqlWalker.php line 305

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