vendor/doctrine/orm/lib/Doctrine/ORM/Persisters/Collection/OneToManyPersister.php line 102

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Persisters\Collection;
  7. use BadMethodCallException;
  8. use Doctrine\Common\Collections\Criteria;
  9. use Doctrine\DBAL\Exception as DBALException;
  10. use Doctrine\DBAL\Types\Type;
  11. use Doctrine\ORM\PersistentCollection;
  12. use Doctrine\ORM\Utility\PersisterHelper;
  14. use function array_merge;
  15. use function array_reverse;
  16. use function array_values;
  17. use function assert;
  18. use function implode;
  19. use function is_string;
  21. /**
  22.  * Persister for one-to-many collections.
  23.  */
  24. class OneToManyPersister extends AbstractCollectionPersister
  25. {
  26.     /**
  27.      * {@inheritdoc}
  28.      *
  29.      * @return int|null
  30.      */
  31.     public function delete(PersistentCollection $collection)
  32.     {
  33.         // The only valid case here is when you have weak entities. In this
  34.         // scenario, you have @OneToMany with orphanRemoval=true, and replacing
  35.         // the entire collection with a new would trigger this operation.
  36.         $mapping = $collection->getMapping();
  38.         if (! $mapping['orphanRemoval']) {
  39.             // Handling non-orphan removal should never happen, as @OneToMany
  40.             // can only be inverse side. For owning side one to many, it is
  41.             // required to have a join table, which would classify as a ManyToManyPersister.
  42.             return;
  43.         }
  45.         $targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
  47.         return $targetClass->isInheritanceTypeJoined()
  48.             ? $this->deleteJoinedEntityCollection($collection)
  49.             : $this->deleteEntityCollection($collection);
  50.     }
  52.     /**
  53.      * {@inheritdoc}
  54.      */
  55.     public function update(PersistentCollection $collection)
  56.     {
  57.         // This can never happen. One to many can only be inverse side.
  58.         // For owning side one to many, it is required to have a join table,
  59.         // then classifying it as a ManyToManyPersister.
  60.         return;
  61.     }
  63.     /**
  64.      * {@inheritdoc}
  65.      */
  66.     public function get(PersistentCollection $collection, $index)
  67.     {
  68.         $mapping = $collection->getMapping();
  70.         if (! isset($mapping['indexBy'])) {
  71.             throw new BadMethodCallException('Selecting a collection by index is only supported on indexed collections.');
  72.         }
  74.         $persister = $this->uow->getEntityPersister($mapping['targetEntity']);
  76.         return $persister->load(
  77.             [
  78.                 $mapping['mappedBy'] => $collection->getOwner(),
  79.                 $mapping['indexBy']  => $index,
  80.             ],
  81.             null,
  82.             $mapping,
  83.             [],
  84.             null,
  85.             1
  86.         );
  87.     }
  89.     /**
  90.      * {@inheritdoc}
  91.      */
  92.     public function count(PersistentCollection $collection)
  93.     {
  94.         $mapping   = $collection->getMapping();
  95.         $persister = $this->uow->getEntityPersister($mapping['targetEntity']);
  97.         // only works with single id identifier entities. Will throw an
  98.         // exception in Entity Persisters if that is not the case for the
  99.         // 'mappedBy' field.
  100.         $criteria = new Criteria(Criteria::expr()->eq($mapping['mappedBy'], $collection->getOwner()));
  102.         return $persister->count($criteria);
  103.     }
  105.     /**
  106.      * {@inheritdoc}
  107.      */
  108.     public function slice(PersistentCollection $collection, $offset, $length = null)
  109.     {
  110.         $mapping   = $collection->getMapping();
  111.         $persister = $this->uow->getEntityPersister($mapping['targetEntity']);
  113.         return $persister->getOneToManyCollection($mapping, $collection->getOwner(), $offset, $length);
  114.     }
  116.     /**
  117.      * {@inheritdoc}
  118.      */
  119.     public function containsKey(PersistentCollection $collection, $key)
  120.     {
  121.         $mapping = $collection->getMapping();
  123.         if (! isset($mapping['indexBy'])) {
  124.             throw new BadMethodCallException('Selecting a collection by index is only supported on indexed collections.');
  125.         }
  127.         $persister = $this->uow->getEntityPersister($mapping['targetEntity']);
  129.         // only works with single id identifier entities. Will throw an
  130.         // exception in Entity Persisters if that is not the case for the
  131.         // 'mappedBy' field.
  132.         $criteria = new Criteria();
  134.         $criteria->andWhere(Criteria::expr()->eq($mapping['mappedBy'], $collection->getOwner()));
  135.         $criteria->andWhere(Criteria::expr()->eq($mapping['indexBy'], $key));
  137.         return (bool) $persister->count($criteria);
  138.     }
  140.      /**
  141.       * {@inheritdoc}
  142.       */
  143.     public function contains(PersistentCollection $collection, $element)
  144.     {
  145.         if (! $this->isValidEntityState($element)) {
  146.             return false;
  147.         }
  149.         $mapping   = $collection->getMapping();
  150.         $persister = $this->uow->getEntityPersister($mapping['targetEntity']);
  152.         // only works with single id identifier entities. Will throw an
  153.         // exception in Entity Persisters if that is not the case for the
  154.         // 'mappedBy' field.
  155.         $criteria = new Criteria(Criteria::expr()->eq($mapping['mappedBy'], $collection->getOwner()));
  157.         return $persister->exists($element, $criteria);
  158.     }
  160.     /**
  161.      * {@inheritdoc}
  162.      */
  163.     public function loadCriteria(PersistentCollection $collection, Criteria $criteria)
  164.     {
  165.         throw new BadMethodCallException('Filtering a collection by Criteria is not supported by this CollectionPersister.');
  166.     }
  168.     /** @throws DBALException */
  169.     private function deleteEntityCollection(PersistentCollection $collection): int
  170.     {
  171.         $mapping     = $collection->getMapping();
  172.         $identifier  = $this->uow->getEntityIdentifier($collection->getOwner());
  173.         $sourceClass = $this->em->getClassMetadata($mapping['sourceEntity']);
  174.         $targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
  175.         $columns     = [];
  176.         $parameters  = [];
  178.         foreach ($targetClass->associationMappings[$mapping['mappedBy']]['joinColumns'] as $joinColumn) {
  179.             $columns[]    = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  180.             $parameters[] = $identifier[$sourceClass->getFieldForColumn($joinColumn['referencedColumnName'])];
  181.         }
  183.         $statement = 'DELETE FROM ' . $this->quoteStrategy->getTableName($targetClass, $this->platform)
  184.             . ' WHERE ' . implode(' = ? AND ', $columns) . ' = ?';
  186.         return $this->conn->executeStatement($statement, $parameters);
  187.     }
  189.     /**
  190.      * Delete Class Table Inheritance entities.
  191.      * A temporary table is needed to keep IDs to be deleted in both parent and child class' tables.
  192.      *
  193.      * Thanks Steve Ebersole (Hibernate) for idea on how to tackle reliably this scenario, we owe him a beer! =)
  194.      *
  195.      * @throws DBALException
  196.      */
  197.     private function deleteJoinedEntityCollection(PersistentCollection $collection): int
  198.     {
  199.         $mapping     = $collection->getMapping();
  200.         $sourceClass = $this->em->getClassMetadata($mapping['sourceEntity']);
  201.         $targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
  202.         $rootClass   = $this->em->getClassMetadata($targetClass->rootEntityName);
  204.         // 1) Build temporary table DDL
  205.         $tempTable         = $this->platform->getTemporaryTableName($rootClass->getTemporaryIdTableName());
  206.         $idColumnNames     = $rootClass->getIdentifierColumnNames();
  207.         $idColumnList      = implode(', ', $idColumnNames);
  208.         $columnDefinitions = [];
  210.         foreach ($idColumnNames as $idColumnName) {
  211.             $columnDefinitions[$idColumnName] = [
  212.                 'notnull' => true,
  213.                 'type'    => Type::getType(PersisterHelper::getTypeOfColumn($idColumnName, $rootClass, $this->em)),
  214.             ];
  215.         }
  217.         $statement = $this->platform->getCreateTemporaryTableSnippetSQL() . ' ' . $tempTable
  218.             . ' (' . $this->platform->getColumnDeclarationListSQL($columnDefinitions) . ')';
  220.         $this->conn->executeStatement($statement);
  222.         // 2) Build insert table records into temporary table
  223.         $query = $this->em->createQuery(
  224.             ' SELECT t0.' . implode(', t0.', $rootClass->getIdentifierFieldNames())
  225.             . ' FROM ' . $targetClass->name . ' t0 WHERE t0.' . $mapping['mappedBy'] . ' = :owner'
  226.         )->setParameter('owner', $collection->getOwner());
  228.         $sql = $query->getSQL();
  229.         assert(is_string($sql));
  230.         $statement  = 'INSERT INTO ' . $tempTable . ' (' . $idColumnList . ') ' . $sql;
  231.         $parameters = array_values($sourceClass->getIdentifierValues($collection->getOwner()));
  232.         $numDeleted = $this->conn->executeStatement($statement, $parameters);
  234.         // 3) Delete records on each table in the hierarchy
  235.         $classNames = array_merge($targetClass->parentClasses, [$targetClass->name], $targetClass->subClasses);
  237.         foreach (array_reverse($classNames) as $className) {
  238.             $tableName = $this->quoteStrategy->getTableName($this->em->getClassMetadata($className), $this->platform);
  239.             $statement = 'DELETE FROM ' . $tableName . ' WHERE (' . $idColumnList . ')'
  240.                 . ' IN (SELECT ' . $idColumnList . ' FROM ' . $tempTable . ')';
  242.             $this->conn->executeStatement($statement);
  243.         }
  245.         // 4) Drop temporary table
  246.         $statement = $this->platform->getDropTemporaryTableSQL($tempTable);
  248.         $this->conn->executeStatement($statement);
  250.         return $numDeleted;
  251.     }
  252. }