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

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\PersisterHelper;
  20. use InvalidArgumentException;
  21. use LogicException;
  23. use function array_diff;
  24. use function array_filter;
  25. use function array_keys;
  26. use function array_map;
  27. use function array_merge;
  28. use function assert;
  29. use function count;
  30. use function implode;
  31. use function in_array;
  32. use function is_array;
  33. use function is_float;
  34. use function is_numeric;
  35. use function is_string;
  36. use function preg_match;
  37. use function reset;
  38. use function sprintf;
  39. use function strtolower;
  40. use function strtoupper;
  41. use function trim;
  43. /**
  44.  * The SqlWalker walks over a DQL AST and constructs the corresponding SQL.
  45.  *
  46.  * @psalm-import-type QueryComponent from Parser
  47.  * @psalm-consistent-constructor
  48.  */
  49. class SqlWalker implements TreeWalker
  50. {
  51.     public const HINT_DISTINCT = 'doctrine.distinct';
  53.     /**
  54.      * Used to mark a query as containing a PARTIAL expression, which needs to be known by SLC.
  55.      */
  56.     public const HINT_PARTIAL = 'doctrine.partial';
  58.     /** @var ResultSetMapping */
  59.     private $rsm;
  61.     /**
  62.      * Counter for generating unique column aliases.
  63.      *
  64.      * @var int
  65.      */
  66.     private $aliasCounter = 0;
  68.     /**
  69.      * Counter for generating unique table aliases.
  70.      *
  71.      * @var int
  72.      */
  73.     private $tableAliasCounter = 0;
  75.     /**
  76.      * Counter for generating unique scalar result.
  77.      *
  78.      * @var int
  79.      */
  80.     private $scalarResultCounter = 1;
  82.     /**
  83.      * Counter for generating unique parameter indexes.
  84.      *
  85.      * @var int
  86.      */
  87.     private $sqlParamIndex = 0;
  89.     /**
  90.      * Counter for generating indexes.
  91.      *
  92.      * @var int
  93.      */
  94.     private $newObjectCounter = 0;
  96.     /** @var ParserResult */
  97.     private $parserResult;
  99.     /** @var EntityManagerInterface */
  100.     private $em;
  102.     /** @var Connection */
  103.     private $conn;
  105.     /** @var Query */
  106.     private $query;
  108.     /** @var mixed[] */
  109.     private $tableAliasMap = [];
  111.     /**
  112.      * Map from result variable names to their SQL column alias names.
  113.      *
  114.      * @psalm-var array<string|int, string|list<string>>
  115.      */
  116.     private $scalarResultAliasMap = [];
  118.     /**
  119.      * Map from Table-Alias + Column-Name to OrderBy-Direction.
  120.      *
  121.      * @var array<string, string>
  122.      */
  123.     private $orderedColumnsMap = [];
  125.     /**
  126.      * Map from DQL-Alias + Field-Name to SQL Column Alias.
  127.      *
  128.      * @var array<string, array<string, string>>
  129.      */
  130.     private $scalarFields = [];
  132.     /**
  133.      * Map of all components/classes that appear in the DQL query.
  134.      *
  135.      * @psalm-var array<string, QueryComponent>
  136.      */
  137.     private $queryComponents;
  139.     /**
  140.      * A list of classes that appear in non-scalar SelectExpressions.
  141.      *
  142.      * @psalm-var array<string, array{class: ClassMetadata, dqlAlias: string, resultAlias: string|null}>
  143.      */
  144.     private $selectedClasses = [];
  146.     /**
  147.      * The DQL alias of the root class of the currently traversed query.
  148.      *
  149.      * @psalm-var list<string>
  150.      */
  151.     private $rootAliases = [];
  153.     /**
  154.      * Flag that indicates whether to generate SQL table aliases in the SQL.
  155.      * These should only be generated for SELECT queries, not for UPDATE/DELETE.
  156.      *
  157.      * @var bool
  158.      */
  159.     private $useSqlTableAliases = true;
  161.     /**
  162.      * The database platform abstraction.
  163.      *
  164.      * @var AbstractPlatform
  165.      */
  166.     private $platform;
  168.     /**
  169.      * The quote strategy.
  170.      *
  171.      * @var QuoteStrategy
  172.      */
  173.     private $quoteStrategy;
  175.     /**
  176.      * @param Query        $query        The parsed Query.
  177.      * @param ParserResult $parserResult The result of the parsing process.
  178.      * @psalm-param array<string, QueryComponent> $queryComponents The query components (symbol table).
  179.      */
  180.     public function __construct($query, $parserResult, array $queryComponents)
  181.     {
  182.         $this->query           = $query;
  183.         $this->parserResult    = $parserResult;
  184.         $this->queryComponents = $queryComponents;
  185.         $this->rsm             = $parserResult->getResultSetMapping();
  186.         $this->em              = $query->getEntityManager();
  187.         $this->conn            = $this->em->getConnection();
  188.         $this->platform        = $this->conn->getDatabasePlatform();
  189.         $this->quoteStrategy   = $this->em->getConfiguration()->getQuoteStrategy();
  190.     }
  192.     /**
  193.      * Gets the Query instance used by the walker.
  194.      *
  195.      * @return Query
  196.      */
  197.     public function getQuery()
  198.     {
  199.         return $this->query;
  200.     }
  202.     /**
  203.      * Gets the Connection used by the walker.
  204.      *
  205.      * @return Connection
  206.      */
  207.     public function getConnection()
  208.     {
  209.         return $this->conn;
  210.     }
  212.     /**
  213.      * Gets the EntityManager used by the walker.
  214.      *
  215.      * @return EntityManagerInterface
  216.      */
  217.     public function getEntityManager()
  218.     {
  219.         return $this->em;
  220.     }
  222.     /**
  223.      * Gets the information about a single query component.
  224.      *
  225.      * @param string $dqlAlias The DQL alias.
  226.      *
  227.      * @return mixed[]
  228.      * @psalm-return QueryComponent
  229.      */
  230.     public function getQueryComponent($dqlAlias)
  231.     {
  232.         return $this->queryComponents[$dqlAlias];
  233.     }
  235.     public function getMetadataForDqlAlias(string $dqlAlias): ClassMetadata
  236.     {
  237.         if (! isset($this->queryComponents[$dqlAlias]['metadata'])) {
  238.             throw new LogicException(sprintf('No metadata for DQL alias: %s', $dqlAlias));
  239.         }
  241.         return $this->queryComponents[$dqlAlias]['metadata'];
  242.     }
  244.     /**
  245.      * Returns internal queryComponents array.
  246.      *
  247.      * @return array<string, QueryComponent>
  248.      */
  249.     public function getQueryComponents()
  250.     {
  251.         return $this->queryComponents;
  252.     }
  254.     /**
  255.      * Sets or overrides a query component for a given dql alias.
  256.      *
  257.      * @param string $dqlAlias The DQL alias.
  258.      * @psalm-param QueryComponent $queryComponent
  259.      *
  260.      * @return void
  261.      *
  262.      * @not-deprecated
  263.      */
  264.     public function setQueryComponent($dqlAlias, array $queryComponent)
  265.     {
  266.         $requiredKeys = ['metadata', 'parent', 'relation', 'map', 'nestingLevel', 'token'];
  268.         if (array_diff($requiredKeys, array_keys($queryComponent))) {
  269.             throw QueryException::invalidQueryComponent($dqlAlias);
  270.         }
  272.         $this->queryComponents[$dqlAlias] = $queryComponent;
  273.     }
  275.     /**
  276.      * Gets an executor that can be used to execute the result of this walker.
  277.      *
  278.      * @deprecated Output walkers should no longer create the executor directly, but instead provide
  279.      *             a SqlFinalizer by implementing the `OutputWalker` interface. Thus, this method is
  280.      *             no longer needed and will be removed in 4.0.
  281.      *
  282.      * @param AST\DeleteStatement|AST\UpdateStatement|AST\SelectStatement $AST
  283.      *
  284.      * @return Exec\AbstractSqlExecutor
  285.      */
  286.     public function getExecutor($AST)
  287.     {
  288.         switch (true) {
  289.             case $AST instanceof AST\DeleteStatement:
  290.                 return $this->createDeleteStatementExecutor($AST);
  292.             case $AST instanceof AST\UpdateStatement:
  293.                 return $this->createUpdateStatementExecutor($AST);
  295.             default:
  296.                 return new Exec\SingleSelectExecutor($AST, $this);
  297.         }
  298.     }
  300.     /** @psalm-internal Doctrine\ORM */
  301.     protected function createUpdateStatementExecutor(AST\UpdateStatement $AST): Exec\AbstractSqlExecutor
  302.     {
  303.         $primaryClass = $this->em->getClassMetadata($AST->updateClause->abstractSchemaName);
  305.         return $primaryClass->isInheritanceTypeJoined()
  306.             ? new Exec\MultiTableUpdateExecutor($AST, $this)
  307.             : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
  308.     }
  310.     /** @psalm-internal Doctrine\ORM */
  311.     protected function createDeleteStatementExecutor(AST\DeleteStatement $AST): Exec\AbstractSqlExecutor
  312.     {
  313.         $primaryClass = $this->em->getClassMetadata($AST->deleteClause->abstractSchemaName);
  315.         return $primaryClass->isInheritanceTypeJoined()
  316.             ? new Exec\MultiTableDeleteExecutor($AST, $this)
  317.             : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
  318.     }
  320.     /**
  321.      * Generates a unique, short SQL table alias.
  322.      *
  323.      * @param string $tableName Table name
  324.      * @param string $dqlAlias  The DQL alias.
  325.      *
  326.      * @return string Generated table alias.
  327.      */
  328.     public function getSQLTableAlias($tableName, $dqlAlias = '')
  329.     {
  330.         $tableName .= $dqlAlias ? '@[' . $dqlAlias . ']' : '';
  332.         if (! isset($this->tableAliasMap[$tableName])) {
  333.             $this->tableAliasMap[$tableName] = (preg_match('/[a-z]/i', $tableName[0]) ? strtolower($tableName[0]) : 't')
  334.                 . $this->tableAliasCounter++ . '_';
  335.         }
  337.         return $this->tableAliasMap[$tableName];
  338.     }
  340.     /**
  341.      * Forces the SqlWalker to use a specific alias for a table name, rather than
  342.      * generating an alias on its own.
  343.      *
  344.      * @param string $tableName
  345.      * @param string $alias
  346.      * @param string $dqlAlias
  347.      *
  348.      * @return string
  349.      */
  350.     public function setSQLTableAlias($tableName, $alias, $dqlAlias = '')
  351.     {
  352.         $tableName .= $dqlAlias ? '@[' . $dqlAlias . ']' : '';
  354.         $this->tableAliasMap[$tableName] = $alias;
  356.         return $alias;
  357.     }
  359.     /**
  360.      * Gets an SQL column alias for a column name.
  361.      *
  362.      * @param string $columnName
  363.      *
  364.      * @return string
  365.      */
  366.     public function getSQLColumnAlias($columnName)
  367.     {
  368.         return $this->quoteStrategy->getColumnAlias($columnName, $this->aliasCounter++, $this->platform);
  369.     }
  371.     /**
  372.      * Generates the SQL JOINs that are necessary for Class Table Inheritance
  373.      * for the given class.
  374.      *
  375.      * @param ClassMetadata $class    The class for which to generate the joins.
  376.      * @param string        $dqlAlias The DQL alias of the class.
  377.      *
  378.      * @return string The SQL.
  379.      */
  380.     private function generateClassTableInheritanceJoins(
  381.         ClassMetadata $class,
  382.         string $dqlAlias
  383.     ): string {
  384.         $sql = '';
  386.         $baseTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  388.         // INNER JOIN parent class tables
  389.         foreach ($class->parentClasses as $parentClassName) {
  390.             $parentClass = $this->em->getClassMetadata($parentClassName);
  391.             $tableAlias  = $this->getSQLTableAlias($parentClass->getTableName(), $dqlAlias);
  393.             // If this is a joined association we must use left joins to preserve the correct result.
  394.             $sql .= isset($this->queryComponents[$dqlAlias]['relation']) ? ' LEFT ' : ' INNER ';
  395.             $sql .= 'JOIN ' . $this->quoteStrategy->getTableName($parentClass, $this->platform) . ' ' . $tableAlias . ' ON ';
  397.             $sqlParts = [];
  399.             foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
  400.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
  401.             }
  403.             // Add filters on the root class
  404.             $sqlParts[] = $this->generateFilterConditionSQL($parentClass, $tableAlias);
  406.             $sql .= implode(' AND ', array_filter($sqlParts));
  407.         }
  409.         // Ignore subclassing inclusion if partial objects is disallowed
  410.         if ($this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
  411.             return $sql;
  412.         }
  414.         // LEFT JOIN child class tables
  415.         foreach ($class->subClasses as $subClassName) {
  416.             $subClass   = $this->em->getClassMetadata($subClassName);
  417.             $tableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  419.             $sql .= ' LEFT JOIN ' . $this->quoteStrategy->getTableName($subClass, $this->platform) . ' ' . $tableAlias . ' ON ';
  421.             $sqlParts = [];
  423.             foreach ($this->quoteStrategy->getIdentifierColumnNames($subClass, $this->platform) as $columnName) {
  424.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
  425.             }
  427.             $sql .= implode(' AND ', $sqlParts);
  428.         }
  430.         return $sql;
  431.     }
  433.     private function generateOrderedCollectionOrderByItems(): string
  434.     {
  435.         $orderedColumns = [];
  437.         foreach ($this->selectedClasses as $selectedClass) {
  438.             $dqlAlias = $selectedClass['dqlAlias'];
  439.             $qComp    = $this->queryComponents[$dqlAlias];
  441.             if (! isset($qComp['relation']['orderBy'])) {
  442.                 continue;
  443.             }
  445.             assert(isset($qComp['metadata']));
  446.             $persister = $this->em->getUnitOfWork()->getEntityPersister($qComp['metadata']->name);
  448.             foreach ($qComp['relation']['orderBy'] as $fieldName => $orientation) {
  449.                 $columnName = $this->quoteStrategy->getColumnName($fieldName, $qComp['metadata'], $this->platform);
  450.                 $tableName  = $qComp['metadata']->isInheritanceTypeJoined()
  451.                     ? $persister->getOwningTable($fieldName)
  452.                     : $qComp['metadata']->getTableName();
  454.                 $orderedColumn = $this->getSQLTableAlias($tableName, $dqlAlias) . '.' . $columnName;
  456.                 // OrderByClause should replace an ordered relation. see - DDC-2475
  457.                 if (isset($this->orderedColumnsMap[$orderedColumn])) {
  458.                     continue;
  459.                 }
  461.                 $this->orderedColumnsMap[$orderedColumn] = $orientation;
  462.                 $orderedColumns[]                        = $orderedColumn . ' ' . $orientation;
  463.             }
  464.         }
  466.         return implode(', ', $orderedColumns);
  467.     }
  469.     /**
  470.      * Generates a discriminator column SQL condition for the class with the given DQL alias.
  471.      *
  472.      * @psalm-param list<string> $dqlAliases List of root DQL aliases to inspect for discriminator restrictions.
  473.      */
  474.     private function generateDiscriminatorColumnConditionSQL(array $dqlAliases): string
  475.     {
  476.         $sqlParts = [];
  478.         foreach ($dqlAliases as $dqlAlias) {
  479.             $class = $this->getMetadataForDqlAlias($dqlAlias);
  481.             if (! $class->isInheritanceTypeSingleTable()) {
  482.                 continue;
  483.             }
  485.             $sqlTableAlias = $this->useSqlTableAliases
  486.                 ? $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.'
  487.                 : '';
  489.             $conn   = $this->em->getConnection();
  490.             $values = [];
  492.             if ($class->discriminatorValue !== null) { // discriminators can be 0
  493.                 $values[] = $conn->quote($class->discriminatorValue);
  494.             }
  496.             foreach ($class->subClasses as $subclassName) {
  497.                 $subclassMetadata = $this->em->getClassMetadata($subclassName);
  499.                 // Abstract entity classes show up in the list of subClasses, but may be omitted
  500.                 // from the discriminator map. In that case, they have a null discriminator value.
  501.                 if ($subclassMetadata->discriminatorValue === null) {
  502.                     continue;
  503.                 }
  505.                 $values[] = $conn->quote($subclassMetadata->discriminatorValue);
  506.             }
  508.             if ($values !== []) {
  509.                 $sqlParts[] = $sqlTableAlias . $class->getDiscriminatorColumn()['name'] . ' IN (' . implode(', ', $values) . ')';
  510.             } else {
  511.                 $sqlParts[] = '1=0'; // impossible condition
  512.             }
  513.         }
  515.         $sql = implode(' AND ', $sqlParts);
  517.         return count($sqlParts) > 1 ? '(' . $sql . ')' : $sql;
  518.     }
  520.     /**
  521.      * Generates the filter SQL for a given entity and table alias.
  522.      *
  523.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
  524.      * @param string        $targetTableAlias The table alias of the joined/selected table.
  525.      *
  526.      * @return string The SQL query part to add to a query.
  527.      */
  528.     private function generateFilterConditionSQL(
  529.         ClassMetadata $targetEntity,
  530.         string $targetTableAlias
  531.     ): string {
  532.         if (! $this->em->hasFilters()) {
  533.             return '';
  534.         }
  536.         switch ($targetEntity->inheritanceType) {
  537.             case ClassMetadata::INHERITANCE_TYPE_NONE:
  538.                 break;
  539.             case ClassMetadata::INHERITANCE_TYPE_JOINED:
  540.                 // The classes in the inheritance will be added to the query one by one,
  541.                 // but only the root node is getting filtered
  542.                 if ($targetEntity->name !== $targetEntity->rootEntityName) {
  543.                     return '';
  544.                 }
  546.                 break;
  547.             case ClassMetadata::INHERITANCE_TYPE_SINGLE_TABLE:
  548.                 // With STI the table will only be queried once, make sure that the filters
  549.                 // are added to the root entity
  550.                 $targetEntity = $this->em->getClassMetadata($targetEntity->rootEntityName);
  551.                 break;
  552.             default:
  553.                 //@todo: throw exception?
  554.                 return '';
  555.         }
  557.         $filterClauses = [];
  558.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  559.             $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
  560.             if ($filterExpr !== '') {
  561.                 $filterClauses[] = '(' . $filterExpr . ')';
  562.             }
  563.         }
  565.         return implode(' AND ', $filterClauses);
  566.     }
  568.     /**
  569.      * Walks down a SelectStatement AST node, thereby generating the appropriate SQL.
  570.      *
  571.      * @return string
  572.      */
  573.     public function walkSelectStatement(AST\SelectStatement $AST)
  574.     {
  575.         $sql       = $this->createSqlForFinalizer($AST);
  576.         $finalizer = new Exec\SingleSelectSqlFinalizer($sql);
  578.         return $finalizer->finalizeSql($this->query);
  579.     }
  581.     protected function createSqlForFinalizer(AST\SelectStatement $AST): string
  582.     {
  583.         $sql = $this->walkSelectClause($AST->selectClause)
  584.             . $this->walkFromClause($AST->fromClause)
  585.             . $this->walkWhereClause($AST->whereClause);
  587.         if ($AST->groupByClause) {
  588.             $sql .= $this->walkGroupByClause($AST->groupByClause);
  589.         }
  591.         if ($AST->havingClause) {
  592.             $sql .= $this->walkHavingClause($AST->havingClause);
  593.         }
  595.         if ($AST->orderByClause) {
  596.             $sql .= $this->walkOrderByClause($AST->orderByClause);
  597.         }
  599.         $orderBySql = $this->generateOrderedCollectionOrderByItems();
  600.         if (! $AST->orderByClause && $orderBySql) {
  601.             $sql .= ' ORDER BY ' . $orderBySql;
  602.         }
  604.         $this->assertOptimisticLockingHasAllClassesVersioned();
  606.         return $sql;
  607.     }
  609.     private function assertOptimisticLockingHasAllClassesVersioned(): void
  610.     {
  611.         $lockMode = $this->query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE;
  613.         if ($lockMode === LockMode::OPTIMISTIC) {
  614.             foreach ($this->selectedClasses as $selectedClass) {
  615.                 if (! $selectedClass['class']->isVersioned) {
  616.                     throw OptimisticLockException::lockFailed($selectedClass['class']->name);
  617.                 }
  618.             }
  619.         }
  620.     }
  622.     /**
  623.      * Walks down an UpdateStatement AST node, thereby generating the appropriate SQL.
  624.      *
  625.      * @return string
  626.      */
  627.     public function walkUpdateStatement(AST\UpdateStatement $AST)
  628.     {
  629.         $this->useSqlTableAliases = false;
  630.         $this->rsm->isSelect      = false;
  632.         return $this->walkUpdateClause($AST->updateClause)
  633.             . $this->walkWhereClause($AST->whereClause);
  634.     }
  636.     /**
  637.      * Walks down a DeleteStatement AST node, thereby generating the appropriate SQL.
  638.      *
  639.      * @return string
  640.      */
  641.     public function walkDeleteStatement(AST\DeleteStatement $AST)
  642.     {
  643.         $this->useSqlTableAliases = false;
  644.         $this->rsm->isSelect      = false;
  646.         return $this->walkDeleteClause($AST->deleteClause)
  647.             . $this->walkWhereClause($AST->whereClause);
  648.     }
  650.     /**
  651.      * Walks down an IdentificationVariable AST node, thereby generating the appropriate SQL.
  652.      * This one differs of ->walkIdentificationVariable() because it generates the entity identifiers.
  653.      *
  654.      * @param string $identVariable
  655.      *
  656.      * @return string
  657.      *
  658.      * @not-deprecated
  659.      */
  660.     public function walkEntityIdentificationVariable($identVariable)
  661.     {
  662.         $class      = $this->getMetadataForDqlAlias($identVariable);
  663.         $tableAlias = $this->getSQLTableAlias($class->getTableName(), $identVariable);
  664.         $sqlParts   = [];
  666.         foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
  667.             $sqlParts[] = $tableAlias . '.' . $columnName;
  668.         }
  670.         return implode(', ', $sqlParts);
  671.     }
  673.     /**
  674.      * Walks down an IdentificationVariable (no AST node associated), thereby generating the SQL.
  675.      *
  676.      * @param string $identificationVariable
  677.      * @param string $fieldName
  678.      *
  679.      * @return string The SQL.
  680.      *
  681.      * @not-deprecated
  682.      */
  683.     public function walkIdentificationVariable($identificationVariable, $fieldName = null)
  684.     {
  685.         $class = $this->getMetadataForDqlAlias($identificationVariable);
  687.         if (
  688.             $fieldName !== null && $class->isInheritanceTypeJoined() &&
  689.             isset($class->fieldMappings[$fieldName]['inherited'])
  690.         ) {
  691.             $class = $this->em->getClassMetadata($class->fieldMappings[$fieldName]['inherited']);
  692.         }
  694.         return $this->getSQLTableAlias($class->getTableName(), $identificationVariable);
  695.     }
  697.     /**
  698.      * Walks down a PathExpression AST node, thereby generating the appropriate SQL.
  699.      *
  700.      * @param AST\PathExpression $pathExpr
  701.      *
  702.      * @return string
  703.      *
  704.      * @not-deprecated
  705.      */
  706.     public function walkPathExpression($pathExpr)
  707.     {
  708.         $sql = '';
  709.         assert($pathExpr->field !== null);
  711.         switch ($pathExpr->type) {
  712.             case AST\PathExpression::TYPE_STATE_FIELD:
  713.                 $fieldName = $pathExpr->field;
  714.                 $dqlAlias  = $pathExpr->identificationVariable;
  715.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
  717.                 if ($this->useSqlTableAliases) {
  718.                     $sql .= $this->walkIdentificationVariable($dqlAlias, $fieldName) . '.';
  719.                 }
  721.                 $sql .= $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  722.                 break;
  724.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
  725.                 // 1- the owning side:
  726.                 //    Just use the foreign key, i.e. u.group_id
  727.                 $fieldName = $pathExpr->field;
  728.                 $dqlAlias  = $pathExpr->identificationVariable;
  729.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
  731.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
  732.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
  733.                 }
  735.                 $assoc = $class->associationMappings[$fieldName];
  737.                 if (! $assoc['isOwningSide']) {
  738.                     throw QueryException::associationPathInverseSideNotSupported($pathExpr);
  739.                 }
  741.                 // COMPOSITE KEYS NOT (YET?) SUPPORTED
  742.                 if (count($assoc['sourceToTargetKeyColumns']) > 1) {
  743.                     throw QueryException::associationPathCompositeKeyNotSupported();
  744.                 }
  746.                 if ($this->useSqlTableAliases) {
  747.                     $sql .= $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.';
  748.                 }
  750.                 $sql .= reset($assoc['targetToSourceKeyColumns']);
  751.                 break;
  753.             default:
  754.                 throw QueryException::invalidPathExpression($pathExpr);
  755.         }
  757.         return $sql;
  758.     }
  760.     /**
  761.      * Walks down a SelectClause AST node, thereby generating the appropriate SQL.
  762.      *
  763.      * @param AST\SelectClause $selectClause
  764.      *
  765.      * @return string
  766.      *
  767.      * @not-deprecated
  768.      */
  769.     public function walkSelectClause($selectClause)
  770.     {
  771.         $sql                  = 'SELECT ' . ($selectClause->isDistinct ? 'DISTINCT ' : '');
  772.         $sqlSelectExpressions = array_filter(array_map([$this, 'walkSelectExpression'], $selectClause->selectExpressions));
  774.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) === true && $selectClause->isDistinct) {
  775.             $this->query->setHint(self::HINT_DISTINCT, true);
  776.         }
  778.         $addMetaColumns = ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD) &&
  779.             $this->query->getHydrationMode() === Query::HYDRATE_OBJECT
  780.             || $this->query->getHint(Query::HINT_INCLUDE_META_COLUMNS);
  782.         foreach ($this->selectedClasses as $selectedClass) {
  783.             $class       = $selectedClass['class'];
  784.             $dqlAlias    = $selectedClass['dqlAlias'];
  785.             $resultAlias = $selectedClass['resultAlias'];
  787.             // Register as entity or joined entity result
  788.             if (! isset($this->queryComponents[$dqlAlias]['relation'])) {
  789.                 $this->rsm->addEntityResult($class->name, $dqlAlias, $resultAlias);
  790.             } else {
  791.                 assert(isset($this->queryComponents[$dqlAlias]['parent']));
  793.                 $this->rsm->addJoinedEntityResult(
  794.                     $class->name,
  795.                     $dqlAlias,
  796.                     $this->queryComponents[$dqlAlias]['parent'],
  797.                     $this->queryComponents[$dqlAlias]['relation']['fieldName']
  798.                 );
  799.             }
  801.             if ($class->isInheritanceTypeSingleTable() || $class->isInheritanceTypeJoined()) {
  802.                 // Add discriminator columns to SQL
  803.                 $rootClass   = $this->em->getClassMetadata($class->rootEntityName);
  804.                 $tblAlias    = $this->getSQLTableAlias($rootClass->getTableName(), $dqlAlias);
  805.                 $discrColumn = $rootClass->getDiscriminatorColumn();
  806.                 $columnAlias = $this->getSQLColumnAlias($discrColumn['name']);
  808.                 $sqlSelectExpressions[] = $tblAlias . '.' . $discrColumn['name'] . ' AS ' . $columnAlias;
  810.                 $this->rsm->setDiscriminatorColumn($dqlAlias, $columnAlias);
  811.                 $this->rsm->addMetaResult($dqlAlias, $columnAlias, $discrColumn['fieldName'], false, $discrColumn['type']);
  812.                 if (! empty($discrColumn['enumType'])) {
  813.                     $this->rsm->addEnumResult($columnAlias, $discrColumn['enumType']);
  814.                 }
  815.             }
  817.             // Add foreign key columns to SQL, if necessary
  818.             if (! $addMetaColumns && ! $class->containsForeignIdentifier) {
  819.                 continue;
  820.             }
  822.             // Add foreign key columns of class and also parent classes
  823.             foreach ($class->associationMappings as $assoc) {
  824.                 if (
  825.                     ! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)
  826.                     || ( ! $addMetaColumns && ! isset($assoc['id']))
  827.                 ) {
  828.                     continue;
  829.                 }
  831.                 $targetClass   = $this->em->getClassMetadata($assoc['targetEntity']);
  832.                 $isIdentifier  = (isset($assoc['id']) && $assoc['id'] === true);
  833.                 $owningClass   = isset($assoc['inherited']) ? $this->em->getClassMetadata($assoc['inherited']) : $class;
  834.                 $sqlTableAlias = $this->getSQLTableAlias($owningClass->getTableName(), $dqlAlias);
  836.                 foreach ($assoc['joinColumns'] as $joinColumn) {
  837.                     $columnName  = $joinColumn['name'];
  838.                     $columnAlias = $this->getSQLColumnAlias($columnName);
  839.                     $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  841.                     $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  842.                     $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
  844.                     $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $isIdentifier, $columnType);
  845.                 }
  846.             }
  848.             // Add foreign key columns to SQL, if necessary
  849.             if (! $addMetaColumns) {
  850.                 continue;
  851.             }
  853.             // Add foreign key columns of subclasses
  854.             foreach ($class->subClasses as $subClassName) {
  855.                 $subClass      = $this->em->getClassMetadata($subClassName);
  856.                 $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  858.                 foreach ($subClass->associationMappings as $assoc) {
  859.                     // Skip if association is inherited
  860.                     if (isset($assoc['inherited'])) {
  861.                         continue;
  862.                     }
  864.                     if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
  865.                         $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  867.                         foreach ($assoc['joinColumns'] as $joinColumn) {
  868.                             $columnName  = $joinColumn['name'];
  869.                             $columnAlias = $this->getSQLColumnAlias($columnName);
  870.                             $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  872.                             $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $subClass, $this->platform);
  873.                             $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
  875.                             $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $subClass->isIdentifier($columnName), $columnType);
  876.                         }
  877.                     }
  878.                 }
  879.             }
  880.         }
  882.         return $sql . implode(', ', $sqlSelectExpressions);
  883.     }
  885.     /**
  886.      * Walks down a FromClause AST node, thereby generating the appropriate SQL.
  887.      *
  888.      * @param AST\FromClause $fromClause
  889.      *
  890.      * @return string
  891.      *
  892.      * @not-deprecated
  893.      */
  894.     public function walkFromClause($fromClause)
  895.     {
  896.         $identificationVarDecls = $fromClause->identificationVariableDeclarations;
  897.         $sqlParts               = [];
  899.         foreach ($identificationVarDecls as $identificationVariableDecl) {
  900.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($identificationVariableDecl);
  901.         }
  903.         return ' FROM ' . implode(', ', $sqlParts);
  904.     }
  906.     /**
  907.      * Walks down a IdentificationVariableDeclaration AST node, thereby generating the appropriate SQL.
  908.      *
  909.      * @param AST\IdentificationVariableDeclaration $identificationVariableDecl
  910.      *
  911.      * @return string
  912.      *
  913.      * @not-deprecated
  914.      */
  915.     public function walkIdentificationVariableDeclaration($identificationVariableDecl)
  916.     {
  917.         $sql = $this->walkRangeVariableDeclaration($identificationVariableDecl->rangeVariableDeclaration);
  919.         if ($identificationVariableDecl->indexBy) {
  920.             $this->walkIndexBy($identificationVariableDecl->indexBy);
  921.         }
  923.         foreach ($identificationVariableDecl->joins as $join) {
  924.             $sql .= $this->walkJoin($join);
  925.         }
  927.         return $sql;
  928.     }
  930.     /**
  931.      * Walks down a IndexBy AST node.
  932.      *
  933.      * @param AST\IndexBy $indexBy
  934.      *
  935.      * @return void
  936.      *
  937.      * @not-deprecated
  938.      */
  939.     public function walkIndexBy($indexBy)
  940.     {
  941.         $pathExpression = $indexBy->singleValuedPathExpression;
  942.         $alias          = $pathExpression->identificationVariable;
  943.         assert($pathExpression->field !== null);
  945.         switch ($pathExpression->type) {
  946.             case AST\PathExpression::TYPE_STATE_FIELD:
  947.                 $field = $pathExpression->field;
  948.                 break;
  950.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
  951.                 // Just use the foreign key, i.e. u.group_id
  952.                 $fieldName = $pathExpression->field;
  953.                 $class     = $this->getMetadataForDqlAlias($alias);
  955.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
  956.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
  957.                 }
  959.                 $association = $class->associationMappings[$fieldName];
  961.                 if (! $association['isOwningSide']) {
  962.                     throw QueryException::associationPathInverseSideNotSupported($pathExpression);
  963.                 }
  965.                 if (count($association['sourceToTargetKeyColumns']) > 1) {
  966.                     throw QueryException::associationPathCompositeKeyNotSupported();
  967.                 }
  969.                 $field = reset($association['targetToSourceKeyColumns']);
  970.                 break;
  972.             default:
  973.                 throw QueryException::invalidPathExpression($pathExpression);
  974.         }
  976.         if (isset($this->scalarFields[$alias][$field])) {
  977.             $this->rsm->addIndexByScalar($this->scalarFields[$alias][$field]);
  979.             return;
  980.         }
  982.         $this->rsm->addIndexBy($alias, $field);
  983.     }
  985.     /**
  986.      * Walks down a RangeVariableDeclaration AST node, thereby generating the appropriate SQL.
  987.      *
  988.      * @param AST\RangeVariableDeclaration $rangeVariableDeclaration
  989.      *
  990.      * @return string
  991.      *
  992.      * @not-deprecated
  993.      */
  994.     public function walkRangeVariableDeclaration($rangeVariableDeclaration)
  995.     {
  996.         return $this->generateRangeVariableDeclarationSQL($rangeVariableDeclaration, false);
  997.     }
  999.     /**
  1000.      * Generate appropriate SQL for RangeVariableDeclaration AST node
  1001.      */
  1002.     private function generateRangeVariableDeclarationSQL(
  1003.         AST\RangeVariableDeclaration $rangeVariableDeclaration,
  1004.         bool $buildNestedJoins
  1005.     ): string {
  1006.         $class    = $this->em->getClassMetadata($rangeVariableDeclaration->abstractSchemaName);
  1007.         $dqlAlias = $rangeVariableDeclaration->aliasIdentificationVariable;
  1009.         if ($rangeVariableDeclaration->isRoot) {
  1010.             $this->rootAliases[] = $dqlAlias;
  1011.         }
  1013.         $sql = $this->platform->appendLockHint(
  1014.             $this->quoteStrategy->getTableName($class, $this->platform) . ' ' .
  1015.             $this->getSQLTableAlias($class->getTableName(), $dqlAlias),
  1016.             $this->query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE
  1017.         );
  1019.         if (! $class->isInheritanceTypeJoined()) {
  1020.             return $sql;
  1021.         }
  1023.         $classTableInheritanceJoins = $this->generateClassTableInheritanceJoins($class, $dqlAlias);
  1025.         if (! $buildNestedJoins) {
  1026.             return $sql . $classTableInheritanceJoins;
  1027.         }
  1029.         return $classTableInheritanceJoins === '' ? $sql : '(' . $sql . $classTableInheritanceJoins . ')';
  1030.     }
  1032.     /**
  1033.      * Walks down a JoinAssociationDeclaration AST node, thereby generating the appropriate SQL.
  1034.      *
  1035.      * @param AST\JoinAssociationDeclaration                             $joinAssociationDeclaration
  1036.      * @param int                                                        $joinType
  1037.      * @param AST\ConditionalExpression|AST\Phase2OptimizableConditional $condExpr
  1038.      * @psalm-param AST\Join::JOIN_TYPE_* $joinType
  1039.      *
  1040.      * @return string
  1041.      *
  1042.      * @throws QueryException
  1043.      *
  1044.      * @not-deprecated
  1045.      */
  1046.     public function walkJoinAssociationDeclaration($joinAssociationDeclaration, $joinType = AST\Join::JOIN_TYPE_INNER, $condExpr = null)
  1047.     {
  1048.         $sql = '';
  1050.         $associationPathExpression = $joinAssociationDeclaration->joinAssociationPathExpression;
  1051.         $joinedDqlAlias            = $joinAssociationDeclaration->aliasIdentificationVariable;
  1052.         $indexBy                   = $joinAssociationDeclaration->indexBy;
  1054.         $relation = $this->queryComponents[$joinedDqlAlias]['relation'] ?? null;
  1055.         assert($relation !== null);
  1056.         $targetClass     = $this->em->getClassMetadata($relation['targetEntity']);
  1057.         $sourceClass     = $this->em->getClassMetadata($relation['sourceEntity']);
  1058.         $targetTableName = $this->quoteStrategy->getTableName($targetClass, $this->platform);
  1060.         $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName(), $joinedDqlAlias);
  1061.         $sourceTableAlias = $this->getSQLTableAlias($sourceClass->getTableName(), $associationPathExpression->identificationVariable);
  1063.         // Ensure we got the owning side, since it has all mapping info
  1064.         $assoc = ! $relation['isOwningSide'] ? $targetClass->associationMappings[$relation['mappedBy']] : $relation;
  1066.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) === true && (! $this->query->getHint(self::HINT_DISTINCT) || isset($this->selectedClasses[$joinedDqlAlias]))) {
  1067.             if ($relation['type'] === ClassMetadata::ONE_TO_MANY || $relation['type'] === ClassMetadata::MANY_TO_MANY) {
  1068.                 throw QueryException::iterateWithFetchJoinNotAllowed($assoc);
  1069.             }
  1070.         }
  1072.         $fetchMode = $this->query->getHint('fetchMode')[$assoc['sourceEntity']][$assoc['fieldName']] ?? $relation['fetch'];
  1074.         if ($fetchMode === ClassMetadata::FETCH_EAGER && $condExpr !== null) {
  1075.             throw QueryException::eagerFetchJoinWithNotAllowed($assoc['sourceEntity'], $assoc['fieldName']);
  1076.         }
  1078.         // This condition is not checking ClassMetadata::MANY_TO_ONE, because by definition it cannot
  1079.         // be the owning side and previously we ensured that $assoc is always the owning side of the associations.
  1080.         // The owning side is necessary at this point because only it contains the JoinColumn information.
  1081.         switch (true) {
  1082.             case $assoc['type'] & ClassMetadata::TO_ONE:
  1083.                 $conditions = [];
  1085.                 foreach ($assoc['joinColumns'] as $joinColumn) {
  1086.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  1087.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  1089.                     if ($relation['isOwningSide']) {
  1090.                         $conditions[] = $sourceTableAlias . '.' . $quotedSourceColumn . ' = ' . $targetTableAlias . '.' . $quotedTargetColumn;
  1092.                         continue;
  1093.                     }
  1095.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $targetTableAlias . '.' . $quotedSourceColumn;
  1096.                 }
  1098.                 // Apply remaining inheritance restrictions
  1099.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
  1101.                 if ($discrSql) {
  1102.                     $conditions[] = $discrSql;
  1103.                 }
  1105.                 // Apply the filters
  1106.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
  1108.                 if ($filterExpr) {
  1109.                     $conditions[] = $filterExpr;
  1110.                 }
  1112.                 $targetTableJoin = [
  1113.                     'table' => $targetTableName . ' ' . $targetTableAlias,
  1114.                     'condition' => implode(' AND ', $conditions),
  1115.                 ];
  1116.                 break;
  1118.             case $assoc['type'] === ClassMetadata::MANY_TO_MANY:
  1119.                 // Join relation table
  1120.                 $joinTable      = $assoc['joinTable'];
  1121.                 $joinTableAlias = $this->getSQLTableAlias($joinTable['name'], $joinedDqlAlias);
  1122.                 $joinTableName  = $this->quoteStrategy->getJoinTableName($assoc, $sourceClass, $this->platform);
  1124.                 $conditions      = [];
  1125.                 $relationColumns = $relation['isOwningSide']
  1126.                     ? $assoc['joinTable']['joinColumns']
  1127.                     : $assoc['joinTable']['inverseJoinColumns'];
  1129.                 foreach ($relationColumns as $joinColumn) {
  1130.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  1131.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  1133.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
  1134.                 }
  1136.                 $sql .= $joinTableName . ' ' . $joinTableAlias . ' ON ' . implode(' AND ', $conditions);
  1138.                 // Join target table
  1139.                 $sql .= $joinType === AST\Join::JOIN_TYPE_LEFT || $joinType === AST\Join::JOIN_TYPE_LEFTOUTER ? ' LEFT JOIN ' : ' INNER JOIN ';
  1141.                 $conditions      = [];
  1142.                 $relationColumns = $relation['isOwningSide']
  1143.                     ? $assoc['joinTable']['inverseJoinColumns']
  1144.                     : $assoc['joinTable']['joinColumns'];
  1146.                 foreach ($relationColumns as $joinColumn) {
  1147.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  1148.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  1150.                     $conditions[] = $targetTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
  1151.                 }
  1153.                 // Apply remaining inheritance restrictions
  1154.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
  1156.                 if ($discrSql) {
  1157.                     $conditions[] = $discrSql;
  1158.                 }
  1160.                 // Apply the filters
  1161.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
  1163.                 if ($filterExpr) {
  1164.                     $conditions[] = $filterExpr;
  1165.                 }
  1167.                 $targetTableJoin = [
  1168.                     'table' => $targetTableName . ' ' . $targetTableAlias,
  1169.                     'condition' => implode(' AND ', $conditions),
  1170.                 ];
  1171.                 break;
  1173.             default:
  1174.                 throw new BadMethodCallException('Type of association must be one of *_TO_ONE or MANY_TO_MANY');
  1175.         }
  1177.         // Handle WITH clause
  1178.         $withCondition = $condExpr === null ? '' : ('(' . $this->walkConditionalExpression($condExpr) . ')');
  1180.         if ($targetClass->isInheritanceTypeJoined()) {
  1181.             $ctiJoins = $this->generateClassTableInheritanceJoins($targetClass, $joinedDqlAlias);
  1182.             // If we have WITH condition, we need to build nested joins for target class table and cti joins
  1183.             if ($withCondition && $ctiJoins) {
  1184.                 $sql .= '(' . $targetTableJoin['table'] . $ctiJoins . ') ON ' . $targetTableJoin['condition'];
  1185.             } else {
  1186.                 $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'] . $ctiJoins;
  1187.             }
  1188.         } else {
  1189.             $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'];
  1190.         }
  1192.         if ($withCondition) {
  1193.             $sql .= ' AND ' . $withCondition;
  1194.         }
  1196.         // Apply the indexes
  1197.         if ($indexBy) {
  1198.             // For Many-To-One or One-To-One associations this obviously makes no sense, but is ignored silently.
  1199.             $this->walkIndexBy($indexBy);
  1200.         } elseif (isset($relation['indexBy'])) {
  1201.             $this->rsm->addIndexBy($joinedDqlAlias, $relation['indexBy']);
  1202.         }
  1204.         return $sql;
  1205.     }
  1207.     /**
  1208.      * Walks down a FunctionNode AST node, thereby generating the appropriate SQL.
  1209.      *
  1210.      * @param AST\Functions\FunctionNode $function
  1211.      *
  1212.      * @return string
  1213.      *
  1214.      * @not-deprecated
  1215.      */
  1216.     public function walkFunction($function)
  1217.     {
  1218.         return $function->getSql($this);
  1219.     }
  1221.     /**
  1222.      * Walks down an OrderByClause AST node, thereby generating the appropriate SQL.
  1223.      *
  1224.      * @param AST\OrderByClause $orderByClause
  1225.      *
  1226.      * @return string
  1227.      *
  1228.      * @not-deprecated
  1229.      */
  1230.     public function walkOrderByClause($orderByClause)
  1231.     {
  1232.         $orderByItems = array_map([$this, 'walkOrderByItem'], $orderByClause->orderByItems);
  1234.         $collectionOrderByItems = $this->generateOrderedCollectionOrderByItems();
  1235.         if ($collectionOrderByItems !== '') {
  1236.             $orderByItems = array_merge($orderByItems, (array) $collectionOrderByItems);
  1237.         }
  1239.         return ' ORDER BY ' . implode(', ', $orderByItems);
  1240.     }
  1242.     /**
  1243.      * Walks down an OrderByItem AST node, thereby generating the appropriate SQL.
  1244.      *
  1245.      * @param AST\OrderByItem $orderByItem
  1246.      *
  1247.      * @return string
  1248.      *
  1249.      * @not-deprecated
  1250.      */
  1251.     public function walkOrderByItem($orderByItem)
  1252.     {
  1253.         $type = strtoupper($orderByItem->type);
  1254.         $expr = $orderByItem->expression;
  1255.         $sql  = $expr instanceof AST\Node
  1256.             ? $expr->dispatch($this)
  1257.             : $this->walkResultVariable($this->queryComponents[$expr]['token']->value);
  1259.         $this->orderedColumnsMap[$sql] = $type;
  1261.         if ($expr instanceof AST\Subselect) {
  1262.             return '(' . $sql . ') ' . $type;
  1263.         }
  1265.         return $sql . ' ' . $type;
  1266.     }
  1268.     /**
  1269.      * Walks down a HavingClause AST node, thereby generating the appropriate SQL.
  1270.      *
  1271.      * @param AST\HavingClause $havingClause
  1272.      *
  1273.      * @return string The SQL.
  1274.      *
  1275.      * @not-deprecated
  1276.      */
  1277.     public function walkHavingClause($havingClause)
  1278.     {
  1279.         return ' HAVING ' . $this->walkConditionalExpression($havingClause->conditionalExpression);
  1280.     }
  1282.     /**
  1283.      * Walks down a Join AST node and creates the corresponding SQL.
  1284.      *
  1285.      * @param AST\Join $join
  1286.      *
  1287.      * @return string
  1288.      *
  1289.      * @not-deprecated
  1290.      */
  1291.     public function walkJoin($join)
  1292.     {
  1293.         $joinType        = $join->joinType;
  1294.         $joinDeclaration = $join->joinAssociationDeclaration;
  1296.         $sql = $joinType === AST\Join::JOIN_TYPE_LEFT || $joinType === AST\Join::JOIN_TYPE_LEFTOUTER
  1297.             ? ' LEFT JOIN '
  1298.             : ' INNER JOIN ';
  1300.         switch (true) {
  1301.             case $joinDeclaration instanceof AST\RangeVariableDeclaration:
  1302.                 $class      = $this->em->getClassMetadata($joinDeclaration->abstractSchemaName);
  1303.                 $dqlAlias   = $joinDeclaration->aliasIdentificationVariable;
  1304.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
  1305.                 $conditions = [];
  1307.                 if ($join->conditionalExpression) {
  1308.                     $conditions[] = '(' . $this->walkConditionalExpression($join->conditionalExpression) . ')';
  1309.                 }
  1311.                 $isUnconditionalJoin = $conditions === [];
  1312.                 $condExprConjunction = $class->isInheritanceTypeJoined() && $joinType !== AST\Join::JOIN_TYPE_LEFT && $joinType !== AST\Join::JOIN_TYPE_LEFTOUTER && $isUnconditionalJoin
  1313.                     ? ' AND '
  1314.                     : ' ON ';
  1316.                 $sql .= $this->generateRangeVariableDeclarationSQL($joinDeclaration, ! $isUnconditionalJoin);
  1318.                 // Apply remaining inheritance restrictions
  1319.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$dqlAlias]);
  1321.                 if ($discrSql) {
  1322.                     $conditions[] = $discrSql;
  1323.                 }
  1325.                 // Apply the filters
  1326.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
  1328.                 if ($filterExpr) {
  1329.                     $conditions[] = $filterExpr;
  1330.                 }
  1332.                 if ($conditions) {
  1333.                     $sql .= $condExprConjunction . implode(' AND ', $conditions);
  1334.                 }
  1336.                 break;
  1338.             case $joinDeclaration instanceof AST\JoinAssociationDeclaration:
  1339.                 $sql .= $this->walkJoinAssociationDeclaration($joinDeclaration, $joinType, $join->conditionalExpression);
  1340.                 break;
  1341.         }
  1343.         return $sql;
  1344.     }
  1346.     /**
  1347.      * Walks down a CoalesceExpression AST node and generates the corresponding SQL.
  1348.      *
  1349.      * @param AST\CoalesceExpression $coalesceExpression
  1350.      *
  1351.      * @return string The SQL.
  1352.      *
  1353.      * @not-deprecated
  1354.      */
  1355.     public function walkCoalesceExpression($coalesceExpression)
  1356.     {
  1357.         $sql = 'COALESCE(';
  1359.         $scalarExpressions = [];
  1361.         foreach ($coalesceExpression->scalarExpressions as $scalarExpression) {
  1362.             $scalarExpressions[] = $this->walkSimpleArithmeticExpression($scalarExpression);
  1363.         }
  1365.         return $sql . implode(', ', $scalarExpressions) . ')';
  1366.     }
  1368.     /**
  1369.      * Walks down a NullIfExpression AST node and generates the corresponding SQL.
  1370.      *
  1371.      * @param AST\NullIfExpression $nullIfExpression
  1372.      *
  1373.      * @return string The SQL.
  1374.      *
  1375.      * @not-deprecated
  1376.      */
  1377.     public function walkNullIfExpression($nullIfExpression)
  1378.     {
  1379.         $firstExpression = is_string($nullIfExpression->firstExpression)
  1380.             ? $this->conn->quote($nullIfExpression->firstExpression)
  1381.             : $this->walkSimpleArithmeticExpression($nullIfExpression->firstExpression);
  1383.         $secondExpression = is_string($nullIfExpression->secondExpression)
  1384.             ? $this->conn->quote($nullIfExpression->secondExpression)
  1385.             : $this->walkSimpleArithmeticExpression($nullIfExpression->secondExpression);
  1387.         return 'NULLIF(' . $firstExpression . ', ' . $secondExpression . ')';
  1388.     }
  1390.     /**
  1391.      * Walks down a GeneralCaseExpression AST node and generates the corresponding SQL.
  1392.      *
  1393.      * @return string The SQL.
  1394.      *
  1395.      * @not-deprecated
  1396.      */
  1397.     public function walkGeneralCaseExpression(AST\GeneralCaseExpression $generalCaseExpression)
  1398.     {
  1399.         $sql = 'CASE';
  1401.         foreach ($generalCaseExpression->whenClauses as $whenClause) {
  1402.             $sql .= ' WHEN ' . $this->walkConditionalExpression($whenClause->caseConditionExpression);
  1403.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($whenClause->thenScalarExpression);
  1404.         }
  1406.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($generalCaseExpression->elseScalarExpression) . ' END';
  1408.         return $sql;
  1409.     }
  1411.     /**
  1412.      * Walks down a SimpleCaseExpression AST node and generates the corresponding SQL.
  1413.      *
  1414.      * @param AST\SimpleCaseExpression $simpleCaseExpression
  1415.      *
  1416.      * @return string The SQL.
  1417.      *
  1418.      * @not-deprecated
  1419.      */
  1420.     public function walkSimpleCaseExpression($simpleCaseExpression)
  1421.     {
  1422.         $sql = 'CASE ' . $this->walkStateFieldPathExpression($simpleCaseExpression->caseOperand);
  1424.         foreach ($simpleCaseExpression->simpleWhenClauses as $simpleWhenClause) {
  1425.             $sql .= ' WHEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->caseScalarExpression);
  1426.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->thenScalarExpression);
  1427.         }
  1429.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($simpleCaseExpression->elseScalarExpression) . ' END';
  1431.         return $sql;
  1432.     }
  1434.     /**
  1435.      * Walks down a SelectExpression AST node and generates the corresponding SQL.
  1436.      *
  1437.      * @param AST\SelectExpression $selectExpression
  1438.      *
  1439.      * @return string
  1440.      *
  1441.      * @not-deprecated
  1442.      */
  1443.     public function walkSelectExpression($selectExpression)
  1444.     {
  1445.         $sql    = '';
  1446.         $expr   = $selectExpression->expression;
  1447.         $hidden = $selectExpression->hiddenAliasResultVariable;
  1449.         switch (true) {
  1450.             case $expr instanceof AST\PathExpression:
  1451.                 if ($expr->type !== AST\PathExpression::TYPE_STATE_FIELD) {
  1452.                     throw QueryException::invalidPathExpression($expr);
  1453.                 }
  1455.                 assert($expr->field !== null);
  1456.                 $fieldName = $expr->field;
  1457.                 $dqlAlias  = $expr->identificationVariable;
  1458.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
  1460.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $fieldName;
  1461.                 $tableName   = $class->isInheritanceTypeJoined()
  1462.                     ? $this->em->getUnitOfWork()->getEntityPersister($class->name)->getOwningTable($fieldName)
  1463.                     : $class->getTableName();
  1465.                 $sqlTableAlias = $this->getSQLTableAlias($tableName, $dqlAlias);
  1466.                 $fieldMapping  = $class->fieldMappings[$fieldName];
  1467.                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  1468.                 $columnAlias   = $this->getSQLColumnAlias($fieldMapping['columnName']);
  1469.                 $col           = $sqlTableAlias . '.' . $columnName;
  1471.                 if (isset($fieldMapping['requireSQLConversion'])) {
  1472.                     $type = Type::getType($fieldMapping['type']);
  1473.                     $col  = $type->convertToPHPValueSQL($col, $this->conn->getDatabasePlatform());
  1474.                 }
  1476.                 $sql .= $col . ' AS ' . $columnAlias;
  1478.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1480.                 if (! $hidden) {
  1481.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldMapping['type']);
  1482.                     $this->scalarFields[$dqlAlias][$fieldName] = $columnAlias;
  1484.                     if (! empty($fieldMapping['enumType'])) {
  1485.                         $this->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
  1486.                     }
  1487.                 }
  1489.                 break;
  1491.             case $expr instanceof AST\AggregateExpression:
  1492.             case $expr instanceof AST\Functions\FunctionNode:
  1493.             case $expr instanceof AST\SimpleArithmeticExpression:
  1494.             case $expr instanceof AST\ArithmeticTerm:
  1495.             case $expr instanceof AST\ArithmeticFactor:
  1496.             case $expr instanceof AST\ParenthesisExpression:
  1497.             case $expr instanceof AST\Literal:
  1498.             case $expr instanceof AST\NullIfExpression:
  1499.             case $expr instanceof AST\CoalesceExpression:
  1500.             case $expr instanceof AST\GeneralCaseExpression:
  1501.             case $expr instanceof AST\SimpleCaseExpression:
  1502.                 $columnAlias = $this->getSQLColumnAlias('sclr');
  1503.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1505.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
  1507.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1509.                 if ($hidden) {
  1510.                     break;
  1511.                 }
  1513.                 if (! $expr instanceof Query\AST\TypedExpression) {
  1514.                     // Conceptually we could resolve field type here by traverse through AST to retrieve field type,
  1515.                     // but this is not a feasible solution; assume 'string'.
  1516.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
  1518.                     break;
  1519.                 }
  1521.                 $this->rsm->addScalarResult($columnAlias, $resultAlias, Type::getTypeRegistry()->lookupName($expr->getReturnType()));
  1523.                 break;
  1525.             case $expr instanceof AST\Subselect:
  1526.                 $columnAlias = $this->getSQLColumnAlias('sclr');
  1527.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1529.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
  1531.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1533.                 if (! $hidden) {
  1534.                     // We cannot resolve field type here; assume 'string'.
  1535.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
  1536.                 }
  1538.                 break;
  1540.             case $expr instanceof AST\NewObjectExpression:
  1541.                 $sql .= $this->walkNewObject($expr, $selectExpression->fieldIdentificationVariable);
  1542.                 break;
  1544.             default:
  1545.                 // IdentificationVariable or PartialObjectExpression
  1546.                 if ($expr instanceof AST\PartialObjectExpression) {
  1547.                     $this->query->setHint(self::HINT_PARTIAL, true);
  1549.                     $dqlAlias        = $expr->identificationVariable;
  1550.                     $partialFieldSet = $expr->partialFieldSet;
  1551.                 } else {
  1552.                     $dqlAlias        = $expr;
  1553.                     $partialFieldSet = [];
  1554.                 }
  1556.                 $class       = $this->getMetadataForDqlAlias($dqlAlias);
  1557.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: null;
  1559.                 if (! isset($this->selectedClasses[$dqlAlias])) {
  1560.                     $this->selectedClasses[$dqlAlias] = [
  1561.                         'class'       => $class,
  1562.                         'dqlAlias'    => $dqlAlias,
  1563.                         'resultAlias' => $resultAlias,
  1564.                     ];
  1565.                 }
  1567.                 $sqlParts = [];
  1569.                 // Select all fields from the queried class
  1570.                 foreach ($class->fieldMappings as $fieldName => $mapping) {
  1571.                     if ($partialFieldSet && ! in_array($fieldName, $partialFieldSet, true)) {
  1572.                         continue;
  1573.                     }
  1575.                     $tableName = isset($mapping['inherited'])
  1576.                         ? $this->em->getClassMetadata($mapping['inherited'])->getTableName()
  1577.                         : $class->getTableName();
  1579.                     $sqlTableAlias    = $this->getSQLTableAlias($tableName, $dqlAlias);
  1580.                     $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
  1581.                     $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  1583.                     $col = $sqlTableAlias . '.' . $quotedColumnName;
  1585.                     if (isset($mapping['requireSQLConversion'])) {
  1586.                         $type = Type::getType($mapping['type']);
  1587.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
  1588.                     }
  1590.                     $sqlParts[] = $col . ' AS ' . $columnAlias;
  1592.                     $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
  1594.                     $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $class->name);
  1596.                     if (! empty($mapping['enumType'])) {
  1597.                         $this->rsm->addEnumResult($columnAlias, $mapping['enumType']);
  1598.                     }
  1599.                 }
  1601.                 // Add any additional fields of subclasses (excluding inherited fields)
  1602.                 // 1) on Single Table Inheritance: always, since its marginal overhead
  1603.                 // 2) on Class Table Inheritance only if partial objects are disallowed,
  1604.                 //    since it requires outer joining subtables.
  1605.                 if ($class->isInheritanceTypeSingleTable() || ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
  1606.                     foreach ($class->subClasses as $subClassName) {
  1607.                         $subClass      = $this->em->getClassMetadata($subClassName);
  1608.                         $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  1610.                         foreach ($subClass->fieldMappings as $fieldName => $mapping) {
  1611.                             if (isset($mapping['inherited']) || ($partialFieldSet && ! in_array($fieldName, $partialFieldSet, true))) {
  1612.                                 continue;
  1613.                             }
  1615.                             $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
  1616.                             $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $subClass, $this->platform);
  1618.                             $col = $sqlTableAlias . '.' . $quotedColumnName;
  1620.                             if (isset($mapping['requireSQLConversion'])) {
  1621.                                 $type = Type::getType($mapping['type']);
  1622.                                 $col  = $type->convertToPHPValueSQL($col, $this->platform);
  1623.                             }
  1625.                             $sqlParts[] = $col . ' AS ' . $columnAlias;
  1627.                             $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
  1629.                             $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $subClassName);
  1630.                         }
  1631.                     }
  1632.                 }
  1634.                 $sql .= implode(', ', $sqlParts);
  1635.         }
  1637.         return $sql;
  1638.     }
  1640.     /**
  1641.      * Walks down a QuantifiedExpression AST node, thereby generating the appropriate SQL.
  1642.      *
  1643.      * @param AST\QuantifiedExpression $qExpr
  1644.      *
  1645.      * @return string
  1646.      *
  1647.      * @not-deprecated
  1648.      */
  1649.     public function walkQuantifiedExpression($qExpr)
  1650.     {
  1651.         return ' ' . strtoupper($qExpr->type) . '(' . $this->walkSubselect($qExpr->subselect) . ')';
  1652.     }
  1654.     /**
  1655.      * Walks down a Subselect AST node, thereby generating the appropriate SQL.
  1656.      *
  1657.      * @param AST\Subselect $subselect
  1658.      *
  1659.      * @return string
  1660.      *
  1661.      * @not-deprecated
  1662.      */
  1663.     public function walkSubselect($subselect)
  1664.     {
  1665.         $useAliasesBefore  = $this->useSqlTableAliases;
  1666.         $rootAliasesBefore = $this->rootAliases;
  1668.         $this->rootAliases        = []; // reset the rootAliases for the subselect
  1669.         $this->useSqlTableAliases = true;
  1671.         $sql  = $this->walkSimpleSelectClause($subselect->simpleSelectClause);
  1672.         $sql .= $this->walkSubselectFromClause($subselect->subselectFromClause);
  1673.         $sql .= $this->walkWhereClause($subselect->whereClause);
  1675.         $sql .= $subselect->groupByClause ? $this->walkGroupByClause($subselect->groupByClause) : '';
  1676.         $sql .= $subselect->havingClause ? $this->walkHavingClause($subselect->havingClause) : '';
  1677.         $sql .= $subselect->orderByClause ? $this->walkOrderByClause($subselect->orderByClause) : '';
  1679.         $this->rootAliases        = $rootAliasesBefore; // put the main aliases back
  1680.         $this->useSqlTableAliases = $useAliasesBefore;
  1682.         return $sql;
  1683.     }
  1685.     /**
  1686.      * Walks down a SubselectFromClause AST node, thereby generating the appropriate SQL.
  1687.      *
  1688.      * @param AST\SubselectFromClause $subselectFromClause
  1689.      *
  1690.      * @return string
  1691.      *
  1692.      * @not-deprecated
  1693.      */
  1694.     public function walkSubselectFromClause($subselectFromClause)
  1695.     {
  1696.         $identificationVarDecls = $subselectFromClause->identificationVariableDeclarations;
  1697.         $sqlParts               = [];
  1699.         foreach ($identificationVarDecls as $subselectIdVarDecl) {
  1700.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($subselectIdVarDecl);
  1701.         }
  1703.         return ' FROM ' . implode(', ', $sqlParts);
  1704.     }
  1706.     /**
  1707.      * Walks down a SimpleSelectClause AST node, thereby generating the appropriate SQL.
  1708.      *
  1709.      * @param AST\SimpleSelectClause $simpleSelectClause
  1710.      *
  1711.      * @return string
  1712.      *
  1713.      * @not-deprecated
  1714.      */
  1715.     public function walkSimpleSelectClause($simpleSelectClause)
  1716.     {
  1717.         return 'SELECT' . ($simpleSelectClause->isDistinct ? ' DISTINCT' : '')
  1718.             . $this->walkSimpleSelectExpression($simpleSelectClause->simpleSelectExpression);
  1719.     }
  1721.     /** @return string */
  1722.     public function walkParenthesisExpression(AST\ParenthesisExpression $parenthesisExpression)
  1723.     {
  1724.         return sprintf('(%s)', $parenthesisExpression->expression->dispatch($this));
  1725.     }
  1727.     /**
  1728.      * @param AST\NewObjectExpression $newObjectExpression
  1729.      * @param string|null             $newObjectResultAlias
  1730.      *
  1731.      * @return string The SQL.
  1732.      */
  1733.     public function walkNewObject($newObjectExpression, $newObjectResultAlias = null)
  1734.     {
  1735.         $sqlSelectExpressions = [];
  1736.         $objIndex             = $newObjectResultAlias ?: $this->newObjectCounter++;
  1738.         foreach ($newObjectExpression->args as $argIndex => $e) {
  1739.             $resultAlias = $this->scalarResultCounter++;
  1740.             $columnAlias = $this->getSQLColumnAlias('sclr');
  1741.             $fieldType   = 'string';
  1743.             switch (true) {
  1744.                 case $e instanceof AST\NewObjectExpression:
  1745.                     $sqlSelectExpressions[] = $e->dispatch($this);
  1746.                     break;
  1748.                 case $e instanceof AST\Subselect:
  1749.                     $sqlSelectExpressions[] = '(' . $e->dispatch($this) . ') AS ' . $columnAlias;
  1750.                     break;
  1752.                 case $e instanceof AST\PathExpression:
  1753.                     assert($e->field !== null);
  1754.                     $dqlAlias     = $e->identificationVariable;
  1755.                     $class        = $this->getMetadataForDqlAlias($dqlAlias);
  1756.                     $fieldName    = $e->field;
  1757.                     $fieldMapping = $class->fieldMappings[$fieldName];
  1758.                     $fieldType    = $fieldMapping['type'];
  1759.                     $col          = trim($e->dispatch($this));
  1761.                     if (isset($fieldMapping['requireSQLConversion'])) {
  1762.                         $type = Type::getType($fieldType);
  1763.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
  1764.                     }
  1766.                     $sqlSelectExpressions[] = $col . ' AS ' . $columnAlias;
  1768.                     if (! empty($fieldMapping['enumType'])) {
  1769.                         $this->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
  1770.                     }
  1772.                     break;
  1774.                 case $e instanceof AST\Literal:
  1775.                     switch ($e->type) {
  1776.                         case AST\Literal::BOOLEAN:
  1777.                             $fieldType = 'boolean';
  1778.                             break;
  1780.                         case AST\Literal::NUMERIC:
  1781.                             $fieldType = is_float($e->value) ? 'float' : 'integer';
  1782.                             break;
  1783.                     }
  1785.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
  1786.                     break;
  1788.                 default:
  1789.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
  1790.                     break;
  1791.             }
  1793.             $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1794.             $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldType);
  1796.             $this->rsm->newObjectMappings[$columnAlias] = [
  1797.                 'className' => $newObjectExpression->className,
  1798.                 'objIndex'  => $objIndex,
  1799.                 'argIndex'  => $argIndex,
  1800.             ];
  1801.         }
  1803.         return implode(', ', $sqlSelectExpressions);
  1804.     }
  1806.     /**
  1807.      * Walks down a SimpleSelectExpression AST node, thereby generating the appropriate SQL.
  1808.      *
  1809.      * @param AST\SimpleSelectExpression $simpleSelectExpression
  1810.      *
  1811.      * @return string
  1812.      *
  1813.      * @not-deprecated
  1814.      */
  1815.     public function walkSimpleSelectExpression($simpleSelectExpression)
  1816.     {
  1817.         $expr = $simpleSelectExpression->expression;
  1818.         $sql  = ' ';
  1820.         switch (true) {
  1821.             case $expr instanceof AST\PathExpression:
  1822.                 $sql .= $this->walkPathExpression($expr);
  1823.                 break;
  1825.             case $expr instanceof AST\Subselect:
  1826.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1828.                 $columnAlias                        = 'sclr' . $this->aliasCounter++;
  1829.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
  1831.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
  1832.                 break;
  1834.             case $expr instanceof AST\Functions\FunctionNode:
  1835.             case $expr instanceof AST\SimpleArithmeticExpression:
  1836.             case $expr instanceof AST\ArithmeticTerm:
  1837.             case $expr instanceof AST\ArithmeticFactor:
  1838.             case $expr instanceof AST\Literal:
  1839.             case $expr instanceof AST\NullIfExpression:
  1840.             case $expr instanceof AST\CoalesceExpression:
  1841.             case $expr instanceof AST\GeneralCaseExpression:
  1842.             case $expr instanceof AST\SimpleCaseExpression:
  1843.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1845.                 $columnAlias                        = $this->getSQLColumnAlias('sclr');
  1846.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
  1848.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
  1849.                 break;
  1851.             case $expr instanceof AST\ParenthesisExpression:
  1852.                 $sql .= $this->walkParenthesisExpression($expr);
  1853.                 break;
  1855.             default: // IdentificationVariable
  1856.                 $sql .= $this->walkEntityIdentificationVariable($expr);
  1857.                 break;
  1858.         }
  1860.         return $sql;
  1861.     }
  1863.     /**
  1864.      * Walks down an AggregateExpression AST node, thereby generating the appropriate SQL.
  1865.      *
  1866.      * @param AST\AggregateExpression $aggExpression
  1867.      *
  1868.      * @return string
  1869.      *
  1870.      * @not-deprecated
  1871.      */
  1872.     public function walkAggregateExpression($aggExpression)
  1873.     {
  1874.         return $aggExpression->functionName . '(' . ($aggExpression->isDistinct ? 'DISTINCT ' : '')
  1875.             . $this->walkSimpleArithmeticExpression($aggExpression->pathExpression) . ')';
  1876.     }
  1878.     /**
  1879.      * Walks down a GroupByClause AST node, thereby generating the appropriate SQL.
  1880.      *
  1881.      * @param AST\GroupByClause $groupByClause
  1882.      *
  1883.      * @return string
  1884.      *
  1885.      * @not-deprecated
  1886.      */
  1887.     public function walkGroupByClause($groupByClause)
  1888.     {
  1889.         $sqlParts = [];
  1891.         foreach ($groupByClause->groupByItems as $groupByItem) {
  1892.             $sqlParts[] = $this->walkGroupByItem($groupByItem);
  1893.         }
  1895.         return ' GROUP BY ' . implode(', ', $sqlParts);
  1896.     }
  1898.     /**
  1899.      * Walks down a GroupByItem AST node, thereby generating the appropriate SQL.
  1900.      *
  1901.      * @param AST\PathExpression|string $groupByItem
  1902.      *
  1903.      * @return string
  1904.      *
  1905.      * @not-deprecated
  1906.      */
  1907.     public function walkGroupByItem($groupByItem)
  1908.     {
  1909.         // StateFieldPathExpression
  1910.         if (! is_string($groupByItem)) {
  1911.             return $this->walkPathExpression($groupByItem);
  1912.         }
  1914.         // ResultVariable
  1915.         if (isset($this->queryComponents[$groupByItem]['resultVariable'])) {
  1916.             $resultVariable = $this->queryComponents[$groupByItem]['resultVariable'];
  1918.             if ($resultVariable instanceof AST\PathExpression) {
  1919.                 return $this->walkPathExpression($resultVariable);
  1920.             }
  1922.             if ($resultVariable instanceof AST\Node && isset($resultVariable->pathExpression)) {
  1923.                 return $this->walkPathExpression($resultVariable->pathExpression);
  1924.             }
  1926.             return $this->walkResultVariable($groupByItem);
  1927.         }
  1929.         // IdentificationVariable
  1930.         $sqlParts = [];
  1932.         foreach ($this->getMetadataForDqlAlias($groupByItem)->fieldNames as $field) {
  1933.             $item       = new AST\PathExpression(AST\PathExpression::TYPE_STATE_FIELD, $groupByItem, $field);
  1934.             $item->type = AST\PathExpression::TYPE_STATE_FIELD;
  1936.             $sqlParts[] = $this->walkPathExpression($item);
  1937.         }
  1939.         foreach ($this->getMetadataForDqlAlias($groupByItem)->associationMappings as $mapping) {
  1940.             if ($mapping['isOwningSide'] && $mapping['type'] & ClassMetadata::TO_ONE) {
  1941.                 $item       = new AST\PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION, $groupByItem, $mapping['fieldName']);
  1942.                 $item->type = AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION;
  1944.                 $sqlParts[] = $this->walkPathExpression($item);
  1945.             }
  1946.         }
  1948.         return implode(', ', $sqlParts);
  1949.     }
  1951.     /**
  1952.      * Walks down a DeleteClause AST node, thereby generating the appropriate SQL.
  1953.      *
  1954.      * @return string
  1955.      *
  1956.      * @not-deprecated
  1957.      */
  1958.     public function walkDeleteClause(AST\DeleteClause $deleteClause)
  1959.     {
  1960.         $class     = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1961.         $tableName = $class->getTableName();
  1962.         $sql       = 'DELETE FROM ' . $this->quoteStrategy->getTableName($class, $this->platform);
  1964.         $this->setSQLTableAlias($tableName, $tableName, $deleteClause->aliasIdentificationVariable);
  1965.         $this->rootAliases[] = $deleteClause->aliasIdentificationVariable;
  1967.         return $sql;
  1968.     }
  1970.     /**
  1971.      * Walks down an UpdateClause AST node, thereby generating the appropriate SQL.
  1972.      *
  1973.      * @param AST\UpdateClause $updateClause
  1974.      *
  1975.      * @return string
  1976.      *
  1977.      * @not-deprecated
  1978.      */
  1979.     public function walkUpdateClause($updateClause)
  1980.     {
  1981.         $class     = $this->em->getClassMetadata($updateClause->abstractSchemaName);
  1982.         $tableName = $class->getTableName();
  1983.         $sql       = 'UPDATE ' . $this->quoteStrategy->getTableName($class, $this->platform);
  1985.         $this->setSQLTableAlias($tableName, $tableName, $updateClause->aliasIdentificationVariable);
  1986.         $this->rootAliases[] = $updateClause->aliasIdentificationVariable;
  1988.         return $sql . ' SET ' . implode(', ', array_map([$this, 'walkUpdateItem'], $updateClause->updateItems));
  1989.     }
  1991.     /**
  1992.      * Walks down an UpdateItem AST node, thereby generating the appropriate SQL.
  1993.      *
  1994.      * @param AST\UpdateItem $updateItem
  1995.      *
  1996.      * @return string
  1997.      *
  1998.      * @not-deprecated
  1999.      */
  2000.     public function walkUpdateItem($updateItem)
  2001.     {
  2002.         $useTableAliasesBefore    = $this->useSqlTableAliases;
  2003.         $this->useSqlTableAliases = false;
  2005.         $sql      = $this->walkPathExpression($updateItem->pathExpression) . ' = ';
  2006.         $newValue = $updateItem->newValue;
  2008.         switch (true) {
  2009.             case $newValue instanceof AST\Node:
  2010.                 $sql .= $newValue->dispatch($this);
  2011.                 break;
  2013.             case $newValue === null:
  2014.                 $sql .= 'NULL';
  2015.                 break;
  2017.             default:
  2018.                 $sql .= $this->conn->quote($newValue);
  2019.                 break;
  2020.         }
  2022.         $this->useSqlTableAliases = $useTableAliasesBefore;
  2024.         return $sql;
  2025.     }
  2027.     /**
  2028.      * Walks down a WhereClause AST node, thereby generating the appropriate SQL.
  2029.      * WhereClause or not, the appropriate discriminator sql is added.
  2030.      *
  2031.      * @param AST\WhereClause $whereClause
  2032.      *
  2033.      * @return string
  2034.      *
  2035.      * @not-deprecated
  2036.      */
  2037.     public function walkWhereClause($whereClause)
  2038.     {
  2039.         $condSql  = $whereClause !== null ? $this->walkConditionalExpression($whereClause->conditionalExpression) : '';
  2040.         $discrSql = $this->generateDiscriminatorColumnConditionSQL($this->rootAliases);
  2042.         if ($this->em->hasFilters()) {
  2043.             $filterClauses = [];
  2044.             foreach ($this->rootAliases as $dqlAlias) {
  2045.                 $class      = $this->getMetadataForDqlAlias($dqlAlias);
  2046.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
  2048.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
  2049.                 if ($filterExpr) {
  2050.                     $filterClauses[] = $filterExpr;
  2051.                 }
  2052.             }
  2054.             if (count($filterClauses)) {
  2055.                 if ($condSql) {
  2056.                     $condSql = '(' . $condSql . ') AND ';
  2057.                 }
  2059.                 $condSql .= implode(' AND ', $filterClauses);
  2060.             }
  2061.         }
  2063.         if ($condSql) {
  2064.             return ' WHERE ' . (! $discrSql ? $condSql : '(' . $condSql . ') AND ' . $discrSql);
  2065.         }
  2067.         if ($discrSql) {
  2068.             return ' WHERE ' . $discrSql;
  2069.         }
  2071.         return '';
  2072.     }
  2074.     /**
  2075.      * Walk down a ConditionalExpression AST node, thereby generating the appropriate SQL.
  2076.      *
  2077.      * @param AST\ConditionalExpression|AST\Phase2OptimizableConditional $condExpr
  2078.      *
  2079.      * @return string
  2080.      *
  2081.      * @not-deprecated
  2082.      */
  2083.     public function walkConditionalExpression($condExpr)
  2084.     {
  2085.         // Phase 2 AST optimization: Skip processing of ConditionalExpression
  2086.         // if only one ConditionalTerm is defined
  2087.         if (! ($condExpr instanceof AST\ConditionalExpression)) {
  2088.             return $this->walkConditionalTerm($condExpr);
  2089.         }
  2091.         return implode(' OR ', array_map([$this, 'walkConditionalTerm'], $condExpr->conditionalTerms));
  2092.     }
  2094.     /**
  2095.      * Walks down a ConditionalTerm AST node, thereby generating the appropriate SQL.
  2096.      *
  2097.      * @param AST\ConditionalTerm|AST\ConditionalFactor|AST\ConditionalPrimary $condTerm
  2098.      *
  2099.      * @return string
  2100.      *
  2101.      * @not-deprecated
  2102.      */
  2103.     public function walkConditionalTerm($condTerm)
  2104.     {
  2105.         // Phase 2 AST optimization: Skip processing of ConditionalTerm
  2106.         // if only one ConditionalFactor is defined
  2107.         if (! ($condTerm instanceof AST\ConditionalTerm)) {
  2108.             return $this->walkConditionalFactor($condTerm);
  2109.         }
  2111.         return implode(' AND ', array_map([$this, 'walkConditionalFactor'], $condTerm->conditionalFactors));
  2112.     }
  2114.     /**
  2115.      * Walks down a ConditionalFactor AST node, thereby generating the appropriate SQL.
  2116.      *
  2117.      * @param AST\ConditionalFactor|AST\ConditionalPrimary $factor
  2118.      *
  2119.      * @return string The SQL.
  2120.      *
  2121.      * @not-deprecated
  2122.      */
  2123.     public function walkConditionalFactor($factor)
  2124.     {
  2125.         // Phase 2 AST optimization: Skip processing of ConditionalFactor
  2126.         // if only one ConditionalPrimary is defined
  2127.         return ! ($factor instanceof AST\ConditionalFactor)
  2128.             ? $this->walkConditionalPrimary($factor)
  2129.             : ($factor->not ? 'NOT ' : '') . $this->walkConditionalPrimary($factor->conditionalPrimary);
  2130.     }
  2132.     /**
  2133.      * Walks down a ConditionalPrimary AST node, thereby generating the appropriate SQL.
  2134.      *
  2135.      * @param AST\ConditionalPrimary $primary
  2136.      *
  2137.      * @return string
  2138.      *
  2139.      * @not-deprecated
  2140.      */
  2141.     public function walkConditionalPrimary($primary)
  2142.     {
  2143.         if ($primary->isSimpleConditionalExpression()) {
  2144.             return $primary->simpleConditionalExpression->dispatch($this);
  2145.         }
  2147.         if ($primary->isConditionalExpression()) {
  2148.             $condExpr = $primary->conditionalExpression;
  2150.             return '(' . $this->walkConditionalExpression($condExpr) . ')';
  2151.         }
  2152.     }
  2154.     /**
  2155.      * Walks down an ExistsExpression AST node, thereby generating the appropriate SQL.
  2156.      *
  2157.      * @param AST\ExistsExpression $existsExpr
  2158.      *
  2159.      * @return string
  2160.      *
  2161.      * @not-deprecated
  2162.      */
  2163.     public function walkExistsExpression($existsExpr)
  2164.     {
  2165.         $sql = $existsExpr->not ? 'NOT ' : '';
  2167.         $sql .= 'EXISTS (' . $this->walkSubselect($existsExpr->subselect) . ')';
  2169.         return $sql;
  2170.     }
  2172.     /**
  2173.      * Walks down a CollectionMemberExpression AST node, thereby generating the appropriate SQL.
  2174.      *
  2175.      * @param AST\CollectionMemberExpression $collMemberExpr
  2176.      *
  2177.      * @return string
  2178.      *
  2179.      * @not-deprecated
  2180.      */
  2181.     public function walkCollectionMemberExpression($collMemberExpr)
  2182.     {
  2183.         $sql  = $collMemberExpr->not ? 'NOT ' : '';
  2184.         $sql .= 'EXISTS (SELECT 1 FROM ';
  2186.         $entityExpr   = $collMemberExpr->entityExpression;
  2187.         $collPathExpr = $collMemberExpr->collectionValuedPathExpression;
  2188.         assert($collPathExpr->field !== null);
  2190.         $fieldName = $collPathExpr->field;
  2191.         $dqlAlias  = $collPathExpr->identificationVariable;
  2193.         $class = $this->getMetadataForDqlAlias($dqlAlias);
  2195.         switch (true) {
  2196.             // InputParameter
  2197.             case $entityExpr instanceof AST\InputParameter:
  2198.                 $dqlParamKey = $entityExpr->name;
  2199.                 $entitySql   = '?';
  2200.                 break;
  2202.             // SingleValuedAssociationPathExpression | IdentificationVariable
  2203.             case $entityExpr instanceof AST\PathExpression:
  2204.                 $entitySql = $this->walkPathExpression($entityExpr);
  2205.                 break;
  2207.             default:
  2208.                 throw new BadMethodCallException('Not implemented');
  2209.         }
  2211.         $assoc = $class->associationMappings[$fieldName];
  2213.         if ($assoc['type'] === ClassMetadata::ONE_TO_MANY) {
  2214.             $targetClass      = $this->em->getClassMetadata($assoc['targetEntity']);
  2215.             $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName());
  2216.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  2218.             $sql .= $this->quoteStrategy->getTableName($targetClass, $this->platform) . ' ' . $targetTableAlias . ' WHERE ';
  2220.             $owningAssoc = $targetClass->associationMappings[$assoc['mappedBy']];
  2221.             $sqlParts    = [];
  2223.             foreach ($owningAssoc['targetToSourceKeyColumns'] as $targetColumn => $sourceColumn) {
  2224.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$targetColumn], $class, $this->platform);
  2226.                 $sqlParts[] = $sourceTableAlias . '.' . $targetColumn . ' = ' . $targetTableAlias . '.' . $sourceColumn;
  2227.             }
  2229.             foreach ($this->quoteStrategy->getIdentifierColumnNames($targetClass, $this->platform) as $targetColumnName) {
  2230.                 if (isset($dqlParamKey)) {
  2231.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
  2232.                 }
  2234.                 $sqlParts[] = $targetTableAlias . '.' . $targetColumnName . ' = ' . $entitySql;
  2235.             }
  2237.             $sql .= implode(' AND ', $sqlParts);
  2238.         } else { // many-to-many
  2239.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  2241.             $owningAssoc = $assoc['isOwningSide'] ? $assoc : $targetClass->associationMappings[$assoc['mappedBy']];
  2242.             $joinTable   = $owningAssoc['joinTable'];
  2244.             // SQL table aliases
  2245.             $joinTableAlias   = $this->getSQLTableAlias($joinTable['name']);
  2246.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  2248.             $sql .= $this->quoteStrategy->getJoinTableName($owningAssoc, $targetClass, $this->platform) . ' ' . $joinTableAlias . ' WHERE ';
  2250.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['joinColumns'] : $joinTable['inverseJoinColumns'];
  2251.             $sqlParts    = [];
  2253.             foreach ($joinColumns as $joinColumn) {
  2254.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$joinColumn['referencedColumnName']], $class, $this->platform);
  2256.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' = ' . $sourceTableAlias . '.' . $targetColumn;
  2257.             }
  2259.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['inverseJoinColumns'] : $joinTable['joinColumns'];
  2261.             foreach ($joinColumns as $joinColumn) {
  2262.                 if (isset($dqlParamKey)) {
  2263.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
  2264.                 }
  2266.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' IN (' . $entitySql . ')';
  2267.             }
  2269.             $sql .= implode(' AND ', $sqlParts);
  2270.         }
  2272.         return $sql . ')';
  2273.     }
  2275.     /**
  2276.      * Walks down an EmptyCollectionComparisonExpression AST node, thereby generating the appropriate SQL.
  2277.      *
  2278.      * @param AST\EmptyCollectionComparisonExpression $emptyCollCompExpr
  2279.      *
  2280.      * @return string
  2281.      *
  2282.      * @not-deprecated
  2283.      */
  2284.     public function walkEmptyCollectionComparisonExpression($emptyCollCompExpr)
  2285.     {
  2286.         $sizeFunc                           = new AST\Functions\SizeFunction('size');
  2287.         $sizeFunc->collectionPathExpression = $emptyCollCompExpr->expression;
  2289.         return $sizeFunc->getSql($this) . ($emptyCollCompExpr->not ? ' > 0' : ' = 0');
  2290.     }
  2292.     /**
  2293.      * Walks down a NullComparisonExpression AST node, thereby generating the appropriate SQL.
  2294.      *
  2295.      * @param AST\NullComparisonExpression $nullCompExpr
  2296.      *
  2297.      * @return string
  2298.      *
  2299.      * @not-deprecated
  2300.      */
  2301.     public function walkNullComparisonExpression($nullCompExpr)
  2302.     {
  2303.         $expression = $nullCompExpr->expression;
  2304.         $comparison = ' IS' . ($nullCompExpr->not ? ' NOT' : '') . ' NULL';
  2306.         // Handle ResultVariable
  2307.         if (is_string($expression) && isset($this->queryComponents[$expression]['resultVariable'])) {
  2308.             return $this->walkResultVariable($expression) . $comparison;
  2309.         }
  2311.         // Handle InputParameter mapping inclusion to ParserResult
  2312.         if ($expression instanceof AST\InputParameter) {
  2313.             return $this->walkInputParameter($expression) . $comparison;
  2314.         }
  2316.         return $expression->dispatch($this) . $comparison;
  2317.     }
  2319.     /**
  2320.      * Walks down an InExpression AST node, thereby generating the appropriate SQL.
  2321.      *
  2322.      * @deprecated Use {@see walkInListExpression()} or {@see walkInSubselectExpression()} instead.
  2323.      *
  2324.      * @param AST\InExpression $inExpr
  2325.      *
  2326.      * @return string
  2327.      */
  2328.     public function walkInExpression($inExpr)
  2329.     {
  2330.         Deprecation::triggerIfCalledFromOutside(
  2331.             'doctrine/orm',
  2332.             'https://github.com/doctrine/orm/pull/10267',
  2333.             '%s() is deprecated, call walkInListExpression() or walkInSubselectExpression() instead.',
  2334.             __METHOD__
  2335.         );
  2337.         if ($inExpr instanceof AST\InListExpression) {
  2338.             return $this->walkInListExpression($inExpr);
  2339.         }
  2341.         if ($inExpr instanceof AST\InSubselectExpression) {
  2342.             return $this->walkInSubselectExpression($inExpr);
  2343.         }
  2345.         $sql = $this->walkArithmeticExpression($inExpr->expression) . ($inExpr->not ? ' NOT' : '') . ' IN (';
  2347.         $sql .= $inExpr->subselect
  2348.             ? $this->walkSubselect($inExpr->subselect)
  2349.             : implode(', ', array_map([$this, 'walkInParameter'], $inExpr->literals));
  2351.         $sql .= ')';
  2353.         return $sql;
  2354.     }
  2356.     /**
  2357.      * Walks down an InExpression AST node, thereby generating the appropriate SQL.
  2358.      */
  2359.     public function walkInListExpression(AST\InListExpression $inExpr): string
  2360.     {
  2361.         return $this->walkArithmeticExpression($inExpr->expression)
  2362.             . ($inExpr->not ? ' NOT' : '') . ' IN ('
  2363.             . implode(', ', array_map([$this, 'walkInParameter'], $inExpr->literals))
  2364.             . ')';
  2365.     }
  2367.     /**
  2368.      * Walks down an InExpression AST node, thereby generating the appropriate SQL.
  2369.      */
  2370.     public function walkInSubselectExpression(AST\InSubselectExpression $inExpr): string
  2371.     {
  2372.         return $this->walkArithmeticExpression($inExpr->expression)
  2373.             . ($inExpr->not ? ' NOT' : '') . ' IN ('
  2374.             . $this->walkSubselect($inExpr->subselect)
  2375.             . ')';
  2376.     }
  2378.     /**
  2379.      * Walks down an InstanceOfExpression AST node, thereby generating the appropriate SQL.
  2380.      *
  2381.      * @param AST\InstanceOfExpression $instanceOfExpr
  2382.      *
  2383.      * @return string
  2384.      *
  2385.      * @throws QueryException
  2386.      *
  2387.      * @not-deprecated
  2388.      */
  2389.     public function walkInstanceOfExpression($instanceOfExpr)
  2390.     {
  2391.         $sql = '';
  2393.         $dqlAlias   = $instanceOfExpr->identificationVariable;
  2394.         $discrClass = $class = $this->getMetadataForDqlAlias($dqlAlias);
  2396.         if ($class->discriminatorColumn) {
  2397.             $discrClass = $this->em->getClassMetadata($class->rootEntityName);
  2398.         }
  2400.         if ($this->useSqlTableAliases) {
  2401.             $sql .= $this->getSQLTableAlias($discrClass->getTableName(), $dqlAlias) . '.';
  2402.         }
  2404.         $sql .= $class->getDiscriminatorColumn()['name'] . ($instanceOfExpr->not ? ' NOT IN ' : ' IN ');
  2405.         $sql .= $this->getChildDiscriminatorsFromClassMetadata($discrClass, $instanceOfExpr);
  2407.         return $sql;
  2408.     }
  2410.     /**
  2411.      * @param mixed $inParam
  2412.      *
  2413.      * @return string
  2414.      *
  2415.      * @not-deprecated
  2416.      */
  2417.     public function walkInParameter($inParam)
  2418.     {
  2419.         return $inParam instanceof AST\InputParameter
  2420.             ? $this->walkInputParameter($inParam)
  2421.             : $this->walkArithmeticExpression($inParam);
  2422.     }
  2424.     /**
  2425.      * Walks down a literal that represents an AST node, thereby generating the appropriate SQL.
  2426.      *
  2427.      * @param AST\Literal $literal
  2428.      *
  2429.      * @return string
  2430.      *
  2431.      * @not-deprecated
  2432.      */
  2433.     public function walkLiteral($literal)
  2434.     {
  2435.         switch ($literal->type) {
  2436.             case AST\Literal::STRING:
  2437.                 return $this->conn->quote($literal->value);
  2439.             case AST\Literal::BOOLEAN:
  2440.                 return (string) $this->conn->getDatabasePlatform()->convertBooleans(strtolower($literal->value) === 'true');
  2442.             case AST\Literal::NUMERIC:
  2443.                 return (string) $literal->value;
  2445.             default:
  2446.                 throw QueryException::invalidLiteral($literal);
  2447.         }
  2448.     }
  2450.     /**
  2451.      * Walks down a BetweenExpression AST node, thereby generating the appropriate SQL.
  2452.      *
  2453.      * @param AST\BetweenExpression $betweenExpr
  2454.      *
  2455.      * @return string
  2456.      *
  2457.      * @not-deprecated
  2458.      */
  2459.     public function walkBetweenExpression($betweenExpr)
  2460.     {
  2461.         $sql = $this->walkArithmeticExpression($betweenExpr->expression);
  2463.         if ($betweenExpr->not) {
  2464.             $sql .= ' NOT';
  2465.         }
  2467.         $sql .= ' BETWEEN ' . $this->walkArithmeticExpression($betweenExpr->leftBetweenExpression)
  2468.             . ' AND ' . $this->walkArithmeticExpression($betweenExpr->rightBetweenExpression);
  2470.         return $sql;
  2471.     }
  2473.     /**
  2474.      * Walks down a LikeExpression AST node, thereby generating the appropriate SQL.
  2475.      *
  2476.      * @param AST\LikeExpression $likeExpr
  2477.      *
  2478.      * @return string
  2479.      *
  2480.      * @not-deprecated
  2481.      */
  2482.     public function walkLikeExpression($likeExpr)
  2483.     {
  2484.         $stringExpr = $likeExpr->stringExpression;
  2485.         if (is_string($stringExpr)) {
  2486.             if (! isset($this->queryComponents[$stringExpr]['resultVariable'])) {
  2487.                 throw new LogicException(sprintf('No result variable found for string expression "%s".', $stringExpr));
  2488.             }
  2490.             $leftExpr = $this->walkResultVariable($stringExpr);
  2491.         } else {
  2492.             $leftExpr = $stringExpr->dispatch($this);
  2493.         }
  2495.         $sql = $leftExpr . ($likeExpr->not ? ' NOT' : '') . ' LIKE ';
  2497.         if ($likeExpr->stringPattern instanceof AST\InputParameter) {
  2498.             $sql .= $this->walkInputParameter($likeExpr->stringPattern);
  2499.         } elseif ($likeExpr->stringPattern instanceof AST\Functions\FunctionNode) {
  2500.             $sql .= $this->walkFunction($likeExpr->stringPattern);
  2501.         } elseif ($likeExpr->stringPattern instanceof AST\PathExpression) {
  2502.             $sql .= $this->walkPathExpression($likeExpr->stringPattern);
  2503.         } else {
  2504.             $sql .= $this->walkLiteral($likeExpr->stringPattern);
  2505.         }
  2507.         if ($likeExpr->escapeChar) {
  2508.             $sql .= ' ESCAPE ' . $this->walkLiteral($likeExpr->escapeChar);
  2509.         }
  2511.         return $sql;
  2512.     }
  2514.     /**
  2515.      * Walks down a StateFieldPathExpression AST node, thereby generating the appropriate SQL.
  2516.      *
  2517.      * @param AST\PathExpression $stateFieldPathExpression
  2518.      *
  2519.      * @return string
  2520.      *
  2521.      * @not-deprecated
  2522.      */
  2523.     public function walkStateFieldPathExpression($stateFieldPathExpression)
  2524.     {
  2525.         return $this->walkPathExpression($stateFieldPathExpression);
  2526.     }
  2528.     /**
  2529.      * Walks down a ComparisonExpression AST node, thereby generating the appropriate SQL.
  2530.      *
  2531.      * @param AST\ComparisonExpression $compExpr
  2532.      *
  2533.      * @return string
  2534.      *
  2535.      * @not-deprecated
  2536.      */
  2537.     public function walkComparisonExpression($compExpr)
  2538.     {
  2539.         $leftExpr  = $compExpr->leftExpression;
  2540.         $rightExpr = $compExpr->rightExpression;
  2541.         $sql       = '';
  2543.         $sql .= $leftExpr instanceof AST\Node
  2544.             ? $leftExpr->dispatch($this)
  2545.             : (is_numeric($leftExpr) ? $leftExpr : $this->conn->quote($leftExpr));
  2547.         $sql .= ' ' . $compExpr->operator . ' ';
  2549.         $sql .= $rightExpr instanceof AST\Node
  2550.             ? $rightExpr->dispatch($this)
  2551.             : (is_numeric($rightExpr) ? $rightExpr : $this->conn->quote($rightExpr));
  2553.         return $sql;
  2554.     }
  2556.     /**
  2557.      * Walks down an InputParameter AST node, thereby generating the appropriate SQL.
  2558.      *
  2559.      * @param AST\InputParameter $inputParam
  2560.      *
  2561.      * @return string
  2562.      *
  2563.      * @not-deprecated
  2564.      */
  2565.     public function walkInputParameter($inputParam)
  2566.     {
  2567.         $this->parserResult->addParameterMapping($inputParam->name, $this->sqlParamIndex++);
  2569.         $parameter = $this->query->getParameter($inputParam->name);
  2571.         if ($parameter) {
  2572.             $type = $parameter->getType();
  2573.             if (Type::hasType($type)) {
  2574.                 return Type::getType($type)->convertToDatabaseValueSQL('?', $this->platform);
  2575.             }
  2576.         }
  2578.         return '?';
  2579.     }
  2581.     /**
  2582.      * Walks down an ArithmeticExpression AST node, thereby generating the appropriate SQL.
  2583.      *
  2584.      * @param AST\ArithmeticExpression $arithmeticExpr
  2585.      *
  2586.      * @return string
  2587.      *
  2588.      * @not-deprecated
  2589.      */
  2590.     public function walkArithmeticExpression($arithmeticExpr)
  2591.     {
  2592.         return $arithmeticExpr->isSimpleArithmeticExpression()
  2593.             ? $this->walkSimpleArithmeticExpression($arithmeticExpr->simpleArithmeticExpression)
  2594.             : '(' . $this->walkSubselect($arithmeticExpr->subselect) . ')';
  2595.     }
  2597.     /**
  2598.      * Walks down an SimpleArithmeticExpression AST node, thereby generating the appropriate SQL.
  2599.      *
  2600.      * @param AST\Node|string $simpleArithmeticExpr
  2601.      *
  2602.      * @return string
  2603.      *
  2604.      * @not-deprecated
  2605.      */
  2606.     public function walkSimpleArithmeticExpression($simpleArithmeticExpr)
  2607.     {
  2608.         if (! ($simpleArithmeticExpr instanceof AST\SimpleArithmeticExpression)) {
  2609.             return $this->walkArithmeticTerm($simpleArithmeticExpr);
  2610.         }
  2612.         return implode(' ', array_map([$this, 'walkArithmeticTerm'], $simpleArithmeticExpr->arithmeticTerms));
  2613.     }
  2615.     /**
  2616.      * Walks down an ArithmeticTerm AST node, thereby generating the appropriate SQL.
  2617.      *
  2618.      * @param mixed $term
  2619.      *
  2620.      * @return string
  2621.      *
  2622.      * @not-deprecated
  2623.      */
  2624.     public function walkArithmeticTerm($term)
  2625.     {
  2626.         if (is_string($term)) {
  2627.             return isset($this->queryComponents[$term])
  2628.                 ? $this->walkResultVariable($this->queryComponents[$term]['token']->value)
  2629.                 : $term;
  2630.         }
  2632.         // Phase 2 AST optimization: Skip processing of ArithmeticTerm
  2633.         // if only one ArithmeticFactor is defined
  2634.         if (! ($term instanceof AST\ArithmeticTerm)) {
  2635.             return $this->walkArithmeticFactor($term);
  2636.         }
  2638.         return implode(' ', array_map([$this, 'walkArithmeticFactor'], $term->arithmeticFactors));
  2639.     }
  2641.     /**
  2642.      * Walks down an ArithmeticFactor that represents an AST node, thereby generating the appropriate SQL.
  2643.      *
  2644.      * @param mixed $factor
  2645.      *
  2646.      * @return string
  2647.      *
  2648.      * @not-deprecated
  2649.      */
  2650.     public function walkArithmeticFactor($factor)
  2651.     {
  2652.         if (is_string($factor)) {
  2653.             return isset($this->queryComponents[$factor])
  2654.                 ? $this->walkResultVariable($this->queryComponents[$factor]['token']->value)
  2655.                 : $factor;
  2656.         }
  2658.         // Phase 2 AST optimization: Skip processing of ArithmeticFactor
  2659.         // if only one ArithmeticPrimary is defined
  2660.         if (! ($factor instanceof AST\ArithmeticFactor)) {
  2661.             return $this->walkArithmeticPrimary($factor);
  2662.         }
  2664.         $sign = $factor->isNegativeSigned() ? '-' : ($factor->isPositiveSigned() ? '+' : '');
  2666.         return $sign . $this->walkArithmeticPrimary($factor->arithmeticPrimary);
  2667.     }
  2669.     /**
  2670.      * Walks down an ArithmeticPrimary that represents an AST node, thereby generating the appropriate SQL.
  2671.      *
  2672.      * @param mixed $primary
  2673.      *
  2674.      * @return string The SQL.
  2675.      *
  2676.      * @not-deprecated
  2677.      */
  2678.     public function walkArithmeticPrimary($primary)
  2679.     {
  2680.         if ($primary instanceof AST\SimpleArithmeticExpression) {
  2681.             return '(' . $this->walkSimpleArithmeticExpression($primary) . ')';
  2682.         }
  2684.         if ($primary instanceof AST\Node) {
  2685.             return $primary->dispatch($this);
  2686.         }
  2688.         return $this->walkEntityIdentificationVariable($primary);
  2689.     }
  2691.     /**
  2692.      * Walks down a StringPrimary that represents an AST node, thereby generating the appropriate SQL.
  2693.      *
  2694.      * @param mixed $stringPrimary
  2695.      *
  2696.      * @return string
  2697.      *
  2698.      * @not-deprecated
  2699.      */
  2700.     public function walkStringPrimary($stringPrimary)
  2701.     {
  2702.         return is_string($stringPrimary)
  2703.             ? $this->conn->quote($stringPrimary)
  2704.             : $stringPrimary->dispatch($this);
  2705.     }
  2707.     /**
  2708.      * Walks down a ResultVariable that represents an AST node, thereby generating the appropriate SQL.
  2709.      *
  2710.      * @param string $resultVariable
  2711.      *
  2712.      * @return string
  2713.      *
  2714.      * @not-deprecated
  2715.      */
  2716.     public function walkResultVariable($resultVariable)
  2717.     {
  2718.         if (! isset($this->scalarResultAliasMap[$resultVariable])) {
  2719.             throw new InvalidArgumentException(sprintf('Unknown result variable: %s', $resultVariable));
  2720.         }
  2722.         $resultAlias = $this->scalarResultAliasMap[$resultVariable];
  2724.         if (is_array($resultAlias)) {
  2725.             return implode(', ', $resultAlias);
  2726.         }
  2728.         return $resultAlias;
  2729.     }
  2731.     /**
  2732.      * @return string The list in parentheses of valid child discriminators from the given class
  2733.      *
  2734.      * @throws QueryException
  2735.      */
  2736.     private function getChildDiscriminatorsFromClassMetadata(
  2737.         ClassMetadata $rootClass,
  2738.         AST\InstanceOfExpression $instanceOfExpr
  2739.     ): string {
  2740.         $sqlParameterList = [];
  2741.         $discriminators   = [];
  2742.         foreach ($instanceOfExpr->value as $parameter) {
  2743.             if ($parameter instanceof AST\InputParameter) {
  2744.                 $this->rsm->discriminatorParameters[$parameter->name] = $parameter->name;
  2745.                 $sqlParameterList[]                                   = $this->walkInParameter($parameter);
  2746.                 continue;
  2747.             }
  2749.             $metadata = $this->em->getClassMetadata($parameter);
  2751.             if ($metadata->getName() !== $rootClass->name && ! $metadata->getReflectionClass()->isSubclassOf($rootClass->name)) {
  2752.                 throw QueryException::instanceOfUnrelatedClass($parameter, $rootClass->name);
  2753.             }
  2755.             $discriminators += HierarchyDiscriminatorResolver::resolveDiscriminatorsForClass($metadata, $this->em);
  2756.         }
  2758.         foreach (array_keys($discriminators) as $dis) {
  2759.             $sqlParameterList[] = $this->conn->quote($dis);
  2760.         }
  2762.         return '(' . implode(', ', $sqlParameterList) . ')';
  2763.     }
  2764. }