vendor/doctrine/orm/src/EntityManager.php line 812

  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM;
  7. use BackedEnum;
  8. use BadMethodCallException;
  9. use Doctrine\Common\Cache\Psr6\CacheAdapter;
  10. use Doctrine\Common\EventManager;
  11. use Doctrine\Common\Persistence\PersistentObject;
  12. use Doctrine\DBAL\Connection;
  13. use Doctrine\DBAL\DriverManager;
  14. use Doctrine\DBAL\LockMode;
  15. use Doctrine\Deprecations\Deprecation;
  16. use Doctrine\ORM\Exception\EntityManagerClosed;
  17. use Doctrine\ORM\Exception\InvalidHydrationMode;
  18. use Doctrine\ORM\Exception\MismatchedEventManager;
  19. use Doctrine\ORM\Exception\MissingIdentifierField;
  20. use Doctrine\ORM\Exception\MissingMappingDriverImplementation;
  21. use Doctrine\ORM\Exception\NotSupported;
  22. use Doctrine\ORM\Exception\ORMException;
  23. use Doctrine\ORM\Exception\UnrecognizedIdentifierFields;
  24. use Doctrine\ORM\Mapping\ClassMetadata;
  25. use Doctrine\ORM\Mapping\ClassMetadataFactory;
  26. use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
  27. use Doctrine\ORM\Proxy\ProxyFactory;
  28. use Doctrine\ORM\Query\Expr;
  29. use Doctrine\ORM\Query\FilterCollection;
  30. use Doctrine\ORM\Query\ResultSetMapping;
  31. use Doctrine\ORM\Repository\RepositoryFactory;
  32. use Doctrine\Persistence\Mapping\MappingException;
  33. use Doctrine\Persistence\ObjectRepository;
  34. use InvalidArgumentException;
  35. use Throwable;
  37. use function array_keys;
  38. use function class_exists;
  39. use function get_debug_type;
  40. use function gettype;
  41. use function is_array;
  42. use function is_callable;
  43. use function is_object;
  44. use function is_string;
  45. use function ltrim;
  46. use function sprintf;
  47. use function strpos;
  49. /**
  50.  * The EntityManager is the central access point to ORM functionality.
  51.  *
  52.  * It is a facade to all different ORM subsystems such as UnitOfWork,
  53.  * Query Language and Repository API. Instantiation is done through
  54.  * the static create() method. The quickest way to obtain a fully
  55.  * configured EntityManager is:
  56.  *
  57.  *     use Doctrine\ORM\Tools\ORMSetup;
  58.  *     use Doctrine\ORM\EntityManager;
  59.  *
  60.  *     $paths = ['/path/to/entity/mapping/files'];
  61.  *
  62.  *     $config = ORMSetup::createAttributeMetadataConfiguration($paths);
  63.  *     $connection = DriverManager::getConnection(['driver' => 'pdo_sqlite', 'memory' => true], $config);
  64.  *     $entityManager = new EntityManager($connection, $config);
  65.  *
  66.  * For more information see
  67.  * {@link http://docs.doctrine-project.org/projects/doctrine-orm/en/stable/reference/configuration.html}
  68.  *
  69.  * You should never attempt to inherit from the EntityManager: Inheritance
  70.  * is not a valid extension point for the EntityManager. Instead you
  71.  * should take a look at the {@see \Doctrine\ORM\Decorator\EntityManagerDecorator}
  72.  * and wrap your entity manager in a decorator.
  73.  *
  74.  * @final
  75.  */
  76. class EntityManager implements EntityManagerInterface
  77. {
  78.     /**
  79.      * The used Configuration.
  80.      *
  81.      * @var Configuration
  82.      */
  83.     private $config;
  85.     /**
  86.      * The database connection used by the EntityManager.
  87.      *
  88.      * @var Connection
  89.      */
  90.     private $conn;
  92.     /**
  93.      * The metadata factory, used to retrieve the ORM metadata of entity classes.
  94.      *
  95.      * @var ClassMetadataFactory
  96.      */
  97.     private $metadataFactory;
  99.     /**
  100.      * The UnitOfWork used to coordinate object-level transactions.
  101.      *
  102.      * @var UnitOfWork
  103.      */
  104.     private $unitOfWork;
  106.     /**
  107.      * The event manager that is the central point of the event system.
  108.      *
  109.      * @var EventManager
  110.      */
  111.     private $eventManager;
  113.     /**
  114.      * The proxy factory used to create dynamic proxies.
  115.      *
  116.      * @var ProxyFactory
  117.      */
  118.     private $proxyFactory;
  120.     /**
  121.      * The repository factory used to create dynamic repositories.
  122.      *
  123.      * @var RepositoryFactory
  124.      */
  125.     private $repositoryFactory;
  127.     /**
  128.      * The expression builder instance used to generate query expressions.
  129.      *
  130.      * @var Expr|null
  131.      */
  132.     private $expressionBuilder;
  134.     /**
  135.      * Whether the EntityManager is closed or not.
  136.      *
  137.      * @var bool
  138.      */
  139.     private $closed = false;
  141.     /**
  142.      * Collection of query filters.
  143.      *
  144.      * @var FilterCollection|null
  145.      */
  146.     private $filterCollection;
  148.     /**
  149.      * The second level cache regions API.
  150.      *
  151.      * @var Cache|null
  152.      */
  153.     private $cache;
  155.     /**
  156.      * Creates a new EntityManager that operates on the given database connection
  157.      * and uses the given Configuration and EventManager implementations.
  158.      */
  159.     public function __construct(Connection $conn, Configuration $config, ?EventManager $eventManager = null)
  160.     {
  161.         if (! $config->getMetadataDriverImpl()) {
  162.             throw MissingMappingDriverImplementation::create();
  163.         }
  165.         $this->conn         = $conn;
  166.         $this->config       = $config;
  167.         $this->eventManager = $eventManager ?? $conn->getEventManager();
  169.         $metadataFactoryClassName = $config->getClassMetadataFactoryName();
  171.         $this->metadataFactory = new $metadataFactoryClassName();
  172.         $this->metadataFactory->setEntityManager($this);
  174.         $this->configureMetadataCache();
  176.         $this->repositoryFactory = $config->getRepositoryFactory();
  177.         $this->unitOfWork        = new UnitOfWork($this);
  178.         $this->proxyFactory      = new ProxyFactory(
  179.             $this,
  180.             $config->getProxyDir(),
  181.             $config->getProxyNamespace(),
  182.             $config->getAutoGenerateProxyClasses()
  183.         );
  185.         if ($config->isSecondLevelCacheEnabled()) {
  186.             $cacheConfig  = $config->getSecondLevelCacheConfiguration();
  187.             $cacheFactory = $cacheConfig->getCacheFactory();
  188.             $this->cache  = $cacheFactory->createCache($this);
  189.         }
  190.     }
  192.     /**
  193.      * {@inheritDoc}
  194.      */
  195.     public function getConnection()
  196.     {
  197.         return $this->conn;
  198.     }
  200.     /**
  201.      * Gets the metadata factory used to gather the metadata of classes.
  202.      *
  203.      * @return ClassMetadataFactory
  204.      */
  205.     public function getMetadataFactory()
  206.     {
  207.         return $this->metadataFactory;
  208.     }
  210.     /**
  211.      * {@inheritDoc}
  212.      */
  213.     public function getExpressionBuilder()
  214.     {
  215.         if ($this->expressionBuilder === null) {
  216.             $this->expressionBuilder = new Query\Expr();
  217.         }
  219.         return $this->expressionBuilder;
  220.     }
  222.     /**
  223.      * {@inheritDoc}
  224.      */
  225.     public function beginTransaction()
  226.     {
  227.         $this->conn->beginTransaction();
  228.     }
  230.     /**
  231.      * {@inheritDoc}
  232.      */
  233.     public function getCache()
  234.     {
  235.         return $this->cache;
  236.     }
  238.     /**
  239.      * {@inheritDoc}
  240.      */
  241.     public function transactional($func)
  242.     {
  243.         if (! is_callable($func)) {
  244.             throw new InvalidArgumentException('Expected argument of type "callable", got "' . gettype($func) . '"');
  245.         }
  247.         $this->conn->beginTransaction();
  249.         try {
  250.             $return = $func($this);
  252.             $this->flush();
  253.             $this->conn->commit();
  255.             return $return ?: true;
  256.         } catch (Throwable $e) {
  257.             $this->close();
  258.             $this->conn->rollBack();
  260.             throw $e;
  261.         }
  262.     }
  264.     /**
  265.      * {@inheritDoc}
  266.      */
  267.     public function wrapInTransaction(callable $func)
  268.     {
  269.         $this->conn->beginTransaction();
  271.         try {
  272.             $return = $func($this);
  274.             $this->flush();
  275.             $this->conn->commit();
  277.             return $return;
  278.         } catch (Throwable $e) {
  279.             $this->close();
  280.             $this->conn->rollBack();
  282.             throw $e;
  283.         }
  284.     }
  286.     /**
  287.      * {@inheritDoc}
  288.      */
  289.     public function commit()
  290.     {
  291.         $this->conn->commit();
  292.     }
  294.     /**
  295.      * {@inheritDoc}
  296.      */
  297.     public function rollback()
  298.     {
  299.         $this->conn->rollBack();
  300.     }
  302.     /**
  303.      * Returns the ORM metadata descriptor for a class.
  304.      *
  305.      * The class name must be the fully-qualified class name without a leading backslash
  306.      * (as it is returned by get_class($obj)) or an aliased class name.
  307.      *
  308.      * Examples:
  309.      * MyProject\Domain\User
  310.      * sales:PriceRequest
  311.      *
  312.      * Internal note: Performance-sensitive method.
  313.      *
  314.      * {@inheritDoc}
  315.      */
  316.     public function getClassMetadata($className)
  317.     {
  318.         return $this->metadataFactory->getMetadataFor($className);
  319.     }
  321.     /**
  322.      * {@inheritDoc}
  323.      */
  324.     public function createQuery($dql = '')
  325.     {
  326.         $query = new Query($this);
  328.         if (! empty($dql)) {
  329.             $query->setDQL($dql);
  330.         }
  332.         return $query;
  333.     }
  335.     /**
  336.      * {@inheritDoc}
  337.      */
  338.     public function createNamedQuery($name)
  339.     {
  340.         return $this->createQuery($this->config->getNamedQuery($name));
  341.     }
  343.     /**
  344.      * {@inheritDoc}
  345.      */
  346.     public function createNativeQuery($sql, ResultSetMapping $rsm)
  347.     {
  348.         $query = new NativeQuery($this);
  350.         $query->setSQL($sql);
  351.         $query->setResultSetMapping($rsm);
  353.         return $query;
  354.     }
  356.     /**
  357.      * {@inheritDoc}
  358.      */
  359.     public function createNamedNativeQuery($name)
  360.     {
  361.         [$sql, $rsm] = $this->config->getNamedNativeQuery($name);
  363.         return $this->createNativeQuery($sql, $rsm);
  364.     }
  366.     /**
  367.      * {@inheritDoc}
  368.      */
  369.     public function createQueryBuilder()
  370.     {
  371.         return new QueryBuilder($this);
  372.     }
  374.     /**
  375.      * Flushes all changes to objects that have been queued up to now to the database.
  376.      * This effectively synchronizes the in-memory state of managed objects with the
  377.      * database.
  378.      *
  379.      * If an entity is explicitly passed to this method only this entity and
  380.      * the cascade-persist semantics + scheduled inserts/removals are synchronized.
  381.      *
  382.      * @param object|mixed[]|null $entity
  383.      *
  384.      * @return void
  385.      *
  386.      * @throws OptimisticLockException If a version check on an entity that
  387.      * makes use of optimistic locking fails.
  388.      * @throws ORMException
  389.      */
  390.     public function flush($entity = null)
  391.     {
  392.         if ($entity !== null) {
  393.             Deprecation::trigger(
  394.                 'doctrine/orm',
  395.                 'https://github.com/doctrine/orm/issues/8459',
  396.                 'Calling %s() with any arguments to flush specific entities is deprecated and will not be supported in Doctrine ORM 3.0.',
  397.                 __METHOD__
  398.             );
  399.         }
  401.         $this->errorIfClosed();
  403.         $this->unitOfWork->commit($entity);
  404.     }
  406.     /**
  407.      * Finds an Entity by its identifier.
  408.      *
  409.      * @param string   $className   The class name of the entity to find.
  410.      * @param mixed    $id          The identity of the entity to find.
  411.      * @param int|null $lockMode    One of the \Doctrine\DBAL\LockMode::* constants
  412.      *    or NULL if no specific lock mode should be used
  413.      *    during the search.
  414.      * @param int|null $lockVersion The version of the entity to find when using
  415.      * optimistic locking.
  416.      * @psalm-param class-string<T> $className
  417.      * @psalm-param LockMode::*|null $lockMode
  418.      *
  419.      * @return object|null The entity instance or NULL if the entity can not be found.
  420.      * @psalm-return ?T
  421.      *
  422.      * @throws OptimisticLockException
  423.      * @throws ORMInvalidArgumentException
  424.      * @throws TransactionRequiredException
  425.      * @throws ORMException
  426.      *
  427.      * @template T
  428.      */
  429.     public function find($className, $id, $lockMode = null, $lockVersion = null)
  430.     {
  431.         $class = $this->metadataFactory->getMetadataFor(ltrim($className, '\\'));
  433.         if ($lockMode !== null) {
  434.             $this->checkLockRequirements($lockMode, $class);
  435.         }
  437.         if (! is_array($id)) {
  438.             if ($class->isIdentifierComposite) {
  439.                 throw ORMInvalidArgumentException::invalidCompositeIdentifier();
  440.             }
  442.             $id = [$class->identifier[0] => $id];
  443.         }
  445.         foreach ($id as $i => $value) {
  446.             if (is_object($value)) {
  447.                 $className = DefaultProxyClassNameResolver::getClass($value);
  448.                 if ($this->metadataFactory->hasMetadataFor($className)) {
  449.                     $id[$i] = $this->unitOfWork->getSingleIdentifierValue($value);
  451.                     if ($id[$i] === null) {
  452.                         throw ORMInvalidArgumentException::invalidIdentifierBindingEntity($className);
  453.                     }
  454.                 }
  455.             }
  456.         }
  458.         $sortedId = [];
  460.         foreach ($class->identifier as $identifier) {
  461.             if (! isset($id[$identifier])) {
  462.                 throw MissingIdentifierField::fromFieldAndClass($identifier, $class->name);
  463.             }
  465.             if ($id[$identifier] instanceof BackedEnum) {
  466.                 $sortedId[$identifier] = $id[$identifier]->value;
  467.             } else {
  468.                 $sortedId[$identifier] = $id[$identifier];
  469.             }
  471.             unset($id[$identifier]);
  472.         }
  474.         if ($id) {
  475.             throw UnrecognizedIdentifierFields::fromClassAndFieldNames($class->name, array_keys($id));
  476.         }
  478.         $unitOfWork = $this->getUnitOfWork();
  480.         $entity = $unitOfWork->tryGetById($sortedId, $class->rootEntityName);
  482.         // Check identity map first
  483.         if ($entity !== false) {
  484.             if (! ($entity instanceof $class->name)) {
  485.                 return null;
  486.             }
  488.             switch (true) {
  489.                 case $lockMode === LockMode::OPTIMISTIC:
  490.                     $this->lock($entity, $lockMode, $lockVersion);
  491.                     break;
  493.                 case $lockMode === LockMode::NONE:
  494.                 case $lockMode === LockMode::PESSIMISTIC_READ:
  495.                 case $lockMode === LockMode::PESSIMISTIC_WRITE:
  496.                     $persister = $unitOfWork->getEntityPersister($class->name);
  497.                     $persister->refresh($sortedId, $entity, $lockMode);
  498.                     break;
  499.             }
  501.             return $entity; // Hit!
  502.         }
  504.         $persister = $unitOfWork->getEntityPersister($class->name);
  506.         switch (true) {
  507.             case $lockMode === LockMode::OPTIMISTIC:
  508.                 $entity = $persister->load($sortedId);
  510.                 if ($entity !== null) {
  511.                     $unitOfWork->lock($entity, $lockMode, $lockVersion);
  512.                 }
  514.                 return $entity;
  516.             case $lockMode === LockMode::PESSIMISTIC_READ:
  517.             case $lockMode === LockMode::PESSIMISTIC_WRITE:
  518.                 return $persister->load($sortedId, null, null, [], $lockMode);
  520.             default:
  521.                 return $persister->loadById($sortedId);
  522.         }
  523.     }
  525.     /**
  526.      * {@inheritDoc}
  527.      */
  528.     public function getReference($entityName, $id)
  529.     {
  530.         $class = $this->metadataFactory->getMetadataFor(ltrim($entityName, '\\'));
  532.         if (! is_array($id)) {
  533.             $id = [$class->identifier[0] => $id];
  534.         }
  536.         $sortedId = [];
  538.         foreach ($class->identifier as $identifier) {
  539.             if (! isset($id[$identifier])) {
  540.                 throw MissingIdentifierField::fromFieldAndClass($identifier, $class->name);
  541.             }
  543.             $sortedId[$identifier] = $id[$identifier];
  544.             unset($id[$identifier]);
  545.         }
  547.         if ($id) {
  548.             throw UnrecognizedIdentifierFields::fromClassAndFieldNames($class->name, array_keys($id));
  549.         }
  551.         $entity = $this->unitOfWork->tryGetById($sortedId, $class->rootEntityName);
  553.         // Check identity map first, if its already in there just return it.
  554.         if ($entity !== false) {
  555.             return $entity instanceof $class->name ? $entity : null;
  556.         }
  558.         if ($class->subClasses) {
  559.             return $this->find($entityName, $sortedId);
  560.         }
  562.         $entity = $this->proxyFactory->getProxy($class->name, $sortedId);
  564.         $this->unitOfWork->registerManaged($entity, $sortedId, []);
  566.         return $entity;
  567.     }
  569.     /**
  570.      * {@inheritDoc}
  571.      */
  572.     public function getPartialReference($entityName, $identifier)
  573.     {
  574.         Deprecation::trigger(
  575.             'doctrine/orm',
  576.             'https://github.com/doctrine/orm/pull/10987',
  577.             'Method %s is deprecated and will be removed in 3.0.',
  578.             __METHOD__
  579.         );
  580.         $class = $this->metadataFactory->getMetadataFor(ltrim($entityName, '\\'));
  582.         $entity = $this->unitOfWork->tryGetById($identifier, $class->rootEntityName);
  584.         // Check identity map first, if its already in there just return it.
  585.         if ($entity !== false) {
  586.             return $entity instanceof $class->name ? $entity : null;
  587.         }
  589.         if (! is_array($identifier)) {
  590.             $identifier = [$class->identifier[0] => $identifier];
  591.         }
  593.         $entity = $class->newInstance();
  595.         $class->setIdentifierValues($entity, $identifier);
  597.         $this->unitOfWork->registerManaged($entity, $identifier, []);
  598.         $this->unitOfWork->markReadOnly($entity);
  600.         return $entity;
  601.     }
  603.     /**
  604.      * Clears the EntityManager. All entities that are currently managed
  605.      * by this EntityManager become detached.
  606.      *
  607.      * @param string|null $entityName if given, only entities of this type will get detached
  608.      *
  609.      * @return void
  610.      *
  611.      * @throws ORMInvalidArgumentException If a non-null non-string value is given.
  612.      * @throws MappingException            If a $entityName is given, but that entity is not
  613.      *                                     found in the mappings.
  614.      */
  615.     public function clear($entityName = null)
  616.     {
  617.         if ($entityName !== null && ! is_string($entityName)) {
  618.             throw ORMInvalidArgumentException::invalidEntityName($entityName);
  619.         }
  621.         if ($entityName !== null) {
  622.             Deprecation::trigger(
  623.                 'doctrine/orm',
  624.                 'https://github.com/doctrine/orm/issues/8460',
  625.                 'Calling %s() with any arguments to clear specific entities is deprecated and will not be supported in Doctrine ORM 3.0.',
  626.                 __METHOD__
  627.             );
  628.         }
  630.         $this->unitOfWork->clear(
  631.             $entityName === null
  632.                 ? null
  633.                 : $this->metadataFactory->getMetadataFor($entityName)->getName()
  634.         );
  635.     }
  637.     /**
  638.      * {@inheritDoc}
  639.      */
  640.     public function close()
  641.     {
  642.         $this->clear();
  644.         $this->closed = true;
  645.     }
  647.     /**
  648.      * Tells the EntityManager to make an instance managed and persistent.
  649.      *
  650.      * The entity will be entered into the database at or before transaction
  651.      * commit or as a result of the flush operation.
  652.      *
  653.      * NOTE: The persist operation always considers entities that are not yet known to
  654.      * this EntityManager as NEW. Do not pass detached entities to the persist operation.
  655.      *
  656.      * @param object $entity The instance to make managed and persistent.
  657.      *
  658.      * @return void
  659.      *
  660.      * @throws ORMInvalidArgumentException
  661.      * @throws ORMException
  662.      */
  663.     public function persist($entity)
  664.     {
  665.         if (! is_object($entity)) {
  666.             throw ORMInvalidArgumentException::invalidObject('EntityManager#persist()', $entity);
  667.         }
  669.         $this->errorIfClosed();
  671.         $this->unitOfWork->persist($entity);
  672.     }
  674.     /**
  675.      * Removes an entity instance.
  676.      *
  677.      * A removed entity will be removed from the database at or before transaction commit
  678.      * or as a result of the flush operation.
  679.      *
  680.      * @param object $entity The entity instance to remove.
  681.      *
  682.      * @return void
  683.      *
  684.      * @throws ORMInvalidArgumentException
  685.      * @throws ORMException
  686.      */
  687.     public function remove($entity)
  688.     {
  689.         if (! is_object($entity)) {
  690.             throw ORMInvalidArgumentException::invalidObject('EntityManager#remove()', $entity);
  691.         }
  693.         $this->errorIfClosed();
  695.         $this->unitOfWork->remove($entity);
  696.     }
  698.     /**
  699.      * Refreshes the persistent state of an entity from the database,
  700.      * overriding any local changes that have not yet been persisted.
  701.      *
  702.      * @param object $entity The entity to refresh
  703.      * @psalm-param LockMode::*|null $lockMode
  704.      *
  705.      * @return void
  706.      *
  707.      * @throws ORMInvalidArgumentException
  708.      * @throws ORMException
  709.      * @throws TransactionRequiredException
  710.      */
  711.     public function refresh($entity, ?int $lockMode = null)
  712.     {
  713.         if (! is_object($entity)) {
  714.             throw ORMInvalidArgumentException::invalidObject('EntityManager#refresh()', $entity);
  715.         }
  717.         $this->errorIfClosed();
  719.         $this->unitOfWork->refresh($entity, $lockMode);
  720.     }
  722.     /**
  723.      * Detaches an entity from the EntityManager, causing a managed entity to
  724.      * become detached.  Unflushed changes made to the entity if any
  725.      * (including removal of the entity), will not be synchronized to the database.
  726.      * Entities which previously referenced the detached entity will continue to
  727.      * reference it.
  728.      *
  729.      * @param object $entity The entity to detach.
  730.      *
  731.      * @return void
  732.      *
  733.      * @throws ORMInvalidArgumentException
  734.      */
  735.     public function detach($entity)
  736.     {
  737.         if (! is_object($entity)) {
  738.             throw ORMInvalidArgumentException::invalidObject('EntityManager#detach()', $entity);
  739.         }
  741.         $this->unitOfWork->detach($entity);
  742.     }
  744.     /**
  745.      * Merges the state of a detached entity into the persistence context
  746.      * of this EntityManager and returns the managed copy of the entity.
  747.      * The entity passed to merge will not become associated/managed with this EntityManager.
  748.      *
  749.      * @deprecated 2.7 This method is being removed from the ORM and won't have any replacement
  750.      *
  751.      * @param object $entity The detached entity to merge into the persistence context.
  752.      *
  753.      * @return object The managed copy of the entity.
  754.      *
  755.      * @throws ORMInvalidArgumentException
  756.      * @throws ORMException
  757.      */
  758.     public function merge($entity)
  759.     {
  760.         Deprecation::trigger(
  761.             'doctrine/orm',
  762.             'https://github.com/doctrine/orm/issues/8461',
  763.             'Method %s() is deprecated and will be removed in Doctrine ORM 3.0.',
  764.             __METHOD__
  765.         );
  767.         if (! is_object($entity)) {
  768.             throw ORMInvalidArgumentException::invalidObject('EntityManager#merge()', $entity);
  769.         }
  771.         $this->errorIfClosed();
  773.         return $this->unitOfWork->merge($entity);
  774.     }
  776.     /**
  777.      * {@inheritDoc}
  778.      *
  779.      * @psalm-return never
  780.      */
  781.     public function copy($entity, $deep = false)
  782.     {
  783.         Deprecation::trigger(
  784.             'doctrine/orm',
  785.             'https://github.com/doctrine/orm/issues/8462',
  786.             'Method %s() is deprecated and will be removed in Doctrine ORM 3.0.',
  787.             __METHOD__
  788.         );
  790.         throw new BadMethodCallException('Not implemented.');
  791.     }
  793.     /**
  794.      * {@inheritDoc}
  795.      */
  796.     public function lock($entity, $lockMode, $lockVersion = null)
  797.     {
  798.         $this->unitOfWork->lock($entity, $lockMode, $lockVersion);
  799.     }
  801.     /**
  802.      * Gets the repository for an entity class.
  803.      *
  804.      * @param string $entityName The name of the entity.
  805.      * @psalm-param class-string<T> $entityName
  806.      *
  807.      * @return ObjectRepository|EntityRepository The repository class.
  808.      * @psalm-return EntityRepository<T>
  809.      *
  810.      * @template T of object
  811.      */
  812.     public function getRepository($entityName)
  813.     {
  814.         if (strpos($entityName, ':') !== false) {
  815.             if (class_exists(PersistentObject::class)) {
  816.                 Deprecation::trigger(
  817.                     'doctrine/orm',
  818.                     'https://github.com/doctrine/orm/issues/8818',
  819.                     'Short namespace aliases such as "%s" are deprecated and will be removed in Doctrine ORM 3.0.',
  820.                     $entityName
  821.                 );
  822.             } else {
  823.                 throw NotSupported::createForPersistence3(sprintf(
  824.                     'Using short namespace alias "%s" when calling %s',
  825.                     $entityName,
  826.                     __METHOD__
  827.                 ));
  828.             }
  829.         }
  831.         $repository = $this->repositoryFactory->getRepository($this, $entityName);
  832.         if (! $repository instanceof EntityRepository) {
  833.             Deprecation::trigger(
  834.                 'doctrine/orm',
  835.                 'https://github.com/doctrine/orm/pull/9533',
  836.                 'Not returning an instance of %s from %s::getRepository() is deprecated and will cause a TypeError on 3.0.',
  837.                 EntityRepository::class,
  838.                 get_debug_type($this->repositoryFactory)
  839.             );
  840.         }
  842.         return $repository;
  843.     }
  845.     /**
  846.      * Determines whether an entity instance is managed in this EntityManager.
  847.      *
  848.      * @param object $entity
  849.      *
  850.      * @return bool TRUE if this EntityManager currently manages the given entity, FALSE otherwise.
  851.      */
  852.     public function contains($entity)
  853.     {
  854.         return $this->unitOfWork->isScheduledForInsert($entity)
  855.             || $this->unitOfWork->isInIdentityMap($entity)
  856.             && ! $this->unitOfWork->isScheduledForDelete($entity);
  857.     }
  859.     /**
  860.      * {@inheritDoc}
  861.      */
  862.     public function getEventManager()
  863.     {
  864.         return $this->eventManager;
  865.     }
  867.     /**
  868.      * {@inheritDoc}
  869.      */
  870.     public function getConfiguration()
  871.     {
  872.         return $this->config;
  873.     }
  875.     /**
  876.      * Throws an exception if the EntityManager is closed or currently not active.
  877.      *
  878.      * @throws EntityManagerClosed If the EntityManager is closed.
  879.      */
  880.     private function errorIfClosed(): void
  881.     {
  882.         if ($this->closed) {
  883.             throw EntityManagerClosed::create();
  884.         }
  885.     }
  887.     /**
  888.      * {@inheritDoc}
  889.      */
  890.     public function isOpen()
  891.     {
  892.         return ! $this->closed;
  893.     }
  895.     /**
  896.      * {@inheritDoc}
  897.      */
  898.     public function getUnitOfWork()
  899.     {
  900.         return $this->unitOfWork;
  901.     }
  903.     /**
  904.      * {@inheritDoc}
  905.      */
  906.     public function getHydrator($hydrationMode)
  907.     {
  908.         return $this->newHydrator($hydrationMode);
  909.     }
  911.     /**
  912.      * {@inheritDoc}
  913.      */
  914.     public function newHydrator($hydrationMode)
  915.     {
  916.         switch ($hydrationMode) {
  917.             case Query::HYDRATE_OBJECT:
  918.                 return new Internal\Hydration\ObjectHydrator($this);
  920.             case Query::HYDRATE_ARRAY:
  921.                 return new Internal\Hydration\ArrayHydrator($this);
  923.             case Query::HYDRATE_SCALAR:
  924.                 return new Internal\Hydration\ScalarHydrator($this);
  926.             case Query::HYDRATE_SINGLE_SCALAR:
  927.                 return new Internal\Hydration\SingleScalarHydrator($this);
  929.             case Query::HYDRATE_SIMPLEOBJECT:
  930.                 return new Internal\Hydration\SimpleObjectHydrator($this);
  932.             case Query::HYDRATE_SCALAR_COLUMN:
  933.                 return new Internal\Hydration\ScalarColumnHydrator($this);
  935.             default:
  936.                 $class = $this->config->getCustomHydrationMode($hydrationMode);
  938.                 if ($class !== null) {
  939.                     return new $class($this);
  940.                 }
  941.         }
  943.         throw InvalidHydrationMode::fromMode((string) $hydrationMode);
  944.     }
  946.     /**
  947.      * {@inheritDoc}
  948.      */
  949.     public function getProxyFactory()
  950.     {
  951.         return $this->proxyFactory;
  952.     }
  954.     /**
  955.      * {@inheritDoc}
  956.      */
  957.     public function initializeObject($obj)
  958.     {
  959.         $this->unitOfWork->initializeObject($obj);
  960.     }
  962.     /**
  963.      * {@inheritDoc}
  964.      */
  965.     public function isUninitializedObject($obj): bool
  966.     {
  967.         return $this->unitOfWork->isUninitializedObject($obj);
  968.     }
  970.     /**
  971.      * Factory method to create EntityManager instances.
  972.      *
  973.      * @deprecated Use {@see DriverManager::getConnection()} to bootstrap the connection and call the constructor.
  974.      *
  975.      * @param mixed[]|Connection $connection   An array with the connection parameters or an existing Connection instance.
  976.      * @param Configuration      $config       The Configuration instance to use.
  977.      * @param EventManager|null  $eventManager The EventManager instance to use.
  978.      * @psalm-param array<string, mixed>|Connection $connection
  979.      *
  980.      * @return EntityManager The created EntityManager.
  981.      *
  982.      * @throws InvalidArgumentException
  983.      * @throws ORMException
  984.      */
  985.     public static function create($connection, Configuration $config, ?EventManager $eventManager = null)
  986.     {
  987.         Deprecation::trigger(
  988.             'doctrine/orm',
  989.             'https://github.com/doctrine/orm/pull/9961',
  990.             '%s() is deprecated. To bootstrap a DBAL connection, call %s::getConnection() instead. Use the constructor to create an instance of %s.',
  991.             __METHOD__,
  992.             DriverManager::class,
  993.             self::class
  994.         );
  996.         $connection = static::createConnection($connection, $config, $eventManager);
  998.         return new EntityManager($connection, $config);
  999.     }
  1001.     /**
  1002.      * Factory method to create Connection instances.
  1003.      *
  1004.      * @deprecated Use {@see DriverManager::getConnection()} to bootstrap the connection.
  1005.      *
  1006.      * @param mixed[]|Connection $connection   An array with the connection parameters or an existing Connection instance.
  1007.      * @param Configuration      $config       The Configuration instance to use.
  1008.      * @param EventManager|null  $eventManager The EventManager instance to use.
  1009.      * @psalm-param array<string, mixed>|Connection $connection
  1010.      *
  1011.      * @return Connection
  1012.      *
  1013.      * @throws InvalidArgumentException
  1014.      * @throws ORMException
  1015.      */
  1016.     protected static function createConnection($connection, Configuration $config, ?EventManager $eventManager = null)
  1017.     {
  1018.         Deprecation::triggerIfCalledFromOutside(
  1019.             'doctrine/orm',
  1020.             'https://github.com/doctrine/orm/pull/9961',
  1021.             '%s() is deprecated, call %s::getConnection() instead.',
  1022.             __METHOD__,
  1023.             DriverManager::class
  1024.         );
  1026.         if (is_array($connection)) {
  1027.             return DriverManager::getConnection($connection, $config, $eventManager ?: new EventManager());
  1028.         }
  1030.         if (! $connection instanceof Connection) {
  1031.             throw new InvalidArgumentException(
  1032.                 sprintf(
  1033.                     'Invalid $connection argument of type %s given%s.',
  1034.                     get_debug_type($connection),
  1035.                     is_object($connection) ? '' : ': "' . $connection . '"'
  1036.                 )
  1037.             );
  1038.         }
  1040.         if ($eventManager !== null && $connection->getEventManager() !== $eventManager) {
  1041.             throw MismatchedEventManager::create();
  1042.         }
  1044.         return $connection;
  1045.     }
  1047.     /**
  1048.      * {@inheritDoc}
  1049.      */
  1050.     public function getFilters()
  1051.     {
  1052.         if ($this->filterCollection === null) {
  1053.             $this->filterCollection = new FilterCollection($this);
  1054.         }
  1056.         return $this->filterCollection;
  1057.     }
  1059.     /**
  1060.      * {@inheritDoc}
  1061.      */
  1062.     public function isFiltersStateClean()
  1063.     {
  1064.         return $this->filterCollection === null || $this->filterCollection->isClean();
  1065.     }
  1067.     /**
  1068.      * {@inheritDoc}
  1069.      */
  1070.     public function hasFilters()
  1071.     {
  1072.         return $this->filterCollection !== null;
  1073.     }
  1075.     /**
  1076.      * @psalm-param LockMode::* $lockMode
  1077.      *
  1078.      * @throws OptimisticLockException
  1079.      * @throws TransactionRequiredException
  1080.      */
  1081.     private function checkLockRequirements(int $lockMode, ClassMetadata $class): void
  1082.     {
  1083.         switch ($lockMode) {
  1084.             case LockMode::OPTIMISTIC:
  1085.                 if (! $class->isVersioned) {
  1086.                     throw OptimisticLockException::notVersioned($class->name);
  1087.                 }
  1089.                 break;
  1090.             case LockMode::PESSIMISTIC_READ:
  1091.             case LockMode::PESSIMISTIC_WRITE:
  1092.                 if (! $this->getConnection()->isTransactionActive()) {
  1093.                     throw TransactionRequiredException::transactionRequired();
  1094.                 }
  1095.         }
  1096.     }
  1098.     private function configureMetadataCache(): void
  1099.     {
  1100.         $metadataCache = $this->config->getMetadataCache();
  1101.         if (! $metadataCache) {
  1102.             $this->configureLegacyMetadataCache();
  1104.             return;
  1105.         }
  1107.         $this->metadataFactory->setCache($metadataCache);
  1108.     }
  1110.     private function configureLegacyMetadataCache(): void
  1111.     {
  1112.         $metadataCache = $this->config->getMetadataCacheImpl();
  1113.         if (! $metadataCache) {
  1114.             return;
  1115.         }
  1117.         // Wrap doctrine/cache to provide PSR-6 interface
  1118.         $this->metadataFactory->setCache(CacheAdapter::wrap($metadataCache));
  1119.     }
  1120. }