vendor/doctrine/orm/lib/Doctrine/ORM/EntityRepository.php line 203

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM;
  7. use BadMethodCallException;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\Common\Collections\Criteria;
  10. use Doctrine\Common\Collections\Selectable;
  11. use Doctrine\DBAL\LockMode;
  12. use Doctrine\Deprecations\Deprecation;
  13. use Doctrine\Inflector\Inflector;
  14. use Doctrine\Inflector\InflectorFactory;
  15. use Doctrine\ORM\Mapping\ClassMetadata;
  16. use Doctrine\ORM\Query\ResultSetMappingBuilder;
  17. use Doctrine\ORM\Repository\Exception\InvalidMagicMethodCall;
  18. use Doctrine\Persistence\ObjectRepository;
  20. use function array_slice;
  21. use function lcfirst;
  22. use function sprintf;
  23. use function strpos;
  24. use function substr;
  26. /**
  27.  * An EntityRepository serves as a repository for entities with generic as well as
  28.  * business specific methods for retrieving entities.
  29.  *
  30.  * This class is designed for inheritance and users can subclass this class to
  31.  * write their own repositories with business-specific methods to locate entities.
  32.  *
  33.  * @template T
  34.  * @template-implements Selectable<int,T>
  35.  * @template-implements ObjectRepository<T>
  36.  */
  37. class EntityRepository implements ObjectRepository, Selectable
  38. {
  39.     /** @var string */
  40.     protected $_entityName;
  42.     /** @var EntityManagerInterface */
  43.     protected $_em;
  45.     /** @var ClassMetadata */
  46.     protected $_class;
  48.     /** @var Inflector */
  49.     private static $inflector;
  51.     /**
  52.      * Initializes a new <tt>EntityRepository</tt>.
  53.      */
  54.     public function __construct(EntityManagerInterface $em, Mapping\ClassMetadata $class)
  55.     {
  56.         $this->_entityName = $class->name;
  57.         $this->_em         = $em;
  58.         $this->_class      = $class;
  59.     }
  61.     /**
  62.      * Creates a new QueryBuilder instance that is prepopulated for this entity name.
  63.      *
  64.      * @param string $alias
  65.      * @param string $indexBy The index for the from.
  66.      *
  67.      * @return QueryBuilder
  68.      */
  69.     public function createQueryBuilder($alias, $indexBy = null)
  70.     {
  71.         return $this->_em->createQueryBuilder()
  72.             ->select($alias)
  73.             ->from($this->_entityName, $alias, $indexBy);
  74.     }
  76.     /**
  77.      * Creates a new result set mapping builder for this entity.
  78.      *
  79.      * The column naming strategy is "INCREMENT".
  80.      *
  81.      * @param string $alias
  82.      *
  83.      * @return ResultSetMappingBuilder
  84.      */
  85.     public function createResultSetMappingBuilder($alias)
  86.     {
  87.         $rsm = new ResultSetMappingBuilder($this->_em, ResultSetMappingBuilder::COLUMN_RENAMING_INCREMENT);
  88.         $rsm->addRootEntityFromClassMetadata($this->_entityName, $alias);
  90.         return $rsm;
  91.     }
  93.     /**
  94.      * Creates a new Query instance based on a predefined metadata named query.
  95.      *
  96.      * @deprecated
  97.      *
  98.      * @param string $queryName
  99.      *
  100.      * @return Query
  101.      */
  102.     public function createNamedQuery($queryName)
  103.     {
  104.         Deprecation::trigger(
  105.             'doctrine/orm',
  106.             'https://github.com/doctrine/orm/issues/8592',
  107.             'Named Queries are deprecated, here "%s" on entity %s. Move the query logic into EntityRepository',
  108.             $queryName,
  109.             $this->_class->name
  110.         );
  112.         return $this->_em->createQuery($this->_class->getNamedQuery($queryName));
  113.     }
  115.     /**
  116.      * Creates a native SQL query.
  117.      *
  118.      * @deprecated
  119.      *
  120.      * @param string $queryName
  121.      *
  122.      * @return NativeQuery
  123.      */
  124.     public function createNativeNamedQuery($queryName)
  125.     {
  126.         Deprecation::trigger(
  127.             'doctrine/orm',
  128.             'https://github.com/doctrine/orm/issues/8592',
  129.             'Named Native Queries are deprecated, here "%s" on entity %s. Move the query logic into EntityRepository',
  130.             $queryName,
  131.             $this->_class->name
  132.         );
  134.         $queryMapping = $this->_class->getNamedNativeQuery($queryName);
  135.         $rsm          = new Query\ResultSetMappingBuilder($this->_em);
  136.         $rsm->addNamedNativeQueryMapping($this->_class, $queryMapping);
  138.         return $this->_em->createNativeQuery($queryMapping['query'], $rsm);
  139.     }
  141.     /**
  142.      * Clears the repository, causing all managed entities to become detached.
  143.      *
  144.      * @deprecated 2.8 This method is being removed from the ORM and won't have any replacement
  145.      *
  146.      * @return void
  147.      */
  148.     public function clear()
  149.     {
  150.         Deprecation::trigger(
  151.             'doctrine/orm',
  152.             'https://github.com/doctrine/orm/issues/8460',
  153.             'Calling %s() is deprecated and will not be supported in Doctrine ORM 3.0.',
  154.             __METHOD__
  155.         );
  157.         $this->_em->clear($this->_class->rootEntityName);
  158.     }
  160.     /**
  161.      * Finds an entity by its primary key / identifier.
  162.      *
  163.      * @param mixed    $id          The identifier.
  164.      * @param int|null $lockMode    One of the \Doctrine\DBAL\LockMode::* constants
  165.      *                              or NULL if no specific lock mode should be used
  166.      *                              during the search.
  167.      * @param int|null $lockVersion The lock version.
  168.      * @psalm-param LockMode::*|null $lockMode
  169.      *
  170.      * @return object|null The entity instance or NULL if the entity can not be found.
  171.      * @psalm-return ?T
  172.      */
  173.     public function find($id, $lockMode = null, $lockVersion = null)
  174.     {
  175.         return $this->_em->find($this->_entityName, $id, $lockMode, $lockVersion);
  176.     }
  178.     /**
  179.      * Finds all entities in the repository.
  180.      *
  181.      * @psalm-return list<T> The entities.
  182.      */
  183.     public function findAll()
  184.     {
  185.         return $this->findBy([]);
  186.     }
  188.     /**
  189.      * Finds entities by a set of criteria.
  190.      *
  191.      * @param int|null $limit
  192.      * @param int|null $offset
  193.      * @psalm-param array<string, mixed> $criteria
  194.      * @psalm-param array<string, string>|null $orderBy
  195.      *
  196.      * @return object[] The objects.
  197.      * @psalm-return list<T>
  198.      */
  199.     public function findBy(array $criteria, ?array $orderBy = null, $limit = null, $offset = null)
  200.     {
  201.         $persister = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName);
  203.         return $persister->loadAll($criteria, $orderBy, $limit, $offset);
  204.     }
  206.     /**
  207.      * Finds a single entity by a set of criteria.
  208.      *
  209.      * @psalm-param array<string, mixed> $criteria
  210.      * @psalm-param array<string, string>|null $orderBy
  211.      *
  212.      * @return object|null The entity instance or NULL if the entity can not be found.
  213.      * @psalm-return ?T
  214.      */
  215.     public function findOneBy(array $criteria, ?array $orderBy = null)
  216.     {
  217.         $persister = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName);
  219.         return $persister->load($criteria, null, null, [], null, 1, $orderBy);
  220.     }
  222.     /**
  223.      * Counts entities by a set of criteria.
  224.      *
  225.      * @psalm-param array<string, mixed> $criteria
  226.      *
  227.      * @return int The cardinality of the objects that match the given criteria.
  228.      *
  229.      * @todo Add this method to `ObjectRepository` interface in the next major release
  230.      */
  231.     public function count(array $criteria)
  232.     {
  233.         return $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName)->count($criteria);
  234.     }
  236.     /**
  237.      * Adds support for magic method calls.
  238.      *
  239.      * @param string  $method
  240.      * @param mixed[] $arguments
  241.      * @psalm-param list<mixed> $arguments
  242.      *
  243.      * @return mixed The returned value from the resolved method.
  244.      *
  245.      * @throws BadMethodCallException If the method called is invalid.
  246.      */
  247.     public function __call($method, $arguments)
  248.     {
  249.         if (strpos($method, 'findBy') === 0) {
  250.             return $this->resolveMagicCall('findBy', substr($method, 6), $arguments);
  251.         }
  253.         if (strpos($method, 'findOneBy') === 0) {
  254.             return $this->resolveMagicCall('findOneBy', substr($method, 9), $arguments);
  255.         }
  257.         if (strpos($method, 'countBy') === 0) {
  258.             return $this->resolveMagicCall('count', substr($method, 7), $arguments);
  259.         }
  261.         throw new BadMethodCallException(sprintf(
  262.             'Undefined method "%s". The method name must start with ' .
  263.             'either findBy, findOneBy or countBy!',
  264.             $method
  265.         ));
  266.     }
  268.     /**
  269.      * @return string
  270.      */
  271.     protected function getEntityName()
  272.     {
  273.         return $this->_entityName;
  274.     }
  276.     /**
  277.      * @return string
  278.      */
  279.     public function getClassName()
  280.     {
  281.         return $this->getEntityName();
  282.     }
  284.     /**
  285.      * @return EntityManagerInterface
  286.      */
  287.     protected function getEntityManager()
  288.     {
  289.         return $this->_em;
  290.     }
  292.     /**
  293.      * @return Mapping\ClassMetadata
  294.      */
  295.     protected function getClassMetadata()
  296.     {
  297.         return $this->_class;
  298.     }
  300.     /**
  301.      * Select all elements from a selectable that match the expression and
  302.      * return a new collection containing these elements.
  303.      *
  304.      * @return LazyCriteriaCollection
  305.      * @psalm-return Collection<int, T>
  306.      */
  307.     public function matching(Criteria $criteria)
  308.     {
  309.         $persister = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName);
  311.         return new LazyCriteriaCollection($persister, $criteria);
  312.     }
  314.     /**
  315.      * Resolves a magic method call to the proper existent method at `EntityRepository`.
  316.      *
  317.      * @param string $method The method to call
  318.      * @param string $by     The property name used as condition
  319.      * @psalm-param list<mixed> $arguments The arguments to pass at method call
  320.      *
  321.      * @return mixed
  322.      *
  323.      * @throws InvalidMagicMethodCall If the method called is invalid or the
  324.      *                                requested field/association does not exist.
  325.      */
  326.     private function resolveMagicCall(string $method, string $by, array $arguments)
  327.     {
  328.         if (! $arguments) {
  329.             throw InvalidMagicMethodCall::onMissingParameter($method . $by);
  330.         }
  332.         if (self::$inflector === null) {
  333.             self::$inflector = InflectorFactory::create()->build();
  334.         }
  336.         $fieldName = lcfirst(self::$inflector->classify($by));
  338.         if (! ($this->_class->hasField($fieldName) || $this->_class->hasAssociation($fieldName))) {
  339.             throw InvalidMagicMethodCall::becauseFieldNotFoundIn(
  340.                 $this->_entityName,
  341.                 $fieldName,
  342.                 $method . $by
  343.             );
  344.         }
  346.         return $this->$method([$fieldName => $arguments[0]], ...array_slice($arguments, 1));
  347.     }
  348. }