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

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\QuoteStrategy;
  15. use Doctrine\ORM\OptimisticLockException;
  16. use Doctrine\ORM\Query;
  17. use Doctrine\ORM\Utility\HierarchyDiscriminatorResolver;
  18. use Doctrine\ORM\Utility\PersisterHelper;
  19. use InvalidArgumentException;
  20. use LogicException;
  22. use function array_diff;
  23. use function array_filter;
  24. use function array_keys;
  25. use function array_map;
  26. use function array_merge;
  27. use function assert;
  28. use function count;
  29. use function implode;
  30. use function in_array;
  31. use function is_array;
  32. use function is_float;
  33. use function is_numeric;
  34. use function is_string;
  35. use function preg_match;
  36. use function reset;
  37. use function sprintf;
  38. use function strtolower;
  39. use function strtoupper;
  40. use function trim;
  42. /**
  43.  * The SqlWalker walks over a DQL AST and constructs the corresponding SQL.
  44.  *
  45.  * @psalm-import-type QueryComponent from Parser
  46.  * @psalm-consistent-constructor
  47.  */
  48. class SqlWalker implements TreeWalker
  49. {
  50.     public const HINT_DISTINCT = 'doctrine.distinct';
  52.     /**
  53.      * Used to mark a query as containing a PARTIAL expression, which needs to be known by SLC.
  54.      */
  55.     public const HINT_PARTIAL = 'doctrine.partial';
  57.     /** @var ResultSetMapping */
  58.     private $rsm;
  60.     /**
  61.      * Counter for generating unique column aliases.
  62.      *
  63.      * @var int
  64.      */
  65.     private $aliasCounter = 0;
  67.     /**
  68.      * Counter for generating unique table aliases.
  69.      *
  70.      * @var int
  71.      */
  72.     private $tableAliasCounter = 0;
  74.     /**
  75.      * Counter for generating unique scalar result.
  76.      *
  77.      * @var int
  78.      */
  79.     private $scalarResultCounter = 1;
  81.     /**
  82.      * Counter for generating unique parameter indexes.
  83.      *
  84.      * @var int
  85.      */
  86.     private $sqlParamIndex = 0;
  88.     /**
  89.      * Counter for generating indexes.
  90.      *
  91.      * @var int
  92.      */
  93.     private $newObjectCounter = 0;
  95.     /** @var ParserResult */
  96.     private $parserResult;
  98.     /** @var EntityManagerInterface */
  99.     private $em;
  101.     /** @var Connection */
  102.     private $conn;
  104.     /** @var Query */
  105.     private $query;
  107.     /** @var mixed[] */
  108.     private $tableAliasMap = [];
  110.     /**
  111.      * Map from result variable names to their SQL column alias names.
  112.      *
  113.      * @psalm-var array<string|int, string|list<string>>
  114.      */
  115.     private $scalarResultAliasMap = [];
  117.     /**
  118.      * Map from Table-Alias + Column-Name to OrderBy-Direction.
  119.      *
  120.      * @var array<string, string>
  121.      */
  122.     private $orderedColumnsMap = [];
  124.     /**
  125.      * Map from DQL-Alias + Field-Name to SQL Column Alias.
  126.      *
  127.      * @var array<string, array<string, string>>
  128.      */
  129.     private $scalarFields = [];
  131.     /**
  132.      * Map of all components/classes that appear in the DQL query.
  133.      *
  134.      * @psalm-var array<string, QueryComponent>
  135.      */
  136.     private $queryComponents;
  138.     /**
  139.      * A list of classes that appear in non-scalar SelectExpressions.
  140.      *
  141.      * @psalm-var array<string, array{class: ClassMetadata, dqlAlias: string, resultAlias: string|null}>
  142.      */
  143.     private $selectedClasses = [];
  145.     /**
  146.      * The DQL alias of the root class of the currently traversed query.
  147.      *
  148.      * @psalm-var list<string>
  149.      */
  150.     private $rootAliases = [];
  152.     /**
  153.      * Flag that indicates whether to generate SQL table aliases in the SQL.
  154.      * These should only be generated for SELECT queries, not for UPDATE/DELETE.
  155.      *
  156.      * @var bool
  157.      */
  158.     private $useSqlTableAliases = true;
  160.     /**
  161.      * The database platform abstraction.
  162.      *
  163.      * @var AbstractPlatform
  164.      */
  165.     private $platform;
  167.     /**
  168.      * The quote strategy.
  169.      *
  170.      * @var QuoteStrategy
  171.      */
  172.     private $quoteStrategy;
  174.     /**
  175.      * @param Query        $query        The parsed Query.
  176.      * @param ParserResult $parserResult The result of the parsing process.
  177.      * @psalm-param array<string, QueryComponent> $queryComponents The query components (symbol table).
  178.      */
  179.     public function __construct($query, $parserResult, array $queryComponents)
  180.     {
  181.         $this->query           = $query;
  182.         $this->parserResult    = $parserResult;
  183.         $this->queryComponents = $queryComponents;
  184.         $this->rsm             = $parserResult->getResultSetMapping();
  185.         $this->em              = $query->getEntityManager();
  186.         $this->conn            = $this->em->getConnection();
  187.         $this->platform        = $this->conn->getDatabasePlatform();
  188.         $this->quoteStrategy   = $this->em->getConfiguration()->getQuoteStrategy();
  189.     }
  191.     /**
  192.      * Gets the Query instance used by the walker.
  193.      *
  194.      * @return Query
  195.      */
  196.     public function getQuery()
  197.     {
  198.         return $this->query;
  199.     }
  201.     /**
  202.      * Gets the Connection used by the walker.
  203.      *
  204.      * @return Connection
  205.      */
  206.     public function getConnection()
  207.     {
  208.         return $this->conn;
  209.     }
  211.     /**
  212.      * Gets the EntityManager used by the walker.
  213.      *
  214.      * @return EntityManagerInterface
  215.      */
  216.     public function getEntityManager()
  217.     {
  218.         return $this->em;
  219.     }
  221.     /**
  222.      * Gets the information about a single query component.
  223.      *
  224.      * @param string $dqlAlias The DQL alias.
  225.      *
  226.      * @return mixed[]
  227.      * @psalm-return QueryComponent
  228.      */
  229.     public function getQueryComponent($dqlAlias)
  230.     {
  231.         return $this->queryComponents[$dqlAlias];
  232.     }
  234.     public function getMetadataForDqlAlias(string $dqlAlias): ClassMetadata
  235.     {
  236.         if (! isset($this->queryComponents[$dqlAlias]['metadata'])) {
  237.             throw new LogicException(sprintf('No metadata for DQL alias: %s', $dqlAlias));
  238.         }
  240.         return $this->queryComponents[$dqlAlias]['metadata'];
  241.     }
  243.     /**
  244.      * Returns internal queryComponents array.
  245.      *
  246.      * @return array<string, QueryComponent>
  247.      */
  248.     public function getQueryComponents()
  249.     {
  250.         return $this->queryComponents;
  251.     }
  253.     /**
  254.      * Sets or overrides a query component for a given dql alias.
  255.      *
  256.      * @param string $dqlAlias The DQL alias.
  257.      * @psalm-param QueryComponent $queryComponent
  258.      *
  259.      * @return void
  260.      */
  261.     public function setQueryComponent($dqlAlias, array $queryComponent)
  262.     {
  263.         $requiredKeys = ['metadata', 'parent', 'relation', 'map', 'nestingLevel', 'token'];
  265.         if (array_diff($requiredKeys, array_keys($queryComponent))) {
  266.             throw QueryException::invalidQueryComponent($dqlAlias);
  267.         }
  269.         $this->queryComponents[$dqlAlias] = $queryComponent;
  270.     }
  272.     /**
  273.      * Gets an executor that can be used to execute the result of this walker.
  274.      *
  275.      * @param AST\DeleteStatement|AST\UpdateStatement|AST\SelectStatement $AST
  276.      *
  277.      * @return Exec\AbstractSqlExecutor
  278.      */
  279.     public function getExecutor($AST)
  280.     {
  281.         switch (true) {
  282.             case $AST instanceof AST\DeleteStatement:
  283.                 $primaryClass = $this->em->getClassMetadata($AST->deleteClause->abstractSchemaName);
  285.                 return $primaryClass->isInheritanceTypeJoined()
  286.                     ? new Exec\MultiTableDeleteExecutor($AST, $this)
  287.                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
  289.             case $AST instanceof AST\UpdateStatement:
  290.                 $primaryClass = $this->em->getClassMetadata($AST->updateClause->abstractSchemaName);
  292.                 return $primaryClass->isInheritanceTypeJoined()
  293.                     ? new Exec\MultiTableUpdateExecutor($AST, $this)
  294.                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
  296.             default:
  297.                 return new Exec\SingleSelectExecutor($AST, $this);
  298.         }
  299.     }
  301.     /**
  302.      * Generates a unique, short SQL table alias.
  303.      *
  304.      * @param string $tableName Table name
  305.      * @param string $dqlAlias  The DQL alias.
  306.      *
  307.      * @return string Generated table alias.
  308.      */
  309.     public function getSQLTableAlias($tableName, $dqlAlias = '')
  310.     {
  311.         $tableName .= $dqlAlias ? '@[' . $dqlAlias . ']' : '';
  313.         if (! isset($this->tableAliasMap[$tableName])) {
  314.             $this->tableAliasMap[$tableName] = (preg_match('/[a-z]/i', $tableName[0]) ? strtolower($tableName[0]) : 't')
  315.                 . $this->tableAliasCounter++ . '_';
  316.         }
  318.         return $this->tableAliasMap[$tableName];
  319.     }
  321.     /**
  322.      * Forces the SqlWalker to use a specific alias for a table name, rather than
  323.      * generating an alias on its own.
  324.      *
  325.      * @param string $tableName
  326.      * @param string $alias
  327.      * @param string $dqlAlias
  328.      *
  329.      * @return string
  330.      */
  331.     public function setSQLTableAlias($tableName, $alias, $dqlAlias = '')
  332.     {
  333.         $tableName .= $dqlAlias ? '@[' . $dqlAlias . ']' : '';
  335.         $this->tableAliasMap[$tableName] = $alias;
  337.         return $alias;
  338.     }
  340.     /**
  341.      * Gets an SQL column alias for a column name.
  342.      *
  343.      * @param string $columnName
  344.      *
  345.      * @return string
  346.      */
  347.     public function getSQLColumnAlias($columnName)
  348.     {
  349.         return $this->quoteStrategy->getColumnAlias($columnName, $this->aliasCounter++, $this->platform);
  350.     }
  352.     /**
  353.      * Generates the SQL JOINs that are necessary for Class Table Inheritance
  354.      * for the given class.
  355.      *
  356.      * @param ClassMetadata $class    The class for which to generate the joins.
  357.      * @param string        $dqlAlias The DQL alias of the class.
  358.      *
  359.      * @return string The SQL.
  360.      */
  361.     private function generateClassTableInheritanceJoins(
  362.         ClassMetadata $class,
  363.         string $dqlAlias
  364.     ): string {
  365.         $sql = '';
  367.         $baseTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  369.         // INNER JOIN parent class tables
  370.         foreach ($class->parentClasses as $parentClassName) {
  371.             $parentClass = $this->em->getClassMetadata($parentClassName);
  372.             $tableAlias  = $this->getSQLTableAlias($parentClass->getTableName(), $dqlAlias);
  374.             // If this is a joined association we must use left joins to preserve the correct result.
  375.             $sql .= isset($this->queryComponents[$dqlAlias]['relation']) ? ' LEFT ' : ' INNER ';
  376.             $sql .= 'JOIN ' . $this->quoteStrategy->getTableName($parentClass, $this->platform) . ' ' . $tableAlias . ' ON ';
  378.             $sqlParts = [];
  380.             foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
  381.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
  382.             }
  384.             // Add filters on the root class
  385.             $sqlParts[] = $this->generateFilterConditionSQL($parentClass, $tableAlias);
  387.             $sql .= implode(' AND ', array_filter($sqlParts));
  388.         }
  390.         // Ignore subclassing inclusion if partial objects is disallowed
  391.         if ($this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
  392.             return $sql;
  393.         }
  395.         // LEFT JOIN child class tables
  396.         foreach ($class->subClasses as $subClassName) {
  397.             $subClass   = $this->em->getClassMetadata($subClassName);
  398.             $tableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  400.             $sql .= ' LEFT JOIN ' . $this->quoteStrategy->getTableName($subClass, $this->platform) . ' ' . $tableAlias . ' ON ';
  402.             $sqlParts = [];
  404.             foreach ($this->quoteStrategy->getIdentifierColumnNames($subClass, $this->platform) as $columnName) {
  405.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
  406.             }
  408.             $sql .= implode(' AND ', $sqlParts);
  409.         }
  411.         return $sql;
  412.     }
  414.     private function generateOrderedCollectionOrderByItems(): string
  415.     {
  416.         $orderedColumns = [];
  418.         foreach ($this->selectedClasses as $selectedClass) {
  419.             $dqlAlias = $selectedClass['dqlAlias'];
  420.             $qComp    = $this->queryComponents[$dqlAlias];
  422.             if (! isset($qComp['relation']['orderBy'])) {
  423.                 continue;
  424.             }
  426.             assert(isset($qComp['metadata']));
  427.             $persister = $this->em->getUnitOfWork()->getEntityPersister($qComp['metadata']->name);
  429.             foreach ($qComp['relation']['orderBy'] as $fieldName => $orientation) {
  430.                 $columnName = $this->quoteStrategy->getColumnName($fieldName, $qComp['metadata'], $this->platform);
  431.                 $tableName  = $qComp['metadata']->isInheritanceTypeJoined()
  432.                     ? $persister->getOwningTable($fieldName)
  433.                     : $qComp['metadata']->getTableName();
  435.                 $orderedColumn = $this->getSQLTableAlias($tableName, $dqlAlias) . '.' . $columnName;
  437.                 // OrderByClause should replace an ordered relation. see - DDC-2475
  438.                 if (isset($this->orderedColumnsMap[$orderedColumn])) {
  439.                     continue;
  440.                 }
  442.                 $this->orderedColumnsMap[$orderedColumn] = $orientation;
  443.                 $orderedColumns[]                        = $orderedColumn . ' ' . $orientation;
  444.             }
  445.         }
  447.         return implode(', ', $orderedColumns);
  448.     }
  450.     /**
  451.      * Generates a discriminator column SQL condition for the class with the given DQL alias.
  452.      *
  453.      * @psalm-param list<string> $dqlAliases List of root DQL aliases to inspect for discriminator restrictions.
  454.      */
  455.     private function generateDiscriminatorColumnConditionSQL(array $dqlAliases): string
  456.     {
  457.         $sqlParts = [];
  459.         foreach ($dqlAliases as $dqlAlias) {
  460.             $class = $this->getMetadataForDqlAlias($dqlAlias);
  462.             if (! $class->isInheritanceTypeSingleTable()) {
  463.                 continue;
  464.             }
  466.             $conn   = $this->em->getConnection();
  467.             $values = [];
  469.             if ($class->discriminatorValue !== null) { // discriminators can be 0
  470.                 $values[] = $conn->quote($class->discriminatorValue);
  471.             }
  473.             foreach ($class->subClasses as $subclassName) {
  474.                 $values[] = $conn->quote($this->em->getClassMetadata($subclassName)->discriminatorValue);
  475.             }
  477.             $sqlTableAlias = $this->useSqlTableAliases
  478.                 ? $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.'
  479.                 : '';
  481.             $sqlParts[] = $sqlTableAlias . $class->getDiscriminatorColumn()['name'] . ' IN (' . implode(', ', $values) . ')';
  482.         }
  484.         $sql = implode(' AND ', $sqlParts);
  486.         return count($sqlParts) > 1 ? '(' . $sql . ')' : $sql;
  487.     }
  489.     /**
  490.      * Generates the filter SQL for a given entity and table alias.
  491.      *
  492.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
  493.      * @param string        $targetTableAlias The table alias of the joined/selected table.
  494.      *
  495.      * @return string The SQL query part to add to a query.
  496.      */
  497.     private function generateFilterConditionSQL(
  498.         ClassMetadata $targetEntity,
  499.         string $targetTableAlias
  500.     ): string {
  501.         if (! $this->em->hasFilters()) {
  502.             return '';
  503.         }
  505.         switch ($targetEntity->inheritanceType) {
  506.             case ClassMetadata::INHERITANCE_TYPE_NONE:
  507.                 break;
  508.             case ClassMetadata::INHERITANCE_TYPE_JOINED:
  509.                 // The classes in the inheritance will be added to the query one by one,
  510.                 // but only the root node is getting filtered
  511.                 if ($targetEntity->name !== $targetEntity->rootEntityName) {
  512.                     return '';
  513.                 }
  515.                 break;
  516.             case ClassMetadata::INHERITANCE_TYPE_SINGLE_TABLE:
  517.                 // With STI the table will only be queried once, make sure that the filters
  518.                 // are added to the root entity
  519.                 $targetEntity = $this->em->getClassMetadata($targetEntity->rootEntityName);
  520.                 break;
  521.             default:
  522.                 //@todo: throw exception?
  523.                 return '';
  524.         }
  526.         $filterClauses = [];
  527.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  528.             $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
  529.             if ($filterExpr !== '') {
  530.                 $filterClauses[] = '(' . $filterExpr . ')';
  531.             }
  532.         }
  534.         return implode(' AND ', $filterClauses);
  535.     }
  537.     /**
  538.      * Walks down a SelectStatement AST node, thereby generating the appropriate SQL.
  539.      *
  540.      * @return string
  541.      */
  542.     public function walkSelectStatement(AST\SelectStatement $AST)
  543.     {
  544.         $limit    = $this->query->getMaxResults();
  545.         $offset   = $this->query->getFirstResult();
  546.         $lockMode = $this->query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE;
  547.         $sql      = $this->walkSelectClause($AST->selectClause)
  548.             . $this->walkFromClause($AST->fromClause)
  549.             . $this->walkWhereClause($AST->whereClause);
  551.         if ($AST->groupByClause) {
  552.             $sql .= $this->walkGroupByClause($AST->groupByClause);
  553.         }
  555.         if ($AST->havingClause) {
  556.             $sql .= $this->walkHavingClause($AST->havingClause);
  557.         }
  559.         if ($AST->orderByClause) {
  560.             $sql .= $this->walkOrderByClause($AST->orderByClause);
  561.         }
  563.         $orderBySql = $this->generateOrderedCollectionOrderByItems();
  564.         if (! $AST->orderByClause && $orderBySql) {
  565.             $sql .= ' ORDER BY ' . $orderBySql;
  566.         }
  568.         $sql = $this->platform->modifyLimitQuery($sql, $limit, $offset ?? 0);
  570.         if ($lockMode === LockMode::NONE) {
  571.             return $sql;
  572.         }
  574.         if ($lockMode === LockMode::PESSIMISTIC_READ) {
  575.             return $sql . ' ' . $this->platform->getReadLockSQL();
  576.         }
  578.         if ($lockMode === LockMode::PESSIMISTIC_WRITE) {
  579.             return $sql . ' ' . $this->platform->getWriteLockSQL();
  580.         }
  582.         if ($lockMode !== LockMode::OPTIMISTIC) {
  583.             throw QueryException::invalidLockMode();
  584.         }
  586.         foreach ($this->selectedClasses as $selectedClass) {
  587.             if (! $selectedClass['class']->isVersioned) {
  588.                 throw OptimisticLockException::lockFailed($selectedClass['class']->name);
  589.             }
  590.         }
  592.         return $sql;
  593.     }
  595.     /**
  596.      * Walks down an UpdateStatement AST node, thereby generating the appropriate SQL.
  597.      *
  598.      * @return string
  599.      */
  600.     public function walkUpdateStatement(AST\UpdateStatement $AST)
  601.     {
  602.         $this->useSqlTableAliases = false;
  603.         $this->rsm->isSelect      = false;
  605.         return $this->walkUpdateClause($AST->updateClause)
  606.             . $this->walkWhereClause($AST->whereClause);
  607.     }
  609.     /**
  610.      * Walks down a DeleteStatement AST node, thereby generating the appropriate SQL.
  611.      *
  612.      * @return string
  613.      */
  614.     public function walkDeleteStatement(AST\DeleteStatement $AST)
  615.     {
  616.         $this->useSqlTableAliases = false;
  617.         $this->rsm->isSelect      = false;
  619.         return $this->walkDeleteClause($AST->deleteClause)
  620.             . $this->walkWhereClause($AST->whereClause);
  621.     }
  623.     /**
  624.      * Walks down an IdentificationVariable AST node, thereby generating the appropriate SQL.
  625.      * This one differs of ->walkIdentificationVariable() because it generates the entity identifiers.
  626.      *
  627.      * @param string $identVariable
  628.      *
  629.      * @return string
  630.      */
  631.     public function walkEntityIdentificationVariable($identVariable)
  632.     {
  633.         $class      = $this->getMetadataForDqlAlias($identVariable);
  634.         $tableAlias = $this->getSQLTableAlias($class->getTableName(), $identVariable);
  635.         $sqlParts   = [];
  637.         foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
  638.             $sqlParts[] = $tableAlias . '.' . $columnName;
  639.         }
  641.         return implode(', ', $sqlParts);
  642.     }
  644.     /**
  645.      * Walks down an IdentificationVariable (no AST node associated), thereby generating the SQL.
  646.      *
  647.      * @param string $identificationVariable
  648.      * @param string $fieldName
  649.      *
  650.      * @return string The SQL.
  651.      */
  652.     public function walkIdentificationVariable($identificationVariable, $fieldName = null)
  653.     {
  654.         $class = $this->getMetadataForDqlAlias($identificationVariable);
  656.         if (
  657.             $fieldName !== null && $class->isInheritanceTypeJoined() &&
  658.             isset($class->fieldMappings[$fieldName]['inherited'])
  659.         ) {
  660.             $class = $this->em->getClassMetadata($class->fieldMappings[$fieldName]['inherited']);
  661.         }
  663.         return $this->getSQLTableAlias($class->getTableName(), $identificationVariable);
  664.     }
  666.     /**
  667.      * Walks down a PathExpression AST node, thereby generating the appropriate SQL.
  668.      *
  669.      * @param AST\PathExpression $pathExpr
  670.      *
  671.      * @return string
  672.      */
  673.     public function walkPathExpression($pathExpr)
  674.     {
  675.         $sql = '';
  676.         assert($pathExpr->field !== null);
  678.         switch ($pathExpr->type) {
  679.             case AST\PathExpression::TYPE_STATE_FIELD:
  680.                 $fieldName = $pathExpr->field;
  681.                 $dqlAlias  = $pathExpr->identificationVariable;
  682.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
  684.                 if ($this->useSqlTableAliases) {
  685.                     $sql .= $this->walkIdentificationVariable($dqlAlias, $fieldName) . '.';
  686.                 }
  688.                 $sql .= $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  689.                 break;
  691.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
  692.                 // 1- the owning side:
  693.                 //    Just use the foreign key, i.e. u.group_id
  694.                 $fieldName = $pathExpr->field;
  695.                 $dqlAlias  = $pathExpr->identificationVariable;
  696.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
  698.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
  699.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
  700.                 }
  702.                 $assoc = $class->associationMappings[$fieldName];
  704.                 if (! $assoc['isOwningSide']) {
  705.                     throw QueryException::associationPathInverseSideNotSupported($pathExpr);
  706.                 }
  708.                 // COMPOSITE KEYS NOT (YET?) SUPPORTED
  709.                 if (count($assoc['sourceToTargetKeyColumns']) > 1) {
  710.                     throw QueryException::associationPathCompositeKeyNotSupported();
  711.                 }
  713.                 if ($this->useSqlTableAliases) {
  714.                     $sql .= $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.';
  715.                 }
  717.                 $sql .= reset($assoc['targetToSourceKeyColumns']);
  718.                 break;
  720.             default:
  721.                 throw QueryException::invalidPathExpression($pathExpr);
  722.         }
  724.         return $sql;
  725.     }
  727.     /**
  728.      * Walks down a SelectClause AST node, thereby generating the appropriate SQL.
  729.      *
  730.      * @param AST\SelectClause $selectClause
  731.      *
  732.      * @return string
  733.      */
  734.     public function walkSelectClause($selectClause)
  735.     {
  736.         $sql                  = 'SELECT ' . ($selectClause->isDistinct ? 'DISTINCT ' : '');
  737.         $sqlSelectExpressions = array_filter(array_map([$this, 'walkSelectExpression'], $selectClause->selectExpressions));
  739.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) === true && $selectClause->isDistinct) {
  740.             $this->query->setHint(self::HINT_DISTINCT, true);
  741.         }
  743.         $addMetaColumns = ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD) &&
  744.             $this->query->getHydrationMode() === Query::HYDRATE_OBJECT
  745.             || $this->query->getHint(Query::HINT_INCLUDE_META_COLUMNS);
  747.         foreach ($this->selectedClasses as $selectedClass) {
  748.             $class       = $selectedClass['class'];
  749.             $dqlAlias    = $selectedClass['dqlAlias'];
  750.             $resultAlias = $selectedClass['resultAlias'];
  752.             // Register as entity or joined entity result
  753.             if (! isset($this->queryComponents[$dqlAlias]['relation'])) {
  754.                 $this->rsm->addEntityResult($class->name, $dqlAlias, $resultAlias);
  755.             } else {
  756.                 assert(isset($this->queryComponents[$dqlAlias]['parent']));
  758.                 $this->rsm->addJoinedEntityResult(
  759.                     $class->name,
  760.                     $dqlAlias,
  761.                     $this->queryComponents[$dqlAlias]['parent'],
  762.                     $this->queryComponents[$dqlAlias]['relation']['fieldName']
  763.                 );
  764.             }
  766.             if ($class->isInheritanceTypeSingleTable() || $class->isInheritanceTypeJoined()) {
  767.                 // Add discriminator columns to SQL
  768.                 $rootClass   = $this->em->getClassMetadata($class->rootEntityName);
  769.                 $tblAlias    = $this->getSQLTableAlias($rootClass->getTableName(), $dqlAlias);
  770.                 $discrColumn = $rootClass->getDiscriminatorColumn();
  771.                 $columnAlias = $this->getSQLColumnAlias($discrColumn['name']);
  773.                 $sqlSelectExpressions[] = $tblAlias . '.' . $discrColumn['name'] . ' AS ' . $columnAlias;
  775.                 $this->rsm->setDiscriminatorColumn($dqlAlias, $columnAlias);
  776.                 $this->rsm->addMetaResult($dqlAlias, $columnAlias, $discrColumn['fieldName'], false, $discrColumn['type']);
  777.             }
  779.             // Add foreign key columns to SQL, if necessary
  780.             if (! $addMetaColumns && ! $class->containsForeignIdentifier) {
  781.                 continue;
  782.             }
  784.             // Add foreign key columns of class and also parent classes
  785.             foreach ($class->associationMappings as $assoc) {
  786.                 if (
  787.                     ! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)
  788.                     || ( ! $addMetaColumns && ! isset($assoc['id']))
  789.                 ) {
  790.                     continue;
  791.                 }
  793.                 $targetClass   = $this->em->getClassMetadata($assoc['targetEntity']);
  794.                 $isIdentifier  = (isset($assoc['id']) && $assoc['id'] === true);
  795.                 $owningClass   = isset($assoc['inherited']) ? $this->em->getClassMetadata($assoc['inherited']) : $class;
  796.                 $sqlTableAlias = $this->getSQLTableAlias($owningClass->getTableName(), $dqlAlias);
  798.                 foreach ($assoc['joinColumns'] as $joinColumn) {
  799.                     $columnName  = $joinColumn['name'];
  800.                     $columnAlias = $this->getSQLColumnAlias($columnName);
  801.                     $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  803.                     $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  804.                     $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
  806.                     $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $isIdentifier, $columnType);
  807.                 }
  808.             }
  810.             // Add foreign key columns to SQL, if necessary
  811.             if (! $addMetaColumns) {
  812.                 continue;
  813.             }
  815.             // Add foreign key columns of subclasses
  816.             foreach ($class->subClasses as $subClassName) {
  817.                 $subClass      = $this->em->getClassMetadata($subClassName);
  818.                 $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  820.                 foreach ($subClass->associationMappings as $assoc) {
  821.                     // Skip if association is inherited
  822.                     if (isset($assoc['inherited'])) {
  823.                         continue;
  824.                     }
  826.                     if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
  827.                         $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  829.                         foreach ($assoc['joinColumns'] as $joinColumn) {
  830.                             $columnName  = $joinColumn['name'];
  831.                             $columnAlias = $this->getSQLColumnAlias($columnName);
  832.                             $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  834.                             $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $subClass, $this->platform);
  835.                             $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
  837.                             $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $subClass->isIdentifier($columnName), $columnType);
  838.                         }
  839.                     }
  840.                 }
  841.             }
  842.         }
  844.         return $sql . implode(', ', $sqlSelectExpressions);
  845.     }
  847.     /**
  848.      * Walks down a FromClause AST node, thereby generating the appropriate SQL.
  849.      *
  850.      * @param AST\FromClause $fromClause
  851.      *
  852.      * @return string
  853.      */
  854.     public function walkFromClause($fromClause)
  855.     {
  856.         $identificationVarDecls = $fromClause->identificationVariableDeclarations;
  857.         $sqlParts               = [];
  859.         foreach ($identificationVarDecls as $identificationVariableDecl) {
  860.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($identificationVariableDecl);
  861.         }
  863.         return ' FROM ' . implode(', ', $sqlParts);
  864.     }
  866.     /**
  867.      * Walks down a IdentificationVariableDeclaration AST node, thereby generating the appropriate SQL.
  868.      *
  869.      * @param AST\IdentificationVariableDeclaration $identificationVariableDecl
  870.      *
  871.      * @return string
  872.      */
  873.     public function walkIdentificationVariableDeclaration($identificationVariableDecl)
  874.     {
  875.         $sql = $this->walkRangeVariableDeclaration($identificationVariableDecl->rangeVariableDeclaration);
  877.         if ($identificationVariableDecl->indexBy) {
  878.             $this->walkIndexBy($identificationVariableDecl->indexBy);
  879.         }
  881.         foreach ($identificationVariableDecl->joins as $join) {
  882.             $sql .= $this->walkJoin($join);
  883.         }
  885.         return $sql;
  886.     }
  888.     /**
  889.      * Walks down a IndexBy AST node.
  890.      *
  891.      * @param AST\IndexBy $indexBy
  892.      *
  893.      * @return void
  894.      */
  895.     public function walkIndexBy($indexBy)
  896.     {
  897.         $pathExpression = $indexBy->singleValuedPathExpression;
  898.         $alias          = $pathExpression->identificationVariable;
  899.         assert($pathExpression->field !== null);
  901.         switch ($pathExpression->type) {
  902.             case AST\PathExpression::TYPE_STATE_FIELD:
  903.                 $field = $pathExpression->field;
  904.                 break;
  906.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
  907.                 // Just use the foreign key, i.e. u.group_id
  908.                 $fieldName = $pathExpression->field;
  909.                 $class     = $this->getMetadataForDqlAlias($alias);
  911.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
  912.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
  913.                 }
  915.                 $association = $class->associationMappings[$fieldName];
  917.                 if (! $association['isOwningSide']) {
  918.                     throw QueryException::associationPathInverseSideNotSupported($pathExpression);
  919.                 }
  921.                 if (count($association['sourceToTargetKeyColumns']) > 1) {
  922.                     throw QueryException::associationPathCompositeKeyNotSupported();
  923.                 }
  925.                 $field = reset($association['targetToSourceKeyColumns']);
  926.                 break;
  928.             default:
  929.                 throw QueryException::invalidPathExpression($pathExpression);
  930.         }
  932.         if (isset($this->scalarFields[$alias][$field])) {
  933.             $this->rsm->addIndexByScalar($this->scalarFields[$alias][$field]);
  935.             return;
  936.         }
  938.         $this->rsm->addIndexBy($alias, $field);
  939.     }
  941.     /**
  942.      * Walks down a RangeVariableDeclaration AST node, thereby generating the appropriate SQL.
  943.      *
  944.      * @param AST\RangeVariableDeclaration $rangeVariableDeclaration
  945.      *
  946.      * @return string
  947.      */
  948.     public function walkRangeVariableDeclaration($rangeVariableDeclaration)
  949.     {
  950.         return $this->generateRangeVariableDeclarationSQL($rangeVariableDeclaration, false);
  951.     }
  953.     /**
  954.      * Generate appropriate SQL for RangeVariableDeclaration AST node
  955.      */
  956.     private function generateRangeVariableDeclarationSQL(
  957.         AST\RangeVariableDeclaration $rangeVariableDeclaration,
  958.         bool $buildNestedJoins
  959.     ): string {
  960.         $class    = $this->em->getClassMetadata($rangeVariableDeclaration->abstractSchemaName);
  961.         $dqlAlias = $rangeVariableDeclaration->aliasIdentificationVariable;
  963.         if ($rangeVariableDeclaration->isRoot) {
  964.             $this->rootAliases[] = $dqlAlias;
  965.         }
  967.         $sql = $this->platform->appendLockHint(
  968.             $this->quoteStrategy->getTableName($class, $this->platform) . ' ' .
  969.             $this->getSQLTableAlias($class->getTableName(), $dqlAlias),
  970.             $this->query->getHint(Query::HINT_LOCK_MODE) ?: LockMode::NONE
  971.         );
  973.         if (! $class->isInheritanceTypeJoined()) {
  974.             return $sql;
  975.         }
  977.         $classTableInheritanceJoins = $this->generateClassTableInheritanceJoins($class, $dqlAlias);
  979.         if (! $buildNestedJoins) {
  980.             return $sql . $classTableInheritanceJoins;
  981.         }
  983.         return $classTableInheritanceJoins === '' ? $sql : '(' . $sql . $classTableInheritanceJoins . ')';
  984.     }
  986.     /**
  987.      * Walks down a JoinAssociationDeclaration AST node, thereby generating the appropriate SQL.
  988.      *
  989.      * @param AST\JoinAssociationDeclaration $joinAssociationDeclaration
  990.      * @param int                            $joinType
  991.      * @param AST\ConditionalExpression      $condExpr
  992.      * @psalm-param AST\Join::JOIN_TYPE_* $joinType
  993.      *
  994.      * @return string
  995.      *
  996.      * @throws QueryException
  997.      */
  998.     public function walkJoinAssociationDeclaration($joinAssociationDeclaration, $joinType = AST\Join::JOIN_TYPE_INNER, $condExpr = null)
  999.     {
  1000.         $sql = '';
  1002.         $associationPathExpression = $joinAssociationDeclaration->joinAssociationPathExpression;
  1003.         $joinedDqlAlias            = $joinAssociationDeclaration->aliasIdentificationVariable;
  1004.         $indexBy                   = $joinAssociationDeclaration->indexBy;
  1006.         $relation = $this->queryComponents[$joinedDqlAlias]['relation'] ?? null;
  1007.         assert($relation !== null);
  1008.         $targetClass     = $this->em->getClassMetadata($relation['targetEntity']);
  1009.         $sourceClass     = $this->em->getClassMetadata($relation['sourceEntity']);
  1010.         $targetTableName = $this->quoteStrategy->getTableName($targetClass, $this->platform);
  1012.         $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName(), $joinedDqlAlias);
  1013.         $sourceTableAlias = $this->getSQLTableAlias($sourceClass->getTableName(), $associationPathExpression->identificationVariable);
  1015.         // Ensure we got the owning side, since it has all mapping info
  1016.         $assoc = ! $relation['isOwningSide'] ? $targetClass->associationMappings[$relation['mappedBy']] : $relation;
  1018.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) === true && (! $this->query->getHint(self::HINT_DISTINCT) || isset($this->selectedClasses[$joinedDqlAlias]))) {
  1019.             if ($relation['type'] === ClassMetadata::ONE_TO_MANY || $relation['type'] === ClassMetadata::MANY_TO_MANY) {
  1020.                 throw QueryException::iterateWithFetchJoinNotAllowed($assoc);
  1021.             }
  1022.         }
  1024.         $targetTableJoin = null;
  1026.         // This condition is not checking ClassMetadata::MANY_TO_ONE, because by definition it cannot
  1027.         // be the owning side and previously we ensured that $assoc is always the owning side of the associations.
  1028.         // The owning side is necessary at this point because only it contains the JoinColumn information.
  1029.         switch (true) {
  1030.             case $assoc['type'] & ClassMetadata::TO_ONE:
  1031.                 $conditions = [];
  1033.                 foreach ($assoc['joinColumns'] as $joinColumn) {
  1034.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  1035.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  1037.                     if ($relation['isOwningSide']) {
  1038.                         $conditions[] = $sourceTableAlias . '.' . $quotedSourceColumn . ' = ' . $targetTableAlias . '.' . $quotedTargetColumn;
  1040.                         continue;
  1041.                     }
  1043.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $targetTableAlias . '.' . $quotedSourceColumn;
  1044.                 }
  1046.                 // Apply remaining inheritance restrictions
  1047.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
  1049.                 if ($discrSql) {
  1050.                     $conditions[] = $discrSql;
  1051.                 }
  1053.                 // Apply the filters
  1054.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
  1056.                 if ($filterExpr) {
  1057.                     $conditions[] = $filterExpr;
  1058.                 }
  1060.                 $targetTableJoin = [
  1061.                     'table' => $targetTableName . ' ' . $targetTableAlias,
  1062.                     'condition' => implode(' AND ', $conditions),
  1063.                 ];
  1064.                 break;
  1066.             case $assoc['type'] === ClassMetadata::MANY_TO_MANY:
  1067.                 // Join relation table
  1068.                 $joinTable      = $assoc['joinTable'];
  1069.                 $joinTableAlias = $this->getSQLTableAlias($joinTable['name'], $joinedDqlAlias);
  1070.                 $joinTableName  = $this->quoteStrategy->getJoinTableName($assoc, $sourceClass, $this->platform);
  1072.                 $conditions      = [];
  1073.                 $relationColumns = $relation['isOwningSide']
  1074.                     ? $assoc['joinTable']['joinColumns']
  1075.                     : $assoc['joinTable']['inverseJoinColumns'];
  1077.                 foreach ($relationColumns as $joinColumn) {
  1078.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  1079.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  1081.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
  1082.                 }
  1084.                 $sql .= $joinTableName . ' ' . $joinTableAlias . ' ON ' . implode(' AND ', $conditions);
  1086.                 // Join target table
  1087.                 $sql .= $joinType === AST\Join::JOIN_TYPE_LEFT || $joinType === AST\Join::JOIN_TYPE_LEFTOUTER ? ' LEFT JOIN ' : ' INNER JOIN ';
  1089.                 $conditions      = [];
  1090.                 $relationColumns = $relation['isOwningSide']
  1091.                     ? $assoc['joinTable']['inverseJoinColumns']
  1092.                     : $assoc['joinTable']['joinColumns'];
  1094.                 foreach ($relationColumns as $joinColumn) {
  1095.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  1096.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  1098.                     $conditions[] = $targetTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
  1099.                 }
  1101.                 // Apply remaining inheritance restrictions
  1102.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
  1104.                 if ($discrSql) {
  1105.                     $conditions[] = $discrSql;
  1106.                 }
  1108.                 // Apply the filters
  1109.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
  1111.                 if ($filterExpr) {
  1112.                     $conditions[] = $filterExpr;
  1113.                 }
  1115.                 $targetTableJoin = [
  1116.                     'table' => $targetTableName . ' ' . $targetTableAlias,
  1117.                     'condition' => implode(' AND ', $conditions),
  1118.                 ];
  1119.                 break;
  1121.             default:
  1122.                 throw new BadMethodCallException('Type of association must be one of *_TO_ONE or MANY_TO_MANY');
  1123.         }
  1125.         // Handle WITH clause
  1126.         $withCondition = $condExpr === null ? '' : ('(' . $this->walkConditionalExpression($condExpr) . ')');
  1128.         if ($targetClass->isInheritanceTypeJoined()) {
  1129.             $ctiJoins = $this->generateClassTableInheritanceJoins($targetClass, $joinedDqlAlias);
  1130.             // If we have WITH condition, we need to build nested joins for target class table and cti joins
  1131.             if ($withCondition && $ctiJoins) {
  1132.                 $sql .= '(' . $targetTableJoin['table'] . $ctiJoins . ') ON ' . $targetTableJoin['condition'];
  1133.             } else {
  1134.                 $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'] . $ctiJoins;
  1135.             }
  1136.         } else {
  1137.             $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'];
  1138.         }
  1140.         if ($withCondition) {
  1141.             $sql .= ' AND ' . $withCondition;
  1142.         }
  1144.         // Apply the indexes
  1145.         if ($indexBy) {
  1146.             // For Many-To-One or One-To-One associations this obviously makes no sense, but is ignored silently.
  1147.             $this->walkIndexBy($indexBy);
  1148.         } elseif (isset($relation['indexBy'])) {
  1149.             $this->rsm->addIndexBy($joinedDqlAlias, $relation['indexBy']);
  1150.         }
  1152.         return $sql;
  1153.     }
  1155.     /**
  1156.      * Walks down a FunctionNode AST node, thereby generating the appropriate SQL.
  1157.      *
  1158.      * @param AST\Functions\FunctionNode $function
  1159.      *
  1160.      * @return string
  1161.      */
  1162.     public function walkFunction($function)
  1163.     {
  1164.         return $function->getSql($this);
  1165.     }
  1167.     /**
  1168.      * Walks down an OrderByClause AST node, thereby generating the appropriate SQL.
  1169.      *
  1170.      * @param AST\OrderByClause $orderByClause
  1171.      *
  1172.      * @return string
  1173.      */
  1174.     public function walkOrderByClause($orderByClause)
  1175.     {
  1176.         $orderByItems = array_map([$this, 'walkOrderByItem'], $orderByClause->orderByItems);
  1178.         $collectionOrderByItems = $this->generateOrderedCollectionOrderByItems();
  1179.         if ($collectionOrderByItems !== '') {
  1180.             $orderByItems = array_merge($orderByItems, (array) $collectionOrderByItems);
  1181.         }
  1183.         return ' ORDER BY ' . implode(', ', $orderByItems);
  1184.     }
  1186.     /**
  1187.      * Walks down an OrderByItem AST node, thereby generating the appropriate SQL.
  1188.      *
  1189.      * @param AST\OrderByItem $orderByItem
  1190.      *
  1191.      * @return string
  1192.      */
  1193.     public function walkOrderByItem($orderByItem)
  1194.     {
  1195.         $type = strtoupper($orderByItem->type);
  1196.         $expr = $orderByItem->expression;
  1197.         $sql  = $expr instanceof AST\Node
  1198.             ? $expr->dispatch($this)
  1199.             : $this->walkResultVariable($this->queryComponents[$expr]['token']['value']);
  1201.         $this->orderedColumnsMap[$sql] = $type;
  1203.         if ($expr instanceof AST\Subselect) {
  1204.             return '(' . $sql . ') ' . $type;
  1205.         }
  1207.         return $sql . ' ' . $type;
  1208.     }
  1210.     /**
  1211.      * Walks down a HavingClause AST node, thereby generating the appropriate SQL.
  1212.      *
  1213.      * @param AST\HavingClause $havingClause
  1214.      *
  1215.      * @return string The SQL.
  1216.      */
  1217.     public function walkHavingClause($havingClause)
  1218.     {
  1219.         return ' HAVING ' . $this->walkConditionalExpression($havingClause->conditionalExpression);
  1220.     }
  1222.     /**
  1223.      * Walks down a Join AST node and creates the corresponding SQL.
  1224.      *
  1225.      * @param AST\Join $join
  1226.      *
  1227.      * @return string
  1228.      */
  1229.     public function walkJoin($join)
  1230.     {
  1231.         $joinType        = $join->joinType;
  1232.         $joinDeclaration = $join->joinAssociationDeclaration;
  1234.         $sql = $joinType === AST\Join::JOIN_TYPE_LEFT || $joinType === AST\Join::JOIN_TYPE_LEFTOUTER
  1235.             ? ' LEFT JOIN '
  1236.             : ' INNER JOIN ';
  1238.         switch (true) {
  1239.             case $joinDeclaration instanceof AST\RangeVariableDeclaration:
  1240.                 $class      = $this->em->getClassMetadata($joinDeclaration->abstractSchemaName);
  1241.                 $dqlAlias   = $joinDeclaration->aliasIdentificationVariable;
  1242.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
  1243.                 $conditions = [];
  1245.                 if ($join->conditionalExpression) {
  1246.                     $conditions[] = '(' . $this->walkConditionalExpression($join->conditionalExpression) . ')';
  1247.                 }
  1249.                 $isUnconditionalJoin = $conditions === [];
  1250.                 $condExprConjunction = $class->isInheritanceTypeJoined() && $joinType !== AST\Join::JOIN_TYPE_LEFT && $joinType !== AST\Join::JOIN_TYPE_LEFTOUTER && $isUnconditionalJoin
  1251.                     ? ' AND '
  1252.                     : ' ON ';
  1254.                 $sql .= $this->generateRangeVariableDeclarationSQL($joinDeclaration, ! $isUnconditionalJoin);
  1256.                 // Apply remaining inheritance restrictions
  1257.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$dqlAlias]);
  1259.                 if ($discrSql) {
  1260.                     $conditions[] = $discrSql;
  1261.                 }
  1263.                 // Apply the filters
  1264.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
  1266.                 if ($filterExpr) {
  1267.                     $conditions[] = $filterExpr;
  1268.                 }
  1270.                 if ($conditions) {
  1271.                     $sql .= $condExprConjunction . implode(' AND ', $conditions);
  1272.                 }
  1274.                 break;
  1276.             case $joinDeclaration instanceof AST\JoinAssociationDeclaration:
  1277.                 $sql .= $this->walkJoinAssociationDeclaration($joinDeclaration, $joinType, $join->conditionalExpression);
  1278.                 break;
  1279.         }
  1281.         return $sql;
  1282.     }
  1284.     /**
  1285.      * Walks down a CoalesceExpression AST node and generates the corresponding SQL.
  1286.      *
  1287.      * @param AST\CoalesceExpression $coalesceExpression
  1288.      *
  1289.      * @return string The SQL.
  1290.      */
  1291.     public function walkCoalesceExpression($coalesceExpression)
  1292.     {
  1293.         $sql = 'COALESCE(';
  1295.         $scalarExpressions = [];
  1297.         foreach ($coalesceExpression->scalarExpressions as $scalarExpression) {
  1298.             $scalarExpressions[] = $this->walkSimpleArithmeticExpression($scalarExpression);
  1299.         }
  1301.         return $sql . implode(', ', $scalarExpressions) . ')';
  1302.     }
  1304.     /**
  1305.      * Walks down a NullIfExpression AST node and generates the corresponding SQL.
  1306.      *
  1307.      * @param AST\NullIfExpression $nullIfExpression
  1308.      *
  1309.      * @return string The SQL.
  1310.      */
  1311.     public function walkNullIfExpression($nullIfExpression)
  1312.     {
  1313.         $firstExpression = is_string($nullIfExpression->firstExpression)
  1314.             ? $this->conn->quote($nullIfExpression->firstExpression)
  1315.             : $this->walkSimpleArithmeticExpression($nullIfExpression->firstExpression);
  1317.         $secondExpression = is_string($nullIfExpression->secondExpression)
  1318.             ? $this->conn->quote($nullIfExpression->secondExpression)
  1319.             : $this->walkSimpleArithmeticExpression($nullIfExpression->secondExpression);
  1321.         return 'NULLIF(' . $firstExpression . ', ' . $secondExpression . ')';
  1322.     }
  1324.     /**
  1325.      * Walks down a GeneralCaseExpression AST node and generates the corresponding SQL.
  1326.      *
  1327.      * @return string The SQL.
  1328.      */
  1329.     public function walkGeneralCaseExpression(AST\GeneralCaseExpression $generalCaseExpression)
  1330.     {
  1331.         $sql = 'CASE';
  1333.         foreach ($generalCaseExpression->whenClauses as $whenClause) {
  1334.             $sql .= ' WHEN ' . $this->walkConditionalExpression($whenClause->caseConditionExpression);
  1335.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($whenClause->thenScalarExpression);
  1336.         }
  1338.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($generalCaseExpression->elseScalarExpression) . ' END';
  1340.         return $sql;
  1341.     }
  1343.     /**
  1344.      * Walks down a SimpleCaseExpression AST node and generates the corresponding SQL.
  1345.      *
  1346.      * @param AST\SimpleCaseExpression $simpleCaseExpression
  1347.      *
  1348.      * @return string The SQL.
  1349.      */
  1350.     public function walkSimpleCaseExpression($simpleCaseExpression)
  1351.     {
  1352.         $sql = 'CASE ' . $this->walkStateFieldPathExpression($simpleCaseExpression->caseOperand);
  1354.         foreach ($simpleCaseExpression->simpleWhenClauses as $simpleWhenClause) {
  1355.             $sql .= ' WHEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->caseScalarExpression);
  1356.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->thenScalarExpression);
  1357.         }
  1359.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($simpleCaseExpression->elseScalarExpression) . ' END';
  1361.         return $sql;
  1362.     }
  1364.     /**
  1365.      * Walks down a SelectExpression AST node and generates the corresponding SQL.
  1366.      *
  1367.      * @param AST\SelectExpression $selectExpression
  1368.      *
  1369.      * @return string
  1370.      */
  1371.     public function walkSelectExpression($selectExpression)
  1372.     {
  1373.         $sql    = '';
  1374.         $expr   = $selectExpression->expression;
  1375.         $hidden = $selectExpression->hiddenAliasResultVariable;
  1377.         switch (true) {
  1378.             case $expr instanceof AST\PathExpression:
  1379.                 if ($expr->type !== AST\PathExpression::TYPE_STATE_FIELD) {
  1380.                     throw QueryException::invalidPathExpression($expr);
  1381.                 }
  1383.                 assert($expr->field !== null);
  1384.                 $fieldName = $expr->field;
  1385.                 $dqlAlias  = $expr->identificationVariable;
  1386.                 $class     = $this->getMetadataForDqlAlias($dqlAlias);
  1388.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $fieldName;
  1389.                 $tableName   = $class->isInheritanceTypeJoined()
  1390.                     ? $this->em->getUnitOfWork()->getEntityPersister($class->name)->getOwningTable($fieldName)
  1391.                     : $class->getTableName();
  1393.                 $sqlTableAlias = $this->getSQLTableAlias($tableName, $dqlAlias);
  1394.                 $fieldMapping  = $class->fieldMappings[$fieldName];
  1395.                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  1396.                 $columnAlias   = $this->getSQLColumnAlias($fieldMapping['columnName']);
  1397.                 $col           = $sqlTableAlias . '.' . $columnName;
  1399.                 if (isset($fieldMapping['requireSQLConversion'])) {
  1400.                     $type = Type::getType($fieldMapping['type']);
  1401.                     $col  = $type->convertToPHPValueSQL($col, $this->conn->getDatabasePlatform());
  1402.                 }
  1404.                 $sql .= $col . ' AS ' . $columnAlias;
  1406.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1408.                 if (! $hidden) {
  1409.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldMapping['type']);
  1410.                     $this->scalarFields[$dqlAlias][$fieldName] = $columnAlias;
  1412.                     if (! empty($fieldMapping['enumType'])) {
  1413.                         $this->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
  1414.                     }
  1415.                 }
  1417.                 break;
  1419.             case $expr instanceof AST\AggregateExpression:
  1420.             case $expr instanceof AST\Functions\FunctionNode:
  1421.             case $expr instanceof AST\SimpleArithmeticExpression:
  1422.             case $expr instanceof AST\ArithmeticTerm:
  1423.             case $expr instanceof AST\ArithmeticFactor:
  1424.             case $expr instanceof AST\ParenthesisExpression:
  1425.             case $expr instanceof AST\Literal:
  1426.             case $expr instanceof AST\NullIfExpression:
  1427.             case $expr instanceof AST\CoalesceExpression:
  1428.             case $expr instanceof AST\GeneralCaseExpression:
  1429.             case $expr instanceof AST\SimpleCaseExpression:
  1430.                 $columnAlias = $this->getSQLColumnAlias('sclr');
  1431.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1433.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
  1435.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1437.                 if ($hidden) {
  1438.                     break;
  1439.                 }
  1441.                 if (! $expr instanceof Query\AST\TypedExpression) {
  1442.                     // Conceptually we could resolve field type here by traverse through AST to retrieve field type,
  1443.                     // but this is not a feasible solution; assume 'string'.
  1444.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
  1446.                     break;
  1447.                 }
  1449.                 $this->rsm->addScalarResult($columnAlias, $resultAlias, Type::getTypeRegistry()->lookupName($expr->getReturnType()));
  1451.                 break;
  1453.             case $expr instanceof AST\Subselect:
  1454.                 $columnAlias = $this->getSQLColumnAlias('sclr');
  1455.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1457.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
  1459.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1461.                 if (! $hidden) {
  1462.                     // We cannot resolve field type here; assume 'string'.
  1463.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
  1464.                 }
  1466.                 break;
  1468.             case $expr instanceof AST\NewObjectExpression:
  1469.                 $sql .= $this->walkNewObject($expr, $selectExpression->fieldIdentificationVariable);
  1470.                 break;
  1472.             default:
  1473.                 // IdentificationVariable or PartialObjectExpression
  1474.                 if ($expr instanceof AST\PartialObjectExpression) {
  1475.                     $this->query->setHint(self::HINT_PARTIAL, true);
  1477.                     $dqlAlias        = $expr->identificationVariable;
  1478.                     $partialFieldSet = $expr->partialFieldSet;
  1479.                 } else {
  1480.                     $dqlAlias        = $expr;
  1481.                     $partialFieldSet = [];
  1482.                 }
  1484.                 $class       = $this->getMetadataForDqlAlias($dqlAlias);
  1485.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: null;
  1487.                 if (! isset($this->selectedClasses[$dqlAlias])) {
  1488.                     $this->selectedClasses[$dqlAlias] = [
  1489.                         'class'       => $class,
  1490.                         'dqlAlias'    => $dqlAlias,
  1491.                         'resultAlias' => $resultAlias,
  1492.                     ];
  1493.                 }
  1495.                 $sqlParts = [];
  1497.                 // Select all fields from the queried class
  1498.                 foreach ($class->fieldMappings as $fieldName => $mapping) {
  1499.                     if ($partialFieldSet && ! in_array($fieldName, $partialFieldSet, true)) {
  1500.                         continue;
  1501.                     }
  1503.                     $tableName = isset($mapping['inherited'])
  1504.                         ? $this->em->getClassMetadata($mapping['inherited'])->getTableName()
  1505.                         : $class->getTableName();
  1507.                     $sqlTableAlias    = $this->getSQLTableAlias($tableName, $dqlAlias);
  1508.                     $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
  1509.                     $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  1511.                     $col = $sqlTableAlias . '.' . $quotedColumnName;
  1513.                     if (isset($mapping['requireSQLConversion'])) {
  1514.                         $type = Type::getType($mapping['type']);
  1515.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
  1516.                     }
  1518.                     $sqlParts[] = $col . ' AS ' . $columnAlias;
  1520.                     $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
  1522.                     $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $class->name);
  1524.                     if (! empty($mapping['enumType'])) {
  1525.                         $this->rsm->addEnumResult($columnAlias, $mapping['enumType']);
  1526.                     }
  1527.                 }
  1529.                 // Add any additional fields of subclasses (excluding inherited fields)
  1530.                 // 1) on Single Table Inheritance: always, since its marginal overhead
  1531.                 // 2) on Class Table Inheritance only if partial objects are disallowed,
  1532.                 //    since it requires outer joining subtables.
  1533.                 if ($class->isInheritanceTypeSingleTable() || ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
  1534.                     foreach ($class->subClasses as $subClassName) {
  1535.                         $subClass      = $this->em->getClassMetadata($subClassName);
  1536.                         $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  1538.                         foreach ($subClass->fieldMappings as $fieldName => $mapping) {
  1539.                             if (isset($mapping['inherited']) || ($partialFieldSet && ! in_array($fieldName, $partialFieldSet, true))) {
  1540.                                 continue;
  1541.                             }
  1543.                             $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
  1544.                             $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $subClass, $this->platform);
  1546.                             $col = $sqlTableAlias . '.' . $quotedColumnName;
  1548.                             if (isset($mapping['requireSQLConversion'])) {
  1549.                                 $type = Type::getType($mapping['type']);
  1550.                                 $col  = $type->convertToPHPValueSQL($col, $this->platform);
  1551.                             }
  1553.                             $sqlParts[] = $col . ' AS ' . $columnAlias;
  1555.                             $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
  1557.                             $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $subClassName);
  1558.                         }
  1559.                     }
  1560.                 }
  1562.                 $sql .= implode(', ', $sqlParts);
  1563.         }
  1565.         return $sql;
  1566.     }
  1568.     /**
  1569.      * Walks down a QuantifiedExpression AST node, thereby generating the appropriate SQL.
  1570.      *
  1571.      * @param AST\QuantifiedExpression $qExpr
  1572.      *
  1573.      * @return string
  1574.      */
  1575.     public function walkQuantifiedExpression($qExpr)
  1576.     {
  1577.         return ' ' . strtoupper($qExpr->type) . '(' . $this->walkSubselect($qExpr->subselect) . ')';
  1578.     }
  1580.     /**
  1581.      * Walks down a Subselect AST node, thereby generating the appropriate SQL.
  1582.      *
  1583.      * @param AST\Subselect $subselect
  1584.      *
  1585.      * @return string
  1586.      */
  1587.     public function walkSubselect($subselect)
  1588.     {
  1589.         $useAliasesBefore  = $this->useSqlTableAliases;
  1590.         $rootAliasesBefore = $this->rootAliases;
  1592.         $this->rootAliases        = []; // reset the rootAliases for the subselect
  1593.         $this->useSqlTableAliases = true;
  1595.         $sql  = $this->walkSimpleSelectClause($subselect->simpleSelectClause);
  1596.         $sql .= $this->walkSubselectFromClause($subselect->subselectFromClause);
  1597.         $sql .= $this->walkWhereClause($subselect->whereClause);
  1599.         $sql .= $subselect->groupByClause ? $this->walkGroupByClause($subselect->groupByClause) : '';
  1600.         $sql .= $subselect->havingClause ? $this->walkHavingClause($subselect->havingClause) : '';
  1601.         $sql .= $subselect->orderByClause ? $this->walkOrderByClause($subselect->orderByClause) : '';
  1603.         $this->rootAliases        = $rootAliasesBefore; // put the main aliases back
  1604.         $this->useSqlTableAliases = $useAliasesBefore;
  1606.         return $sql;
  1607.     }
  1609.     /**
  1610.      * Walks down a SubselectFromClause AST node, thereby generating the appropriate SQL.
  1611.      *
  1612.      * @param AST\SubselectFromClause $subselectFromClause
  1613.      *
  1614.      * @return string
  1615.      */
  1616.     public function walkSubselectFromClause($subselectFromClause)
  1617.     {
  1618.         $identificationVarDecls = $subselectFromClause->identificationVariableDeclarations;
  1619.         $sqlParts               = [];
  1621.         foreach ($identificationVarDecls as $subselectIdVarDecl) {
  1622.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($subselectIdVarDecl);
  1623.         }
  1625.         return ' FROM ' . implode(', ', $sqlParts);
  1626.     }
  1628.     /**
  1629.      * Walks down a SimpleSelectClause AST node, thereby generating the appropriate SQL.
  1630.      *
  1631.      * @param AST\SimpleSelectClause $simpleSelectClause
  1632.      *
  1633.      * @return string
  1634.      */
  1635.     public function walkSimpleSelectClause($simpleSelectClause)
  1636.     {
  1637.         return 'SELECT' . ($simpleSelectClause->isDistinct ? ' DISTINCT' : '')
  1638.             . $this->walkSimpleSelectExpression($simpleSelectClause->simpleSelectExpression);
  1639.     }
  1641.     /** @return string */
  1642.     public function walkParenthesisExpression(AST\ParenthesisExpression $parenthesisExpression)
  1643.     {
  1644.         return sprintf('(%s)', $parenthesisExpression->expression->dispatch($this));
  1645.     }
  1647.     /**
  1648.      * @param AST\NewObjectExpression $newObjectExpression
  1649.      * @param string|null             $newObjectResultAlias
  1650.      *
  1651.      * @return string The SQL.
  1652.      */
  1653.     public function walkNewObject($newObjectExpression, $newObjectResultAlias = null)
  1654.     {
  1655.         $sqlSelectExpressions = [];
  1656.         $objIndex             = $newObjectResultAlias ?: $this->newObjectCounter++;
  1658.         foreach ($newObjectExpression->args as $argIndex => $e) {
  1659.             $resultAlias = $this->scalarResultCounter++;
  1660.             $columnAlias = $this->getSQLColumnAlias('sclr');
  1661.             $fieldType   = 'string';
  1663.             switch (true) {
  1664.                 case $e instanceof AST\NewObjectExpression:
  1665.                     $sqlSelectExpressions[] = $e->dispatch($this);
  1666.                     break;
  1668.                 case $e instanceof AST\Subselect:
  1669.                     $sqlSelectExpressions[] = '(' . $e->dispatch($this) . ') AS ' . $columnAlias;
  1670.                     break;
  1672.                 case $e instanceof AST\PathExpression:
  1673.                     assert($e->field !== null);
  1674.                     $dqlAlias     = $e->identificationVariable;
  1675.                     $class        = $this->getMetadataForDqlAlias($dqlAlias);
  1676.                     $fieldName    = $e->field;
  1677.                     $fieldMapping = $class->fieldMappings[$fieldName];
  1678.                     $fieldType    = $fieldMapping['type'];
  1679.                     $col          = trim($e->dispatch($this));
  1681.                     if (isset($fieldMapping['requireSQLConversion'])) {
  1682.                         $type = Type::getType($fieldType);
  1683.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
  1684.                     }
  1686.                     $sqlSelectExpressions[] = $col . ' AS ' . $columnAlias;
  1688.                     if (! empty($fieldMapping['enumType'])) {
  1689.                         $this->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
  1690.                     }
  1692.                     break;
  1694.                 case $e instanceof AST\Literal:
  1695.                     switch ($e->type) {
  1696.                         case AST\Literal::BOOLEAN:
  1697.                             $fieldType = 'boolean';
  1698.                             break;
  1700.                         case AST\Literal::NUMERIC:
  1701.                             $fieldType = is_float($e->value) ? 'float' : 'integer';
  1702.                             break;
  1703.                     }
  1705.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
  1706.                     break;
  1708.                 default:
  1709.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
  1710.                     break;
  1711.             }
  1713.             $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1714.             $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldType);
  1716.             $this->rsm->newObjectMappings[$columnAlias] = [
  1717.                 'className' => $newObjectExpression->className,
  1718.                 'objIndex'  => $objIndex,
  1719.                 'argIndex'  => $argIndex,
  1720.             ];
  1721.         }
  1723.         return implode(', ', $sqlSelectExpressions);
  1724.     }
  1726.     /**
  1727.      * Walks down a SimpleSelectExpression AST node, thereby generating the appropriate SQL.
  1728.      *
  1729.      * @param AST\SimpleSelectExpression $simpleSelectExpression
  1730.      *
  1731.      * @return string
  1732.      */
  1733.     public function walkSimpleSelectExpression($simpleSelectExpression)
  1734.     {
  1735.         $expr = $simpleSelectExpression->expression;
  1736.         $sql  = ' ';
  1738.         switch (true) {
  1739.             case $expr instanceof AST\PathExpression:
  1740.                 $sql .= $this->walkPathExpression($expr);
  1741.                 break;
  1743.             case $expr instanceof AST\Subselect:
  1744.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1746.                 $columnAlias                        = 'sclr' . $this->aliasCounter++;
  1747.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
  1749.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
  1750.                 break;
  1752.             case $expr instanceof AST\Functions\FunctionNode:
  1753.             case $expr instanceof AST\SimpleArithmeticExpression:
  1754.             case $expr instanceof AST\ArithmeticTerm:
  1755.             case $expr instanceof AST\ArithmeticFactor:
  1756.             case $expr instanceof AST\Literal:
  1757.             case $expr instanceof AST\NullIfExpression:
  1758.             case $expr instanceof AST\CoalesceExpression:
  1759.             case $expr instanceof AST\GeneralCaseExpression:
  1760.             case $expr instanceof AST\SimpleCaseExpression:
  1761.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1763.                 $columnAlias                        = $this->getSQLColumnAlias('sclr');
  1764.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
  1766.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
  1767.                 break;
  1769.             case $expr instanceof AST\ParenthesisExpression:
  1770.                 $sql .= $this->walkParenthesisExpression($expr);
  1771.                 break;
  1773.             default: // IdentificationVariable
  1774.                 $sql .= $this->walkEntityIdentificationVariable($expr);
  1775.                 break;
  1776.         }
  1778.         return $sql;
  1779.     }
  1781.     /**
  1782.      * Walks down an AggregateExpression AST node, thereby generating the appropriate SQL.
  1783.      *
  1784.      * @param AST\AggregateExpression $aggExpression
  1785.      *
  1786.      * @return string
  1787.      */
  1788.     public function walkAggregateExpression($aggExpression)
  1789.     {
  1790.         return $aggExpression->functionName . '(' . ($aggExpression->isDistinct ? 'DISTINCT ' : '')
  1791.             . $this->walkSimpleArithmeticExpression($aggExpression->pathExpression) . ')';
  1792.     }
  1794.     /**
  1795.      * Walks down a GroupByClause AST node, thereby generating the appropriate SQL.
  1796.      *
  1797.      * @param AST\GroupByClause $groupByClause
  1798.      *
  1799.      * @return string
  1800.      */
  1801.     public function walkGroupByClause($groupByClause)
  1802.     {
  1803.         $sqlParts = [];
  1805.         foreach ($groupByClause->groupByItems as $groupByItem) {
  1806.             $sqlParts[] = $this->walkGroupByItem($groupByItem);
  1807.         }
  1809.         return ' GROUP BY ' . implode(', ', $sqlParts);
  1810.     }
  1812.     /**
  1813.      * Walks down a GroupByItem AST node, thereby generating the appropriate SQL.
  1814.      *
  1815.      * @param AST\PathExpression|string $groupByItem
  1816.      *
  1817.      * @return string
  1818.      */
  1819.     public function walkGroupByItem($groupByItem)
  1820.     {
  1821.         // StateFieldPathExpression
  1822.         if (! is_string($groupByItem)) {
  1823.             return $this->walkPathExpression($groupByItem);
  1824.         }
  1826.         // ResultVariable
  1827.         if (isset($this->queryComponents[$groupByItem]['resultVariable'])) {
  1828.             $resultVariable = $this->queryComponents[$groupByItem]['resultVariable'];
  1830.             if ($resultVariable instanceof AST\PathExpression) {
  1831.                 return $this->walkPathExpression($resultVariable);
  1832.             }
  1834.             if ($resultVariable instanceof AST\Node && isset($resultVariable->pathExpression)) {
  1835.                 return $this->walkPathExpression($resultVariable->pathExpression);
  1836.             }
  1838.             return $this->walkResultVariable($groupByItem);
  1839.         }
  1841.         // IdentificationVariable
  1842.         $sqlParts = [];
  1844.         foreach ($this->getMetadataForDqlAlias($groupByItem)->fieldNames as $field) {
  1845.             $item       = new AST\PathExpression(AST\PathExpression::TYPE_STATE_FIELD, $groupByItem, $field);
  1846.             $item->type = AST\PathExpression::TYPE_STATE_FIELD;
  1848.             $sqlParts[] = $this->walkPathExpression($item);
  1849.         }
  1851.         foreach ($this->getMetadataForDqlAlias($groupByItem)->associationMappings as $mapping) {
  1852.             if ($mapping['isOwningSide'] && $mapping['type'] & ClassMetadata::TO_ONE) {
  1853.                 $item       = new AST\PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION, $groupByItem, $mapping['fieldName']);
  1854.                 $item->type = AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION;
  1856.                 $sqlParts[] = $this->walkPathExpression($item);
  1857.             }
  1858.         }
  1860.         return implode(', ', $sqlParts);
  1861.     }
  1863.     /**
  1864.      * Walks down a DeleteClause AST node, thereby generating the appropriate SQL.
  1865.      *
  1866.      * @return string
  1867.      */
  1868.     public function walkDeleteClause(AST\DeleteClause $deleteClause)
  1869.     {
  1870.         $class     = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1871.         $tableName = $class->getTableName();
  1872.         $sql       = 'DELETE FROM ' . $this->quoteStrategy->getTableName($class, $this->platform);
  1874.         $this->setSQLTableAlias($tableName, $tableName, $deleteClause->aliasIdentificationVariable);
  1875.         $this->rootAliases[] = $deleteClause->aliasIdentificationVariable;
  1877.         return $sql;
  1878.     }
  1880.     /**
  1881.      * Walks down an UpdateClause AST node, thereby generating the appropriate SQL.
  1882.      *
  1883.      * @param AST\UpdateClause $updateClause
  1884.      *
  1885.      * @return string
  1886.      */
  1887.     public function walkUpdateClause($updateClause)
  1888.     {
  1889.         $class     = $this->em->getClassMetadata($updateClause->abstractSchemaName);
  1890.         $tableName = $class->getTableName();
  1891.         $sql       = 'UPDATE ' . $this->quoteStrategy->getTableName($class, $this->platform);
  1893.         $this->setSQLTableAlias($tableName, $tableName, $updateClause->aliasIdentificationVariable);
  1894.         $this->rootAliases[] = $updateClause->aliasIdentificationVariable;
  1896.         return $sql . ' SET ' . implode(', ', array_map([$this, 'walkUpdateItem'], $updateClause->updateItems));
  1897.     }
  1899.     /**
  1900.      * Walks down an UpdateItem AST node, thereby generating the appropriate SQL.
  1901.      *
  1902.      * @param AST\UpdateItem $updateItem
  1903.      *
  1904.      * @return string
  1905.      */
  1906.     public function walkUpdateItem($updateItem)
  1907.     {
  1908.         $useTableAliasesBefore    = $this->useSqlTableAliases;
  1909.         $this->useSqlTableAliases = false;
  1911.         $sql      = $this->walkPathExpression($updateItem->pathExpression) . ' = ';
  1912.         $newValue = $updateItem->newValue;
  1914.         switch (true) {
  1915.             case $newValue instanceof AST\Node:
  1916.                 $sql .= $newValue->dispatch($this);
  1917.                 break;
  1919.             case $newValue === null:
  1920.                 $sql .= 'NULL';
  1921.                 break;
  1923.             default:
  1924.                 $sql .= $this->conn->quote($newValue);
  1925.                 break;
  1926.         }
  1928.         $this->useSqlTableAliases = $useTableAliasesBefore;
  1930.         return $sql;
  1931.     }
  1933.     /**
  1934.      * Walks down a WhereClause AST node, thereby generating the appropriate SQL.
  1935.      * WhereClause or not, the appropriate discriminator sql is added.
  1936.      *
  1937.      * @param AST\WhereClause $whereClause
  1938.      *
  1939.      * @return string
  1940.      */
  1941.     public function walkWhereClause($whereClause)
  1942.     {
  1943.         $condSql  = $whereClause !== null ? $this->walkConditionalExpression($whereClause->conditionalExpression) : '';
  1944.         $discrSql = $this->generateDiscriminatorColumnConditionSQL($this->rootAliases);
  1946.         if ($this->em->hasFilters()) {
  1947.             $filterClauses = [];
  1948.             foreach ($this->rootAliases as $dqlAlias) {
  1949.                 $class      = $this->getMetadataForDqlAlias($dqlAlias);
  1950.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
  1952.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
  1953.                 if ($filterExpr) {
  1954.                     $filterClauses[] = $filterExpr;
  1955.                 }
  1956.             }
  1958.             if (count($filterClauses)) {
  1959.                 if ($condSql) {
  1960.                     $condSql = '(' . $condSql . ') AND ';
  1961.                 }
  1963.                 $condSql .= implode(' AND ', $filterClauses);
  1964.             }
  1965.         }
  1967.         if ($condSql) {
  1968.             return ' WHERE ' . (! $discrSql ? $condSql : '(' . $condSql . ') AND ' . $discrSql);
  1969.         }
  1971.         if ($discrSql) {
  1972.             return ' WHERE ' . $discrSql;
  1973.         }
  1975.         return '';
  1976.     }
  1978.     /**
  1979.      * Walk down a ConditionalExpression AST node, thereby generating the appropriate SQL.
  1980.      *
  1981.      * @param AST\ConditionalExpression $condExpr
  1982.      *
  1983.      * @return string
  1984.      */
  1985.     public function walkConditionalExpression($condExpr)
  1986.     {
  1987.         // Phase 2 AST optimization: Skip processing of ConditionalExpression
  1988.         // if only one ConditionalTerm is defined
  1989.         if (! ($condExpr instanceof AST\ConditionalExpression)) {
  1990.             return $this->walkConditionalTerm($condExpr);
  1991.         }
  1993.         return implode(' OR ', array_map([$this, 'walkConditionalTerm'], $condExpr->conditionalTerms));
  1994.     }
  1996.     /**
  1997.      * Walks down a ConditionalTerm AST node, thereby generating the appropriate SQL.
  1998.      *
  1999.      * @param AST\ConditionalTerm $condTerm
  2000.      *
  2001.      * @return string
  2002.      */
  2003.     public function walkConditionalTerm($condTerm)
  2004.     {
  2005.         // Phase 2 AST optimization: Skip processing of ConditionalTerm
  2006.         // if only one ConditionalFactor is defined
  2007.         if (! ($condTerm instanceof AST\ConditionalTerm)) {
  2008.             return $this->walkConditionalFactor($condTerm);
  2009.         }
  2011.         return implode(' AND ', array_map([$this, 'walkConditionalFactor'], $condTerm->conditionalFactors));
  2012.     }
  2014.     /**
  2015.      * Walks down a ConditionalFactor AST node, thereby generating the appropriate SQL.
  2016.      *
  2017.      * @param AST\ConditionalFactor $factor
  2018.      *
  2019.      * @return string The SQL.
  2020.      */
  2021.     public function walkConditionalFactor($factor)
  2022.     {
  2023.         // Phase 2 AST optimization: Skip processing of ConditionalFactor
  2024.         // if only one ConditionalPrimary is defined
  2025.         return ! ($factor instanceof AST\ConditionalFactor)
  2026.             ? $this->walkConditionalPrimary($factor)
  2027.             : ($factor->not ? 'NOT ' : '') . $this->walkConditionalPrimary($factor->conditionalPrimary);
  2028.     }
  2030.     /**
  2031.      * Walks down a ConditionalPrimary AST node, thereby generating the appropriate SQL.
  2032.      *
  2033.      * @param AST\ConditionalPrimary $primary
  2034.      *
  2035.      * @return string
  2036.      */
  2037.     public function walkConditionalPrimary($primary)
  2038.     {
  2039.         if ($primary->isSimpleConditionalExpression()) {
  2040.             return $primary->simpleConditionalExpression->dispatch($this);
  2041.         }
  2043.         if ($primary->isConditionalExpression()) {
  2044.             $condExpr = $primary->conditionalExpression;
  2046.             return '(' . $this->walkConditionalExpression($condExpr) . ')';
  2047.         }
  2048.     }
  2050.     /**
  2051.      * Walks down an ExistsExpression AST node, thereby generating the appropriate SQL.
  2052.      *
  2053.      * @param AST\ExistsExpression $existsExpr
  2054.      *
  2055.      * @return string
  2056.      */
  2057.     public function walkExistsExpression($existsExpr)
  2058.     {
  2059.         $sql = $existsExpr->not ? 'NOT ' : '';
  2061.         $sql .= 'EXISTS (' . $this->walkSubselect($existsExpr->subselect) . ')';
  2063.         return $sql;
  2064.     }
  2066.     /**
  2067.      * Walks down a CollectionMemberExpression AST node, thereby generating the appropriate SQL.
  2068.      *
  2069.      * @param AST\CollectionMemberExpression $collMemberExpr
  2070.      *
  2071.      * @return string
  2072.      */
  2073.     public function walkCollectionMemberExpression($collMemberExpr)
  2074.     {
  2075.         $sql  = $collMemberExpr->not ? 'NOT ' : '';
  2076.         $sql .= 'EXISTS (SELECT 1 FROM ';
  2078.         $entityExpr   = $collMemberExpr->entityExpression;
  2079.         $collPathExpr = $collMemberExpr->collectionValuedPathExpression;
  2080.         assert($collPathExpr->field !== null);
  2082.         $fieldName = $collPathExpr->field;
  2083.         $dqlAlias  = $collPathExpr->identificationVariable;
  2085.         $class = $this->getMetadataForDqlAlias($dqlAlias);
  2087.         switch (true) {
  2088.             // InputParameter
  2089.             case $entityExpr instanceof AST\InputParameter:
  2090.                 $dqlParamKey = $entityExpr->name;
  2091.                 $entitySql   = '?';
  2092.                 break;
  2094.             // SingleValuedAssociationPathExpression | IdentificationVariable
  2095.             case $entityExpr instanceof AST\PathExpression:
  2096.                 $entitySql = $this->walkPathExpression($entityExpr);
  2097.                 break;
  2099.             default:
  2100.                 throw new BadMethodCallException('Not implemented');
  2101.         }
  2103.         $assoc = $class->associationMappings[$fieldName];
  2105.         if ($assoc['type'] === ClassMetadata::ONE_TO_MANY) {
  2106.             $targetClass      = $this->em->getClassMetadata($assoc['targetEntity']);
  2107.             $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName());
  2108.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  2110.             $sql .= $this->quoteStrategy->getTableName($targetClass, $this->platform) . ' ' . $targetTableAlias . ' WHERE ';
  2112.             $owningAssoc = $targetClass->associationMappings[$assoc['mappedBy']];
  2113.             $sqlParts    = [];
  2115.             foreach ($owningAssoc['targetToSourceKeyColumns'] as $targetColumn => $sourceColumn) {
  2116.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$targetColumn], $class, $this->platform);
  2118.                 $sqlParts[] = $sourceTableAlias . '.' . $targetColumn . ' = ' . $targetTableAlias . '.' . $sourceColumn;
  2119.             }
  2121.             foreach ($this->quoteStrategy->getIdentifierColumnNames($targetClass, $this->platform) as $targetColumnName) {
  2122.                 if (isset($dqlParamKey)) {
  2123.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
  2124.                 }
  2126.                 $sqlParts[] = $targetTableAlias . '.' . $targetColumnName . ' = ' . $entitySql;
  2127.             }
  2129.             $sql .= implode(' AND ', $sqlParts);
  2130.         } else { // many-to-many
  2131.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  2133.             $owningAssoc = $assoc['isOwningSide'] ? $assoc : $targetClass->associationMappings[$assoc['mappedBy']];
  2134.             $joinTable   = $owningAssoc['joinTable'];
  2136.             // SQL table aliases
  2137.             $joinTableAlias   = $this->getSQLTableAlias($joinTable['name']);
  2138.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  2140.             $sql .= $this->quoteStrategy->getJoinTableName($owningAssoc, $targetClass, $this->platform) . ' ' . $joinTableAlias . ' WHERE ';
  2142.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['joinColumns'] : $joinTable['inverseJoinColumns'];
  2143.             $sqlParts    = [];
  2145.             foreach ($joinColumns as $joinColumn) {
  2146.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$joinColumn['referencedColumnName']], $class, $this->platform);
  2148.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' = ' . $sourceTableAlias . '.' . $targetColumn;
  2149.             }
  2151.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['inverseJoinColumns'] : $joinTable['joinColumns'];
  2153.             foreach ($joinColumns as $joinColumn) {
  2154.                 if (isset($dqlParamKey)) {
  2155.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
  2156.                 }
  2158.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' IN (' . $entitySql . ')';
  2159.             }
  2161.             $sql .= implode(' AND ', $sqlParts);
  2162.         }
  2164.         return $sql . ')';
  2165.     }
  2167.     /**
  2168.      * Walks down an EmptyCollectionComparisonExpression AST node, thereby generating the appropriate SQL.
  2169.      *
  2170.      * @param AST\EmptyCollectionComparisonExpression $emptyCollCompExpr
  2171.      *
  2172.      * @return string
  2173.      */
  2174.     public function walkEmptyCollectionComparisonExpression($emptyCollCompExpr)
  2175.     {
  2176.         $sizeFunc                           = new AST\Functions\SizeFunction('size');
  2177.         $sizeFunc->collectionPathExpression = $emptyCollCompExpr->expression;
  2179.         return $sizeFunc->getSql($this) . ($emptyCollCompExpr->not ? ' > 0' : ' = 0');
  2180.     }
  2182.     /**
  2183.      * Walks down a NullComparisonExpression AST node, thereby generating the appropriate SQL.
  2184.      *
  2185.      * @param AST\NullComparisonExpression $nullCompExpr
  2186.      *
  2187.      * @return string
  2188.      */
  2189.     public function walkNullComparisonExpression($nullCompExpr)
  2190.     {
  2191.         $expression = $nullCompExpr->expression;
  2192.         $comparison = ' IS' . ($nullCompExpr->not ? ' NOT' : '') . ' NULL';
  2194.         // Handle ResultVariable
  2195.         if (is_string($expression) && isset($this->queryComponents[$expression]['resultVariable'])) {
  2196.             return $this->walkResultVariable($expression) . $comparison;
  2197.         }
  2199.         // Handle InputParameter mapping inclusion to ParserResult
  2200.         if ($expression instanceof AST\InputParameter) {
  2201.             return $this->walkInputParameter($expression) . $comparison;
  2202.         }
  2204.         return $expression->dispatch($this) . $comparison;
  2205.     }
  2207.     /**
  2208.      * Walks down an InExpression AST node, thereby generating the appropriate SQL.
  2209.      *
  2210.      * @param AST\InExpression $inExpr
  2211.      *
  2212.      * @return string
  2213.      */
  2214.     public function walkInExpression($inExpr)
  2215.     {
  2216.         $sql = $this->walkArithmeticExpression($inExpr->expression) . ($inExpr->not ? ' NOT' : '') . ' IN (';
  2218.         $sql .= $inExpr->subselect
  2219.             ? $this->walkSubselect($inExpr->subselect)
  2220.             : implode(', ', array_map([$this, 'walkInParameter'], $inExpr->literals));
  2222.         $sql .= ')';
  2224.         return $sql;
  2225.     }
  2227.     /**
  2228.      * Walks down an InstanceOfExpression AST node, thereby generating the appropriate SQL.
  2229.      *
  2230.      * @param AST\InstanceOfExpression $instanceOfExpr
  2231.      *
  2232.      * @return string
  2233.      *
  2234.      * @throws QueryException
  2235.      */
  2236.     public function walkInstanceOfExpression($instanceOfExpr)
  2237.     {
  2238.         $sql = '';
  2240.         $dqlAlias   = $instanceOfExpr->identificationVariable;
  2241.         $discrClass = $class = $this->getMetadataForDqlAlias($dqlAlias);
  2243.         if ($class->discriminatorColumn) {
  2244.             $discrClass = $this->em->getClassMetadata($class->rootEntityName);
  2245.         }
  2247.         if ($this->useSqlTableAliases) {
  2248.             $sql .= $this->getSQLTableAlias($discrClass->getTableName(), $dqlAlias) . '.';
  2249.         }
  2251.         $sql .= $class->getDiscriminatorColumn()['name'] . ($instanceOfExpr->not ? ' NOT IN ' : ' IN ');
  2252.         $sql .= $this->getChildDiscriminatorsFromClassMetadata($discrClass, $instanceOfExpr);
  2254.         return $sql;
  2255.     }
  2257.     /**
  2258.      * @param mixed $inParam
  2259.      *
  2260.      * @return string
  2261.      */
  2262.     public function walkInParameter($inParam)
  2263.     {
  2264.         return $inParam instanceof AST\InputParameter
  2265.             ? $this->walkInputParameter($inParam)
  2266.             : $this->walkArithmeticExpression($inParam);
  2267.     }
  2269.     /**
  2270.      * Walks down a literal that represents an AST node, thereby generating the appropriate SQL.
  2271.      *
  2272.      * @param AST\Literal $literal
  2273.      *
  2274.      * @return string
  2275.      */
  2276.     public function walkLiteral($literal)
  2277.     {
  2278.         switch ($literal->type) {
  2279.             case AST\Literal::STRING:
  2280.                 return $this->conn->quote($literal->value);
  2282.             case AST\Literal::BOOLEAN:
  2283.                 return (string) $this->conn->getDatabasePlatform()->convertBooleans(strtolower($literal->value) === 'true');
  2285.             case AST\Literal::NUMERIC:
  2286.                 return (string) $literal->value;
  2288.             default:
  2289.                 throw QueryException::invalidLiteral($literal);
  2290.         }
  2291.     }
  2293.     /**
  2294.      * Walks down a BetweenExpression AST node, thereby generating the appropriate SQL.
  2295.      *
  2296.      * @param AST\BetweenExpression $betweenExpr
  2297.      *
  2298.      * @return string
  2299.      */
  2300.     public function walkBetweenExpression($betweenExpr)
  2301.     {
  2302.         $sql = $this->walkArithmeticExpression($betweenExpr->expression);
  2304.         if ($betweenExpr->not) {
  2305.             $sql .= ' NOT';
  2306.         }
  2308.         $sql .= ' BETWEEN ' . $this->walkArithmeticExpression($betweenExpr->leftBetweenExpression)
  2309.             . ' AND ' . $this->walkArithmeticExpression($betweenExpr->rightBetweenExpression);
  2311.         return $sql;
  2312.     }
  2314.     /**
  2315.      * Walks down a LikeExpression AST node, thereby generating the appropriate SQL.
  2316.      *
  2317.      * @param AST\LikeExpression $likeExpr
  2318.      *
  2319.      * @return string
  2320.      */
  2321.     public function walkLikeExpression($likeExpr)
  2322.     {
  2323.         $stringExpr = $likeExpr->stringExpression;
  2324.         if (is_string($stringExpr)) {
  2325.             if (! isset($this->queryComponents[$stringExpr]['resultVariable'])) {
  2326.                 throw new LogicException(sprintf('No result variable found for string expression "%s".', $stringExpr));
  2327.             }
  2329.             $leftExpr = $this->walkResultVariable($stringExpr);
  2330.         } else {
  2331.             $leftExpr = $stringExpr->dispatch($this);
  2332.         }
  2334.         $sql = $leftExpr . ($likeExpr->not ? ' NOT' : '') . ' LIKE ';
  2336.         if ($likeExpr->stringPattern instanceof AST\InputParameter) {
  2337.             $sql .= $this->walkInputParameter($likeExpr->stringPattern);
  2338.         } elseif ($likeExpr->stringPattern instanceof AST\Functions\FunctionNode) {
  2339.             $sql .= $this->walkFunction($likeExpr->stringPattern);
  2340.         } elseif ($likeExpr->stringPattern instanceof AST\PathExpression) {
  2341.             $sql .= $this->walkPathExpression($likeExpr->stringPattern);
  2342.         } else {
  2343.             $sql .= $this->walkLiteral($likeExpr->stringPattern);
  2344.         }
  2346.         if ($likeExpr->escapeChar) {
  2347.             $sql .= ' ESCAPE ' . $this->walkLiteral($likeExpr->escapeChar);
  2348.         }
  2350.         return $sql;
  2351.     }
  2353.     /**
  2354.      * Walks down a StateFieldPathExpression AST node, thereby generating the appropriate SQL.
  2355.      *
  2356.      * @param AST\PathExpression $stateFieldPathExpression
  2357.      *
  2358.      * @return string
  2359.      */
  2360.     public function walkStateFieldPathExpression($stateFieldPathExpression)
  2361.     {
  2362.         return $this->walkPathExpression($stateFieldPathExpression);
  2363.     }
  2365.     /**
  2366.      * Walks down a ComparisonExpression AST node, thereby generating the appropriate SQL.
  2367.      *
  2368.      * @param AST\ComparisonExpression $compExpr
  2369.      *
  2370.      * @return string
  2371.      */
  2372.     public function walkComparisonExpression($compExpr)
  2373.     {
  2374.         $leftExpr  = $compExpr->leftExpression;
  2375.         $rightExpr = $compExpr->rightExpression;
  2376.         $sql       = '';
  2378.         $sql .= $leftExpr instanceof AST\Node
  2379.             ? $leftExpr->dispatch($this)
  2380.             : (is_numeric($leftExpr) ? $leftExpr : $this->conn->quote($leftExpr));
  2382.         $sql .= ' ' . $compExpr->operator . ' ';
  2384.         $sql .= $rightExpr instanceof AST\Node
  2385.             ? $rightExpr->dispatch($this)
  2386.             : (is_numeric($rightExpr) ? $rightExpr : $this->conn->quote($rightExpr));
  2388.         return $sql;
  2389.     }
  2391.     /**
  2392.      * Walks down an InputParameter AST node, thereby generating the appropriate SQL.
  2393.      *
  2394.      * @param AST\InputParameter $inputParam
  2395.      *
  2396.      * @return string
  2397.      */
  2398.     public function walkInputParameter($inputParam)
  2399.     {
  2400.         $this->parserResult->addParameterMapping($inputParam->name, $this->sqlParamIndex++);
  2402.         $parameter = $this->query->getParameter($inputParam->name);
  2404.         if ($parameter) {
  2405.             $type = $parameter->getType();
  2406.             if (Type::hasType($type)) {
  2407.                 return Type::getType($type)->convertToDatabaseValueSQL('?', $this->platform);
  2408.             }
  2409.         }
  2411.         return '?';
  2412.     }
  2414.     /**
  2415.      * Walks down an ArithmeticExpression AST node, thereby generating the appropriate SQL.
  2416.      *
  2417.      * @param AST\ArithmeticExpression $arithmeticExpr
  2418.      *
  2419.      * @return string
  2420.      */
  2421.     public function walkArithmeticExpression($arithmeticExpr)
  2422.     {
  2423.         return $arithmeticExpr->isSimpleArithmeticExpression()
  2424.             ? $this->walkSimpleArithmeticExpression($arithmeticExpr->simpleArithmeticExpression)
  2425.             : '(' . $this->walkSubselect($arithmeticExpr->subselect) . ')';
  2426.     }
  2428.     /**
  2429.      * Walks down an SimpleArithmeticExpression AST node, thereby generating the appropriate SQL.
  2430.      *
  2431.      * @param AST\SimpleArithmeticExpression $simpleArithmeticExpr
  2432.      *
  2433.      * @return string
  2434.      */
  2435.     public function walkSimpleArithmeticExpression($simpleArithmeticExpr)
  2436.     {
  2437.         if (! ($simpleArithmeticExpr instanceof AST\SimpleArithmeticExpression)) {
  2438.             return $this->walkArithmeticTerm($simpleArithmeticExpr);
  2439.         }
  2441.         return implode(' ', array_map([$this, 'walkArithmeticTerm'], $simpleArithmeticExpr->arithmeticTerms));
  2442.     }
  2444.     /**
  2445.      * Walks down an ArithmeticTerm AST node, thereby generating the appropriate SQL.
  2446.      *
  2447.      * @param mixed $term
  2448.      *
  2449.      * @return string
  2450.      */
  2451.     public function walkArithmeticTerm($term)
  2452.     {
  2453.         if (is_string($term)) {
  2454.             return isset($this->queryComponents[$term])
  2455.                 ? $this->walkResultVariable($this->queryComponents[$term]['token']['value'])
  2456.                 : $term;
  2457.         }
  2459.         // Phase 2 AST optimization: Skip processing of ArithmeticTerm
  2460.         // if only one ArithmeticFactor is defined
  2461.         if (! ($term instanceof AST\ArithmeticTerm)) {
  2462.             return $this->walkArithmeticFactor($term);
  2463.         }
  2465.         return implode(' ', array_map([$this, 'walkArithmeticFactor'], $term->arithmeticFactors));
  2466.     }
  2468.     /**
  2469.      * Walks down an ArithmeticFactor that represents an AST node, thereby generating the appropriate SQL.
  2470.      *
  2471.      * @param mixed $factor
  2472.      *
  2473.      * @return string
  2474.      */
  2475.     public function walkArithmeticFactor($factor)
  2476.     {
  2477.         if (is_string($factor)) {
  2478.             return isset($this->queryComponents[$factor])
  2479.                 ? $this->walkResultVariable($this->queryComponents[$factor]['token']['value'])
  2480.                 : $factor;
  2481.         }
  2483.         // Phase 2 AST optimization: Skip processing of ArithmeticFactor
  2484.         // if only one ArithmeticPrimary is defined
  2485.         if (! ($factor instanceof AST\ArithmeticFactor)) {
  2486.             return $this->walkArithmeticPrimary($factor);
  2487.         }
  2489.         $sign = $factor->isNegativeSigned() ? '-' : ($factor->isPositiveSigned() ? '+' : '');
  2491.         return $sign . $this->walkArithmeticPrimary($factor->arithmeticPrimary);
  2492.     }
  2494.     /**
  2495.      * Walks down an ArithmeticPrimary that represents an AST node, thereby generating the appropriate SQL.
  2496.      *
  2497.      * @param mixed $primary
  2498.      *
  2499.      * @return string The SQL.
  2500.      */
  2501.     public function walkArithmeticPrimary($primary)
  2502.     {
  2503.         if ($primary instanceof AST\SimpleArithmeticExpression) {
  2504.             return '(' . $this->walkSimpleArithmeticExpression($primary) . ')';
  2505.         }
  2507.         if ($primary instanceof AST\Node) {
  2508.             return $primary->dispatch($this);
  2509.         }
  2511.         return $this->walkEntityIdentificationVariable($primary);
  2512.     }
  2514.     /**
  2515.      * Walks down a StringPrimary that represents an AST node, thereby generating the appropriate SQL.
  2516.      *
  2517.      * @param mixed $stringPrimary
  2518.      *
  2519.      * @return string
  2520.      */
  2521.     public function walkStringPrimary($stringPrimary)
  2522.     {
  2523.         return is_string($stringPrimary)
  2524.             ? $this->conn->quote($stringPrimary)
  2525.             : $stringPrimary->dispatch($this);
  2526.     }
  2528.     /**
  2529.      * Walks down a ResultVariable that represents an AST node, thereby generating the appropriate SQL.
  2530.      *
  2531.      * @param string $resultVariable
  2532.      *
  2533.      * @return string
  2534.      */
  2535.     public function walkResultVariable($resultVariable)
  2536.     {
  2537.         if (! isset($this->scalarResultAliasMap[$resultVariable])) {
  2538.             throw new InvalidArgumentException(sprintf('Unknown result variable: %s', $resultVariable));
  2539.         }
  2541.         $resultAlias = $this->scalarResultAliasMap[$resultVariable];
  2543.         if (is_array($resultAlias)) {
  2544.             return implode(', ', $resultAlias);
  2545.         }
  2547.         return $resultAlias;
  2548.     }
  2550.     /**
  2551.      * @return string The list in parentheses of valid child discriminators from the given class
  2552.      *
  2553.      * @throws QueryException
  2554.      */
  2555.     private function getChildDiscriminatorsFromClassMetadata(
  2556.         ClassMetadata $rootClass,
  2557.         AST\InstanceOfExpression $instanceOfExpr
  2558.     ): string {
  2559.         $sqlParameterList = [];
  2560.         $discriminators   = [];
  2561.         foreach ($instanceOfExpr->value as $parameter) {
  2562.             if ($parameter instanceof AST\InputParameter) {
  2563.                 $this->rsm->discriminatorParameters[$parameter->name] = $parameter->name;
  2564.                 $sqlParameterList[]                                   = $this->walkInParameter($parameter);
  2565.                 continue;
  2566.             }
  2568.             $metadata = $this->em->getClassMetadata($parameter);
  2570.             if ($metadata->getName() !== $rootClass->name && ! $metadata->getReflectionClass()->isSubclassOf($rootClass->name)) {
  2571.                 throw QueryException::instanceOfUnrelatedClass($parameter, $rootClass->name);
  2572.             }
  2574.             $discriminators += HierarchyDiscriminatorResolver::resolveDiscriminatorsForClass($metadata, $this->em);
  2575.         }
  2577.         foreach (array_keys($discriminators) as $dis) {
  2578.             $sqlParameterList[] = $this->conn->quote($dis);
  2579.         }
  2581.         return '(' . implode(', ', $sqlParameterList) . ')';
  2582.     }
  2583. }