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

Open in your IDE?
  1. <?php
  3. /*
  4.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  5.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  6.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  7.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  8.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  9.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  10.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  11.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  12.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  13.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  14.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  15.  *
  16.  * This software consists of voluntary contributions made by many individuals
  17.  * and is licensed under the MIT license. For more information, see
  18.  * <http://www.doctrine-project.org>.
  19.  */
  21. namespace Doctrine\ORM\Query;
  23. use BadMethodCallException;
  24. use Doctrine\DBAL\Connection;
  25. use Doctrine\DBAL\LockMode;
  26. use Doctrine\DBAL\Platforms\AbstractPlatform;
  27. use Doctrine\DBAL\Types\Type;
  28. use Doctrine\ORM\EntityManagerInterface;
  29. use Doctrine\ORM\Mapping\ClassMetadata;
  30. use Doctrine\ORM\Mapping\ClassMetadataInfo;
  31. use Doctrine\ORM\Mapping\QuoteStrategy;
  32. use Doctrine\ORM\OptimisticLockException;
  33. use Doctrine\ORM\Query;
  34. use Doctrine\ORM\Utility\HierarchyDiscriminatorResolver;
  35. use Doctrine\ORM\Utility\PersisterHelper;
  37. use function array_diff;
  38. use function array_filter;
  39. use function array_keys;
  40. use function array_map;
  41. use function array_merge;
  42. use function count;
  43. use function implode;
  44. use function in_array;
  45. use function is_array;
  46. use function is_float;
  47. use function is_numeric;
  48. use function is_string;
  49. use function preg_match;
  50. use function reset;
  51. use function sprintf;
  52. use function strtolower;
  53. use function strtoupper;
  54. use function trim;
  56. /**
  57.  * The SqlWalker is a TreeWalker that walks over a DQL AST and constructs
  58.  * the corresponding SQL.
  59.  */
  60. class SqlWalker implements TreeWalker
  61. {
  62.     public const HINT_DISTINCT = 'doctrine.distinct';
  64.     /**
  65.      * Used to mark a query as containing a PARTIAL expression, which needs to be known by SLC.
  66.      */
  67.     public const HINT_PARTIAL = 'doctrine.partial';
  69.     /** @var ResultSetMapping */
  70.     private $rsm;
  72.     /**
  73.      * Counter for generating unique column aliases.
  74.      *
  75.      * @var int
  76.      */
  77.     private $aliasCounter = 0;
  79.     /**
  80.      * Counter for generating unique table aliases.
  81.      *
  82.      * @var int
  83.      */
  84.     private $tableAliasCounter = 0;
  86.     /**
  87.      * Counter for generating unique scalar result.
  88.      *
  89.      * @var int
  90.      */
  91.     private $scalarResultCounter = 1;
  93.     /**
  94.      * Counter for generating unique parameter indexes.
  95.      *
  96.      * @var int
  97.      */
  98.     private $sqlParamIndex = 0;
  100.     /**
  101.      * Counter for generating indexes.
  102.      *
  103.      * @var int
  104.      */
  105.     private $newObjectCounter = 0;
  107.     /** @var ParserResult */
  108.     private $parserResult;
  110.     /** @var EntityManagerInterface */
  111.     private $em;
  113.     /** @var Connection */
  114.     private $conn;
  116.     /** @var Query */
  117.     private $query;
  119.     /** @var mixed[] */
  120.     private $tableAliasMap = [];
  122.     /**
  123.      * Map from result variable names to their SQL column alias names.
  124.      *
  125.      * @psalm-var array<string, string|list<string>>
  126.      */
  127.     private $scalarResultAliasMap = [];
  129.     /**
  130.      * Map from Table-Alias + Column-Name to OrderBy-Direction.
  131.      *
  132.      * @var array<string, string>
  133.      */
  134.     private $orderedColumnsMap = [];
  136.     /**
  137.      * Map from DQL-Alias + Field-Name to SQL Column Alias.
  138.      *
  139.      * @var array<string, array<string, string>>
  140.      */
  141.     private $scalarFields = [];
  143.     /**
  144.      * Map of all components/classes that appear in the DQL query.
  145.      *
  146.      * @psalm-var array<string, array{
  147.      *                metadata: ClassMetadata,
  148.      *                parent: string,
  149.      *                relation: mixed[],
  150.      *                map: mixed,
  151.      *                nestingLevel: int,
  152.      *                token: array
  153.      *            }>
  154.      */
  155.     private $queryComponents;
  157.     /**
  158.      * A list of classes that appear in non-scalar SelectExpressions.
  159.      *
  160.      * @psalm-var list<array{class: ClassMetadata, dqlAlias: string, resultAlias: string}>
  161.      */
  162.     private $selectedClasses = [];
  164.     /**
  165.      * The DQL alias of the root class of the currently traversed query.
  166.      *
  167.      * @psalm-var list<string>
  168.      */
  169.     private $rootAliases = [];
  171.     /**
  172.      * Flag that indicates whether to generate SQL table aliases in the SQL.
  173.      * These should only be generated for SELECT queries, not for UPDATE/DELETE.
  174.      *
  175.      * @var bool
  176.      */
  177.     private $useSqlTableAliases = true;
  179.     /**
  180.      * The database platform abstraction.
  181.      *
  182.      * @var AbstractPlatform
  183.      */
  184.     private $platform;
  186.     /**
  187.      * The quote strategy.
  188.      *
  189.      * @var QuoteStrategy
  190.      */
  191.     private $quoteStrategy;
  193.     /**
  194.      * {@inheritDoc}
  195.      */
  196.     public function __construct($query, $parserResult, array $queryComponents)
  197.     {
  198.         $this->query           = $query;
  199.         $this->parserResult    = $parserResult;
  200.         $this->queryComponents = $queryComponents;
  201.         $this->rsm             = $parserResult->getResultSetMapping();
  202.         $this->em              = $query->getEntityManager();
  203.         $this->conn            = $this->em->getConnection();
  204.         $this->platform        = $this->conn->getDatabasePlatform();
  205.         $this->quoteStrategy   = $this->em->getConfiguration()->getQuoteStrategy();
  206.     }
  208.     /**
  209.      * Gets the Query instance used by the walker.
  210.      *
  211.      * @return Query
  212.      */
  213.     public function getQuery()
  214.     {
  215.         return $this->query;
  216.     }
  218.     /**
  219.      * Gets the Connection used by the walker.
  220.      *
  221.      * @return Connection
  222.      */
  223.     public function getConnection()
  224.     {
  225.         return $this->conn;
  226.     }
  228.     /**
  229.      * Gets the EntityManager used by the walker.
  230.      *
  231.      * @return EntityManagerInterface
  232.      */
  233.     public function getEntityManager()
  234.     {
  235.         return $this->em;
  236.     }
  238.     /**
  239.      * Gets the information about a single query component.
  240.      *
  241.      * @param string $dqlAlias The DQL alias.
  242.      *
  243.      * @psalm-return array{
  244.      *                   metadata: ClassMetadata,
  245.      *                   parent: string,
  246.      *                   relation: mixed[],
  247.      *                   map: mixed,
  248.      *                   nestingLevel: int,
  249.      *                   token: array
  250.      *               }
  251.      */
  252.     public function getQueryComponent($dqlAlias)
  253.     {
  254.         return $this->queryComponents[$dqlAlias];
  255.     }
  257.     /**
  258.      * {@inheritdoc}
  259.      */
  260.     public function getQueryComponents()
  261.     {
  262.         return $this->queryComponents;
  263.     }
  265.     /**
  266.      * {@inheritdoc}
  267.      */
  268.     public function setQueryComponent($dqlAlias, array $queryComponent)
  269.     {
  270.         $requiredKeys = ['metadata', 'parent', 'relation', 'map', 'nestingLevel', 'token'];
  272.         if (array_diff($requiredKeys, array_keys($queryComponent))) {
  273.             throw QueryException::invalidQueryComponent($dqlAlias);
  274.         }
  276.         $this->queryComponents[$dqlAlias] = $queryComponent;
  277.     }
  279.     /**
  280.      * {@inheritdoc}
  281.      */
  282.     public function getExecutor($AST)
  283.     {
  284.         switch (true) {
  285.             case $AST instanceof AST\DeleteStatement:
  286.                 $primaryClass = $this->em->getClassMetadata($AST->deleteClause->abstractSchemaName);
  288.                 return $primaryClass->isInheritanceTypeJoined()
  289.                     ? new Exec\MultiTableDeleteExecutor($AST, $this)
  290.                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
  292.             case $AST instanceof AST\UpdateStatement:
  293.                 $primaryClass = $this->em->getClassMetadata($AST->updateClause->abstractSchemaName);
  295.                 return $primaryClass->isInheritanceTypeJoined()
  296.                     ? new Exec\MultiTableUpdateExecutor($AST, $this)
  297.                     : new Exec\SingleTableDeleteUpdateExecutor($AST, $this);
  299.             default:
  300.                 return new Exec\SingleSelectExecutor($AST, $this);
  301.         }
  302.     }
  304.     /**
  305.      * Generates a unique, short SQL table alias.
  306.      *
  307.      * @param string $tableName Table name
  308.      * @param string $dqlAlias  The DQL alias.
  309.      *
  310.      * @return string Generated table alias.
  311.      */
  312.     public function getSQLTableAlias($tableName, $dqlAlias = '')
  313.     {
  314.         $tableName .= $dqlAlias ? '@[' . $dqlAlias . ']' : '';
  316.         if (! isset($this->tableAliasMap[$tableName])) {
  317.             $this->tableAliasMap[$tableName] = (preg_match('/[a-z]/i', $tableName[0]) ? strtolower($tableName[0]) : 't')
  318.                 . $this->tableAliasCounter++ . '_';
  319.         }
  321.         return $this->tableAliasMap[$tableName];
  322.     }
  324.     /**
  325.      * Forces the SqlWalker to use a specific alias for a table name, rather than
  326.      * generating an alias on its own.
  327.      *
  328.      * @param string $tableName
  329.      * @param string $alias
  330.      * @param string $dqlAlias
  331.      *
  332.      * @return string
  333.      */
  334.     public function setSQLTableAlias($tableName, $alias, $dqlAlias = '')
  335.     {
  336.         $tableName .= $dqlAlias ? '@[' . $dqlAlias . ']' : '';
  338.         $this->tableAliasMap[$tableName] = $alias;
  340.         return $alias;
  341.     }
  343.     /**
  344.      * Gets an SQL column alias for a column name.
  345.      *
  346.      * @param string $columnName
  347.      *
  348.      * @return string
  349.      */
  350.     public function getSQLColumnAlias($columnName)
  351.     {
  352.         return $this->quoteStrategy->getColumnAlias($columnName, $this->aliasCounter++, $this->platform);
  353.     }
  355.     /**
  356.      * Generates the SQL JOINs that are necessary for Class Table Inheritance
  357.      * for the given class.
  358.      *
  359.      * @param ClassMetadata $class    The class for which to generate the joins.
  360.      * @param string        $dqlAlias The DQL alias of the class.
  361.      *
  362.      * @return string The SQL.
  363.      */
  364.     private function generateClassTableInheritanceJoins(
  365.         ClassMetadata $class,
  366.         string $dqlAlias
  367.     ): string {
  368.         $sql = '';
  370.         $baseTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  372.         // INNER JOIN parent class tables
  373.         foreach ($class->parentClasses as $parentClassName) {
  374.             $parentClass = $this->em->getClassMetadata($parentClassName);
  375.             $tableAlias  = $this->getSQLTableAlias($parentClass->getTableName(), $dqlAlias);
  377.             // If this is a joined association we must use left joins to preserve the correct result.
  378.             $sql .= isset($this->queryComponents[$dqlAlias]['relation']) ? ' LEFT ' : ' INNER ';
  379.             $sql .= 'JOIN ' . $this->quoteStrategy->getTableName($parentClass, $this->platform) . ' ' . $tableAlias . ' ON ';
  381.             $sqlParts = [];
  383.             foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
  384.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
  385.             }
  387.             // Add filters on the root class
  388.             $sqlParts[] = $this->generateFilterConditionSQL($parentClass, $tableAlias);
  390.             $sql .= implode(' AND ', array_filter($sqlParts));
  391.         }
  393.         // Ignore subclassing inclusion if partial objects is disallowed
  394.         if ($this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
  395.             return $sql;
  396.         }
  398.         // LEFT JOIN child class tables
  399.         foreach ($class->subClasses as $subClassName) {
  400.             $subClass   = $this->em->getClassMetadata($subClassName);
  401.             $tableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  403.             $sql .= ' LEFT JOIN ' . $this->quoteStrategy->getTableName($subClass, $this->platform) . ' ' . $tableAlias . ' ON ';
  405.             $sqlParts = [];
  407.             foreach ($this->quoteStrategy->getIdentifierColumnNames($subClass, $this->platform) as $columnName) {
  408.                 $sqlParts[] = $baseTableAlias . '.' . $columnName . ' = ' . $tableAlias . '.' . $columnName;
  409.             }
  411.             $sql .= implode(' AND ', $sqlParts);
  412.         }
  414.         return $sql;
  415.     }
  417.     private function generateOrderedCollectionOrderByItems(): string
  418.     {
  419.         $orderedColumns = [];
  421.         foreach ($this->selectedClasses as $selectedClass) {
  422.             $dqlAlias = $selectedClass['dqlAlias'];
  423.             $qComp    = $this->queryComponents[$dqlAlias];
  425.             if (! isset($qComp['relation']['orderBy'])) {
  426.                 continue;
  427.             }
  429.             $persister = $this->em->getUnitOfWork()->getEntityPersister($qComp['metadata']->name);
  431.             foreach ($qComp['relation']['orderBy'] as $fieldName => $orientation) {
  432.                 $columnName = $this->quoteStrategy->getColumnName($fieldName, $qComp['metadata'], $this->platform);
  433.                 $tableName  = $qComp['metadata']->isInheritanceTypeJoined()
  434.                     ? $persister->getOwningTable($fieldName)
  435.                     : $qComp['metadata']->getTableName();
  437.                 $orderedColumn = $this->getSQLTableAlias($tableName, $dqlAlias) . '.' . $columnName;
  439.                 // OrderByClause should replace an ordered relation. see - DDC-2475
  440.                 if (isset($this->orderedColumnsMap[$orderedColumn])) {
  441.                     continue;
  442.                 }
  444.                 $this->orderedColumnsMap[$orderedColumn] = $orientation;
  445.                 $orderedColumns[]                        = $orderedColumn . ' ' . $orientation;
  446.             }
  447.         }
  449.         return implode(', ', $orderedColumns);
  450.     }
  452.     /**
  453.      * Generates a discriminator column SQL condition for the class with the given DQL alias.
  454.      *
  455.      * @psalm-param list<string> $dqlAliases List of root DQL aliases to inspect for discriminator restrictions.
  456.      */
  457.     private function generateDiscriminatorColumnConditionSQL(array $dqlAliases): string
  458.     {
  459.         $sqlParts = [];
  461.         foreach ($dqlAliases as $dqlAlias) {
  462.             $class = $this->queryComponents[$dqlAlias]['metadata'];
  464.             if (! $class->isInheritanceTypeSingleTable()) {
  465.                 continue;
  466.             }
  468.             $conn   = $this->em->getConnection();
  469.             $values = [];
  471.             if ($class->discriminatorValue !== null) { // discriminators can be 0
  472.                 $values[] = $conn->quote($class->discriminatorValue);
  473.             }
  475.             foreach ($class->subClasses as $subclassName) {
  476.                 $values[] = $conn->quote($this->em->getClassMetadata($subclassName)->discriminatorValue);
  477.             }
  479.             $sqlTableAlias = $this->useSqlTableAliases
  480.                 ? $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.'
  481.                 : '';
  483.             $sqlParts[] = $sqlTableAlias . $class->discriminatorColumn['name'] . ' IN (' . implode(', ', $values) . ')';
  484.         }
  486.         $sql = implode(' AND ', $sqlParts);
  488.         return count($sqlParts) > 1 ? '(' . $sql . ')' : $sql;
  489.     }
  491.     /**
  492.      * Generates the filter SQL for a given entity and table alias.
  493.      *
  494.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
  495.      * @param string        $targetTableAlias The table alias of the joined/selected table.
  496.      *
  497.      * @return string The SQL query part to add to a query.
  498.      */
  499.     private function generateFilterConditionSQL(
  500.         ClassMetadata $targetEntity,
  501.         string $targetTableAlias
  502.     ): string {
  503.         if (! $this->em->hasFilters()) {
  504.             return '';
  505.         }
  507.         switch ($targetEntity->inheritanceType) {
  508.             case ClassMetadata::INHERITANCE_TYPE_NONE:
  509.                 break;
  510.             case ClassMetadata::INHERITANCE_TYPE_JOINED:
  511.                 // The classes in the inheritance will be added to the query one by one,
  512.                 // but only the root node is getting filtered
  513.                 if ($targetEntity->name !== $targetEntity->rootEntityName) {
  514.                     return '';
  515.                 }
  517.                 break;
  518.             case ClassMetadata::INHERITANCE_TYPE_SINGLE_TABLE:
  519.                 // With STI the table will only be queried once, make sure that the filters
  520.                 // are added to the root entity
  521.                 $targetEntity = $this->em->getClassMetadata($targetEntity->rootEntityName);
  522.                 break;
  523.             default:
  524.                 //@todo: throw exception?
  525.                 return '';
  526.         }
  528.         $filterClauses = [];
  529.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  530.             $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
  531.             if ($filterExpr !== '') {
  532.                 $filterClauses[] = '(' . $filterExpr . ')';
  533.             }
  534.         }
  536.         return implode(' AND ', $filterClauses);
  537.     }
  539.     /**
  540.      * {@inheritdoc}
  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);
  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.         if ($limit !== null || $offset !== null) {
  569.             $sql = $this->platform->modifyLimitQuery($sql, $limit, $offset);
  570.         }
  572.         if ($lockMode === null || $lockMode === false || $lockMode === LockMode::NONE) {
  573.             return $sql;
  574.         }
  576.         if ($lockMode === LockMode::PESSIMISTIC_READ) {
  577.             return $sql . ' ' . $this->platform->getReadLockSQL();
  578.         }
  580.         if ($lockMode === LockMode::PESSIMISTIC_WRITE) {
  581.             return $sql . ' ' . $this->platform->getWriteLockSQL();
  582.         }
  584.         if ($lockMode !== LockMode::OPTIMISTIC) {
  585.             throw QueryException::invalidLockMode();
  586.         }
  588.         foreach ($this->selectedClasses as $selectedClass) {
  589.             if (! $selectedClass['class']->isVersioned) {
  590.                 throw OptimisticLockException::lockFailed($selectedClass['class']->name);
  591.             }
  592.         }
  594.         return $sql;
  595.     }
  597.     /**
  598.      * {@inheritdoc}
  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.      * {@inheritdoc}
  611.      */
  612.     public function walkDeleteStatement(AST\DeleteStatement $AST)
  613.     {
  614.         $this->useSqlTableAliases = false;
  615.         $this->rsm->isSelect      = false;
  617.         return $this->walkDeleteClause($AST->deleteClause)
  618.             . $this->walkWhereClause($AST->whereClause);
  619.     }
  621.     /**
  622.      * Walks down an IdentificationVariable AST node, thereby generating the appropriate SQL.
  623.      * This one differs of ->walkIdentificationVariable() because it generates the entity identifiers.
  624.      *
  625.      * @param string $identVariable
  626.      *
  627.      * @return string
  628.      */
  629.     public function walkEntityIdentificationVariable($identVariable)
  630.     {
  631.         $class      = $this->queryComponents[$identVariable]['metadata'];
  632.         $tableAlias = $this->getSQLTableAlias($class->getTableName(), $identVariable);
  633.         $sqlParts   = [];
  635.         foreach ($this->quoteStrategy->getIdentifierColumnNames($class, $this->platform) as $columnName) {
  636.             $sqlParts[] = $tableAlias . '.' . $columnName;
  637.         }
  639.         return implode(', ', $sqlParts);
  640.     }
  642.     /**
  643.      * Walks down an IdentificationVariable (no AST node associated), thereby generating the SQL.
  644.      *
  645.      * @param string $identificationVariable
  646.      * @param string $fieldName
  647.      *
  648.      * @return string The SQL.
  649.      */
  650.     public function walkIdentificationVariable($identificationVariable, $fieldName = null)
  651.     {
  652.         $class = $this->queryComponents[$identificationVariable]['metadata'];
  654.         if (
  655.             $fieldName !== null && $class->isInheritanceTypeJoined() &&
  656.             isset($class->fieldMappings[$fieldName]['inherited'])
  657.         ) {
  658.             $class = $this->em->getClassMetadata($class->fieldMappings[$fieldName]['inherited']);
  659.         }
  661.         return $this->getSQLTableAlias($class->getTableName(), $identificationVariable);
  662.     }
  664.     /**
  665.      * {@inheritdoc}
  666.      */
  667.     public function walkPathExpression($pathExpr)
  668.     {
  669.         $sql = '';
  671.         switch ($pathExpr->type) {
  672.             case AST\PathExpression::TYPE_STATE_FIELD:
  673.                 $fieldName = $pathExpr->field;
  674.                 $dqlAlias  = $pathExpr->identificationVariable;
  675.                 $class     = $this->queryComponents[$dqlAlias]['metadata'];
  677.                 if ($this->useSqlTableAliases) {
  678.                     $sql .= $this->walkIdentificationVariable($dqlAlias, $fieldName) . '.';
  679.                 }
  681.                 $sql .= $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  682.                 break;
  684.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
  685.                 // 1- the owning side:
  686.                 //    Just use the foreign key, i.e. u.group_id
  687.                 $fieldName = $pathExpr->field;
  688.                 $dqlAlias  = $pathExpr->identificationVariable;
  689.                 $class     = $this->queryComponents[$dqlAlias]['metadata'];
  691.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
  692.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
  693.                 }
  695.                 $assoc = $class->associationMappings[$fieldName];
  697.                 if (! $assoc['isOwningSide']) {
  698.                     throw QueryException::associationPathInverseSideNotSupported($pathExpr);
  699.                 }
  701.                 // COMPOSITE KEYS NOT (YET?) SUPPORTED
  702.                 if (count($assoc['sourceToTargetKeyColumns']) > 1) {
  703.                     throw QueryException::associationPathCompositeKeyNotSupported();
  704.                 }
  706.                 if ($this->useSqlTableAliases) {
  707.                     $sql .= $this->getSQLTableAlias($class->getTableName(), $dqlAlias) . '.';
  708.                 }
  710.                 $sql .= reset($assoc['targetToSourceKeyColumns']);
  711.                 break;
  713.             default:
  714.                 throw QueryException::invalidPathExpression($pathExpr);
  715.         }
  717.         return $sql;
  718.     }
  720.     /**
  721.      * {@inheritdoc}
  722.      */
  723.     public function walkSelectClause($selectClause)
  724.     {
  725.         $sql                  = 'SELECT ' . ($selectClause->isDistinct ? 'DISTINCT ' : '');
  726.         $sqlSelectExpressions = array_filter(array_map([$this, 'walkSelectExpression'], $selectClause->selectExpressions));
  728.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) === true && $selectClause->isDistinct) {
  729.             $this->query->setHint(self::HINT_DISTINCT, true);
  730.         }
  732.         $addMetaColumns = ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD) &&
  733.             $this->query->getHydrationMode() === Query::HYDRATE_OBJECT
  734.             || $this->query->getHint(Query::HINT_INCLUDE_META_COLUMNS);
  736.         foreach ($this->selectedClasses as $selectedClass) {
  737.             $class       = $selectedClass['class'];
  738.             $dqlAlias    = $selectedClass['dqlAlias'];
  739.             $resultAlias = $selectedClass['resultAlias'];
  741.             // Register as entity or joined entity result
  742.             if ($this->queryComponents[$dqlAlias]['relation'] === null) {
  743.                 $this->rsm->addEntityResult($class->name, $dqlAlias, $resultAlias);
  744.             } else {
  745.                 $this->rsm->addJoinedEntityResult(
  746.                     $class->name,
  747.                     $dqlAlias,
  748.                     $this->queryComponents[$dqlAlias]['parent'],
  749.                     $this->queryComponents[$dqlAlias]['relation']['fieldName']
  750.                 );
  751.             }
  753.             if ($class->isInheritanceTypeSingleTable() || $class->isInheritanceTypeJoined()) {
  754.                 // Add discriminator columns to SQL
  755.                 $rootClass   = $this->em->getClassMetadata($class->rootEntityName);
  756.                 $tblAlias    = $this->getSQLTableAlias($rootClass->getTableName(), $dqlAlias);
  757.                 $discrColumn = $rootClass->discriminatorColumn;
  758.                 $columnAlias = $this->getSQLColumnAlias($discrColumn['name']);
  760.                 $sqlSelectExpressions[] = $tblAlias . '.' . $discrColumn['name'] . ' AS ' . $columnAlias;
  762.                 $this->rsm->setDiscriminatorColumn($dqlAlias, $columnAlias);
  763.                 $this->rsm->addMetaResult($dqlAlias, $columnAlias, $discrColumn['fieldName'], false, $discrColumn['type']);
  764.             }
  766.             // Add foreign key columns to SQL, if necessary
  767.             if (! $addMetaColumns && ! $class->containsForeignIdentifier) {
  768.                 continue;
  769.             }
  771.             // Add foreign key columns of class and also parent classes
  772.             foreach ($class->associationMappings as $assoc) {
  773.                 if (
  774.                     ! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)
  775.                     || ( ! $addMetaColumns && ! isset($assoc['id']))
  776.                 ) {
  777.                     continue;
  778.                 }
  780.                 $targetClass   = $this->em->getClassMetadata($assoc['targetEntity']);
  781.                 $isIdentifier  = (isset($assoc['id']) && $assoc['id'] === true);
  782.                 $owningClass   = isset($assoc['inherited']) ? $this->em->getClassMetadata($assoc['inherited']) : $class;
  783.                 $sqlTableAlias = $this->getSQLTableAlias($owningClass->getTableName(), $dqlAlias);
  785.                 foreach ($assoc['joinColumns'] as $joinColumn) {
  786.                     $columnName  = $joinColumn['name'];
  787.                     $columnAlias = $this->getSQLColumnAlias($columnName);
  788.                     $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  790.                     $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  791.                     $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
  793.                     $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $isIdentifier, $columnType);
  794.                 }
  795.             }
  797.             // Add foreign key columns to SQL, if necessary
  798.             if (! $addMetaColumns) {
  799.                 continue;
  800.             }
  802.             // Add foreign key columns of subclasses
  803.             foreach ($class->subClasses as $subClassName) {
  804.                 $subClass      = $this->em->getClassMetadata($subClassName);
  805.                 $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  807.                 foreach ($subClass->associationMappings as $assoc) {
  808.                     // Skip if association is inherited
  809.                     if (isset($assoc['inherited'])) {
  810.                         continue;
  811.                     }
  813.                     if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
  814.                         $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  816.                         foreach ($assoc['joinColumns'] as $joinColumn) {
  817.                             $columnName  = $joinColumn['name'];
  818.                             $columnAlias = $this->getSQLColumnAlias($columnName);
  819.                             $columnType  = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  821.                             $quotedColumnName       = $this->quoteStrategy->getJoinColumnName($joinColumn, $subClass, $this->platform);
  822.                             $sqlSelectExpressions[] = $sqlTableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
  824.                             $this->rsm->addMetaResult($dqlAlias, $columnAlias, $columnName, $subClass->isIdentifier($columnName), $columnType);
  825.                         }
  826.                     }
  827.                 }
  828.             }
  829.         }
  831.         return $sql . implode(', ', $sqlSelectExpressions);
  832.     }
  834.     /**
  835.      * {@inheritdoc}
  836.      */
  837.     public function walkFromClause($fromClause)
  838.     {
  839.         $identificationVarDecls = $fromClause->identificationVariableDeclarations;
  840.         $sqlParts               = [];
  842.         foreach ($identificationVarDecls as $identificationVariableDecl) {
  843.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($identificationVariableDecl);
  844.         }
  846.         return ' FROM ' . implode(', ', $sqlParts);
  847.     }
  849.     /**
  850.      * Walks down a IdentificationVariableDeclaration AST node, thereby generating the appropriate SQL.
  851.      *
  852.      * @param AST\IdentificationVariableDeclaration $identificationVariableDecl
  853.      *
  854.      * @return string
  855.      */
  856.     public function walkIdentificationVariableDeclaration($identificationVariableDecl)
  857.     {
  858.         $sql = $this->walkRangeVariableDeclaration($identificationVariableDecl->rangeVariableDeclaration);
  860.         if ($identificationVariableDecl->indexBy) {
  861.             $this->walkIndexBy($identificationVariableDecl->indexBy);
  862.         }
  864.         foreach ($identificationVariableDecl->joins as $join) {
  865.             $sql .= $this->walkJoin($join);
  866.         }
  868.         return $sql;
  869.     }
  871.     /**
  872.      * Walks down a IndexBy AST node.
  873.      *
  874.      * @param AST\IndexBy $indexBy
  875.      *
  876.      * @return void
  877.      */
  878.     public function walkIndexBy($indexBy)
  879.     {
  880.         $pathExpression = $indexBy->singleValuedPathExpression;
  881.         $alias          = $pathExpression->identificationVariable;
  883.         switch ($pathExpression->type) {
  884.             case AST\PathExpression::TYPE_STATE_FIELD:
  885.                 $field = $pathExpression->field;
  886.                 break;
  888.             case AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION:
  889.                 // Just use the foreign key, i.e. u.group_id
  890.                 $fieldName = $pathExpression->field;
  891.                 $class     = $this->queryComponents[$alias]['metadata'];
  893.                 if (isset($class->associationMappings[$fieldName]['inherited'])) {
  894.                     $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
  895.                 }
  897.                 $association = $class->associationMappings[$fieldName];
  899.                 if (! $association['isOwningSide']) {
  900.                     throw QueryException::associationPathInverseSideNotSupported($pathExpression);
  901.                 }
  903.                 if (count($association['sourceToTargetKeyColumns']) > 1) {
  904.                     throw QueryException::associationPathCompositeKeyNotSupported();
  905.                 }
  907.                 $field = reset($association['targetToSourceKeyColumns']);
  908.                 break;
  910.             default:
  911.                 throw QueryException::invalidPathExpression($pathExpression);
  912.         }
  914.         if (isset($this->scalarFields[$alias][$field])) {
  915.             $this->rsm->addIndexByScalar($this->scalarFields[$alias][$field]);
  917.             return;
  918.         }
  920.         $this->rsm->addIndexBy($alias, $field);
  921.     }
  923.     /**
  924.      * Walks down a RangeVariableDeclaration AST node, thereby generating the appropriate SQL.
  925.      *
  926.      * @param AST\RangeVariableDeclaration $rangeVariableDeclaration
  927.      *
  928.      * @return string
  929.      */
  930.     public function walkRangeVariableDeclaration($rangeVariableDeclaration)
  931.     {
  932.         return $this->generateRangeVariableDeclarationSQL($rangeVariableDeclaration, false);
  933.     }
  935.     /**
  936.      * Generate appropriate SQL for RangeVariableDeclaration AST node
  937.      */
  938.     private function generateRangeVariableDeclarationSQL(
  939.         AST\RangeVariableDeclaration $rangeVariableDeclaration,
  940.         bool $buildNestedJoins
  941.     ): string {
  942.         $class    = $this->em->getClassMetadata($rangeVariableDeclaration->abstractSchemaName);
  943.         $dqlAlias = $rangeVariableDeclaration->aliasIdentificationVariable;
  945.         if ($rangeVariableDeclaration->isRoot) {
  946.             $this->rootAliases[] = $dqlAlias;
  947.         }
  949.         $sql = $this->platform->appendLockHint(
  950.             $this->quoteStrategy->getTableName($class, $this->platform) . ' ' .
  951.             $this->getSQLTableAlias($class->getTableName(), $dqlAlias),
  952.             $this->query->getHint(Query::HINT_LOCK_MODE)
  953.         );
  955.         if (! $class->isInheritanceTypeJoined()) {
  956.             return $sql;
  957.         }
  959.         $classTableInheritanceJoins = $this->generateClassTableInheritanceJoins($class, $dqlAlias);
  961.         if (! $buildNestedJoins) {
  962.             return $sql . $classTableInheritanceJoins;
  963.         }
  965.         return $classTableInheritanceJoins === '' ? $sql : '(' . $sql . $classTableInheritanceJoins . ')';
  966.     }
  968.     /**
  969.      * Walks down a JoinAssociationDeclaration AST node, thereby generating the appropriate SQL.
  970.      *
  971.      * @param AST\JoinAssociationDeclaration $joinAssociationDeclaration
  972.      * @param int                            $joinType
  973.      * @param AST\ConditionalExpression      $condExpr
  974.      *
  975.      * @return string
  976.      *
  977.      * @throws QueryException
  978.      */
  979.     public function walkJoinAssociationDeclaration($joinAssociationDeclaration, $joinType = AST\Join::JOIN_TYPE_INNER, $condExpr = null)
  980.     {
  981.         $sql = '';
  983.         $associationPathExpression = $joinAssociationDeclaration->joinAssociationPathExpression;
  984.         $joinedDqlAlias            = $joinAssociationDeclaration->aliasIdentificationVariable;
  985.         $indexBy                   = $joinAssociationDeclaration->indexBy;
  987.         $relation        = $this->queryComponents[$joinedDqlAlias]['relation'];
  988.         $targetClass     = $this->em->getClassMetadata($relation['targetEntity']);
  989.         $sourceClass     = $this->em->getClassMetadata($relation['sourceEntity']);
  990.         $targetTableName = $this->quoteStrategy->getTableName($targetClass, $this->platform);
  992.         $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName(), $joinedDqlAlias);
  993.         $sourceTableAlias = $this->getSQLTableAlias($sourceClass->getTableName(), $associationPathExpression->identificationVariable);
  995.         // Ensure we got the owning side, since it has all mapping info
  996.         $assoc = ! $relation['isOwningSide'] ? $targetClass->associationMappings[$relation['mappedBy']] : $relation;
  998.         if ($this->query->getHint(Query::HINT_INTERNAL_ITERATION) === true && (! $this->query->getHint(self::HINT_DISTINCT) || isset($this->selectedClasses[$joinedDqlAlias]))) {
  999.             if ($relation['type'] === ClassMetadata::ONE_TO_MANY || $relation['type'] === ClassMetadata::MANY_TO_MANY) {
  1000.                 throw QueryException::iterateWithFetchJoinNotAllowed($assoc);
  1001.             }
  1002.         }
  1004.         $targetTableJoin = null;
  1006.         // This condition is not checking ClassMetadata::MANY_TO_ONE, because by definition it cannot
  1007.         // be the owning side and previously we ensured that $assoc is always the owning side of the associations.
  1008.         // The owning side is necessary at this point because only it contains the JoinColumn information.
  1009.         switch (true) {
  1010.             case $assoc['type'] & ClassMetadata::TO_ONE:
  1011.                 $conditions = [];
  1013.                 foreach ($assoc['joinColumns'] as $joinColumn) {
  1014.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  1015.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  1017.                     if ($relation['isOwningSide']) {
  1018.                         $conditions[] = $sourceTableAlias . '.' . $quotedSourceColumn . ' = ' . $targetTableAlias . '.' . $quotedTargetColumn;
  1020.                         continue;
  1021.                     }
  1023.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $targetTableAlias . '.' . $quotedSourceColumn;
  1024.                 }
  1026.                 // Apply remaining inheritance restrictions
  1027.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
  1029.                 if ($discrSql) {
  1030.                     $conditions[] = $discrSql;
  1031.                 }
  1033.                 // Apply the filters
  1034.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
  1036.                 if ($filterExpr) {
  1037.                     $conditions[] = $filterExpr;
  1038.                 }
  1040.                 $targetTableJoin = [
  1041.                     'table' => $targetTableName . ' ' . $targetTableAlias,
  1042.                     'condition' => implode(' AND ', $conditions),
  1043.                 ];
  1044.                 break;
  1046.             case $assoc['type'] === ClassMetadata::MANY_TO_MANY:
  1047.                 // Join relation table
  1048.                 $joinTable      = $assoc['joinTable'];
  1049.                 $joinTableAlias = $this->getSQLTableAlias($joinTable['name'], $joinedDqlAlias);
  1050.                 $joinTableName  = $this->quoteStrategy->getJoinTableName($assoc, $sourceClass, $this->platform);
  1052.                 $conditions      = [];
  1053.                 $relationColumns = $relation['isOwningSide']
  1054.                     ? $assoc['joinTable']['joinColumns']
  1055.                     : $assoc['joinTable']['inverseJoinColumns'];
  1057.                 foreach ($relationColumns as $joinColumn) {
  1058.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  1059.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  1061.                     $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
  1062.                 }
  1064.                 $sql .= $joinTableName . ' ' . $joinTableAlias . ' ON ' . implode(' AND ', $conditions);
  1066.                 // Join target table
  1067.                 $sql .= $joinType === AST\Join::JOIN_TYPE_LEFT || $joinType === AST\Join::JOIN_TYPE_LEFTOUTER ? ' LEFT JOIN ' : ' INNER JOIN ';
  1069.                 $conditions      = [];
  1070.                 $relationColumns = $relation['isOwningSide']
  1071.                     ? $assoc['joinTable']['inverseJoinColumns']
  1072.                     : $assoc['joinTable']['joinColumns'];
  1074.                 foreach ($relationColumns as $joinColumn) {
  1075.                     $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  1076.                     $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  1078.                     $conditions[] = $targetTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableAlias . '.' . $quotedSourceColumn;
  1079.                 }
  1081.                 // Apply remaining inheritance restrictions
  1082.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$joinedDqlAlias]);
  1084.                 if ($discrSql) {
  1085.                     $conditions[] = $discrSql;
  1086.                 }
  1088.                 // Apply the filters
  1089.                 $filterExpr = $this->generateFilterConditionSQL($targetClass, $targetTableAlias);
  1091.                 if ($filterExpr) {
  1092.                     $conditions[] = $filterExpr;
  1093.                 }
  1095.                 $targetTableJoin = [
  1096.                     'table' => $targetTableName . ' ' . $targetTableAlias,
  1097.                     'condition' => implode(' AND ', $conditions),
  1098.                 ];
  1099.                 break;
  1101.             default:
  1102.                 throw new BadMethodCallException('Type of association must be one of *_TO_ONE or MANY_TO_MANY');
  1103.         }
  1105.         // Handle WITH clause
  1106.         $withCondition = $condExpr === null ? '' : ('(' . $this->walkConditionalExpression($condExpr) . ')');
  1108.         if ($targetClass->isInheritanceTypeJoined()) {
  1109.             $ctiJoins = $this->generateClassTableInheritanceJoins($targetClass, $joinedDqlAlias);
  1110.             // If we have WITH condition, we need to build nested joins for target class table and cti joins
  1111.             if ($withCondition) {
  1112.                 $sql .= '(' . $targetTableJoin['table'] . $ctiJoins . ') ON ' . $targetTableJoin['condition'];
  1113.             } else {
  1114.                 $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'] . $ctiJoins;
  1115.             }
  1116.         } else {
  1117.             $sql .= $targetTableJoin['table'] . ' ON ' . $targetTableJoin['condition'];
  1118.         }
  1120.         if ($withCondition) {
  1121.             $sql .= ' AND ' . $withCondition;
  1122.         }
  1124.         // Apply the indexes
  1125.         if ($indexBy) {
  1126.             // For Many-To-One or One-To-One associations this obviously makes no sense, but is ignored silently.
  1127.             $this->walkIndexBy($indexBy);
  1128.         } elseif (isset($relation['indexBy'])) {
  1129.             $this->rsm->addIndexBy($joinedDqlAlias, $relation['indexBy']);
  1130.         }
  1132.         return $sql;
  1133.     }
  1135.     /**
  1136.      * {@inheritdoc}
  1137.      */
  1138.     public function walkFunction($function)
  1139.     {
  1140.         return $function->getSql($this);
  1141.     }
  1143.     /**
  1144.      * {@inheritdoc}
  1145.      */
  1146.     public function walkOrderByClause($orderByClause)
  1147.     {
  1148.         $orderByItems = array_map([$this, 'walkOrderByItem'], $orderByClause->orderByItems);
  1150.         $collectionOrderByItems = $this->generateOrderedCollectionOrderByItems();
  1151.         if ($collectionOrderByItems !== '') {
  1152.             $orderByItems = array_merge($orderByItems, (array) $collectionOrderByItems);
  1153.         }
  1155.         return ' ORDER BY ' . implode(', ', $orderByItems);
  1156.     }
  1158.     /**
  1159.      * {@inheritdoc}
  1160.      */
  1161.     public function walkOrderByItem($orderByItem)
  1162.     {
  1163.         $type = strtoupper($orderByItem->type);
  1164.         $expr = $orderByItem->expression;
  1165.         $sql  = $expr instanceof AST\Node
  1166.             ? $expr->dispatch($this)
  1167.             : $this->walkResultVariable($this->queryComponents[$expr]['token']['value']);
  1169.         $this->orderedColumnsMap[$sql] = $type;
  1171.         if ($expr instanceof AST\Subselect) {
  1172.             return '(' . $sql . ') ' . $type;
  1173.         }
  1175.         return $sql . ' ' . $type;
  1176.     }
  1178.     /**
  1179.      * {@inheritdoc}
  1180.      */
  1181.     public function walkHavingClause($havingClause)
  1182.     {
  1183.         return ' HAVING ' . $this->walkConditionalExpression($havingClause->conditionalExpression);
  1184.     }
  1186.     /**
  1187.      * {@inheritdoc}
  1188.      */
  1189.     public function walkJoin($join)
  1190.     {
  1191.         $joinType        = $join->joinType;
  1192.         $joinDeclaration = $join->joinAssociationDeclaration;
  1194.         $sql = $joinType === AST\Join::JOIN_TYPE_LEFT || $joinType === AST\Join::JOIN_TYPE_LEFTOUTER
  1195.             ? ' LEFT JOIN '
  1196.             : ' INNER JOIN ';
  1198.         switch (true) {
  1199.             case $joinDeclaration instanceof AST\RangeVariableDeclaration:
  1200.                 $class      = $this->em->getClassMetadata($joinDeclaration->abstractSchemaName);
  1201.                 $dqlAlias   = $joinDeclaration->aliasIdentificationVariable;
  1202.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
  1203.                 $conditions = [];
  1205.                 if ($join->conditionalExpression) {
  1206.                     $conditions[] = '(' . $this->walkConditionalExpression($join->conditionalExpression) . ')';
  1207.                 }
  1209.                 $isUnconditionalJoin = $conditions === [];
  1210.                 $condExprConjunction = $class->isInheritanceTypeJoined() && $joinType !== AST\Join::JOIN_TYPE_LEFT && $joinType !== AST\Join::JOIN_TYPE_LEFTOUTER && $isUnconditionalJoin
  1211.                     ? ' AND '
  1212.                     : ' ON ';
  1214.                 $sql .= $this->generateRangeVariableDeclarationSQL($joinDeclaration, ! $isUnconditionalJoin);
  1216.                 // Apply remaining inheritance restrictions
  1217.                 $discrSql = $this->generateDiscriminatorColumnConditionSQL([$dqlAlias]);
  1219.                 if ($discrSql) {
  1220.                     $conditions[] = $discrSql;
  1221.                 }
  1223.                 // Apply the filters
  1224.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
  1226.                 if ($filterExpr) {
  1227.                     $conditions[] = $filterExpr;
  1228.                 }
  1230.                 if ($conditions) {
  1231.                     $sql .= $condExprConjunction . implode(' AND ', $conditions);
  1232.                 }
  1234.                 break;
  1236.             case $joinDeclaration instanceof AST\JoinAssociationDeclaration:
  1237.                 $sql .= $this->walkJoinAssociationDeclaration($joinDeclaration, $joinType, $join->conditionalExpression);
  1238.                 break;
  1239.         }
  1241.         return $sql;
  1242.     }
  1244.     /**
  1245.      * Walks down a CoalesceExpression AST node and generates the corresponding SQL.
  1246.      *
  1247.      * @param AST\CoalesceExpression $coalesceExpression
  1248.      *
  1249.      * @return string The SQL.
  1250.      */
  1251.     public function walkCoalesceExpression($coalesceExpression)
  1252.     {
  1253.         $sql = 'COALESCE(';
  1255.         $scalarExpressions = [];
  1257.         foreach ($coalesceExpression->scalarExpressions as $scalarExpression) {
  1258.             $scalarExpressions[] = $this->walkSimpleArithmeticExpression($scalarExpression);
  1259.         }
  1261.         return $sql . implode(', ', $scalarExpressions) . ')';
  1262.     }
  1264.     /**
  1265.      * Walks down a NullIfExpression AST node and generates the corresponding SQL.
  1266.      *
  1267.      * @param AST\NullIfExpression $nullIfExpression
  1268.      *
  1269.      * @return string The SQL.
  1270.      */
  1271.     public function walkNullIfExpression($nullIfExpression)
  1272.     {
  1273.         $firstExpression = is_string($nullIfExpression->firstExpression)
  1274.             ? $this->conn->quote($nullIfExpression->firstExpression)
  1275.             : $this->walkSimpleArithmeticExpression($nullIfExpression->firstExpression);
  1277.         $secondExpression = is_string($nullIfExpression->secondExpression)
  1278.             ? $this->conn->quote($nullIfExpression->secondExpression)
  1279.             : $this->walkSimpleArithmeticExpression($nullIfExpression->secondExpression);
  1281.         return 'NULLIF(' . $firstExpression . ', ' . $secondExpression . ')';
  1282.     }
  1284.     /**
  1285.      * Walks down a GeneralCaseExpression AST node and generates the corresponding SQL.
  1286.      *
  1287.      * @return string The SQL.
  1288.      */
  1289.     public function walkGeneralCaseExpression(AST\GeneralCaseExpression $generalCaseExpression)
  1290.     {
  1291.         $sql = 'CASE';
  1293.         foreach ($generalCaseExpression->whenClauses as $whenClause) {
  1294.             $sql .= ' WHEN ' . $this->walkConditionalExpression($whenClause->caseConditionExpression);
  1295.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($whenClause->thenScalarExpression);
  1296.         }
  1298.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($generalCaseExpression->elseScalarExpression) . ' END';
  1300.         return $sql;
  1301.     }
  1303.     /**
  1304.      * Walks down a SimpleCaseExpression AST node and generates the corresponding SQL.
  1305.      *
  1306.      * @param AST\SimpleCaseExpression $simpleCaseExpression
  1307.      *
  1308.      * @return string The SQL.
  1309.      */
  1310.     public function walkSimpleCaseExpression($simpleCaseExpression)
  1311.     {
  1312.         $sql = 'CASE ' . $this->walkStateFieldPathExpression($simpleCaseExpression->caseOperand);
  1314.         foreach ($simpleCaseExpression->simpleWhenClauses as $simpleWhenClause) {
  1315.             $sql .= ' WHEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->caseScalarExpression);
  1316.             $sql .= ' THEN ' . $this->walkSimpleArithmeticExpression($simpleWhenClause->thenScalarExpression);
  1317.         }
  1319.         $sql .= ' ELSE ' . $this->walkSimpleArithmeticExpression($simpleCaseExpression->elseScalarExpression) . ' END';
  1321.         return $sql;
  1322.     }
  1324.     /**
  1325.      * {@inheritdoc}
  1326.      */
  1327.     public function walkSelectExpression($selectExpression)
  1328.     {
  1329.         $sql    = '';
  1330.         $expr   = $selectExpression->expression;
  1331.         $hidden = $selectExpression->hiddenAliasResultVariable;
  1333.         switch (true) {
  1334.             case $expr instanceof AST\PathExpression:
  1335.                 if ($expr->type !== AST\PathExpression::TYPE_STATE_FIELD) {
  1336.                     throw QueryException::invalidPathExpression($expr);
  1337.                 }
  1339.                 $fieldName = $expr->field;
  1340.                 $dqlAlias  = $expr->identificationVariable;
  1341.                 $qComp     = $this->queryComponents[$dqlAlias];
  1342.                 $class     = $qComp['metadata'];
  1344.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $fieldName;
  1345.                 $tableName   = $class->isInheritanceTypeJoined()
  1346.                     ? $this->em->getUnitOfWork()->getEntityPersister($class->name)->getOwningTable($fieldName)
  1347.                     : $class->getTableName();
  1349.                 $sqlTableAlias = $this->getSQLTableAlias($tableName, $dqlAlias);
  1350.                 $fieldMapping  = $class->fieldMappings[$fieldName];
  1351.                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  1352.                 $columnAlias   = $this->getSQLColumnAlias($fieldMapping['columnName']);
  1353.                 $col           = $sqlTableAlias . '.' . $columnName;
  1355.                 if (isset($fieldMapping['requireSQLConversion'])) {
  1356.                     $type = Type::getType($fieldMapping['type']);
  1357.                     $col  = $type->convertToPHPValueSQL($col, $this->conn->getDatabasePlatform());
  1358.                 }
  1360.                 $sql .= $col . ' AS ' . $columnAlias;
  1362.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1364.                 if (! $hidden) {
  1365.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldMapping['type']);
  1366.                     $this->scalarFields[$dqlAlias][$fieldName] = $columnAlias;
  1367.                 }
  1369.                 break;
  1371.             case $expr instanceof AST\AggregateExpression:
  1372.             case $expr instanceof AST\Functions\FunctionNode:
  1373.             case $expr instanceof AST\SimpleArithmeticExpression:
  1374.             case $expr instanceof AST\ArithmeticTerm:
  1375.             case $expr instanceof AST\ArithmeticFactor:
  1376.             case $expr instanceof AST\ParenthesisExpression:
  1377.             case $expr instanceof AST\Literal:
  1378.             case $expr instanceof AST\NullIfExpression:
  1379.             case $expr instanceof AST\CoalesceExpression:
  1380.             case $expr instanceof AST\GeneralCaseExpression:
  1381.             case $expr instanceof AST\SimpleCaseExpression:
  1382.                 $columnAlias = $this->getSQLColumnAlias('sclr');
  1383.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1385.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
  1387.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1389.                 if ($hidden) {
  1390.                     break;
  1391.                 }
  1393.                 if (! $expr instanceof Query\AST\TypedExpression) {
  1394.                     // Conceptually we could resolve field type here by traverse through AST to retrieve field type,
  1395.                     // but this is not a feasible solution; assume 'string'.
  1396.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
  1398.                     break;
  1399.                 }
  1401.                 $this->rsm->addScalarResult($columnAlias, $resultAlias, $expr->getReturnType()->getName());
  1403.                 break;
  1405.             case $expr instanceof AST\Subselect:
  1406.                 $columnAlias = $this->getSQLColumnAlias('sclr');
  1407.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1409.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
  1411.                 $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1413.                 if (! $hidden) {
  1414.                     // We cannot resolve field type here; assume 'string'.
  1415.                     $this->rsm->addScalarResult($columnAlias, $resultAlias, 'string');
  1416.                 }
  1418.                 break;
  1420.             case $expr instanceof AST\NewObjectExpression:
  1421.                 $sql .= $this->walkNewObject($expr, $selectExpression->fieldIdentificationVariable);
  1422.                 break;
  1424.             default:
  1425.                 // IdentificationVariable or PartialObjectExpression
  1426.                 if ($expr instanceof AST\PartialObjectExpression) {
  1427.                     $this->query->setHint(self::HINT_PARTIAL, true);
  1429.                     $dqlAlias        = $expr->identificationVariable;
  1430.                     $partialFieldSet = $expr->partialFieldSet;
  1431.                 } else {
  1432.                     $dqlAlias        = $expr;
  1433.                     $partialFieldSet = [];
  1434.                 }
  1436.                 $queryComp   = $this->queryComponents[$dqlAlias];
  1437.                 $class       = $queryComp['metadata'];
  1438.                 $resultAlias = $selectExpression->fieldIdentificationVariable ?: null;
  1440.                 if (! isset($this->selectedClasses[$dqlAlias])) {
  1441.                     $this->selectedClasses[$dqlAlias] = [
  1442.                         'class'       => $class,
  1443.                         'dqlAlias'    => $dqlAlias,
  1444.                         'resultAlias' => $resultAlias,
  1445.                     ];
  1446.                 }
  1448.                 $sqlParts = [];
  1450.                 // Select all fields from the queried class
  1451.                 foreach ($class->fieldMappings as $fieldName => $mapping) {
  1452.                     if ($partialFieldSet && ! in_array($fieldName, $partialFieldSet)) {
  1453.                         continue;
  1454.                     }
  1456.                     $tableName = isset($mapping['inherited'])
  1457.                         ? $this->em->getClassMetadata($mapping['inherited'])->getTableName()
  1458.                         : $class->getTableName();
  1460.                     $sqlTableAlias    = $this->getSQLTableAlias($tableName, $dqlAlias);
  1461.                     $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
  1462.                     $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $class, $this->platform);
  1464.                     $col = $sqlTableAlias . '.' . $quotedColumnName;
  1466.                     if (isset($mapping['requireSQLConversion'])) {
  1467.                         $type = Type::getType($mapping['type']);
  1468.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
  1469.                     }
  1471.                     $sqlParts[] = $col . ' AS ' . $columnAlias;
  1473.                     $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
  1475.                     $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $class->name);
  1476.                 }
  1478.                 // Add any additional fields of subclasses (excluding inherited fields)
  1479.                 // 1) on Single Table Inheritance: always, since its marginal overhead
  1480.                 // 2) on Class Table Inheritance only if partial objects are disallowed,
  1481.                 //    since it requires outer joining subtables.
  1482.                 if ($class->isInheritanceTypeSingleTable() || ! $this->query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {
  1483.                     foreach ($class->subClasses as $subClassName) {
  1484.                         $subClass      = $this->em->getClassMetadata($subClassName);
  1485.                         $sqlTableAlias = $this->getSQLTableAlias($subClass->getTableName(), $dqlAlias);
  1487.                         foreach ($subClass->fieldMappings as $fieldName => $mapping) {
  1488.                             if (isset($mapping['inherited']) || ($partialFieldSet && ! in_array($fieldName, $partialFieldSet))) {
  1489.                                 continue;
  1490.                             }
  1492.                             $columnAlias      = $this->getSQLColumnAlias($mapping['columnName']);
  1493.                             $quotedColumnName = $this->quoteStrategy->getColumnName($fieldName, $subClass, $this->platform);
  1495.                             $col = $sqlTableAlias . '.' . $quotedColumnName;
  1497.                             if (isset($mapping['requireSQLConversion'])) {
  1498.                                 $type = Type::getType($mapping['type']);
  1499.                                 $col  = $type->convertToPHPValueSQL($col, $this->platform);
  1500.                             }
  1502.                             $sqlParts[] = $col . ' AS ' . $columnAlias;
  1504.                             $this->scalarResultAliasMap[$resultAlias][] = $columnAlias;
  1506.                             $this->rsm->addFieldResult($dqlAlias, $columnAlias, $fieldName, $subClassName);
  1507.                         }
  1508.                     }
  1509.                 }
  1511.                 $sql .= implode(', ', $sqlParts);
  1512.         }
  1514.         return $sql;
  1515.     }
  1517.     /**
  1518.      * {@inheritdoc}
  1519.      */
  1520.     public function walkQuantifiedExpression($qExpr)
  1521.     {
  1522.         return ' ' . strtoupper($qExpr->type) . '(' . $this->walkSubselect($qExpr->subselect) . ')';
  1523.     }
  1525.     /**
  1526.      * {@inheritdoc}
  1527.      */
  1528.     public function walkSubselect($subselect)
  1529.     {
  1530.         $useAliasesBefore  = $this->useSqlTableAliases;
  1531.         $rootAliasesBefore = $this->rootAliases;
  1533.         $this->rootAliases        = []; // reset the rootAliases for the subselect
  1534.         $this->useSqlTableAliases = true;
  1536.         $sql  = $this->walkSimpleSelectClause($subselect->simpleSelectClause);
  1537.         $sql .= $this->walkSubselectFromClause($subselect->subselectFromClause);
  1538.         $sql .= $this->walkWhereClause($subselect->whereClause);
  1540.         $sql .= $subselect->groupByClause ? $this->walkGroupByClause($subselect->groupByClause) : '';
  1541.         $sql .= $subselect->havingClause ? $this->walkHavingClause($subselect->havingClause) : '';
  1542.         $sql .= $subselect->orderByClause ? $this->walkOrderByClause($subselect->orderByClause) : '';
  1544.         $this->rootAliases        = $rootAliasesBefore; // put the main aliases back
  1545.         $this->useSqlTableAliases = $useAliasesBefore;
  1547.         return $sql;
  1548.     }
  1550.     /**
  1551.      * {@inheritdoc}
  1552.      */
  1553.     public function walkSubselectFromClause($subselectFromClause)
  1554.     {
  1555.         $identificationVarDecls = $subselectFromClause->identificationVariableDeclarations;
  1556.         $sqlParts               = [];
  1558.         foreach ($identificationVarDecls as $subselectIdVarDecl) {
  1559.             $sqlParts[] = $this->walkIdentificationVariableDeclaration($subselectIdVarDecl);
  1560.         }
  1562.         return ' FROM ' . implode(', ', $sqlParts);
  1563.     }
  1565.     /**
  1566.      * {@inheritdoc}
  1567.      */
  1568.     public function walkSimpleSelectClause($simpleSelectClause)
  1569.     {
  1570.         return 'SELECT' . ($simpleSelectClause->isDistinct ? ' DISTINCT' : '')
  1571.             . $this->walkSimpleSelectExpression($simpleSelectClause->simpleSelectExpression);
  1572.     }
  1574.     /**
  1575.      * @return string
  1576.      */
  1577.     public function walkParenthesisExpression(AST\ParenthesisExpression $parenthesisExpression)
  1578.     {
  1579.         return sprintf('(%s)', $parenthesisExpression->expression->dispatch($this));
  1580.     }
  1582.     /**
  1583.      * @param AST\NewObjectExpression $newObjectExpression
  1584.      * @param string|null             $newObjectResultAlias
  1585.      *
  1586.      * @return string The SQL.
  1587.      */
  1588.     public function walkNewObject($newObjectExpression, $newObjectResultAlias = null)
  1589.     {
  1590.         $sqlSelectExpressions = [];
  1591.         $objIndex             = $newObjectResultAlias ?: $this->newObjectCounter++;
  1593.         foreach ($newObjectExpression->args as $argIndex => $e) {
  1594.             $resultAlias = $this->scalarResultCounter++;
  1595.             $columnAlias = $this->getSQLColumnAlias('sclr');
  1596.             $fieldType   = 'string';
  1598.             switch (true) {
  1599.                 case $e instanceof AST\NewObjectExpression:
  1600.                     $sqlSelectExpressions[] = $e->dispatch($this);
  1601.                     break;
  1603.                 case $e instanceof AST\Subselect:
  1604.                     $sqlSelectExpressions[] = '(' . $e->dispatch($this) . ') AS ' . $columnAlias;
  1605.                     break;
  1607.                 case $e instanceof AST\PathExpression:
  1608.                     $dqlAlias     = $e->identificationVariable;
  1609.                     $qComp        = $this->queryComponents[$dqlAlias];
  1610.                     $class        = $qComp['metadata'];
  1611.                     $fieldType    = $class->fieldMappings[$e->field]['type'];
  1612.                     $fieldName    = $e->field;
  1613.                     $fieldMapping = $class->fieldMappings[$fieldName];
  1614.                     $col          = trim($e->dispatch($this));
  1616.                     if (isset($fieldMapping['requireSQLConversion'])) {
  1617.                         $type = Type::getType($fieldType);
  1618.                         $col  = $type->convertToPHPValueSQL($col, $this->platform);
  1619.                     }
  1621.                     $sqlSelectExpressions[] = $col . ' AS ' . $columnAlias;
  1622.                     break;
  1624.                 case $e instanceof AST\Literal:
  1625.                     switch ($e->type) {
  1626.                         case AST\Literal::BOOLEAN:
  1627.                             $fieldType = 'boolean';
  1628.                             break;
  1630.                         case AST\Literal::NUMERIC:
  1631.                             $fieldType = is_float($e->value) ? 'float' : 'integer';
  1632.                             break;
  1633.                     }
  1635.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
  1636.                     break;
  1638.                 default:
  1639.                     $sqlSelectExpressions[] = trim($e->dispatch($this)) . ' AS ' . $columnAlias;
  1640.                     break;
  1641.             }
  1643.             $this->scalarResultAliasMap[$resultAlias] = $columnAlias;
  1644.             $this->rsm->addScalarResult($columnAlias, $resultAlias, $fieldType);
  1646.             $this->rsm->newObjectMappings[$columnAlias] = [
  1647.                 'className' => $newObjectExpression->className,
  1648.                 'objIndex'  => $objIndex,
  1649.                 'argIndex'  => $argIndex,
  1650.             ];
  1651.         }
  1653.         return implode(', ', $sqlSelectExpressions);
  1654.     }
  1656.     /**
  1657.      * {@inheritdoc}
  1658.      */
  1659.     public function walkSimpleSelectExpression($simpleSelectExpression)
  1660.     {
  1661.         $expr = $simpleSelectExpression->expression;
  1662.         $sql  = ' ';
  1664.         switch (true) {
  1665.             case $expr instanceof AST\PathExpression:
  1666.                 $sql .= $this->walkPathExpression($expr);
  1667.                 break;
  1669.             case $expr instanceof AST\Subselect:
  1670.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1672.                 $columnAlias                        = 'sclr' . $this->aliasCounter++;
  1673.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
  1675.                 $sql .= '(' . $this->walkSubselect($expr) . ') AS ' . $columnAlias;
  1676.                 break;
  1678.             case $expr instanceof AST\Functions\FunctionNode:
  1679.             case $expr instanceof AST\SimpleArithmeticExpression:
  1680.             case $expr instanceof AST\ArithmeticTerm:
  1681.             case $expr instanceof AST\ArithmeticFactor:
  1682.             case $expr instanceof AST\Literal:
  1683.             case $expr instanceof AST\NullIfExpression:
  1684.             case $expr instanceof AST\CoalesceExpression:
  1685.             case $expr instanceof AST\GeneralCaseExpression:
  1686.             case $expr instanceof AST\SimpleCaseExpression:
  1687.                 $alias = $simpleSelectExpression->fieldIdentificationVariable ?: $this->scalarResultCounter++;
  1689.                 $columnAlias                        = $this->getSQLColumnAlias('sclr');
  1690.                 $this->scalarResultAliasMap[$alias] = $columnAlias;
  1692.                 $sql .= $expr->dispatch($this) . ' AS ' . $columnAlias;
  1693.                 break;
  1695.             case $expr instanceof AST\ParenthesisExpression:
  1696.                 $sql .= $this->walkParenthesisExpression($expr);
  1697.                 break;
  1699.             default: // IdentificationVariable
  1700.                 $sql .= $this->walkEntityIdentificationVariable($expr);
  1701.                 break;
  1702.         }
  1704.         return $sql;
  1705.     }
  1707.     /**
  1708.      * {@inheritdoc}
  1709.      */
  1710.     public function walkAggregateExpression($aggExpression)
  1711.     {
  1712.         return $aggExpression->functionName . '(' . ($aggExpression->isDistinct ? 'DISTINCT ' : '')
  1713.             . $this->walkSimpleArithmeticExpression($aggExpression->pathExpression) . ')';
  1714.     }
  1716.     /**
  1717.      * {@inheritdoc}
  1718.      */
  1719.     public function walkGroupByClause($groupByClause)
  1720.     {
  1721.         $sqlParts = [];
  1723.         foreach ($groupByClause->groupByItems as $groupByItem) {
  1724.             $sqlParts[] = $this->walkGroupByItem($groupByItem);
  1725.         }
  1727.         return ' GROUP BY ' . implode(', ', $sqlParts);
  1728.     }
  1730.     /**
  1731.      * {@inheritdoc}
  1732.      */
  1733.     public function walkGroupByItem($groupByItem)
  1734.     {
  1735.         // StateFieldPathExpression
  1736.         if (! is_string($groupByItem)) {
  1737.             return $this->walkPathExpression($groupByItem);
  1738.         }
  1740.         // ResultVariable
  1741.         if (isset($this->queryComponents[$groupByItem]['resultVariable'])) {
  1742.             $resultVariable = $this->queryComponents[$groupByItem]['resultVariable'];
  1744.             if ($resultVariable instanceof AST\PathExpression) {
  1745.                 return $this->walkPathExpression($resultVariable);
  1746.             }
  1748.             if (isset($resultVariable->pathExpression)) {
  1749.                 return $this->walkPathExpression($resultVariable->pathExpression);
  1750.             }
  1752.             return $this->walkResultVariable($groupByItem);
  1753.         }
  1755.         // IdentificationVariable
  1756.         $sqlParts = [];
  1758.         foreach ($this->queryComponents[$groupByItem]['metadata']->fieldNames as $field) {
  1759.             $item       = new AST\PathExpression(AST\PathExpression::TYPE_STATE_FIELD, $groupByItem, $field);
  1760.             $item->type = AST\PathExpression::TYPE_STATE_FIELD;
  1762.             $sqlParts[] = $this->walkPathExpression($item);
  1763.         }
  1765.         foreach ($this->queryComponents[$groupByItem]['metadata']->associationMappings as $mapping) {
  1766.             if ($mapping['isOwningSide'] && $mapping['type'] & ClassMetadataInfo::TO_ONE) {
  1767.                 $item       = new AST\PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION, $groupByItem, $mapping['fieldName']);
  1768.                 $item->type = AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION;
  1770.                 $sqlParts[] = $this->walkPathExpression($item);
  1771.             }
  1772.         }
  1774.         return implode(', ', $sqlParts);
  1775.     }
  1777.     /**
  1778.      * {@inheritdoc}
  1779.      */
  1780.     public function walkDeleteClause(AST\DeleteClause $deleteClause)
  1781.     {
  1782.         $class     = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1783.         $tableName = $class->getTableName();
  1784.         $sql       = 'DELETE FROM ' . $this->quoteStrategy->getTableName($class, $this->platform);
  1786.         $this->setSQLTableAlias($tableName, $tableName, $deleteClause->aliasIdentificationVariable);
  1787.         $this->rootAliases[] = $deleteClause->aliasIdentificationVariable;
  1789.         return $sql;
  1790.     }
  1792.     /**
  1793.      * {@inheritdoc}
  1794.      */
  1795.     public function walkUpdateClause($updateClause)
  1796.     {
  1797.         $class     = $this->em->getClassMetadata($updateClause->abstractSchemaName);
  1798.         $tableName = $class->getTableName();
  1799.         $sql       = 'UPDATE ' . $this->quoteStrategy->getTableName($class, $this->platform);
  1801.         $this->setSQLTableAlias($tableName, $tableName, $updateClause->aliasIdentificationVariable);
  1802.         $this->rootAliases[] = $updateClause->aliasIdentificationVariable;
  1804.         return $sql . ' SET ' . implode(', ', array_map([$this, 'walkUpdateItem'], $updateClause->updateItems));
  1805.     }
  1807.     /**
  1808.      * {@inheritdoc}
  1809.      */
  1810.     public function walkUpdateItem($updateItem)
  1811.     {
  1812.         $useTableAliasesBefore    = $this->useSqlTableAliases;
  1813.         $this->useSqlTableAliases = false;
  1815.         $sql      = $this->walkPathExpression($updateItem->pathExpression) . ' = ';
  1816.         $newValue = $updateItem->newValue;
  1818.         switch (true) {
  1819.             case $newValue instanceof AST\Node:
  1820.                 $sql .= $newValue->dispatch($this);
  1821.                 break;
  1823.             case $newValue === null:
  1824.                 $sql .= 'NULL';
  1825.                 break;
  1827.             default:
  1828.                 $sql .= $this->conn->quote($newValue);
  1829.                 break;
  1830.         }
  1832.         $this->useSqlTableAliases = $useTableAliasesBefore;
  1834.         return $sql;
  1835.     }
  1837.     /**
  1838.      * {@inheritdoc}
  1839.      */
  1840.     public function walkWhereClause($whereClause)
  1841.     {
  1842.         $condSql  = $whereClause !== null ? $this->walkConditionalExpression($whereClause->conditionalExpression) : '';
  1843.         $discrSql = $this->generateDiscriminatorColumnConditionSQL($this->rootAliases);
  1845.         if ($this->em->hasFilters()) {
  1846.             $filterClauses = [];
  1847.             foreach ($this->rootAliases as $dqlAlias) {
  1848.                 $class      = $this->queryComponents[$dqlAlias]['metadata'];
  1849.                 $tableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);
  1851.                 $filterExpr = $this->generateFilterConditionSQL($class, $tableAlias);
  1852.                 if ($filterExpr) {
  1853.                     $filterClauses[] = $filterExpr;
  1854.                 }
  1855.             }
  1857.             if (count($filterClauses)) {
  1858.                 if ($condSql) {
  1859.                     $condSql = '(' . $condSql . ') AND ';
  1860.                 }
  1862.                 $condSql .= implode(' AND ', $filterClauses);
  1863.             }
  1864.         }
  1866.         if ($condSql) {
  1867.             return ' WHERE ' . (! $discrSql ? $condSql : '(' . $condSql . ') AND ' . $discrSql);
  1868.         }
  1870.         if ($discrSql) {
  1871.             return ' WHERE ' . $discrSql;
  1872.         }
  1874.         return '';
  1875.     }
  1877.     /**
  1878.      * {@inheritdoc}
  1879.      */
  1880.     public function walkConditionalExpression($condExpr)
  1881.     {
  1882.         // Phase 2 AST optimization: Skip processing of ConditionalExpression
  1883.         // if only one ConditionalTerm is defined
  1884.         if (! ($condExpr instanceof AST\ConditionalExpression)) {
  1885.             return $this->walkConditionalTerm($condExpr);
  1886.         }
  1888.         return implode(' OR ', array_map([$this, 'walkConditionalTerm'], $condExpr->conditionalTerms));
  1889.     }
  1891.     /**
  1892.      * {@inheritdoc}
  1893.      */
  1894.     public function walkConditionalTerm($condTerm)
  1895.     {
  1896.         // Phase 2 AST optimization: Skip processing of ConditionalTerm
  1897.         // if only one ConditionalFactor is defined
  1898.         if (! ($condTerm instanceof AST\ConditionalTerm)) {
  1899.             return $this->walkConditionalFactor($condTerm);
  1900.         }
  1902.         return implode(' AND ', array_map([$this, 'walkConditionalFactor'], $condTerm->conditionalFactors));
  1903.     }
  1905.     /**
  1906.      * {@inheritdoc}
  1907.      */
  1908.     public function walkConditionalFactor($factor)
  1909.     {
  1910.         // Phase 2 AST optimization: Skip processing of ConditionalFactor
  1911.         // if only one ConditionalPrimary is defined
  1912.         return ! ($factor instanceof AST\ConditionalFactor)
  1913.             ? $this->walkConditionalPrimary($factor)
  1914.             : ($factor->not ? 'NOT ' : '') . $this->walkConditionalPrimary($factor->conditionalPrimary);
  1915.     }
  1917.     /**
  1918.      * {@inheritdoc}
  1919.      */
  1920.     public function walkConditionalPrimary($primary)
  1921.     {
  1922.         if ($primary->isSimpleConditionalExpression()) {
  1923.             return $primary->simpleConditionalExpression->dispatch($this);
  1924.         }
  1926.         if ($primary->isConditionalExpression()) {
  1927.             $condExpr = $primary->conditionalExpression;
  1929.             return '(' . $this->walkConditionalExpression($condExpr) . ')';
  1930.         }
  1931.     }
  1933.     /**
  1934.      * {@inheritdoc}
  1935.      */
  1936.     public function walkExistsExpression($existsExpr)
  1937.     {
  1938.         $sql = $existsExpr->not ? 'NOT ' : '';
  1940.         $sql .= 'EXISTS (' . $this->walkSubselect($existsExpr->subselect) . ')';
  1942.         return $sql;
  1943.     }
  1945.     /**
  1946.      * {@inheritdoc}
  1947.      */
  1948.     public function walkCollectionMemberExpression($collMemberExpr)
  1949.     {
  1950.         $sql  = $collMemberExpr->not ? 'NOT ' : '';
  1951.         $sql .= 'EXISTS (SELECT 1 FROM ';
  1953.         $entityExpr   = $collMemberExpr->entityExpression;
  1954.         $collPathExpr = $collMemberExpr->collectionValuedPathExpression;
  1956.         $fieldName = $collPathExpr->field;
  1957.         $dqlAlias  = $collPathExpr->identificationVariable;
  1959.         $class = $this->queryComponents[$dqlAlias]['metadata'];
  1961.         switch (true) {
  1962.             // InputParameter
  1963.             case $entityExpr instanceof AST\InputParameter:
  1964.                 $dqlParamKey = $entityExpr->name;
  1965.                 $entitySql   = '?';
  1966.                 break;
  1968.             // SingleValuedAssociationPathExpression | IdentificationVariable
  1969.             case $entityExpr instanceof AST\PathExpression:
  1970.                 $entitySql = $this->walkPathExpression($entityExpr);
  1971.                 break;
  1973.             default:
  1974.                 throw new BadMethodCallException('Not implemented');
  1975.         }
  1977.         $assoc = $class->associationMappings[$fieldName];
  1979.         if ($assoc['type'] === ClassMetadata::ONE_TO_MANY) {
  1980.             $targetClass      = $this->em->getClassMetadata($assoc['targetEntity']);
  1981.             $targetTableAlias = $this->getSQLTableAlias($targetClass->getTableName());
  1982.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  1984.             $sql .= $this->quoteStrategy->getTableName($targetClass, $this->platform) . ' ' . $targetTableAlias . ' WHERE ';
  1986.             $owningAssoc = $targetClass->associationMappings[$assoc['mappedBy']];
  1987.             $sqlParts    = [];
  1989.             foreach ($owningAssoc['targetToSourceKeyColumns'] as $targetColumn => $sourceColumn) {
  1990.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$targetColumn], $class, $this->platform);
  1992.                 $sqlParts[] = $sourceTableAlias . '.' . $targetColumn . ' = ' . $targetTableAlias . '.' . $sourceColumn;
  1993.             }
  1995.             foreach ($this->quoteStrategy->getIdentifierColumnNames($targetClass, $this->platform) as $targetColumnName) {
  1996.                 if (isset($dqlParamKey)) {
  1997.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
  1998.                 }
  2000.                 $sqlParts[] = $targetTableAlias . '.' . $targetColumnName . ' = ' . $entitySql;
  2001.             }
  2003.             $sql .= implode(' AND ', $sqlParts);
  2004.         } else { // many-to-many
  2005.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  2007.             $owningAssoc = $assoc['isOwningSide'] ? $assoc : $targetClass->associationMappings[$assoc['mappedBy']];
  2008.             $joinTable   = $owningAssoc['joinTable'];
  2010.             // SQL table aliases
  2011.             $joinTableAlias   = $this->getSQLTableAlias($joinTable['name']);
  2012.             $sourceTableAlias = $this->getSQLTableAlias($class->getTableName(), $dqlAlias);
  2014.             $sql .= $this->quoteStrategy->getJoinTableName($owningAssoc, $targetClass, $this->platform) . ' ' . $joinTableAlias . ' WHERE ';
  2016.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['joinColumns'] : $joinTable['inverseJoinColumns'];
  2017.             $sqlParts    = [];
  2019.             foreach ($joinColumns as $joinColumn) {
  2020.                 $targetColumn = $this->quoteStrategy->getColumnName($class->fieldNames[$joinColumn['referencedColumnName']], $class, $this->platform);
  2022.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' = ' . $sourceTableAlias . '.' . $targetColumn;
  2023.             }
  2025.             $joinColumns = $assoc['isOwningSide'] ? $joinTable['inverseJoinColumns'] : $joinTable['joinColumns'];
  2027.             foreach ($joinColumns as $joinColumn) {
  2028.                 if (isset($dqlParamKey)) {
  2029.                     $this->parserResult->addParameterMapping($dqlParamKey, $this->sqlParamIndex++);
  2030.                 }
  2032.                 $sqlParts[] = $joinTableAlias . '.' . $joinColumn['name'] . ' IN (' . $entitySql . ')';
  2033.             }
  2035.             $sql .= implode(' AND ', $sqlParts);
  2036.         }
  2038.         return $sql . ')';
  2039.     }
  2041.     /**
  2042.      * {@inheritdoc}
  2043.      */
  2044.     public function walkEmptyCollectionComparisonExpression($emptyCollCompExpr)
  2045.     {
  2046.         $sizeFunc                           = new AST\Functions\SizeFunction('size');
  2047.         $sizeFunc->collectionPathExpression = $emptyCollCompExpr->expression;
  2049.         return $sizeFunc->getSql($this) . ($emptyCollCompExpr->not ? ' > 0' : ' = 0');
  2050.     }
  2052.     /**
  2053.      * {@inheritdoc}
  2054.      */
  2055.     public function walkNullComparisonExpression($nullCompExpr)
  2056.     {
  2057.         $expression = $nullCompExpr->expression;
  2058.         $comparison = ' IS' . ($nullCompExpr->not ? ' NOT' : '') . ' NULL';
  2060.         // Handle ResultVariable
  2061.         if (is_string($expression) && isset($this->queryComponents[$expression]['resultVariable'])) {
  2062.             return $this->walkResultVariable($expression) . $comparison;
  2063.         }
  2065.         // Handle InputParameter mapping inclusion to ParserResult
  2066.         if ($expression instanceof AST\InputParameter) {
  2067.             return $this->walkInputParameter($expression) . $comparison;
  2068.         }
  2070.         return $expression->dispatch($this) . $comparison;
  2071.     }
  2073.     /**
  2074.      * {@inheritdoc}
  2075.      */
  2076.     public function walkInExpression($inExpr)
  2077.     {
  2078.         $sql = $this->walkArithmeticExpression($inExpr->expression) . ($inExpr->not ? ' NOT' : '') . ' IN (';
  2080.         $sql .= $inExpr->subselect
  2081.             ? $this->walkSubselect($inExpr->subselect)
  2082.             : implode(', ', array_map([$this, 'walkInParameter'], $inExpr->literals));
  2084.         $sql .= ')';
  2086.         return $sql;
  2087.     }
  2089.     /**
  2090.      * {@inheritdoc}
  2091.      *
  2092.      * @throws QueryException
  2093.      */
  2094.     public function walkInstanceOfExpression($instanceOfExpr)
  2095.     {
  2096.         $sql = '';
  2098.         $dqlAlias   = $instanceOfExpr->identificationVariable;
  2099.         $discrClass = $class = $this->queryComponents[$dqlAlias]['metadata'];
  2101.         if ($class->discriminatorColumn) {
  2102.             $discrClass = $this->em->getClassMetadata($class->rootEntityName);
  2103.         }
  2105.         if ($this->useSqlTableAliases) {
  2106.             $sql .= $this->getSQLTableAlias($discrClass->getTableName(), $dqlAlias) . '.';
  2107.         }
  2109.         $sql .= $class->discriminatorColumn['name'] . ($instanceOfExpr->not ? ' NOT IN ' : ' IN ');
  2110.         $sql .= $this->getChildDiscriminatorsFromClassMetadata($discrClass, $instanceOfExpr);
  2112.         return $sql;
  2113.     }
  2115.     /**
  2116.      * @param mixed $inParam
  2117.      *
  2118.      * @return string
  2119.      */
  2120.     public function walkInParameter($inParam)
  2121.     {
  2122.         return $inParam instanceof AST\InputParameter
  2123.             ? $this->walkInputParameter($inParam)
  2124.             : $this->walkLiteral($inParam);
  2125.     }
  2127.     /**
  2128.      * {@inheritdoc}
  2129.      */
  2130.     public function walkLiteral($literal)
  2131.     {
  2132.         switch ($literal->type) {
  2133.             case AST\Literal::STRING:
  2134.                 return $this->conn->quote($literal->value);
  2136.             case AST\Literal::BOOLEAN:
  2137.                 return $this->conn->getDatabasePlatform()->convertBooleans(strtolower($literal->value) === 'true');
  2139.             case AST\Literal::NUMERIC:
  2140.                 return $literal->value;
  2142.             default:
  2143.                 throw QueryException::invalidLiteral($literal);
  2144.         }
  2145.     }
  2147.     /**
  2148.      * {@inheritdoc}
  2149.      */
  2150.     public function walkBetweenExpression($betweenExpr)
  2151.     {
  2152.         $sql = $this->walkArithmeticExpression($betweenExpr->expression);
  2154.         if ($betweenExpr->not) {
  2155.             $sql .= ' NOT';
  2156.         }
  2158.         $sql .= ' BETWEEN ' . $this->walkArithmeticExpression($betweenExpr->leftBetweenExpression)
  2159.             . ' AND ' . $this->walkArithmeticExpression($betweenExpr->rightBetweenExpression);
  2161.         return $sql;
  2162.     }
  2164.     /**
  2165.      * {@inheritdoc}
  2166.      */
  2167.     public function walkLikeExpression($likeExpr)
  2168.     {
  2169.         $stringExpr = $likeExpr->stringExpression;
  2170.         $leftExpr   = is_string($stringExpr) && isset($this->queryComponents[$stringExpr]['resultVariable'])
  2171.             ? $this->walkResultVariable($stringExpr)
  2172.             : $stringExpr->dispatch($this);
  2174.         $sql = $leftExpr . ($likeExpr->not ? ' NOT' : '') . ' LIKE ';
  2176.         if ($likeExpr->stringPattern instanceof AST\InputParameter) {
  2177.             $sql .= $this->walkInputParameter($likeExpr->stringPattern);
  2178.         } elseif ($likeExpr->stringPattern instanceof AST\Functions\FunctionNode) {
  2179.             $sql .= $this->walkFunction($likeExpr->stringPattern);
  2180.         } elseif ($likeExpr->stringPattern instanceof AST\PathExpression) {
  2181.             $sql .= $this->walkPathExpression($likeExpr->stringPattern);
  2182.         } else {
  2183.             $sql .= $this->walkLiteral($likeExpr->stringPattern);
  2184.         }
  2186.         if ($likeExpr->escapeChar) {
  2187.             $sql .= ' ESCAPE ' . $this->walkLiteral($likeExpr->escapeChar);
  2188.         }
  2190.         return $sql;
  2191.     }
  2193.     /**
  2194.      * {@inheritdoc}
  2195.      */
  2196.     public function walkStateFieldPathExpression($stateFieldPathExpression)
  2197.     {
  2198.         return $this->walkPathExpression($stateFieldPathExpression);
  2199.     }
  2201.     /**
  2202.      * {@inheritdoc}
  2203.      */
  2204.     public function walkComparisonExpression($compExpr)
  2205.     {
  2206.         $leftExpr  = $compExpr->leftExpression;
  2207.         $rightExpr = $compExpr->rightExpression;
  2208.         $sql       = '';
  2210.         $sql .= $leftExpr instanceof AST\Node
  2211.             ? $leftExpr->dispatch($this)
  2212.             : (is_numeric($leftExpr) ? $leftExpr : $this->conn->quote($leftExpr));
  2214.         $sql .= ' ' . $compExpr->operator . ' ';
  2216.         $sql .= $rightExpr instanceof AST\Node
  2217.             ? $rightExpr->dispatch($this)
  2218.             : (is_numeric($rightExpr) ? $rightExpr : $this->conn->quote($rightExpr));
  2220.         return $sql;
  2221.     }
  2223.     /**
  2224.      * {@inheritdoc}
  2225.      */
  2226.     public function walkInputParameter($inputParam)
  2227.     {
  2228.         $this->parserResult->addParameterMapping($inputParam->name, $this->sqlParamIndex++);
  2230.         $parameter = $this->query->getParameter($inputParam->name);
  2232.         if ($parameter) {
  2233.             $type = $parameter->getType();
  2234.             if (Type::hasType($type)) {
  2235.                 return Type::getType($type)->convertToDatabaseValueSQL('?', $this->platform);
  2236.             }
  2237.         }
  2239.         return '?';
  2240.     }
  2242.     /**
  2243.      * {@inheritdoc}
  2244.      */
  2245.     public function walkArithmeticExpression($arithmeticExpr)
  2246.     {
  2247.         return $arithmeticExpr->isSimpleArithmeticExpression()
  2248.             ? $this->walkSimpleArithmeticExpression($arithmeticExpr->simpleArithmeticExpression)
  2249.             : '(' . $this->walkSubselect($arithmeticExpr->subselect) . ')';
  2250.     }
  2252.     /**
  2253.      * {@inheritdoc}
  2254.      */
  2255.     public function walkSimpleArithmeticExpression($simpleArithmeticExpr)
  2256.     {
  2257.         if (! ($simpleArithmeticExpr instanceof AST\SimpleArithmeticExpression)) {
  2258.             return $this->walkArithmeticTerm($simpleArithmeticExpr);
  2259.         }
  2261.         return implode(' ', array_map([$this, 'walkArithmeticTerm'], $simpleArithmeticExpr->arithmeticTerms));
  2262.     }
  2264.     /**
  2265.      * {@inheritdoc}
  2266.      */
  2267.     public function walkArithmeticTerm($term)
  2268.     {
  2269.         if (is_string($term)) {
  2270.             return isset($this->queryComponents[$term])
  2271.                 ? $this->walkResultVariable($this->queryComponents[$term]['token']['value'])
  2272.                 : $term;
  2273.         }
  2275.         // Phase 2 AST optimization: Skip processing of ArithmeticTerm
  2276.         // if only one ArithmeticFactor is defined
  2277.         if (! ($term instanceof AST\ArithmeticTerm)) {
  2278.             return $this->walkArithmeticFactor($term);
  2279.         }
  2281.         return implode(' ', array_map([$this, 'walkArithmeticFactor'], $term->arithmeticFactors));
  2282.     }
  2284.     /**
  2285.      * {@inheritdoc}
  2286.      */
  2287.     public function walkArithmeticFactor($factor)
  2288.     {
  2289.         if (is_string($factor)) {
  2290.             return isset($this->queryComponents[$factor])
  2291.                 ? $this->walkResultVariable($this->queryComponents[$factor]['token']['value'])
  2292.                 : $factor;
  2293.         }
  2295.         // Phase 2 AST optimization: Skip processing of ArithmeticFactor
  2296.         // if only one ArithmeticPrimary is defined
  2297.         if (! ($factor instanceof AST\ArithmeticFactor)) {
  2298.             return $this->walkArithmeticPrimary($factor);
  2299.         }
  2301.         $sign = $factor->isNegativeSigned() ? '-' : ($factor->isPositiveSigned() ? '+' : '');
  2303.         return $sign . $this->walkArithmeticPrimary($factor->arithmeticPrimary);
  2304.     }
  2306.     /**
  2307.      * Walks down an ArithmeticPrimary that represents an AST node, thereby generating the appropriate SQL.
  2308.      *
  2309.      * @param mixed $primary
  2310.      *
  2311.      * @return string The SQL.
  2312.      */
  2313.     public function walkArithmeticPrimary($primary)
  2314.     {
  2315.         if ($primary instanceof AST\SimpleArithmeticExpression) {
  2316.             return '(' . $this->walkSimpleArithmeticExpression($primary) . ')';
  2317.         }
  2319.         if ($primary instanceof AST\Node) {
  2320.             return $primary->dispatch($this);
  2321.         }
  2323.         return $this->walkEntityIdentificationVariable($primary);
  2324.     }
  2326.     /**
  2327.      * {@inheritdoc}
  2328.      */
  2329.     public function walkStringPrimary($stringPrimary)
  2330.     {
  2331.         return is_string($stringPrimary)
  2332.             ? $this->conn->quote($stringPrimary)
  2333.             : $stringPrimary->dispatch($this);
  2334.     }
  2336.     /**
  2337.      * {@inheritdoc}
  2338.      */
  2339.     public function walkResultVariable($resultVariable)
  2340.     {
  2341.         $resultAlias = $this->scalarResultAliasMap[$resultVariable];
  2343.         if (is_array($resultAlias)) {
  2344.             return implode(', ', $resultAlias);
  2345.         }
  2347.         return $resultAlias;
  2348.     }
  2350.     /**
  2351.      * @return string The list in parentheses of valid child discriminators from the given class
  2352.      *
  2353.      * @throws QueryException
  2354.      */
  2355.     private function getChildDiscriminatorsFromClassMetadata(
  2356.         ClassMetadataInfo $rootClass,
  2357.         AST\InstanceOfExpression $instanceOfExpr
  2358.     ): string {
  2359.         $sqlParameterList = [];
  2360.         $discriminators   = [];
  2361.         foreach ($instanceOfExpr->value as $parameter) {
  2362.             if ($parameter instanceof AST\InputParameter) {
  2363.                 $this->rsm->discriminatorParameters[$parameter->name] = $parameter->name;
  2364.                 $sqlParameterList[]                                   = $this->walkInParameter($parameter);
  2365.                 continue;
  2366.             }
  2368.             $metadata = $this->em->getClassMetadata($parameter);
  2370.             if ($metadata->getName() !== $rootClass->name && ! $metadata->getReflectionClass()->isSubclassOf($rootClass->name)) {
  2371.                 throw QueryException::instanceOfUnrelatedClass($parameter, $rootClass->name);
  2372.             }
  2374.             $discriminators += HierarchyDiscriminatorResolver::resolveDiscriminatorsForClass($metadata, $this->em);
  2375.         }
  2377.         foreach (array_keys($discriminators) as $dis) {
  2378.             $sqlParameterList[] = $this->conn->quote($dis);
  2379.         }
  2381.         return '(' . implode(', ', $sqlParameterList) . ')';
  2382.     }
  2383. }