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

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