vendor/doctrine/orm/lib/Doctrine/ORM/Persisters/Entity/JoinedSubclassPersister.php line 326

Open in your IDE?
  1. <?php
  2. /*
  3.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  4.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  5.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  6.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  7.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  8.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  9.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  *
  15.  * This software consists of voluntary contributions made by many individuals
  16.  * and is licensed under the MIT license. For more information, see
  17.  * <http://www.doctrine-project.org>.
  18.  */
  20. namespace Doctrine\ORM\Persisters\Entity;
  22. use Doctrine\ORM\Mapping\ClassMetadata;
  24. use Doctrine\DBAL\LockMode;
  25. use Doctrine\DBAL\Types\Type;
  27. use Doctrine\Common\Collections\Criteria;
  28. use Doctrine\ORM\Utility\PersisterHelper;
  30. use function array_combine;
  32. /**
  33.  * The joined subclass persister maps a single entity instance to several tables in the
  34.  * database as it is defined by the <tt>Class Table Inheritance</tt> strategy.
  35.  *
  36.  * @author Roman Borschel <roman@code-factory.org>
  37.  * @author Benjamin Eberlei <kontakt@beberlei.de>
  38.  * @author Alexander <iam.asm89@gmail.com>
  39.  * @since 2.0
  40.  * @see http://martinfowler.com/eaaCatalog/classTableInheritance.html
  41.  */
  42. class JoinedSubclassPersister extends AbstractEntityInheritancePersister
  43. {
  44.     /**
  45.      * Map that maps column names to the table names that own them.
  46.      * This is mainly a temporary cache, used during a single request.
  47.      *
  48.      * @var array
  49.      */
  50.     private $owningTableMap = [];
  52.     /**
  53.      * Map of table to quoted table names.
  54.      *
  55.      * @var array
  56.      */
  57.     private $quotedTableMap = [];
  59.     /**
  60.      * {@inheritdoc}
  61.      */
  62.     protected function getDiscriminatorColumnTableName()
  63.     {
  64.         $class = ($this->class->name !== $this->class->rootEntityName)
  65.             ? $this->em->getClassMetadata($this->class->rootEntityName)
  66.             : $this->class;
  68.         return $class->getTableName();
  69.     }
  71.     /**
  72.      * This function finds the ClassMetadata instance in an inheritance hierarchy
  73.      * that is responsible for enabling versioning.
  74.      *
  75.      * @return \Doctrine\ORM\Mapping\ClassMetadata
  76.      */
  77.     private function getVersionedClassMetadata()
  78.     {
  79.         if (isset($this->class->fieldMappings[$this->class->versionField]['inherited'])) {
  80.             $definingClassName = $this->class->fieldMappings[$this->class->versionField]['inherited'];
  82.             return $this->em->getClassMetadata($definingClassName);
  83.         }
  85.         return $this->class;
  86.     }
  88.     /**
  89.      * Gets the name of the table that owns the column the given field is mapped to.
  90.      *
  91.      * @param string $fieldName
  92.      *
  93.      * @return string
  94.      *
  95.      * @override
  96.      */
  97.     public function getOwningTable($fieldName)
  98.     {
  99.         if (isset($this->owningTableMap[$fieldName])) {
  100.             return $this->owningTableMap[$fieldName];
  101.         }
  103.         switch (true) {
  104.             case isset($this->class->associationMappings[$fieldName]['inherited']):
  105.                 $cm = $this->em->getClassMetadata($this->class->associationMappings[$fieldName]['inherited']);
  106.                 break;
  108.             case isset($this->class->fieldMappings[$fieldName]['inherited']):
  109.                 $cm = $this->em->getClassMetadata($this->class->fieldMappings[$fieldName]['inherited']);
  110.                 break;
  112.             default:
  113.                 $cm = $this->class;
  114.                 break;
  115.         }
  117.         $tableName          = $cm->getTableName();
  118.         $quotedTableName    = $this->quoteStrategy->getTableName($cm, $this->platform);
  120.         $this->owningTableMap[$fieldName] = $tableName;
  121.         $this->quotedTableMap[$tableName] = $quotedTableName;
  123.         return $tableName;
  124.     }
  126.     /**
  127.      * {@inheritdoc}
  128.      */
  129.     public function executeInserts()
  130.     {
  131.         if ( ! $this->queuedInserts) {
  132.             return [];
  133.         }
  135.         $postInsertIds  = [];
  136.         $idGenerator    = $this->class->idGenerator;
  137.         $isPostInsertId = $idGenerator->isPostInsertGenerator();
  138.         $rootClass      = ($this->class->name !== $this->class->rootEntityName)
  139.             ? $this->em->getClassMetadata($this->class->rootEntityName)
  140.             : $this->class;
  142.         // Prepare statement for the root table
  143.         $rootPersister = $this->em->getUnitOfWork()->getEntityPersister($rootClass->name);
  144.         $rootTableName = $rootClass->getTableName();
  145.         $rootTableStmt = $this->conn->prepare($rootPersister->getInsertSQL());
  147.         // Prepare statements for sub tables.
  148.         $subTableStmts = [];
  150.         if ($rootClass !== $this->class) {
  151.             $subTableStmts[$this->class->getTableName()] = $this->conn->prepare($this->getInsertSQL());
  152.         }
  154.         foreach ($this->class->parentClasses as $parentClassName) {
  155.             $parentClass = $this->em->getClassMetadata($parentClassName);
  156.             $parentTableName = $parentClass->getTableName();
  158.             if ($parentClass !== $rootClass) {
  159.                 $parentPersister = $this->em->getUnitOfWork()->getEntityPersister($parentClassName);
  160.                 $subTableStmts[$parentTableName] = $this->conn->prepare($parentPersister->getInsertSQL());
  161.             }
  162.         }
  164.         // Execute all inserts. For each entity:
  165.         // 1) Insert on root table
  166.         // 2) Insert on sub tables
  167.         foreach ($this->queuedInserts as $entity) {
  168.             $insertData = $this->prepareInsertData($entity);
  170.             // Execute insert on root table
  171.             $paramIndex = 1;
  173.             foreach ($insertData[$rootTableName] as $columnName => $value) {
  174.                 $rootTableStmt->bindValue($paramIndex++, $value, $this->columnTypes[$columnName]);
  175.             }
  177.             $rootTableStmt->execute();
  179.             if ($isPostInsertId) {
  180.                 $generatedId = $idGenerator->generate($this->em, $entity);
  181.                 $id = [
  182.                     $this->class->identifier[0] => $generatedId
  183.                 ];
  184.                 $postInsertIds[] = [
  185.                     'generatedId' => $generatedId,
  186.                     'entity' => $entity,
  187.                 ];
  188.             } else {
  189.                 $id = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  190.             }
  192.             if ($this->class->isVersioned) {
  193.                 $this->assignDefaultVersionValue($entity, $id);
  194.             }
  196.             // Execute inserts on subtables.
  197.             // The order doesn't matter because all child tables link to the root table via FK.
  198.             foreach ($subTableStmts as $tableName => $stmt) {
  199.                 /** @var \Doctrine\DBAL\Statement $stmt */
  200.                 $paramIndex = 1;
  201.                 $data       = $insertData[$tableName] ?? [];
  203.                 foreach ((array) $id as $idName => $idVal) {
  204.                     $type = isset($this->columnTypes[$idName]) ? $this->columnTypes[$idName] : Type::STRING;
  206.                     $stmt->bindValue($paramIndex++, $idVal, $type);
  207.                 }
  209.                 foreach ($data as $columnName => $value) {
  210.                     if (!is_array($id) || !isset($id[$columnName])) {
  211.                         $stmt->bindValue($paramIndex++, $value, $this->columnTypes[$columnName]);
  212.                     }
  213.                 }
  215.                 $stmt->execute();
  216.             }
  217.         }
  219.         $rootTableStmt->closeCursor();
  221.         foreach ($subTableStmts as $stmt) {
  222.             $stmt->closeCursor();
  223.         }
  225.         $this->queuedInserts = [];
  227.         return $postInsertIds;
  228.     }
  230.     /**
  231.      * {@inheritdoc}
  232.      */
  233.     public function update($entity)
  234.     {
  235.         $updateData = $this->prepareUpdateData($entity);
  237.         if ( ! $updateData) {
  238.             return;
  239.         }
  241.         if (($isVersioned = $this->class->isVersioned) === false) {
  242.             return;
  243.         }
  245.         $versionedClass  = $this->getVersionedClassMetadata();
  246.         $versionedTable  = $versionedClass->getTableName();
  248.         foreach ($updateData as $tableName => $data) {
  249.             $tableName = $this->quotedTableMap[$tableName];
  250.             $versioned = $isVersioned && $versionedTable === $tableName;
  252.             $this->updateTable($entity, $tableName, $data, $versioned);
  253.         }
  255.         // Make sure the table with the version column is updated even if no columns on that
  256.         // table were affected.
  257.         if ($isVersioned) {
  258.             if ( ! isset($updateData[$versionedTable])) {
  259.                 $tableName = $this->quoteStrategy->getTableName($versionedClass, $this->platform);
  261.                 $this->updateTable($entity, $tableName, [], true);
  262.             }
  264.             $identifiers = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  266.             $this->assignDefaultVersionValue($entity, $identifiers);
  267.         }
  268.     }
  270.     /**
  271.      * {@inheritdoc}
  272.      */
  273.     public function delete($entity)
  274.     {
  275.         $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  276.         $id         = array_combine($this->class->getIdentifierColumnNames(), $identifier);
  278.         $this->deleteJoinTableRecords($identifier);
  280.         // If the database platform supports FKs, just
  281.         // delete the row from the root table. Cascades do the rest.
  282.         if ($this->platform->supportsForeignKeyConstraints()) {
  283.             $rootClass = $this->em->getClassMetadata($this->class->rootEntityName);
  284.             $rootTable = $this->quoteStrategy->getTableName($rootClass, $this->platform);
  285.             $rootTypes = $this->getClassIdentifiersTypes($rootClass);
  287.             return (bool) $this->conn->delete($rootTable, $id, $rootTypes);
  288.         }
  290.         // Delete from all tables individually, starting from this class' table up to the root table.
  291.         $rootTable = $this->quoteStrategy->getTableName($this->class, $this->platform);
  292.         $rootTypes = $this->getClassIdentifiersTypes($this->class);
  294.         $affectedRows = $this->conn->delete($rootTable, $id, $rootTypes);
  296.         foreach ($this->class->parentClasses as $parentClass) {
  297.             $parentMetadata = $this->em->getClassMetadata($parentClass);
  298.             $parentTable    = $this->quoteStrategy->getTableName($parentMetadata, $this->platform);
  299.             $parentTypes    = $this->getClassIdentifiersTypes($parentMetadata);
  301.             $this->conn->delete($parentTable, $id, $parentTypes);
  302.         }
  304.         return (bool) $affectedRows;
  305.     }
  307.     /**
  308.      * {@inheritdoc}
  309.      */
  310.     public function getSelectSQL($criteria, $assoc = null, $lockMode = null, $limit = null, $offset = null, array $orderBy = null)
  311.     {
  312.         $this->switchPersisterContext($offset, $limit);
  314.         $baseTableAlias = $this->getSQLTableAlias($this->class->name);
  315.         $joinSql        = $this->getJoinSql($baseTableAlias);
  317.         if ($assoc != null && $assoc['type'] == ClassMetadata::MANY_TO_MANY) {
  318.             $joinSql .= $this->getSelectManyToManyJoinSQL($assoc);
  319.         }
  321.         $conditionSql = ($criteria instanceof Criteria)
  322.             ? $this->getSelectConditionCriteriaSQL($criteria)
  323.             : $this->getSelectConditionSQL($criteria, $assoc);
  325.         // If the current class in the root entity, add the filters
  326.         if ($filterSql = $this->generateFilterConditionSQL($this->em->getClassMetadata($this->class->rootEntityName), $this->getSQLTableAlias($this->class->rootEntityName))) {
  327.             $conditionSql .= $conditionSql
  328.                 ? ' AND ' . $filterSql
  329.                 : $filterSql;
  330.         }
  332.         $orderBySql = '';
  334.         if ($assoc !== null && isset($assoc['orderBy'])) {
  335.             $orderBy = $assoc['orderBy'];
  336.         }
  338.         if ($orderBy) {
  339.             $orderBySql = $this->getOrderBySQL($orderBy, $baseTableAlias);
  340.         }
  342.         $lockSql = '';
  344.         switch ($lockMode) {
  345.             case LockMode::PESSIMISTIC_READ:
  347.                 $lockSql = ' ' . $this->platform->getReadLockSQL();
  349.                 break;
  351.             case LockMode::PESSIMISTIC_WRITE:
  353.                 $lockSql = ' ' . $this->platform->getWriteLockSQL();
  355.                 break;
  356.         }
  358.         $tableName  = $this->quoteStrategy->getTableName($this->class, $this->platform);
  359.         $from       = ' FROM ' . $tableName . ' ' . $baseTableAlias;
  360.         $where      = $conditionSql != '' ? ' WHERE ' . $conditionSql : '';
  361.         $lock       = $this->platform->appendLockHint($from, $lockMode);
  362.         $columnList = $this->getSelectColumnsSQL();
  363.         $query      = 'SELECT '  . $columnList
  364.                     . $lock
  365.                     . $joinSql
  366.                     . $where
  367.                     . $orderBySql;
  369.         return $this->platform->modifyLimitQuery($query, $limit, $offset) . $lockSql;
  370.     }
  372.     /**
  373.      * {@inheritDoc}
  374.      */
  375.     public function getCountSQL($criteria = [])
  376.     {
  377.         $tableName      = $this->quoteStrategy->getTableName($this->class, $this->platform);
  378.         $baseTableAlias = $this->getSQLTableAlias($this->class->name);
  379.         $joinSql        = $this->getJoinSql($baseTableAlias);
  381.         $conditionSql = ($criteria instanceof Criteria)
  382.             ? $this->getSelectConditionCriteriaSQL($criteria)
  383.             : $this->getSelectConditionSQL($criteria);
  385.         $filterSql = $this->generateFilterConditionSQL($this->em->getClassMetadata($this->class->rootEntityName), $this->getSQLTableAlias($this->class->rootEntityName));
  387.         if ('' !== $filterSql) {
  388.             $conditionSql = $conditionSql
  389.                 ? $conditionSql . ' AND ' . $filterSql
  390.                 : $filterSql;
  391.         }
  393.         $sql = 'SELECT COUNT(*) '
  394.             . 'FROM ' . $tableName . ' ' . $baseTableAlias
  395.             . $joinSql
  396.             . (empty($conditionSql) ? '' : ' WHERE ' . $conditionSql);
  398.         return $sql;
  399.     }
  401.     /**
  402.      * {@inheritdoc}
  403.      */
  404.     protected function getLockTablesSql($lockMode)
  405.     {
  406.         $joinSql            = '';
  407.         $identifierColumns  = $this->class->getIdentifierColumnNames();
  408.         $baseTableAlias     = $this->getSQLTableAlias($this->class->name);
  410.         // INNER JOIN parent tables
  411.         foreach ($this->class->parentClasses as $parentClassName) {
  412.             $conditions     = [];
  413.             $tableAlias     = $this->getSQLTableAlias($parentClassName);
  414.             $parentClass    = $this->em->getClassMetadata($parentClassName);
  415.             $joinSql       .= ' INNER JOIN ' . $this->quoteStrategy->getTableName($parentClass, $this->platform) . ' ' . $tableAlias . ' ON ';
  417.             foreach ($identifierColumns as $idColumn) {
  418.                 $conditions[] = $baseTableAlias . '.' . $idColumn . ' = ' . $tableAlias . '.' . $idColumn;
  419.             }
  421.             $joinSql .= implode(' AND ', $conditions);
  422.         }
  424.         return parent::getLockTablesSql($lockMode) . $joinSql;
  425.     }
  427.     /**
  428.      * Ensure this method is never called. This persister overrides getSelectEntitiesSQL directly.
  429.      *
  430.      * @return string
  431.      */
  432.     protected function getSelectColumnsSQL()
  433.     {
  434.         // Create the column list fragment only once
  435.         if ($this->currentPersisterContext->selectColumnListSql !== null) {
  436.             return $this->currentPersisterContext->selectColumnListSql;
  437.         }
  439.         $columnList         = [];
  440.         $discrColumn        = $this->class->discriminatorColumn['name'];
  441.         $discrColumnType    = $this->class->discriminatorColumn['type'];
  442.         $baseTableAlias     = $this->getSQLTableAlias($this->class->name);
  443.         $resultColumnName   = $this->platform->getSQLResultCasing($discrColumn);
  445.         $this->currentPersisterContext->rsm->addEntityResult($this->class->name, 'r');
  446.         $this->currentPersisterContext->rsm->setDiscriminatorColumn('r', $resultColumnName);
  447.         $this->currentPersisterContext->rsm->addMetaResult('r', $resultColumnName, $discrColumn, false, $discrColumnType);
  449.         // Add regular columns
  450.         foreach ($this->class->fieldMappings as $fieldName => $mapping) {
  451.             $class = isset($mapping['inherited'])
  452.                 ? $this->em->getClassMetadata($mapping['inherited'])
  453.                 : $this->class;
  455.             $columnList[] = $this->getSelectColumnSQL($fieldName, $class);
  456.         }
  458.         // Add foreign key columns
  459.         foreach ($this->class->associationMappings as $mapping) {
  460.             if ( ! $mapping['isOwningSide'] || ! ($mapping['type'] & ClassMetadata::TO_ONE)) {
  461.                 continue;
  462.             }
  464.             $tableAlias = isset($mapping['inherited'])
  465.                 ? $this->getSQLTableAlias($mapping['inherited'])
  466.                 : $baseTableAlias;
  468.             $targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
  470.             foreach ($mapping['joinColumns'] as $joinColumn) {
  471.                 $columnList[] = $this->getSelectJoinColumnSQL(
  472.                     $tableAlias,
  473.                     $joinColumn['name'],
  474.                     $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform),
  475.                     PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em)
  476.                 );
  477.             }
  478.         }
  480.         // Add discriminator column (DO NOT ALIAS, see AbstractEntityInheritancePersister#processSQLResult).
  481.         $tableAlias = ($this->class->rootEntityName == $this->class->name)
  482.             ? $baseTableAlias
  483.             : $this->getSQLTableAlias($this->class->rootEntityName);
  485.         $columnList[] = $tableAlias . '.' . $discrColumn;
  487.         // sub tables
  488.         foreach ($this->class->subClasses as $subClassName) {
  489.             $subClass   = $this->em->getClassMetadata($subClassName);
  490.             $tableAlias = $this->getSQLTableAlias($subClassName);
  492.             // Add subclass columns
  493.             foreach ($subClass->fieldMappings as $fieldName => $mapping) {
  494.                 if (isset($mapping['inherited'])) {
  495.                     continue;
  496.                 }
  498.                 $columnList[] = $this->getSelectColumnSQL($fieldName, $subClass);
  499.             }
  501.             // Add join columns (foreign keys)
  502.             foreach ($subClass->associationMappings as $mapping) {
  503.                 if ( ! $mapping['isOwningSide']
  504.                         || ! ($mapping['type'] & ClassMetadata::TO_ONE)
  505.                         || isset($mapping['inherited'])) {
  506.                     continue;
  507.                 }
  509.                 $targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
  511.                 foreach ($mapping['joinColumns'] as $joinColumn) {
  512.                     $columnList[] = $this->getSelectJoinColumnSQL(
  513.                         $tableAlias,
  514.                         $joinColumn['name'],
  515.                         $this->quoteStrategy->getJoinColumnName($joinColumn, $subClass, $this->platform),
  516.                         PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em)
  517.                     );
  518.                 }
  519.             }
  520.         }
  522.         $this->currentPersisterContext->selectColumnListSql = implode(', ', $columnList);
  524.         return $this->currentPersisterContext->selectColumnListSql;
  525.     }
  527.     /**
  528.      * {@inheritdoc}
  529.      */
  530.     protected function getInsertColumnList()
  531.     {
  532.         // Identifier columns must always come first in the column list of subclasses.
  533.         $columns = $this->class->parentClasses
  534.             ? $this->class->getIdentifierColumnNames()
  535.             : [];
  537.         foreach ($this->class->reflFields as $name => $field) {
  538.             if (isset($this->class->fieldMappings[$name]['inherited'])
  539.                     && ! isset($this->class->fieldMappings[$name]['id'])
  540.                     || isset($this->class->associationMappings[$name]['inherited'])
  541.                     || ($this->class->isVersioned && $this->class->versionField == $name)
  542.                     || isset($this->class->embeddedClasses[$name])) {
  543.                 continue;
  544.             }
  546.             if (isset($this->class->associationMappings[$name])) {
  547.                 $assoc = $this->class->associationMappings[$name];
  548.                 if ($assoc['type'] & ClassMetadata::TO_ONE && $assoc['isOwningSide']) {
  549.                     foreach ($assoc['targetToSourceKeyColumns'] as $sourceCol) {
  550.                         $columns[] = $sourceCol;
  551.                     }
  552.                 }
  553.             } else if ($this->class->name != $this->class->rootEntityName ||
  554.                     ! $this->class->isIdGeneratorIdentity() || $this->class->identifier[0] != $name) {
  555.                 $columns[]                  = $this->quoteStrategy->getColumnName($name, $this->class, $this->platform);
  556.                 $this->columnTypes[$name]   = $this->class->fieldMappings[$name]['type'];
  557.             }
  558.         }
  560.         // Add discriminator column if it is the topmost class.
  561.         if ($this->class->name == $this->class->rootEntityName) {
  562.             $columns[] = $this->class->discriminatorColumn['name'];
  563.         }
  565.         return $columns;
  566.     }
  568.     /**
  569.      * {@inheritdoc}
  570.      */
  571.     protected function assignDefaultVersionValue($entity, array $id)
  572.     {
  573.         $value = $this->fetchVersionValue($this->getVersionedClassMetadata(), $id);
  574.         $this->class->setFieldValue($entity, $this->class->versionField, $value);
  575.     }
  577.     /**
  578.      * @param string $baseTableAlias
  579.      *
  580.      * @return string
  581.      */
  582.     private function getJoinSql($baseTableAlias)
  583.     {
  584.         $joinSql          = '';
  585.         $identifierColumn = $this->class->getIdentifierColumnNames();
  587.         // INNER JOIN parent tables
  588.         foreach ($this->class->parentClasses as $parentClassName) {
  589.             $conditions   = [];
  590.             $parentClass  = $this->em->getClassMetadata($parentClassName);
  591.             $tableAlias   = $this->getSQLTableAlias($parentClassName);
  592.             $joinSql     .= ' INNER JOIN ' . $this->quoteStrategy->getTableName($parentClass, $this->platform) . ' ' . $tableAlias . ' ON ';
  595.             foreach ($identifierColumn as $idColumn) {
  596.                 $conditions[] = $baseTableAlias . '.' . $idColumn . ' = ' . $tableAlias . '.' . $idColumn;
  597.             }
  599.             $joinSql .= implode(' AND ', $conditions);
  600.         }
  602.         // OUTER JOIN sub tables
  603.         foreach ($this->class->subClasses as $subClassName) {
  604.             $conditions  = [];
  605.             $subClass    = $this->em->getClassMetadata($subClassName);
  606.             $tableAlias  = $this->getSQLTableAlias($subClassName);
  607.             $joinSql    .= ' LEFT JOIN ' . $this->quoteStrategy->getTableName($subClass, $this->platform) . ' ' . $tableAlias . ' ON ';
  609.             foreach ($identifierColumn as $idColumn) {
  610.                 $conditions[] = $baseTableAlias . '.' . $idColumn . ' = ' . $tableAlias . '.' . $idColumn;
  611.             }
  613.             $joinSql .= implode(' AND ', $conditions);
  614.         }
  616.         return $joinSql;
  617.     }
  618. }