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

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