vendor/doctrine/orm/lib/Doctrine/ORM/Query/SqlWalker.php line 531

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\ORM\EntityManagerInterface;
  13. use Doctrine\ORM\Mapping\ClassMetadata;
  14. use Doctrine\ORM\Mapping\ClassMetadataInfo;
  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 is a TreeWalker that walks over a DQL AST and constructs
  45.  * the corresponding SQL.
  46.  *
  47.  * @psalm-import-type QueryComponent from Parser
  48.  * @psalm-consistent-constructor
  49.  */
  50. class SqlWalker implements TreeWalker
  51. {
  52.     public const HINT_DISTINCT = 'doctrine.distinct';
  54.     /**
  55.      * Used to mark a query as containing a PARTIAL expression, which needs to be known by SLC.
  56.      */
  57.     public const HINT_PARTIAL = 'doctrine.partial';
  59.     /** @var ResultSetMapping */
  60.     private $rsm;
  62.     /**
  63.      * Counter for generating unique column aliases.
  64.      *
  65.      * @var int
  66.      */
  67.     private $aliasCounter = 0;
  69.     /**
  70.      * Counter for generating unique table aliases.
  71.      *
  72.      * @var int
  73.      */
  74.     private $tableAliasCounter = 0;
  76.     /**
  77.      * Counter for generating unique scalar result.
  78.      *
  79.      * @var int
  80.      */
  81.     private $scalarResultCounter = 1;
  83.     /**
  84.      * Counter for generating unique parameter indexes.
  85.      *
  86.      * @var int
  87.      */
  88.     private $sqlParamIndex = 0;
  90.     /**
  91.      * Counter for generating indexes.
  92.      *
  93.      * @var int
  94.      */
  95.     private $newObjectCounter = 0;
  97.     /** @var ParserResult */
  98.     private $parserResult;
  100.     /** @var EntityManagerInterface */
  101.     private $em;
  103.     /** @var Connection */
  104.     private $conn;
  106.     /** @var Query */
  107.     private $query;
  109.     /** @var mixed[] */
  110.     private $tableAliasMap = [];
  112.     /**
  113.      * Map from result variable names to their SQL column alias names.
  114.      *
  115.      * @psalm-var array<string|int, string|list<string>>
  116.      */
  117.     private $scalarResultAliasMap = [];
  119.     /**
  120.      * Map from Table-Alias + Column-Name to OrderBy-Direction.
  121.      *
  122.      * @var array<string, string>
  123.      */
  124.     private $orderedColumnsMap = [];
  126.     /**
  127.      * Map from DQL-Alias + Field-Name to SQL Column Alias.
  128.      *
  129.      * @var array<string, array<string, string>>
  130.      */
  131.     private $scalarFields = [];
  133.     /**
  134.      * Map of all components/classes that appear in the DQL query.
  135.      *
  136.      * @psalm-var array<string, QueryComponent>
  137.      */
  138.     private $queryComponents;
  140.     /**
  141.      * A list of classes that appear in non-scalar SelectExpressions.
  142.      *
  143.      * @psalm-var array<string, array{class: ClassMetadata, dqlAlias: string, resultAlias: string|null}>
  144.      */
  145.     private $selectedClasses = [];
  147.     /**
  148.      * The DQL alias of the root class of the currently traversed query.
  149.      *
  150.      * @psalm-var list<string>
  151.      */
  152.     private $rootAliases = [];
  154.     /**
  155.      * Flag that indicates whether to generate SQL table aliases in the SQL.
  156.      * These should only be generated for SELECT queries, not for UPDATE/DELETE.
  157.      *
  158.      * @var bool
  159.      */
  160.     private $useSqlTableAliases = true;
  162.     /**
  163.      * The database platform abstraction.
  164.      *
  165.      * @var AbstractPlatform
  166.      */
  167.     private $platform;
  169.     /**
  170.      * The quote strategy.
  171.      *
  172.      * @var QuoteStrategy
  173.      */
  174.     private $quoteStrategy;
  176.     /**
  177.      * @param Query        $query        The parsed Query.
  178.      * @param ParserResult $parserResult The result of the parsing process.
  179.      * @psalm-param array<string, QueryComponent> $queryComponents The query components (symbol table).
  180.      */
  181.     public function __construct($query, $parserResult, array $queryComponents)
  182.     {
  183.         $this->query           = $query;
  184.         $this->parserResult    = $parserResult;
  185.         $this->queryComponents = $queryComponents;
  186.         $this->rsm             = $parserResult->getResultSetMapping();
  187.         $this->em              = $query->getEntityManager();
  188.         $this->conn            = $this->em->getConnection();
  189.         $this->platform        = $this->conn->getDatabasePlatform();
  190.         $this->quoteStrategy   = $this->em->getConfiguration()->getQuoteStrategy();
  191.     }
  193.     /**
  194.      * Gets the Query instance used by the walker.
  195.      *
  196.      * @return Query
  197.      */
  198.     public function getQuery()
  199.     {
  200.         return $this->query;
  201.     }
  203.     /**
  204.      * Gets the Connection used by the walker.
  205.      *
  206.      * @return Connection
  207.      */
  208.     public function getConnection()
  209.     {
  210.         return $this->conn;
  211.     }
  213.     /**
  214.      * Gets the EntityManager used by the walker.
  215.      *
  216.      * @return EntityManagerInterface
  217.      */
  218.     public function getEntityManager()
  219.     {
  220.         return $this->em;
  221.     }
  223.     /**
  224.      * Gets the information about a single query component.
  225.      *
  226.      * @param string $dqlAlias The DQL alias.
  227.      *
  228.      * @return mixed[]
  229.      * @psalm-return QueryComponent
  230.      */
  231.     public function getQueryComponent($dqlAlias)
  232.     {
  233.         return $this->queryComponents[$dqlAlias];
  234.     }
  236.     public function getMetadataForDqlAlias(string $dqlAlias): ClassMetadata
  237.     {
  238.         if (! isset($this->queryComponents[$dqlAlias]['metadata'])) {
  239.             throw new LogicException(sprintf('No metadata for DQL alias: %s', $dqlAlias));
  240.         }
  242.         return $this->queryComponents[$dqlAlias]['metadata'];
  243.     }
  245.     /**
  246.      * {@inheritdoc}
  247.      */
  248.     public function getQueryComponents()
  249.     {
  250.         return $this->queryComponents;
  251.     }
  253.     /**
  254.      * {@inheritdoc}
  255.      */
  256.     public function setQueryComponent($dqlAlias, array $queryComponent)
  257.     {
  258.         $requiredKeys = ['metadata', 'parent', 'relation', 'map', 'nestingLevel', 'token'];
  260.         if (array_diff($requiredKeys, array_keys($queryComponent))) {
  261.             throw QueryException::invalidQueryComponent($dqlAlias);
  262.         }
  264.         $this->queryComponents[$dqlAlias] = $queryComponent;
  265.     }
  267.     /**
  268.      * {@inheritdoc}
  269.      */
  270.     public function getExecutor($AST)
  271.     {
  272.         switch (true) {
  273.             case $AST instanceof AST\DeleteStatement:
  274.                 $primaryClass = $this->em->getClassMetadata($AST->deleteClause->abstractSchemaName);
  276.                 return $primaryClass->isInheritanceTypeJoined()
  277.                     ? new Exec\MultiTableDeleteExecutor($AST, $this)
  278.                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
  280.             case $AST instanceof AST\UpdateStatement:
  281.                 $primaryClass = $this->em->getClassMetadata($AST->updateClause->abstractSchemaName);
  283.                 return $primaryClass->isInheritanceTypeJoined()
  284.                     ? new Exec\MultiTableUpdateExecutor($AST, $this)
  285.                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
  287.             default:
  288.                 return new Exec\SingleSelectExecutor($AST, $this);
  289.         }
  290.     }
  292.     /**
  293.      * Generates a unique, short SQL table alias.
  294.      *
  295.      * @param string $tableName Table name
  296.      * @param string $dqlAlias  The DQL alias.
  297.      *
  298.      * @return string Generated table alias.
  299.      */
  300.     public function getSQLTableAlias($tableName, $dqlAlias = '')
  301.     {
  302.         $tableName .= $dqlAlias ? '@[' . $dqlAlias . ']' : '';
  304.         if (! isset($this->tableAliasMap[$tableName])) {
  305.             $this->tableAliasMap[$tableName] = (preg_match('/[a-z]/i', $tableName[0]) ? strtolower($tableName[0]) : 't')
  306.                 . $this->tableAliasCounter++ . '_';
  307.         }
  309.         return $this->tableAliasMap[$tableName];
  310.     }
  312.     /**
  313.      * Forces the SqlWalker to use a specific alias for a table name, rather than
  314.      * generating an alias on its own.
  315.      *
  316.      * @param string $tableName
  317.      * @param string $alias
  318.      * @param string $dqlAlias
  319.      *
  320.      * @return string
  321.      */
  322.     public function setSQLTableAlias($tableName, $alias, $dqlAlias = '')
  323.     {
  324.         $tableName .= $dqlAlias ? '@[' . $dqlAlias . ']' : '';
  326.         $this->tableAliasMap[$tableName] = $alias;
  328.         return $alias;
  329.     }
  331.     /**
  332.      * Gets an SQL column alias for a column name.
  333.      *
  334.      * @param string $columnName
  335.      *
  336.      * @return string
  337.      */
  338.     public function getSQLColumnAlias($columnName)
  339.     {
  340.         return $this->quoteStrategy->getColumnAlias($columnName, $this->aliasCounter++, $this->platform);
  341.     }
  343.     /**
  344.      * Generates the SQL JOINs that are necessary for Class Table Inheritance
  345.      * for the given class.
  346.      *
  347.      * @param ClassMetadata $class    The class for which to generate the joins.
  348.      * @param string        $dqlAlias The DQL alias of the class.
  349.      *
  350.      * @return string The SQL.
  351.      */
  352.     private function generateClassTableInheritanceJoins(
  353.         ClassMetadata $class,
  354.         string $dqlAlias
  355.     ): string {
  356.         $sql = '';
  358.         $baseTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  360.         // INNER JOIN parent class tables
  361.         foreach ($class->parentClasses as $parentClassName) {
  362.             $parentClass = $this->em->getClassMetadata($parentClassName);
  363.             $tableAlias  = $this->getSQLTableAlias($parentClass->getTableName(), $dqlAlias);
  365.             // If this is a joined association we must use left joins to preserve the correct result.
  366.             $sql .= isset($this->queryComponents[$dqlAlias]['relation']) ? ' LEFT ' : ' INNER ';
  367.             $sql .= 'JOIN ' . $this->quoteStrategy->getTableName($parentClass, $this->platform) . ' ' . $tableAlias . ' ON ';
  369.             $sqlParts = [];
  371.             foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
  372.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
  373.             }
  375.             // Add filters on the root class
  376.             $sqlParts[] = $this->generateFilterConditionSQL($parentClass, $tableAlias);
  378.             $sql .= implode(' AND ', array_filter($sqlParts));
  379.         }
  381.         // Ignore subclassing inclusion if partial objects is disallowed
  382.         if ($this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
  383.             return $sql;
  384.         }
  386.         // LEFT JOIN child class tables
  387.         foreach ($class->subClasses as $subClassName) {
  388.             $subClass   = $this->em->getClassMetadata($subClassName);
  389.             $tableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  391.             $sql .= ' LEFT JOIN ' . $this->quoteStrategy->getTableName($subClass, $this->platform) . ' ' . $tableAlias . ' ON ';
  393.             $sqlParts = [];
  395.             foreach ($this->quoteStrategy->getIdentifierColumnNames($subClass, $this->platform) as $columnName) {
  396.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
  397.             }
  399.             $sql .= implode(' AND ', $sqlParts);
  400.         }
  402.         return $sql;
  403.     }
  405.     private function generateOrderedCollectionOrderByItems(): string
  406.     {
  407.         $orderedColumns = [];
  409.         foreach ($this->selectedClasses as $selectedClass) {
  410.             $dqlAlias = $selectedClass['dqlAlias'];
  411.             $qComp    = $this->queryComponents[$dqlAlias];
  413.             if (! isset($qComp['relation']['orderBy'])) {
  414.                 continue;
  415.             }
  417.             assert(isset($qComp['metadata']));
  418.             $persister = $this->em->getUnitOfWork()->getEntityPersister($qComp['metadata']->name);
  420.             foreach ($qComp['relation']['orderBy'] as $fieldName => $orientation) {
  421.                 $columnName = $this->quoteStrategy->getColumnName($fieldName, $qComp['metadata'], $this->platform);
  422.                 $tableName  = $qComp['metadata']->isInheritanceTypeJoined()
  423.                     ? $persister->getOwningTable($fieldName)
  424.                     : $qComp['metadata']->getTableName();
  426.                 $orderedColumn = $this->getSQLTableAlias($tableName, $dqlAlias) . '.' . $columnName;
  428.                 // OrderByClause should replace an ordered relation. see - DDC-2475
  429.                 if (isset($this->orderedColumnsMap[$orderedColumn])) {
  430.                     continue;
  431.                 }
  433.                 $this->orderedColumnsMap[$orderedColumn] = $orientation;
  434.                 $orderedColumns[]                        = $orderedColumn . ' ' . $orientation;
  435.             }
  436.         }
  438.         return implode(', ', $orderedColumns);
  439.     }
  441.     /**
  442.      * Generates a discriminator column SQL condition for the class with the given DQL alias.
  443.      *
  444.      * @psalm-param list<string> $dqlAliases List of root DQL aliases to inspect for discriminator restrictions.
  445.      */
  446.     private function generateDiscriminatorColumnConditionSQL(array $dqlAliases): string
  447.     {
  448.         $sqlParts = [];
  450.         foreach ($dqlAliases as $dqlAlias) {
  451.             $class = $this->getMetadataForDqlAlias($dqlAlias);
  453.             if (! $class->isInheritanceTypeSingleTable()) {
  454.                 continue;
  455.             }
  457.             $conn   = $this->em->getConnection();
  458.             $values = [];
  460.             if ($class->discriminatorValue !== null) { // discriminators can be 0
  461.                 $values[] = $conn->quote($class->discriminatorValue);
  462.             }
  464.             foreach ($class->subClasses as $subclassName) {
  465.                 $values[] = $conn->quote($this->em->getClassMetadata($subclassName)->discriminatorValue);
  466.             }
  468.             $sqlTableAlias = $this->useSqlTableAliases
  469.                 ? $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.'
  470.                 : '';
  472.             $sqlParts[] = $sqlTableAlias . $class->getDiscriminatorColumn()['name'] . ' IN (' . implode(', ', $values) . ')';
  473.         }
  475.         $sql = implode(' AND ', $sqlParts);
  477.         return count($sqlParts) > 1 ? '(' . $sql . ')' : $sql;
  478.     }
  480.     /**
  481.      * Generates the filter SQL for a given entity and table alias.
  482.      *
  483.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
  484.      * @param string        $targetTableAlias The table alias of the joined/selected table.
  485.      *
  486.      * @return string The SQL query part to add to a query.
  487.      */
  488.     private function generateFilterConditionSQL(
  489.         ClassMetadata $targetEntity,
  490.         string $targetTableAlias
  491.     ): string {
  492.         if (! $this->em->hasFilters()) {
  493.             return '';
  494.         }
  496.         switch ($targetEntity->inheritanceType) {
  497.             case ClassMetadata::INHERITANCE_TYPE_NONE:
  498.                 break;
  499.             case ClassMetadata::INHERITANCE_TYPE_JOINED:
  500.                 // The classes in the inheritance will be added to the query one by one,
  501.                 // but only the root node is getting filtered
  502.                 if ($targetEntity->name !== $targetEntity->rootEntityName) {
  503.                     return '';
  504.                 }
  506.                 break;
  507.             case ClassMetadata::INHERITANCE_TYPE_SINGLE_TABLE:
  508.                 // With STI the table will only be queried once, make sure that the filters
  509.                 // are added to the root entity
  510.                 $targetEntity = $this->em->getClassMetadata($targetEntity->rootEntityName);
  511.                 break;
  512.             default:
  513.                 //@todo: throw exception?
  514.                 return '';
  515.         }
  517.         $filterClauses = [];
  518.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  519.             $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
  520.             if ($filterExpr !== '') {
  521.                 $filterClauses[] = '(' . $filterExpr . ')';
  522.             }
  523.         }
  525.         return implode(' AND ', $filterClauses);
  526.     }
  528.     /**
  529.      * {@inheritdoc}
  530.      */
  531.     public function walkSelectStatement(AST\SelectStatement $AST)
  532.     {
  533.         $limit    = $this->query->getMaxResults();
  534.         $offset   = $this->query->getFirstResult();
  535.         $lockMode = $this->query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE;
  536.         $sql      = $this->walkSelectClause($AST->selectClause)
  537.             . $this->walkFromClause($AST->fromClause)
  538.             . $this->walkWhereClause($AST->whereClause);
  540.         if ($AST->groupByClause) {
  541.             $sql .= $this->walkGroupByClause($AST->groupByClause);
  542.         }
  544.         if ($AST->havingClause) {
  545.             $sql .= $this->walkHavingClause($AST->havingClause);
  546.         }
  548.         if ($AST->orderByClause) {
  549.             $sql .= $this->walkOrderByClause($AST->orderByClause);
  550.         }
  552.         $orderBySql = $this->generateOrderedCollectionOrderByItems();
  553.         if (! $AST->orderByClause && $orderBySql) {
  554.             $sql .= ' ORDER BY ' . $orderBySql;
  555.         }
  557.         if ($limit !== null || $offset !== null) {
  558.             $sql = $this->platform->modifyLimitQuery($sql, $limit, $offset ?? 0);
  559.         }
  561.         if ($lockMode === LockMode::NONE) {
  562.             return $sql;
  563.         }
  565.         if ($lockMode === LockMode::PESSIMISTIC_READ) {
  566.             return $sql . ' ' . $this->platform->getReadLockSQL();
  567.         }
  569.         if ($lockMode === LockMode::PESSIMISTIC_WRITE) {
  570.             return $sql . ' ' . $this->platform->getWriteLockSQL();
  571.         }
  573.         if ($lockMode !== LockMode::OPTIMISTIC) {
  574.             throw QueryException::invalidLockMode();
  575.         }
  577.         foreach ($this->selectedClasses as $selectedClass) {
  578.             if (! $selectedClass['class']->isVersioned) {
  579.                 throw OptimisticLockException::lockFailed($selectedClass['class']->name);
  580.             }
  581.         }
  583.         return $sql;
  584.     }
  586.     /**
  587.      * {@inheritdoc}
  588.      */
  589.     public function walkUpdateStatement(AST\UpdateStatement $AST)
  590.     {
  591.         $this->useSqlTableAliases = false;
  592.         $this->rsm->isSelect      = false;
  594.         return $this->walkUpdateClause($AST->updateClause)
  595.             . $this->walkWhereClause($AST->whereClause);
  596.     }
  598.     /**
  599.      * {@inheritdoc}
  600.      */
  601.     public function walkDeleteStatement(AST\DeleteStatement $AST)
  602.     {
  603.         $this->useSqlTableAliases = false;
  604.         $this->rsm->isSelect      = false;
  606.         return $this->walkDeleteClause($AST->deleteClause)
  607.             . $this->walkWhereClause($AST->whereClause);
  608.     }
  610.     /**
  611.      * Walks down an IdentificationVariable AST node, thereby generating the appropriate SQL.
  612.      * This one differs of ->walkIdentificationVariable() because it generates the entity identifiers.
  613.      *
  614.      * @param string $identVariable
  615.      *
  616.      * @return string
  617.      */
  618.     public function walkEntityIdentificationVariable($identVariable)
  619.     {
  620.         $class      = $this->getMetadataForDqlAlias($identVariable);
  621.         $tableAlias = $this->getSQLTableAlias($class->getTableName(), $identVariable);
  622.         $sqlParts   = [];
  624.         foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
  625.             $sqlParts[] = $tableAlias . '.' . $columnName;
  626.         }
  628.         return implode(', ', $sqlParts);
  629.     }
  631.     /**
  632.      * Walks down an IdentificationVariable (no AST node associated), thereby generating the SQL.
  633.      *
  634.      * @param string $identificationVariable
  635.      * @param string $fieldName
  636.      *
  637.      * @return string The SQL.
  638.      */
  639.     public function walkIdentificationVariable($identificationVariable, $fieldName = null)
  640.     {
  641.         $class = $this->getMetadataForDqlAlias($identificationVariable);
  643.         if (
  644.             $fieldName !== null && $class->isInheritanceTypeJoined() &&
  645.             isset($class->fieldMappings[$fieldName]['inherited'])
  646.         ) {
  647.             $class = $this->em->getClassMetadata($class->fieldMappings[$fieldName]['inherited']);
  648.         }
  650.         return $this->getSQLTableAlias($class->getTableName(), $identificationVariable);
  651.     }
  653.     /**
  654.      * {@inheritdoc}
  655.      */
  656.     public function walkPathExpression($pathExpr)
  657.     {
  658.         $sql = '';
  659.         assert($pathExpr->field !== null);
  661.         switch ($pathExpr->type) {
  662.             case AST\PathExpression::TYPE_STATE_FIELD:
  663.                 $fieldName = $pathExpr->field;
  664.                 $dqlAlias  = $pathExpr->identificationVariable;
  665.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
  667.                 if ($this->useSqlTableAliases) {
  668.                     $sql .= $this->walkIdentificationVariable($dqlAlias, $fieldName) . '.';
  669.                 }
  671.                 $sql .= $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  672.                 break;
  674.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
  675.                 // 1- the owning side:
  676.                 //    Just use the foreign key, i.e. u.group_id
  677.                 $fieldName = $pathExpr->field;
  678.                 $dqlAlias  = $pathExpr->identificationVariable;
  679.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
  681.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
  682.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
  683.                 }
  685.                 $assoc = $class->associationMappings[$fieldName];
  687.                 if (! $assoc['isOwningSide']) {
  688.                     throw QueryException::associationPathInverseSideNotSupported($pathExpr);
  689.                 }
  691.                 // COMPOSITE KEYS NOT (YET?) SUPPORTED
  692.                 if (count($assoc['sourceToTargetKeyColumns']) > 1) {
  693.                     throw QueryException::associationPathCompositeKeyNotSupported();
  694.                 }
  696.                 if ($this->useSqlTableAliases) {
  697.                     $sql .= $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.';
  698.                 }
  700.                 $sql .= reset($assoc['targetToSourceKeyColumns']);
  701.                 break;
  703.             default:
  704.                 throw QueryException::invalidPathExpression($pathExpr);
  705.         }
  707.         return $sql;
  708.     }
  710.     /**
  711.      * {@inheritdoc}
  712.      */
  713.     public function walkSelectClause($selectClause)
  714.     {
  715.         $sql                  = 'SELECT ' . ($selectClause->isDistinct ? 'DISTINCT ' : '');
  716.         $sqlSelectExpressions = array_filter(array_map([$this, 'walkSelectExpression'], $selectClause->selectExpressions));
  718.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) === true && $selectClause->isDistinct) {
  719.             $this->query->setHint(self::HINT_DISTINCT, true);
  720.         }
  722.         $addMetaColumns = ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD) &&
  723.             $this->query->getHydrationMode() === Query::HYDRATE_OBJECT
  724.             || $this->query->getHint(Query::HINT_INCLUDE_META_COLUMNS);
  726.         foreach ($this->selectedClasses as $selectedClass) {
  727.             $class       = $selectedClass['class'];
  728.             $dqlAlias    = $selectedClass['dqlAlias'];
  729.             $resultAlias = $selectedClass['resultAlias'];
  731.             // Register as entity or joined entity result
  732.             if (! isset($this->queryComponents[$dqlAlias]['relation'])) {
  733.                 $this->rsm->addEntityResult($class->name, $dqlAlias, $resultAlias);
  734.             } else {
  735.                 assert(isset($this->queryComponents[$dqlAlias]['parent']));
  737.                 $this->rsm->addJoinedEntityResult(
  738.                     $class->name,
  739.                     $dqlAlias,
  740.                     $this->queryComponents[$dqlAlias]['parent'],
  741.                     $this->queryComponents[$dqlAlias]['relation']['fieldName']
  742.                 );
  743.             }
  745.             if ($class->isInheritanceTypeSingleTable() || $class->isInheritanceTypeJoined()) {
  746.                 // Add discriminator columns to SQL
  747.                 $rootClass   = $this->em->getClassMetadata($class->rootEntityName);
  748.                 $tblAlias    = $this->getSQLTableAlias($rootClass->getTableName(), $dqlAlias);
  749.                 $discrColumn = $rootClass->getDiscriminatorColumn();
  750.                 $columnAlias = $this->getSQLColumnAlias($discrColumn['name']);
  752.                 $sqlSelectExpressions[] = $tblAlias . '.' . $discrColumn['name'] . ' AS ' . $columnAlias;
  754.                 $this->rsm->setDiscriminatorColumn($dqlAlias, $columnAlias);
  755.                 $this->rsm->addMetaResult($dqlAlias, $columnAlias, $discrColumn['fieldName'], false, $discrColumn['type']);
  756.             }
  758.             // Add foreign key columns to SQL, if necessary
  759.             if (! $addMetaColumns && ! $class->containsForeignIdentifier) {
  760.                 continue;
  761.             }
  763.             // Add foreign key columns of class and also parent classes
  764.             foreach ($class->associationMappings as $assoc) {
  765.                 if (
  766.                     ! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)
  767.                     || ( ! $addMetaColumns && ! isset($assoc['id']))
  768.                 ) {
  769.                     continue;
  770.                 }
  772.                 $targetClass   = $this->em->getClassMetadata($assoc['targetEntity']);
  773.                 $isIdentifier  = (isset($assoc['id']) && $assoc['id'] === true);
  774.                 $owningClass   = isset($assoc['inherited']) ? $this->em->getClassMetadata($assoc['inherited']) : $class;
  775.                 $sqlTableAlias = $this->getSQLTableAlias($owningClass->getTableName(), $dqlAlias);
  777.                 foreach ($assoc['joinColumns'] as $joinColumn) {
  778.                     $columnName  = $joinColumn['name'];
  779.                     $columnAlias = $this->getSQLColumnAlias($columnName);
  780.                     $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  782.                     $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  783.                     $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
  785.                     $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $isIdentifier, $columnType);
  786.                 }
  787.             }
  789.             // Add foreign key columns to SQL, if necessary
  790.             if (! $addMetaColumns) {
  791.                 continue;
  792.             }
  794.             // Add foreign key columns of subclasses
  795.             foreach ($class->subClasses as $subClassName) {
  796.                 $subClass      = $this->em->getClassMetadata($subClassName);
  797.                 $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  799.                 foreach ($subClass->associationMappings as $assoc) {
  800.                     // Skip if association is inherited
  801.                     if (isset($assoc['inherited'])) {
  802.                         continue;
  803.                     }
  805.                     if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
  806.                         $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  808.                         foreach ($assoc['joinColumns'] as $joinColumn) {
  809.                             $columnName  = $joinColumn['name'];
  810.                             $columnAlias = $this->getSQLColumnAlias($columnName);
  811.                             $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  813.                             $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $subClass, $this->platform);
  814.                             $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
  816.                             $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $subClass->isIdentifier($columnName), $columnType);
  817.                         }
  818.                     }
  819.                 }
  820.             }
  821.         }
  823.         return $sql . implode(', ', $sqlSelectExpressions);
  824.     }
  826.     /**
  827.      * {@inheritdoc}
  828.      */
  829.     public function walkFromClause($fromClause)
  830.     {
  831.         $identificationVarDecls = $fromClause->identificationVariableDeclarations;
  832.         $sqlParts               = [];
  834.         foreach ($identificationVarDecls as $identificationVariableDecl) {
  835.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($identificationVariableDecl);
  836.         }
  838.         return ' FROM ' . implode(', ', $sqlParts);
  839.     }
  841.     /**
  842.      * Walks down a IdentificationVariableDeclaration AST node, thereby generating the appropriate SQL.
  843.      *
  844.      * @param AST\IdentificationVariableDeclaration $identificationVariableDecl
  845.      *
  846.      * @return string
  847.      */
  848.     public function walkIdentificationVariableDeclaration($identificationVariableDecl)
  849.     {
  850.         $sql = $this->walkRangeVariableDeclaration($identificationVariableDecl->rangeVariableDeclaration);
  852.         if ($identificationVariableDecl->indexBy) {
  853.             $this->walkIndexBy($identificationVariableDecl->indexBy);
  854.         }
  856.         foreach ($identificationVariableDecl->joins as $join) {
  857.             $sql .= $this->walkJoin($join);
  858.         }
  860.         return $sql;
  861.     }
  863.     /**
  864.      * Walks down a IndexBy AST node.
  865.      *
  866.      * @param AST\IndexBy $indexBy
  867.      *
  868.      * @return void
  869.      */
  870.     public function walkIndexBy($indexBy)
  871.     {
  872.         $pathExpression = $indexBy->singleValuedPathExpression;
  873.         $alias          = $pathExpression->identificationVariable;
  874.         assert($pathExpression->field !== null);
  876.         switch ($pathExpression->type) {
  877.             case AST\PathExpression::TYPE_STATE_FIELD:
  878.                 $field = $pathExpression->field;
  879.                 break;
  881.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
  882.                 // Just use the foreign key, i.e. u.group_id
  883.                 $fieldName = $pathExpression->field;
  884.                 $class     = $this->getMetadataForDqlAlias($alias);
  886.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
  887.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
  888.                 }
  890.                 $association = $class->associationMappings[$fieldName];
  892.                 if (! $association['isOwningSide']) {
  893.                     throw QueryException::associationPathInverseSideNotSupported($pathExpression);
  894.                 }
  896.                 if (count($association['sourceToTargetKeyColumns']) > 1) {
  897.                     throw QueryException::associationPathCompositeKeyNotSupported();
  898.                 }
  900.                 $field = reset($association['targetToSourceKeyColumns']);
  901.                 break;
  903.             default:
  904.                 throw QueryException::invalidPathExpression($pathExpression);
  905.         }
  907.         if (isset($this->scalarFields[$alias][$field])) {
  908.             $this->rsm->addIndexByScalar($this->scalarFields[$alias][$field]);
  910.             return;
  911.         }
  913.         $this->rsm->addIndexBy($alias, $field);
  914.     }
  916.     /**
  917.      * Walks down a RangeVariableDeclaration AST node, thereby generating the appropriate SQL.
  918.      *
  919.      * @param AST\RangeVariableDeclaration $rangeVariableDeclaration
  920.      *
  921.      * @return string
  922.      */
  923.     public function walkRangeVariableDeclaration($rangeVariableDeclaration)
  924.     {
  925.         return $this->generateRangeVariableDeclarationSQL($rangeVariableDeclaration, false);
  926.     }
  928.     /**
  929.      * Generate appropriate SQL for RangeVariableDeclaration AST node
  930.      */
  931.     private function generateRangeVariableDeclarationSQL(
  932.         AST\RangeVariableDeclaration $rangeVariableDeclaration,
  933.         bool $buildNestedJoins
  934.     ): string {
  935.         $class    = $this->em->getClassMetadata($rangeVariableDeclaration->abstractSchemaName);
  936.         $dqlAlias = $rangeVariableDeclaration->aliasIdentificationVariable;
  938.         if ($rangeVariableDeclaration->isRoot) {
  939.             $this->rootAliases[] = $dqlAlias;
  940.         }
  942.         $sql = $this->platform->appendLockHint(
  943.             $this->quoteStrategy->getTableName($class, $this->platform) . ' ' .
  944.             $this->getSQLTableAlias($class->getTableName(), $dqlAlias),
  945.             $this->query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE
  946.         );
  948.         if (! $class->isInheritanceTypeJoined()) {
  949.             return $sql;
  950.         }
  952.         $classTableInheritanceJoins = $this->generateClassTableInheritanceJoins($class, $dqlAlias);
  954.         if (! $buildNestedJoins) {
  955.             return $sql . $classTableInheritanceJoins;
  956.         }
  958.         return $classTableInheritanceJoins === '' ? $sql : '(' . $sql . $classTableInheritanceJoins . ')';
  959.     }
  961.     /**
  962.      * Walks down a JoinAssociationDeclaration AST node, thereby generating the appropriate SQL.
  963.      *
  964.      * @param AST\JoinAssociationDeclaration $joinAssociationDeclaration
  965.      * @param int                            $joinType
  966.      * @param AST\ConditionalExpression      $condExpr
  967.      * @psalm-param AST\Join::JOIN_TYPE_* $joinType
  968.      *
  969.      * @return string
  970.      *
  971.      * @throws QueryException
  972.      */
  973.     public function walkJoinAssociationDeclaration($joinAssociationDeclaration, $joinType = AST\Join::JOIN_TYPE_INNER, $condExpr = null)
  974.     {
  975.         $sql = '';
  977.         $associationPathExpression = $joinAssociationDeclaration->joinAssociationPathExpression;
  978.         $joinedDqlAlias            = $joinAssociationDeclaration->aliasIdentificationVariable;
  979.         $indexBy                   = $joinAssociationDeclaration->indexBy;
  981.         $relation = $this->queryComponents[$joinedDqlAlias]['relation'] ?? null;
  982.         assert($relation !== null);
  983.         $targetClass     = $this->em->getClassMetadata($relation['targetEntity']);
  984.         $sourceClass     = $this->em->getClassMetadata($relation['sourceEntity']);
  985.         $targetTableName = $this->quoteStrategy->getTableName($targetClass, $this->platform);
  987.         $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName(), $joinedDqlAlias);
  988.         $sourceTableAlias = $this->getSQLTableAlias($sourceClass->getTableName(), $associationPathExpression->identificationVariable);
  990.         // Ensure we got the owning side, since it has all mapping info
  991.         $assoc = ! $relation['isOwningSide'] ? $targetClass->associationMappings[$relation['mappedBy']] : $relation;
  993.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) === true && (! $this->query->getHint(self::HINT_DISTINCT) || isset($this->selectedClasses[$joinedDqlAlias]))) {
  994.             if ($relation['type'] === ClassMetadata::ONE_TO_MANY || $relation['type'] === ClassMetadata::MANY_TO_MANY) {
  995.                 throw QueryException::iterateWithFetchJoinNotAllowed($assoc);
  996.             }
  997.         }
  999.         $targetTableJoin = null;
  1001.         // This condition is not checking ClassMetadata::MANY_TO_ONE, because by definition it cannot
  1002.         // be the owning side and previously we ensured that $assoc is always the owning side of the associations.
  1003.         // The owning side is necessary at this point because only it contains the JoinColumn information.
  1004.         switch (true) {
  1005.             case $assoc['type'] & ClassMetadata::TO_ONE:
  1006.                 $conditions = [];
  1008.                 foreach ($assoc['joinColumns'] as $joinColumn) {
  1009.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  1010.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  1012.                     if ($relation['isOwningSide']) {
  1013.                         $conditions[] = $sourceTableAlias . '.' . $quotedSourceColumn . ' = ' . $targetTableAlias . '.' . $quotedTargetColumn;
  1015.                         continue;
  1016.                     }
  1018.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $targetTableAlias . '.' . $quotedSourceColumn;
  1019.                 }
  1021.                 // Apply remaining inheritance restrictions
  1022.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
  1024.                 if ($discrSql) {
  1025.                     $conditions[] = $discrSql;
  1026.                 }
  1028.                 // Apply the filters
  1029.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
  1031.                 if ($filterExpr) {
  1032.                     $conditions[] = $filterExpr;
  1033.                 }
  1035.                 $targetTableJoin = [
  1036.                     'table' => $targetTableName . ' ' . $targetTableAlias,
  1037.                     'condition' => implode(' AND ', $conditions),
  1038.                 ];
  1039.                 break;
  1041.             case $assoc['type'] === ClassMetadata::MANY_TO_MANY:
  1042.                 // Join relation table
  1043.                 $joinTable      = $assoc['joinTable'];
  1044.                 $joinTableAlias = $this->getSQLTableAlias($joinTable['name'], $joinedDqlAlias);
  1045.                 $joinTableName  = $this->quoteStrategy->getJoinTableName($assoc, $sourceClass, $this->platform);
  1047.                 $conditions      = [];
  1048.                 $relationColumns = $relation['isOwningSide']
  1049.                     ? $assoc['joinTable']['joinColumns']
  1050.                     : $assoc['joinTable']['inverseJoinColumns'];
  1052.                 foreach ($relationColumns as $joinColumn) {
  1053.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  1054.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  1056.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
  1057.                 }
  1059.                 $sql .= $joinTableName . ' ' . $joinTableAlias . ' ON ' . implode(' AND ', $conditions);
  1061.                 // Join target table
  1062.                 $sql .= $joinType === AST\Join::JOIN_TYPE_LEFT || $joinType === AST\Join::JOIN_TYPE_LEFTOUTER ? ' LEFT JOIN ' : ' INNER JOIN ';
  1064.                 $conditions      = [];
  1065.                 $relationColumns = $relation['isOwningSide']
  1066.                     ? $assoc['joinTable']['inverseJoinColumns']
  1067.                     : $assoc['joinTable']['joinColumns'];
  1069.                 foreach ($relationColumns as $joinColumn) {
  1070.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  1071.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  1073.                     $conditions[] = $targetTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
  1074.                 }
  1076.                 // Apply remaining inheritance restrictions
  1077.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
  1079.                 if ($discrSql) {
  1080.                     $conditions[] = $discrSql;
  1081.                 }
  1083.                 // Apply the filters
  1084.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
  1086.                 if ($filterExpr) {
  1087.                     $conditions[] = $filterExpr;
  1088.                 }
  1090.                 $targetTableJoin = [
  1091.                     'table' => $targetTableName . ' ' . $targetTableAlias,
  1092.                     'condition' => implode(' AND ', $conditions),
  1093.                 ];
  1094.                 break;
  1096.             default:
  1097.                 throw new BadMethodCallException('Type of association must be one of *_TO_ONE or MANY_TO_MANY');
  1098.         }
  1100.         // Handle WITH clause
  1101.         $withCondition = $condExpr === null ? '' : ('(' . $this->walkConditionalExpression($condExpr) . ')');
  1103.         if ($targetClass->isInheritanceTypeJoined()) {
  1104.             $ctiJoins = $this->generateClassTableInheritanceJoins($targetClass, $joinedDqlAlias);
  1105.             // If we have WITH condition, we need to build nested joins for target class table and cti joins
  1106.             if ($withCondition && $ctiJoins) {
  1107.                 $sql .= '(' . $targetTableJoin['table'] . $ctiJoins . ') ON ' . $targetTableJoin['condition'];
  1108.             } else {
  1109.                 $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'] . $ctiJoins;
  1110.             }
  1111.         } else {
  1112.             $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'];
  1113.         }
  1115.         if ($withCondition) {
  1116.             $sql .= ' AND ' . $withCondition;
  1117.         }
  1119.         // Apply the indexes
  1120.         if ($indexBy) {
  1121.             // For Many-To-One or One-To-One associations this obviously makes no sense, but is ignored silently.
  1122.             $this->walkIndexBy($indexBy);
  1123.         } elseif (isset($relation['indexBy'])) {
  1124.             $this->rsm->addIndexBy($joinedDqlAlias, $relation['indexBy']);
  1125.         }
  1127.         return $sql;
  1128.     }
  1130.     /**
  1131.      * {@inheritdoc}
  1132.      */
  1133.     public function walkFunction($function)
  1134.     {
  1135.         return $function->getSql($this);
  1136.     }
  1138.     /**
  1139.      * {@inheritdoc}
  1140.      */
  1141.     public function walkOrderByClause($orderByClause)
  1142.     {
  1143.         $orderByItems = array_map([$this, 'walkOrderByItem'], $orderByClause->orderByItems);
  1145.         $collectionOrderByItems = $this->generateOrderedCollectionOrderByItems();
  1146.         if ($collectionOrderByItems !== '') {
  1147.             $orderByItems = array_merge($orderByItems, (array) $collectionOrderByItems);
  1148.         }
  1150.         return ' ORDER BY ' . implode(', ', $orderByItems);
  1151.     }
  1153.     /**
  1154.      * {@inheritdoc}
  1155.      */
  1156.     public function walkOrderByItem($orderByItem)
  1157.     {
  1158.         $type = strtoupper($orderByItem->type);
  1159.         $expr = $orderByItem->expression;
  1160.         $sql  = $expr instanceof AST\Node
  1161.             ? $expr->dispatch($this)
  1162.             : $this->walkResultVariable($this->queryComponents[$expr]['token']['value']);
  1164.         $this->orderedColumnsMap[$sql] = $type;
  1166.         if ($expr instanceof AST\Subselect) {
  1167.             return '(' . $sql . ') ' . $type;
  1168.         }
  1170.         return $sql . ' ' . $type;
  1171.     }
  1173.     /**
  1174.      * {@inheritdoc}
  1175.      */
  1176.     public function walkHavingClause($havingClause)
  1177.     {
  1178.         return ' HAVING ' . $this->walkConditionalExpression($havingClause->conditionalExpression);
  1179.     }
  1181.     /**
  1182.      * {@inheritdoc}
  1183.      */
  1184.     public function walkJoin($join)
  1185.     {
  1186.         $joinType        = $join->joinType;
  1187.         $joinDeclaration = $join->joinAssociationDeclaration;
  1189.         $sql = $joinType === AST\Join::JOIN_TYPE_LEFT || $joinType === AST\Join::JOIN_TYPE_LEFTOUTER
  1190.             ? ' LEFT JOIN '
  1191.             : ' INNER JOIN ';
  1193.         switch (true) {
  1194.             case $joinDeclaration instanceof AST\RangeVariableDeclaration:
  1195.                 $class      = $this->em->getClassMetadata($joinDeclaration->abstractSchemaName);
  1196.                 $dqlAlias   = $joinDeclaration->aliasIdentificationVariable;
  1197.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
  1198.                 $conditions = [];
  1200.                 if ($join->conditionalExpression) {
  1201.                     $conditions[] = '(' . $this->walkConditionalExpression($join->conditionalExpression) . ')';
  1202.                 }
  1204.                 $isUnconditionalJoin = $conditions === [];
  1205.                 $condExprConjunction = $class->isInheritanceTypeJoined() && $joinType !== AST\Join::JOIN_TYPE_LEFT && $joinType !== AST\Join::JOIN_TYPE_LEFTOUTER && $isUnconditionalJoin
  1206.                     ? ' AND '
  1207.                     : ' ON ';
  1209.                 $sql .= $this->generateRangeVariableDeclarationSQL($joinDeclaration, ! $isUnconditionalJoin);
  1211.                 // Apply remaining inheritance restrictions
  1212.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$dqlAlias]);
  1214.                 if ($discrSql) {
  1215.                     $conditions[] = $discrSql;
  1216.                 }
  1218.                 // Apply the filters
  1219.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
  1221.                 if ($filterExpr) {
  1222.                     $conditions[] = $filterExpr;
  1223.                 }
  1225.                 if ($conditions) {
  1226.                     $sql .= $condExprConjunction . implode(' AND ', $conditions);
  1227.                 }
  1229.                 break;
  1231.             case $joinDeclaration instanceof AST\JoinAssociationDeclaration:
  1232.                 $sql .= $this->walkJoinAssociationDeclaration($joinDeclaration, $joinType, $join->conditionalExpression);
  1233.                 break;
  1234.         }
  1236.         return $sql;
  1237.     }
  1239.     /**
  1240.      * Walks down a CoalesceExpression AST node and generates the corresponding SQL.
  1241.      *
  1242.      * @param AST\CoalesceExpression $coalesceExpression
  1243.      *
  1244.      * @return string The SQL.
  1245.      */
  1246.     public function walkCoalesceExpression($coalesceExpression)
  1247.     {
  1248.         $sql = 'COALESCE(';
  1250.         $scalarExpressions = [];
  1252.         foreach ($coalesceExpression->scalarExpressions as $scalarExpression) {
  1253.             $scalarExpressions[] = $this->walkSimpleArithmeticExpression($scalarExpression);
  1254.         }
  1256.         return $sql . implode(', ', $scalarExpressions) . ')';
  1257.     }
  1259.     /**
  1260.      * Walks down a NullIfExpression AST node and generates the corresponding SQL.
  1261.      *
  1262.      * @param AST\NullIfExpression $nullIfExpression
  1263.      *
  1264.      * @return string The SQL.
  1265.      */
  1266.     public function walkNullIfExpression($nullIfExpression)
  1267.     {
  1268.         $firstExpression = is_string($nullIfExpression->firstExpression)
  1269.             ? $this->conn->quote($nullIfExpression->firstExpression)
  1270.             : $this->walkSimpleArithmeticExpression($nullIfExpression->firstExpression);
  1272.         $secondExpression = is_string($nullIfExpression->secondExpression)
  1273.             ? $this->conn->quote($nullIfExpression->secondExpression)
  1274.             : $this->walkSimpleArithmeticExpression($nullIfExpression->secondExpression);
  1276.         return 'NULLIF(' . $firstExpression . ', ' . $secondExpression . ')';
  1277.     }
  1279.     /**
  1280.      * Walks down a GeneralCaseExpression AST node and generates the corresponding SQL.
  1281.      *
  1282.      * @return string The SQL.
  1283.      */
  1284.     public function walkGeneralCaseExpression(AST\GeneralCaseExpression $generalCaseExpression)
  1285.     {
  1286.         $sql = 'CASE';
  1288.         foreach ($generalCaseExpression->whenClauses as $whenClause) {
  1289.             $sql .= ' WHEN ' . $this->walkConditionalExpression($whenClause->caseConditionExpression);
  1290.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($whenClause->thenScalarExpression);
  1291.         }
  1293.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($generalCaseExpression->elseScalarExpression) . ' END';
  1295.         return $sql;
  1296.     }
  1298.     /**
  1299.      * Walks down a SimpleCaseExpression AST node and generates the corresponding SQL.
  1300.      *
  1301.      * @param AST\SimpleCaseExpression $simpleCaseExpression
  1302.      *
  1303.      * @return string The SQL.
  1304.      */
  1305.     public function walkSimpleCaseExpression($simpleCaseExpression)
  1306.     {
  1307.         $sql = 'CASE ' . $this->walkStateFieldPathExpression($simpleCaseExpression->caseOperand);
  1309.         foreach ($simpleCaseExpression->simpleWhenClauses as $simpleWhenClause) {
  1310.             $sql .= ' WHEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->caseScalarExpression);
  1311.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->thenScalarExpression);
  1312.         }
  1314.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($simpleCaseExpression->elseScalarExpression) . ' END';
  1316.         return $sql;
  1317.     }
  1319.     /**
  1320.      * {@inheritdoc}
  1321.      */
  1322.     public function walkSelectExpression($selectExpression)
  1323.     {
  1324.         $sql    = '';
  1325.         $expr   = $selectExpression->expression;
  1326.         $hidden = $selectExpression->hiddenAliasResultVariable;
  1328.         switch (true) {
  1329.             case $expr instanceof AST\PathExpression:
  1330.                 if ($expr->type !== AST\PathExpression::TYPE_STATE_FIELD) {
  1331.                     throw QueryException::invalidPathExpression($expr);
  1332.                 }
  1334.                 assert($expr->field !== null);
  1335.                 $fieldName = $expr->field;
  1336.                 $dqlAlias  = $expr->identificationVariable;
  1337.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
  1339.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $fieldName;
  1340.                 $tableName   = $class->isInheritanceTypeJoined()
  1341.                     ? $this->em->getUnitOfWork()->getEntityPersister($class->name)->getOwningTable($fieldName)
  1342.                     : $class->getTableName();
  1344.                 $sqlTableAlias = $this->getSQLTableAlias($tableName, $dqlAlias);
  1345.                 $fieldMapping  = $class->fieldMappings[$fieldName];
  1346.                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  1347.                 $columnAlias   = $this->getSQLColumnAlias($fieldMapping['columnName']);
  1348.                 $col           = $sqlTableAlias . '.' . $columnName;
  1350.                 if (isset($fieldMapping['requireSQLConversion'])) {
  1351.                     $type = Type::getType($fieldMapping['type']);
  1352.                     $col  = $type->convertToPHPValueSQL($col, $this->conn->getDatabasePlatform());
  1353.                 }
  1355.                 $sql .= $col . ' AS ' . $columnAlias;
  1357.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1359.                 if (! $hidden) {
  1360.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldMapping['type']);
  1361.                     $this->scalarFields[$dqlAlias][$fieldName] = $columnAlias;
  1363.                     if (! empty($fieldMapping['enumType'])) {
  1364.                         $this->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
  1365.                     }
  1366.                 }
  1368.                 break;
  1370.             case $expr instanceof AST\AggregateExpression:
  1371.             case $expr instanceof AST\Functions\FunctionNode:
  1372.             case $expr instanceof AST\SimpleArithmeticExpression:
  1373.             case $expr instanceof AST\ArithmeticTerm:
  1374.             case $expr instanceof AST\ArithmeticFactor:
  1375.             case $expr instanceof AST\ParenthesisExpression:
  1376.             case $expr instanceof AST\Literal:
  1377.             case $expr instanceof AST\NullIfExpression:
  1378.             case $expr instanceof AST\CoalesceExpression:
  1379.             case $expr instanceof AST\GeneralCaseExpression:
  1380.             case $expr instanceof AST\SimpleCaseExpression:
  1381.                 $columnAlias = $this->getSQLColumnAlias('sclr');
  1382.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1384.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
  1386.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1388.                 if ($hidden) {
  1389.                     break;
  1390.                 }
  1392.                 if (! $expr instanceof Query\AST\TypedExpression) {
  1393.                     // Conceptually we could resolve field type here by traverse through AST to retrieve field type,
  1394.                     // but this is not a feasible solution; assume 'string'.
  1395.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
  1397.                     break;
  1398.                 }
  1400.                 $this->rsm->addScalarResult($columnAlias, $resultAlias, $expr->getReturnType()->getName());
  1402.                 break;
  1404.             case $expr instanceof AST\Subselect:
  1405.                 $columnAlias = $this->getSQLColumnAlias('sclr');
  1406.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1408.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
  1410.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1412.                 if (! $hidden) {
  1413.                     // We cannot resolve field type here; assume 'string'.
  1414.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
  1415.                 }
  1417.                 break;
  1419.             case $expr instanceof AST\NewObjectExpression:
  1420.                 $sql .= $this->walkNewObject($expr, $selectExpression->fieldIdentificationVariable);
  1421.                 break;
  1423.             default:
  1424.                 // IdentificationVariable or PartialObjectExpression
  1425.                 if ($expr instanceof AST\PartialObjectExpression) {
  1426.                     $this->query->setHint(self::HINT_PARTIAL, true);
  1428.                     $dqlAlias        = $expr->identificationVariable;
  1429.                     $partialFieldSet = $expr->partialFieldSet;
  1430.                 } else {
  1431.                     $dqlAlias        = $expr;
  1432.                     $partialFieldSet = [];
  1433.                 }
  1435.                 $class       = $this->getMetadataForDqlAlias($dqlAlias);
  1436.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: null;
  1438.                 if (! isset($this->selectedClasses[$dqlAlias])) {
  1439.                     $this->selectedClasses[$dqlAlias] = [
  1440.                         'class'       => $class,
  1441.                         'dqlAlias'    => $dqlAlias,
  1442.                         'resultAlias' => $resultAlias,
  1443.                     ];
  1444.                 }
  1446.                 $sqlParts = [];
  1448.                 // Select all fields from the queried class
  1449.                 foreach ($class->fieldMappings as $fieldName => $mapping) {
  1450.                     if ($partialFieldSet && ! in_array($fieldName, $partialFieldSet, true)) {
  1451.                         continue;
  1452.                     }
  1454.                     $tableName = isset($mapping['inherited'])
  1455.                         ? $this->em->getClassMetadata($mapping['inherited'])->getTableName()
  1456.                         : $class->getTableName();
  1458.                     $sqlTableAlias    = $this->getSQLTableAlias($tableName, $dqlAlias);
  1459.                     $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
  1460.                     $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  1462.                     $col = $sqlTableAlias . '.' . $quotedColumnName;
  1464.                     if (isset($mapping['requireSQLConversion'])) {
  1465.                         $type = Type::getType($mapping['type']);
  1466.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
  1467.                     }
  1469.                     $sqlParts[] = $col . ' AS ' . $columnAlias;
  1471.                     $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
  1473.                     $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $class->name);
  1474.                 }
  1476.                 // Add any additional fields of subclasses (excluding inherited fields)
  1477.                 // 1) on Single Table Inheritance: always, since its marginal overhead
  1478.                 // 2) on Class Table Inheritance only if partial objects are disallowed,
  1479.                 //    since it requires outer joining subtables.
  1480.                 if ($class->isInheritanceTypeSingleTable() || ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
  1481.                     foreach ($class->subClasses as $subClassName) {
  1482.                         $subClass      = $this->em->getClassMetadata($subClassName);
  1483.                         $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  1485.                         foreach ($subClass->fieldMappings as $fieldName => $mapping) {
  1486.                             if (isset($mapping['inherited']) || ($partialFieldSet && ! in_array($fieldName, $partialFieldSet, true))) {
  1487.                                 continue;
  1488.                             }
  1490.                             $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
  1491.                             $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $subClass, $this->platform);
  1493.                             $col = $sqlTableAlias . '.' . $quotedColumnName;
  1495.                             if (isset($mapping['requireSQLConversion'])) {
  1496.                                 $type = Type::getType($mapping['type']);
  1497.                                 $col  = $type->convertToPHPValueSQL($col, $this->platform);
  1498.                             }
  1500.                             $sqlParts[] = $col . ' AS ' . $columnAlias;
  1502.                             $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
  1504.                             $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $subClassName);
  1505.                         }
  1506.                     }
  1507.                 }
  1509.                 $sql .= implode(', ', $sqlParts);
  1510.         }
  1512.         return $sql;
  1513.     }
  1515.     /**
  1516.      * {@inheritdoc}
  1517.      */
  1518.     public function walkQuantifiedExpression($qExpr)
  1519.     {
  1520.         return ' ' . strtoupper($qExpr->type) . '(' . $this->walkSubselect($qExpr->subselect) . ')';
  1521.     }
  1523.     /**
  1524.      * {@inheritdoc}
  1525.      */
  1526.     public function walkSubselect($subselect)
  1527.     {
  1528.         $useAliasesBefore  = $this->useSqlTableAliases;
  1529.         $rootAliasesBefore = $this->rootAliases;
  1531.         $this->rootAliases        = []; // reset the rootAliases for the subselect
  1532.         $this->useSqlTableAliases = true;
  1534.         $sql  = $this->walkSimpleSelectClause($subselect->simpleSelectClause);
  1535.         $sql .= $this->walkSubselectFromClause($subselect->subselectFromClause);
  1536.         $sql .= $this->walkWhereClause($subselect->whereClause);
  1538.         $sql .= $subselect->groupByClause ? $this->walkGroupByClause($subselect->groupByClause) : '';
  1539.         $sql .= $subselect->havingClause ? $this->walkHavingClause($subselect->havingClause) : '';
  1540.         $sql .= $subselect->orderByClause ? $this->walkOrderByClause($subselect->orderByClause) : '';
  1542.         $this->rootAliases        = $rootAliasesBefore; // put the main aliases back
  1543.         $this->useSqlTableAliases = $useAliasesBefore;
  1545.         return $sql;
  1546.     }
  1548.     /**
  1549.      * {@inheritdoc}
  1550.      */
  1551.     public function walkSubselectFromClause($subselectFromClause)
  1552.     {
  1553.         $identificationVarDecls = $subselectFromClause->identificationVariableDeclarations;
  1554.         $sqlParts               = [];
  1556.         foreach ($identificationVarDecls as $subselectIdVarDecl) {
  1557.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($subselectIdVarDecl);
  1558.         }
  1560.         return ' FROM ' . implode(', ', $sqlParts);
  1561.     }
  1563.     /**
  1564.      * {@inheritdoc}
  1565.      */
  1566.     public function walkSimpleSelectClause($simpleSelectClause)
  1567.     {
  1568.         return 'SELECT' . ($simpleSelectClause->isDistinct ? ' DISTINCT' : '')
  1569.             . $this->walkSimpleSelectExpression($simpleSelectClause->simpleSelectExpression);
  1570.     }
  1572.     /**
  1573.      * @return string
  1574.      */
  1575.     public function walkParenthesisExpression(AST\ParenthesisExpression $parenthesisExpression)
  1576.     {
  1577.         return sprintf('(%s)', $parenthesisExpression->expression->dispatch($this));
  1578.     }
  1580.     /**
  1581.      * @param AST\NewObjectExpression $newObjectExpression
  1582.      * @param string|null             $newObjectResultAlias
  1583.      *
  1584.      * @return string The SQL.
  1585.      */
  1586.     public function walkNewObject($newObjectExpression, $newObjectResultAlias = null)
  1587.     {
  1588.         $sqlSelectExpressions = [];
  1589.         $objIndex             = $newObjectResultAlias ?: $this->newObjectCounter++;
  1591.         foreach ($newObjectExpression->args as $argIndex => $e) {
  1592.             $resultAlias = $this->scalarResultCounter++;
  1593.             $columnAlias = $this->getSQLColumnAlias('sclr');
  1594.             $fieldType   = 'string';
  1596.             switch (true) {
  1597.                 case $e instanceof AST\NewObjectExpression:
  1598.                     $sqlSelectExpressions[] = $e->dispatch($this);
  1599.                     break;
  1601.                 case $e instanceof AST\Subselect:
  1602.                     $sqlSelectExpressions[] = '(' . $e->dispatch($this) . ') AS ' . $columnAlias;
  1603.                     break;
  1605.                 case $e instanceof AST\PathExpression:
  1606.                     assert($e->field !== null);
  1607.                     $dqlAlias     = $e->identificationVariable;
  1608.                     $class        = $this->getMetadataForDqlAlias($dqlAlias);
  1609.                     $fieldName    = $e->field;
  1610.                     $fieldMapping = $class->fieldMappings[$fieldName];
  1611.                     $fieldType    = $fieldMapping['type'];
  1612.                     $col          = trim($e->dispatch($this));
  1614.                     if (isset($fieldMapping['requireSQLConversion'])) {
  1615.                         $type = Type::getType($fieldType);
  1616.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
  1617.                     }
  1619.                     $sqlSelectExpressions[] = $col . ' AS ' . $columnAlias;
  1620.                     break;
  1622.                 case $e instanceof AST\Literal:
  1623.                     switch ($e->type) {
  1624.                         case AST\Literal::BOOLEAN:
  1625.                             $fieldType = 'boolean';
  1626.                             break;
  1628.                         case AST\Literal::NUMERIC:
  1629.                             $fieldType = is_float($e->value) ? 'float' : 'integer';
  1630.                             break;
  1631.                     }
  1633.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
  1634.                     break;
  1636.                 default:
  1637.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
  1638.                     break;
  1639.             }
  1641.             $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1642.             $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldType);
  1644.             $this->rsm->newObjectMappings[$columnAlias] = [
  1645.                 'className' => $newObjectExpression->className,
  1646.                 'objIndex'  => $objIndex,
  1647.                 'argIndex'  => $argIndex,
  1648.             ];
  1649.         }
  1651.         return implode(', ', $sqlSelectExpressions);
  1652.     }
  1654.     /**
  1655.      * {@inheritdoc}
  1656.      */
  1657.     public function walkSimpleSelectExpression($simpleSelectExpression)
  1658.     {
  1659.         $expr = $simpleSelectExpression->expression;
  1660.         $sql  = ' ';
  1662.         switch (true) {
  1663.             case $expr instanceof AST\PathExpression:
  1664.                 $sql .= $this->walkPathExpression($expr);
  1665.                 break;
  1667.             case $expr instanceof AST\Subselect:
  1668.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1670.                 $columnAlias                        = 'sclr' . $this->aliasCounter++;
  1671.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
  1673.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
  1674.                 break;
  1676.             case $expr instanceof AST\Functions\FunctionNode:
  1677.             case $expr instanceof AST\SimpleArithmeticExpression:
  1678.             case $expr instanceof AST\ArithmeticTerm:
  1679.             case $expr instanceof AST\ArithmeticFactor:
  1680.             case $expr instanceof AST\Literal:
  1681.             case $expr instanceof AST\NullIfExpression:
  1682.             case $expr instanceof AST\CoalesceExpression:
  1683.             case $expr instanceof AST\GeneralCaseExpression:
  1684.             case $expr instanceof AST\SimpleCaseExpression:
  1685.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1687.                 $columnAlias                        = $this->getSQLColumnAlias('sclr');
  1688.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
  1690.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
  1691.                 break;
  1693.             case $expr instanceof AST\ParenthesisExpression:
  1694.                 $sql .= $this->walkParenthesisExpression($expr);
  1695.                 break;
  1697.             default: // IdentificationVariable
  1698.                 $sql .= $this->walkEntityIdentificationVariable($expr);
  1699.                 break;
  1700.         }
  1702.         return $sql;
  1703.     }
  1705.     /**
  1706.      * {@inheritdoc}
  1707.      */
  1708.     public function walkAggregateExpression($aggExpression)
  1709.     {
  1710.         return $aggExpression->functionName . '(' . ($aggExpression->isDistinct ? 'DISTINCT ' : '')
  1711.             . $this->walkSimpleArithmeticExpression($aggExpression->pathExpression) . ')';
  1712.     }
  1714.     /**
  1715.      * {@inheritdoc}
  1716.      */
  1717.     public function walkGroupByClause($groupByClause)
  1718.     {
  1719.         $sqlParts = [];
  1721.         foreach ($groupByClause->groupByItems as $groupByItem) {
  1722.             $sqlParts[] = $this->walkGroupByItem($groupByItem);
  1723.         }
  1725.         return ' GROUP BY ' . implode(', ', $sqlParts);
  1726.     }
  1728.     /**
  1729.      * {@inheritdoc}
  1730.      */
  1731.     public function walkGroupByItem($groupByItem)
  1732.     {
  1733.         // StateFieldPathExpression
  1734.         if (! is_string($groupByItem)) {
  1735.             return $this->walkPathExpression($groupByItem);
  1736.         }
  1738.         // ResultVariable
  1739.         if (isset($this->queryComponents[$groupByItem]['resultVariable'])) {
  1740.             $resultVariable = $this->queryComponents[$groupByItem]['resultVariable'];
  1742.             if ($resultVariable instanceof AST\PathExpression) {
  1743.                 return $this->walkPathExpression($resultVariable);
  1744.             }
  1746.             if ($resultVariable instanceof AST\Node && isset($resultVariable->pathExpression)) {
  1747.                 return $this->walkPathExpression($resultVariable->pathExpression);
  1748.             }
  1750.             return $this->walkResultVariable($groupByItem);
  1751.         }
  1753.         // IdentificationVariable
  1754.         $sqlParts = [];
  1756.         foreach ($this->getMetadataForDqlAlias($groupByItem)->fieldNames as $field) {
  1757.             $item       = new AST\PathExpression(AST\PathExpression::TYPE_STATE_FIELD, $groupByItem, $field);
  1758.             $item->type = AST\PathExpression::TYPE_STATE_FIELD;
  1760.             $sqlParts[] = $this->walkPathExpression($item);
  1761.         }
  1763.         foreach ($this->getMetadataForDqlAlias($groupByItem)->associationMappings as $mapping) {
  1764.             if ($mapping['isOwningSide'] && $mapping['type'] & ClassMetadataInfo::TO_ONE) {
  1765.                 $item       = new AST\PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION, $groupByItem, $mapping['fieldName']);
  1766.                 $item->type = AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION;
  1768.                 $sqlParts[] = $this->walkPathExpression($item);
  1769.             }
  1770.         }
  1772.         return implode(', ', $sqlParts);
  1773.     }
  1775.     /**
  1776.      * {@inheritdoc}
  1777.      */
  1778.     public function walkDeleteClause(AST\DeleteClause $deleteClause)
  1779.     {
  1780.         $class     = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1781.         $tableName = $class->getTableName();
  1782.         $sql       = 'DELETE FROM ' . $this->quoteStrategy->getTableName($class, $this->platform);
  1784.         $this->setSQLTableAlias($tableName, $tableName, $deleteClause->aliasIdentificationVariable);
  1785.         $this->rootAliases[] = $deleteClause->aliasIdentificationVariable;
  1787.         return $sql;
  1788.     }
  1790.     /**
  1791.      * {@inheritdoc}
  1792.      */
  1793.     public function walkUpdateClause($updateClause)
  1794.     {
  1795.         $class     = $this->em->getClassMetadata($updateClause->abstractSchemaName);
  1796.         $tableName = $class->getTableName();
  1797.         $sql       = 'UPDATE ' . $this->quoteStrategy->getTableName($class, $this->platform);
  1799.         $this->setSQLTableAlias($tableName, $tableName, $updateClause->aliasIdentificationVariable);
  1800.         $this->rootAliases[] = $updateClause->aliasIdentificationVariable;
  1802.         return $sql . ' SET ' . implode(', ', array_map([$this, 'walkUpdateItem'], $updateClause->updateItems));
  1803.     }
  1805.     /**
  1806.      * {@inheritdoc}
  1807.      */
  1808.     public function walkUpdateItem($updateItem)
  1809.     {
  1810.         $useTableAliasesBefore    = $this->useSqlTableAliases;
  1811.         $this->useSqlTableAliases = false;
  1813.         $sql      = $this->walkPathExpression($updateItem->pathExpression) . ' = ';
  1814.         $newValue = $updateItem->newValue;
  1816.         switch (true) {
  1817.             case $newValue instanceof AST\Node:
  1818.                 $sql .= $newValue->dispatch($this);
  1819.                 break;
  1821.             case $newValue === null:
  1822.                 $sql .= 'NULL';
  1823.                 break;
  1825.             default:
  1826.                 $sql .= $this->conn->quote($newValue);
  1827.                 break;
  1828.         }
  1830.         $this->useSqlTableAliases = $useTableAliasesBefore;
  1832.         return $sql;
  1833.     }
  1835.     /**
  1836.      * {@inheritdoc}
  1837.      */
  1838.     public function walkWhereClause($whereClause)
  1839.     {
  1840.         $condSql  = $whereClause !== null ? $this->walkConditionalExpression($whereClause->conditionalExpression) : '';
  1841.         $discrSql = $this->generateDiscriminatorColumnConditionSQL($this->rootAliases);
  1843.         if ($this->em->hasFilters()) {
  1844.             $filterClauses = [];
  1845.             foreach ($this->rootAliases as $dqlAlias) {
  1846.                 $class      = $this->getMetadataForDqlAlias($dqlAlias);
  1847.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
  1849.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
  1850.                 if ($filterExpr) {
  1851.                     $filterClauses[] = $filterExpr;
  1852.                 }
  1853.             }
  1855.             if (count($filterClauses)) {
  1856.                 if ($condSql) {
  1857.                     $condSql = '(' . $condSql . ') AND ';
  1858.                 }
  1860.                 $condSql .= implode(' AND ', $filterClauses);
  1861.             }
  1862.         }
  1864.         if ($condSql) {
  1865.             return ' WHERE ' . (! $discrSql ? $condSql : '(' . $condSql . ') AND ' . $discrSql);
  1866.         }
  1868.         if ($discrSql) {
  1869.             return ' WHERE ' . $discrSql;
  1870.         }
  1872.         return '';
  1873.     }
  1875.     /**
  1876.      * {@inheritdoc}
  1877.      */
  1878.     public function walkConditionalExpression($condExpr)
  1879.     {
  1880.         // Phase 2 AST optimization: Skip processing of ConditionalExpression
  1881.         // if only one ConditionalTerm is defined
  1882.         if (! ($condExpr instanceof AST\ConditionalExpression)) {
  1883.             return $this->walkConditionalTerm($condExpr);
  1884.         }
  1886.         return implode(' OR ', array_map([$this, 'walkConditionalTerm'], $condExpr->conditionalTerms));
  1887.     }
  1889.     /**
  1890.      * {@inheritdoc}
  1891.      */
  1892.     public function walkConditionalTerm($condTerm)
  1893.     {
  1894.         // Phase 2 AST optimization: Skip processing of ConditionalTerm
  1895.         // if only one ConditionalFactor is defined
  1896.         if (! ($condTerm instanceof AST\ConditionalTerm)) {
  1897.             return $this->walkConditionalFactor($condTerm);
  1898.         }
  1900.         return implode(' AND ', array_map([$this, 'walkConditionalFactor'], $condTerm->conditionalFactors));
  1901.     }
  1903.     /**
  1904.      * {@inheritdoc}
  1905.      */
  1906.     public function walkConditionalFactor($factor)
  1907.     {
  1908.         // Phase 2 AST optimization: Skip processing of ConditionalFactor
  1909.         // if only one ConditionalPrimary is defined
  1910.         return ! ($factor instanceof AST\ConditionalFactor)
  1911.             ? $this->walkConditionalPrimary($factor)
  1912.             : ($factor->not ? 'NOT ' : '') . $this->walkConditionalPrimary($factor->conditionalPrimary);
  1913.     }
  1915.     /**
  1916.      * {@inheritdoc}
  1917.      */
  1918.     public function walkConditionalPrimary($primary)
  1919.     {
  1920.         if ($primary->isSimpleConditionalExpression()) {
  1921.             return $primary->simpleConditionalExpression->dispatch($this);
  1922.         }
  1924.         if ($primary->isConditionalExpression()) {
  1925.             $condExpr = $primary->conditionalExpression;
  1927.             return '(' . $this->walkConditionalExpression($condExpr) . ')';
  1928.         }
  1929.     }
  1931.     /**
  1932.      * {@inheritdoc}
  1933.      */
  1934.     public function walkExistsExpression($existsExpr)
  1935.     {
  1936.         $sql = $existsExpr->not ? 'NOT ' : '';
  1938.         $sql .= 'EXISTS (' . $this->walkSubselect($existsExpr->subselect) . ')';
  1940.         return $sql;
  1941.     }
  1943.     /**
  1944.      * {@inheritdoc}
  1945.      */
  1946.     public function walkCollectionMemberExpression($collMemberExpr)
  1947.     {
  1948.         $sql  = $collMemberExpr->not ? 'NOT ' : '';
  1949.         $sql .= 'EXISTS (SELECT 1 FROM ';
  1951.         $entityExpr   = $collMemberExpr->entityExpression;
  1952.         $collPathExpr = $collMemberExpr->collectionValuedPathExpression;
  1953.         assert($collPathExpr->field !== null);
  1955.         $fieldName = $collPathExpr->field;
  1956.         $dqlAlias  = $collPathExpr->identificationVariable;
  1958.         $class = $this->getMetadataForDqlAlias($dqlAlias);
  1960.         switch (true) {
  1961.             // InputParameter
  1962.             case $entityExpr instanceof AST\InputParameter:
  1963.                 $dqlParamKey = $entityExpr->name;
  1964.                 $entitySql   = '?';
  1965.                 break;
  1967.             // SingleValuedAssociationPathExpression | IdentificationVariable
  1968.             case $entityExpr instanceof AST\PathExpression:
  1969.                 $entitySql = $this->walkPathExpression($entityExpr);
  1970.                 break;
  1972.             default:
  1973.                 throw new BadMethodCallException('Not implemented');
  1974.         }
  1976.         $assoc = $class->associationMappings[$fieldName];
  1978.         if ($assoc['type'] === ClassMetadata::ONE_TO_MANY) {
  1979.             $targetClass      = $this->em->getClassMetadata($assoc['targetEntity']);
  1980.             $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName());
  1981.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  1983.             $sql .= $this->quoteStrategy->getTableName($targetClass, $this->platform) . ' ' . $targetTableAlias . ' WHERE ';
  1985.             $owningAssoc = $targetClass->associationMappings[$assoc['mappedBy']];
  1986.             $sqlParts    = [];
  1988.             foreach ($owningAssoc['targetToSourceKeyColumns'] as $targetColumn => $sourceColumn) {
  1989.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$targetColumn], $class, $this->platform);
  1991.                 $sqlParts[] = $sourceTableAlias . '.' . $targetColumn . ' = ' . $targetTableAlias . '.' . $sourceColumn;
  1992.             }
  1994.             foreach ($this->quoteStrategy->getIdentifierColumnNames($targetClass, $this->platform) as $targetColumnName) {
  1995.                 if (isset($dqlParamKey)) {
  1996.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
  1997.                 }
  1999.                 $sqlParts[] = $targetTableAlias . '.' . $targetColumnName . ' = ' . $entitySql;
  2000.             }
  2002.             $sql .= implode(' AND ', $sqlParts);
  2003.         } else { // many-to-many
  2004.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  2006.             $owningAssoc = $assoc['isOwningSide'] ? $assoc : $targetClass->associationMappings[$assoc['mappedBy']];
  2007.             $joinTable   = $owningAssoc['joinTable'];
  2009.             // SQL table aliases
  2010.             $joinTableAlias   = $this->getSQLTableAlias($joinTable['name']);
  2011.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  2013.             $sql .= $this->quoteStrategy->getJoinTableName($owningAssoc, $targetClass, $this->platform) . ' ' . $joinTableAlias . ' WHERE ';
  2015.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['joinColumns'] : $joinTable['inverseJoinColumns'];
  2016.             $sqlParts    = [];
  2018.             foreach ($joinColumns as $joinColumn) {
  2019.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$joinColumn['referencedColumnName']], $class, $this->platform);
  2021.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' = ' . $sourceTableAlias . '.' . $targetColumn;
  2022.             }
  2024.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['inverseJoinColumns'] : $joinTable['joinColumns'];
  2026.             foreach ($joinColumns as $joinColumn) {
  2027.                 if (isset($dqlParamKey)) {
  2028.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
  2029.                 }
  2031.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' IN (' . $entitySql . ')';
  2032.             }
  2034.             $sql .= implode(' AND ', $sqlParts);
  2035.         }
  2037.         return $sql . ')';
  2038.     }
  2040.     /**
  2041.      * {@inheritdoc}
  2042.      */
  2043.     public function walkEmptyCollectionComparisonExpression($emptyCollCompExpr)
  2044.     {
  2045.         $sizeFunc                           = new AST\Functions\SizeFunction('size');
  2046.         $sizeFunc->collectionPathExpression = $emptyCollCompExpr->expression;
  2048.         return $sizeFunc->getSql($this) . ($emptyCollCompExpr->not ? ' > 0' : ' = 0');
  2049.     }
  2051.     /**
  2052.      * {@inheritdoc}
  2053.      */
  2054.     public function walkNullComparisonExpression($nullCompExpr)
  2055.     {
  2056.         $expression = $nullCompExpr->expression;
  2057.         $comparison = ' IS' . ($nullCompExpr->not ? ' NOT' : '') . ' NULL';
  2059.         // Handle ResultVariable
  2060.         if (is_string($expression) && isset($this->queryComponents[$expression]['resultVariable'])) {
  2061.             return $this->walkResultVariable($expression) . $comparison;
  2062.         }
  2064.         // Handle InputParameter mapping inclusion to ParserResult
  2065.         if ($expression instanceof AST\InputParameter) {
  2066.             return $this->walkInputParameter($expression) . $comparison;
  2067.         }
  2069.         return $expression->dispatch($this) . $comparison;
  2070.     }
  2072.     /**
  2073.      * {@inheritdoc}
  2074.      */
  2075.     public function walkInExpression($inExpr)
  2076.     {
  2077.         $sql = $this->walkArithmeticExpression($inExpr->expression) . ($inExpr->not ? ' NOT' : '') . ' IN (';
  2079.         $sql .= $inExpr->subselect
  2080.             ? $this->walkSubselect($inExpr->subselect)
  2081.             : implode(', ', array_map([$this, 'walkInParameter'], $inExpr->literals));
  2083.         $sql .= ')';
  2085.         return $sql;
  2086.     }
  2088.     /**
  2089.      * {@inheritdoc}
  2090.      *
  2091.      * @throws QueryException
  2092.      */
  2093.     public function walkInstanceOfExpression($instanceOfExpr)
  2094.     {
  2095.         $sql = '';
  2097.         $dqlAlias   = $instanceOfExpr->identificationVariable;
  2098.         $discrClass = $class = $this->getMetadataForDqlAlias($dqlAlias);
  2100.         if ($class->discriminatorColumn) {
  2101.             $discrClass = $this->em->getClassMetadata($class->rootEntityName);
  2102.         }
  2104.         if ($this->useSqlTableAliases) {
  2105.             $sql .= $this->getSQLTableAlias($discrClass->getTableName(), $dqlAlias) . '.';
  2106.         }
  2108.         $sql .= $class->getDiscriminatorColumn()['name'] . ($instanceOfExpr->not ? ' NOT IN ' : ' IN ');
  2109.         $sql .= $this->getChildDiscriminatorsFromClassMetadata($discrClass, $instanceOfExpr);
  2111.         return $sql;
  2112.     }
  2114.     /**
  2115.      * @param mixed $inParam
  2116.      *
  2117.      * @return string
  2118.      */
  2119.     public function walkInParameter($inParam)
  2120.     {
  2121.         return $inParam instanceof AST\InputParameter
  2122.             ? $this->walkInputParameter($inParam)
  2123.             : $this->walkArithmeticExpression($inParam);
  2124.     }
  2126.     /**
  2127.      * {@inheritdoc}
  2128.      */
  2129.     public function walkLiteral($literal)
  2130.     {
  2131.         switch ($literal->type) {
  2132.             case AST\Literal::STRING:
  2133.                 return $this->conn->quote($literal->value);
  2135.             case AST\Literal::BOOLEAN:
  2136.                 return (string) $this->conn->getDatabasePlatform()->convertBooleans(strtolower($literal->value) === 'true');
  2138.             case AST\Literal::NUMERIC:
  2139.                 return (string) $literal->value;
  2141.             default:
  2142.                 throw QueryException::invalidLiteral($literal);
  2143.         }
  2144.     }
  2146.     /**
  2147.      * {@inheritdoc}
  2148.      */
  2149.     public function walkBetweenExpression($betweenExpr)
  2150.     {
  2151.         $sql = $this->walkArithmeticExpression($betweenExpr->expression);
  2153.         if ($betweenExpr->not) {
  2154.             $sql .= ' NOT';
  2155.         }
  2157.         $sql .= ' BETWEEN ' . $this->walkArithmeticExpression($betweenExpr->leftBetweenExpression)
  2158.             . ' AND ' . $this->walkArithmeticExpression($betweenExpr->rightBetweenExpression);
  2160.         return $sql;
  2161.     }
  2163.     /**
  2164.      * {@inheritdoc}
  2165.      */
  2166.     public function walkLikeExpression($likeExpr)
  2167.     {
  2168.         $stringExpr = $likeExpr->stringExpression;
  2169.         if (is_string($stringExpr)) {
  2170.             if (! isset($this->queryComponents[$stringExpr]['resultVariable'])) {
  2171.                 throw new LogicException(sprintf('No result variable found for string expression "%s".', $stringExpr));
  2172.             }
  2174.             $leftExpr = $this->walkResultVariable($stringExpr);
  2175.         } else {
  2176.             $leftExpr = $stringExpr->dispatch($this);
  2177.         }
  2179.         $sql = $leftExpr . ($likeExpr->not ? ' NOT' : '') . ' LIKE ';
  2181.         if ($likeExpr->stringPattern instanceof AST\InputParameter) {
  2182.             $sql .= $this->walkInputParameter($likeExpr->stringPattern);
  2183.         } elseif ($likeExpr->stringPattern instanceof AST\Functions\FunctionNode) {
  2184.             $sql .= $this->walkFunction($likeExpr->stringPattern);
  2185.         } elseif ($likeExpr->stringPattern instanceof AST\PathExpression) {
  2186.             $sql .= $this->walkPathExpression($likeExpr->stringPattern);
  2187.         } else {
  2188.             $sql .= $this->walkLiteral($likeExpr->stringPattern);
  2189.         }
  2191.         if ($likeExpr->escapeChar) {
  2192.             $sql .= ' ESCAPE ' . $this->walkLiteral($likeExpr->escapeChar);
  2193.         }
  2195.         return $sql;
  2196.     }
  2198.     /**
  2199.      * {@inheritdoc}
  2200.      */
  2201.     public function walkStateFieldPathExpression($stateFieldPathExpression)
  2202.     {
  2203.         return $this->walkPathExpression($stateFieldPathExpression);
  2204.     }
  2206.     /**
  2207.      * {@inheritdoc}
  2208.      */
  2209.     public function walkComparisonExpression($compExpr)
  2210.     {
  2211.         $leftExpr  = $compExpr->leftExpression;
  2212.         $rightExpr = $compExpr->rightExpression;
  2213.         $sql       = '';
  2215.         $sql .= $leftExpr instanceof AST\Node
  2216.             ? $leftExpr->dispatch($this)
  2217.             : (is_numeric($leftExpr) ? $leftExpr : $this->conn->quote($leftExpr));
  2219.         $sql .= ' ' . $compExpr->operator . ' ';
  2221.         $sql .= $rightExpr instanceof AST\Node
  2222.             ? $rightExpr->dispatch($this)
  2223.             : (is_numeric($rightExpr) ? $rightExpr : $this->conn->quote($rightExpr));
  2225.         return $sql;
  2226.     }
  2228.     /**
  2229.      * {@inheritdoc}
  2230.      */
  2231.     public function walkInputParameter($inputParam)
  2232.     {
  2233.         $this->parserResult->addParameterMapping($inputParam->name, $this->sqlParamIndex++);
  2235.         $parameter = $this->query->getParameter($inputParam->name);
  2237.         if ($parameter) {
  2238.             $type = $parameter->getType();
  2239.             if (Type::hasType($type)) {
  2240.                 return Type::getType($type)->convertToDatabaseValueSQL('?', $this->platform);
  2241.             }
  2242.         }
  2244.         return '?';
  2245.     }
  2247.     /**
  2248.      * {@inheritdoc}
  2249.      */
  2250.     public function walkArithmeticExpression($arithmeticExpr)
  2251.     {
  2252.         return $arithmeticExpr->isSimpleArithmeticExpression()
  2253.             ? $this->walkSimpleArithmeticExpression($arithmeticExpr->simpleArithmeticExpression)
  2254.             : '(' . $this->walkSubselect($arithmeticExpr->subselect) . ')';
  2255.     }
  2257.     /**
  2258.      * {@inheritdoc}
  2259.      */
  2260.     public function walkSimpleArithmeticExpression($simpleArithmeticExpr)
  2261.     {
  2262.         if (! ($simpleArithmeticExpr instanceof AST\SimpleArithmeticExpression)) {
  2263.             return $this->walkArithmeticTerm($simpleArithmeticExpr);
  2264.         }
  2266.         return implode(' ', array_map([$this, 'walkArithmeticTerm'], $simpleArithmeticExpr->arithmeticTerms));
  2267.     }
  2269.     /**
  2270.      * {@inheritdoc}
  2271.      */
  2272.     public function walkArithmeticTerm($term)
  2273.     {
  2274.         if (is_string($term)) {
  2275.             return isset($this->queryComponents[$term])
  2276.                 ? $this->walkResultVariable($this->queryComponents[$term]['token']['value'])
  2277.                 : $term;
  2278.         }
  2280.         // Phase 2 AST optimization: Skip processing of ArithmeticTerm
  2281.         // if only one ArithmeticFactor is defined
  2282.         if (! ($term instanceof AST\ArithmeticTerm)) {
  2283.             return $this->walkArithmeticFactor($term);
  2284.         }
  2286.         return implode(' ', array_map([$this, 'walkArithmeticFactor'], $term->arithmeticFactors));
  2287.     }
  2289.     /**
  2290.      * {@inheritdoc}
  2291.      */
  2292.     public function walkArithmeticFactor($factor)
  2293.     {
  2294.         if (is_string($factor)) {
  2295.             return isset($this->queryComponents[$factor])
  2296.                 ? $this->walkResultVariable($this->queryComponents[$factor]['token']['value'])
  2297.                 : $factor;
  2298.         }
  2300.         // Phase 2 AST optimization: Skip processing of ArithmeticFactor
  2301.         // if only one ArithmeticPrimary is defined
  2302.         if (! ($factor instanceof AST\ArithmeticFactor)) {
  2303.             return $this->walkArithmeticPrimary($factor);
  2304.         }
  2306.         $sign = $factor->isNegativeSigned() ? '-' : ($factor->isPositiveSigned() ? '+' : '');
  2308.         return $sign . $this->walkArithmeticPrimary($factor->arithmeticPrimary);
  2309.     }
  2311.     /**
  2312.      * Walks down an ArithmeticPrimary that represents an AST node, thereby generating the appropriate SQL.
  2313.      *
  2314.      * @param mixed $primary
  2315.      *
  2316.      * @return string The SQL.
  2317.      */
  2318.     public function walkArithmeticPrimary($primary)
  2319.     {
  2320.         if ($primary instanceof AST\SimpleArithmeticExpression) {
  2321.             return '(' . $this->walkSimpleArithmeticExpression($primary) . ')';
  2322.         }
  2324.         if ($primary instanceof AST\Node) {
  2325.             return $primary->dispatch($this);
  2326.         }
  2328.         return $this->walkEntityIdentificationVariable($primary);
  2329.     }
  2331.     /**
  2332.      * {@inheritdoc}
  2333.      */
  2334.     public function walkStringPrimary($stringPrimary)
  2335.     {
  2336.         return is_string($stringPrimary)
  2337.             ? $this->conn->quote($stringPrimary)
  2338.             : $stringPrimary->dispatch($this);
  2339.     }
  2341.     /**
  2342.      * {@inheritdoc}
  2343.      */
  2344.     public function walkResultVariable($resultVariable)
  2345.     {
  2346.         if (! isset($this->scalarResultAliasMap[$resultVariable])) {
  2347.             throw new InvalidArgumentException(sprintf('Unknown result variable: %s', $resultVariable));
  2348.         }
  2350.         $resultAlias = $this->scalarResultAliasMap[$resultVariable];
  2352.         if (is_array($resultAlias)) {
  2353.             return implode(', ', $resultAlias);
  2354.         }
  2356.         return $resultAlias;
  2357.     }
  2359.     /**
  2360.      * @return string The list in parentheses of valid child discriminators from the given class
  2361.      *
  2362.      * @throws QueryException
  2363.      */
  2364.     private function getChildDiscriminatorsFromClassMetadata(
  2365.         ClassMetadataInfo $rootClass,
  2366.         AST\InstanceOfExpression $instanceOfExpr
  2367.     ): string {
  2368.         $sqlParameterList = [];
  2369.         $discriminators   = [];
  2370.         foreach ($instanceOfExpr->value as $parameter) {
  2371.             if ($parameter instanceof AST\InputParameter) {
  2372.                 $this->rsm->discriminatorParameters[$parameter->name] = $parameter->name;
  2373.                 $sqlParameterList[]                                   = $this->walkInParameter($parameter);
  2374.                 continue;
  2375.             }
  2377.             $metadata = $this->em->getClassMetadata($parameter);
  2379.             if ($metadata->getName() !== $rootClass->name && ! $metadata->getReflectionClass()->isSubclassOf($rootClass->name)) {
  2380.                 throw QueryException::instanceOfUnrelatedClass($parameter, $rootClass->name);
  2381.             }
  2383.             $discriminators += HierarchyDiscriminatorResolver::resolveDiscriminatorsForClass($metadata, $this->em);
  2384.         }
  2386.         foreach (array_keys($discriminators) as $dis) {
  2387.             $sqlParameterList[] = $this->conn->quote($dis);
  2388.         }
  2390.         return '(' . implode(', ', $sqlParameterList) . ')';
  2391.     }
  2392. }