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

Open in your IDE?
  1. <?php
  2. /*
  3.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  4.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  5.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  6.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  7.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  8.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  9.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  *
  15.  * This software consists of voluntary contributions made by many individuals
  16.  * and is licensed under the MIT license. For more information, see
  17.  * <http://www.doctrine-project.org>.
  18.  */
  20. namespace Doctrine\ORM;
  22. use Doctrine\Common\Inflector\Inflector;
  23. use Doctrine\ORM\Query\ResultSetMappingBuilder;
  24. use Doctrine\Common\Persistence\ObjectRepository;
  25. use Doctrine\Common\Collections\Selectable;
  26. use Doctrine\Common\Collections\Criteria;
  28. /**
  29.  * An EntityRepository serves as a repository for entities with generic as well as
  30.  * business specific methods for retrieving entities.
  31.  *
  32.  * This class is designed for inheritance and users can subclass this class to
  33.  * write their own repositories with business-specific methods to locate entities.
  34.  *
  35.  * @since   2.0
  36.  * @author  Benjamin Eberlei <kontakt@beberlei.de>
  37.  * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>
  38.  * @author  Jonathan Wage <jonwage@gmail.com>
  39.  * @author  Roman Borschel <roman@code-factory.org>
  40.  */
  41. class EntityRepository implements ObjectRepository, Selectable
  42. {
  43.     /**
  44.      * @var string
  45.      */
  46.     protected $_entityName;
  48.     /**
  49.      * @var EntityManager
  50.      */
  51.     protected $_em;
  53.     /**
  54.      * @var \Doctrine\ORM\Mapping\ClassMetadata
  55.      */
  56.     protected $_class;
  58.     /**
  59.      * Initializes a new <tt>EntityRepository</tt>.
  60.      *
  61.      * @param EntityManager         $em    The EntityManager to use.
  62.      * @param Mapping\ClassMetadata $class The class descriptor.
  63.      */
  64.     public function __construct(EntityManagerInterface $em, Mapping\ClassMetadata $class)
  65.     {
  66.         $this->_entityName = $class->name;
  67.         $this->_em         = $em;
  68.         $this->_class      = $class;
  69.     }
  71.     /**
  72.      * Creates a new QueryBuilder instance that is prepopulated for this entity name.
  73.      *
  74.      * @param string $alias
  75.      * @param string $indexBy The index for the from.
  76.      *
  77.      * @return QueryBuilder
  78.      */
  79.     public function createQueryBuilder($alias, $indexBy = null)
  80.     {
  81.         return $this->_em->createQueryBuilder()
  82.             ->select($alias)
  83.             ->from($this->_entityName, $alias, $indexBy);
  84.     }
  86.     /**
  87.      * Creates a new result set mapping builder for this entity.
  88.      *
  89.      * The column naming strategy is "INCREMENT".
  90.      *
  91.      * @param string $alias
  92.      *
  93.      * @return ResultSetMappingBuilder
  94.      */
  95.     public function createResultSetMappingBuilder($alias)
  96.     {
  97.         $rsm = new ResultSetMappingBuilder($this->_em, ResultSetMappingBuilder::COLUMN_RENAMING_INCREMENT);
  98.         $rsm->addRootEntityFromClassMetadata($this->_entityName, $alias);
  100.         return $rsm;
  101.     }
  103.     /**
  104.      * Creates a new Query instance based on a predefined metadata named query.
  105.      *
  106.      * @param string $queryName
  107.      *
  108.      * @return Query
  109.      */
  110.     public function createNamedQuery($queryName)
  111.     {
  112.         return $this->_em->createQuery($this->_class->getNamedQuery($queryName));
  113.     }
  115.     /**
  116.      * Creates a native SQL query.
  117.      *
  118.      * @param string $queryName
  119.      *
  120.      * @return NativeQuery
  121.      */
  122.     public function createNativeNamedQuery($queryName)
  123.     {
  124.         $queryMapping   = $this->_class->getNamedNativeQuery($queryName);
  125.         $rsm            = new Query\ResultSetMappingBuilder($this->_em);
  126.         $rsm->addNamedNativeQueryMapping($this->_class, $queryMapping);
  128.         return $this->_em->createNativeQuery($queryMapping['query'], $rsm);
  129.     }
  131.     /**
  132.      * Clears the repository, causing all managed entities to become detached.
  133.      *
  134.      * @return void
  135.      */
  136.     public function clear()
  137.     {
  138.         $this->_em->clear($this->_class->rootEntityName);
  139.     }
  141.     /**
  142.      * Finds an entity by its primary key / identifier.
  143.      *
  144.      * @param mixed    $id          The identifier.
  145.      * @param int|null $lockMode    One of the \Doctrine\DBAL\LockMode::* constants
  146.      *                              or NULL if no specific lock mode should be used
  147.      *                              during the search.
  148.      * @param int|null $lockVersion The lock version.
  149.      *
  150.      * @return object|null The entity instance or NULL if the entity can not be found.
  151.      */
  152.     public function find($id, $lockMode = null, $lockVersion = null)
  153.     {
  154.         return $this->_em->find($this->_entityName, $id, $lockMode, $lockVersion);
  155.     }
  157.     /**
  158.      * Finds all entities in the repository.
  159.      *
  160.      * @return array The entities.
  161.      */
  162.     public function findAll()
  163.     {
  164.         return $this->findBy([]);
  165.     }
  167.     /**
  168.      * Finds entities by a set of criteria.
  169.      *
  170.      * @param array      $criteria
  171.      * @param array|null $orderBy
  172.      * @param int|null   $limit
  173.      * @param int|null   $offset
  174.      *
  175.      * @return array The objects.
  176.      */
  177.     public function findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
  178.     {
  179.         $persister = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName);
  181.         return $persister->loadAll($criteria, $orderBy, $limit, $offset);
  182.     }
  184.     /**
  185.      * Finds a single entity by a set of criteria.
  186.      *
  187.      * @param array      $criteria
  188.      * @param array|null $orderBy
  189.      *
  190.      * @return object|null The entity instance or NULL if the entity can not be found.
  191.      */
  192.     public function findOneBy(array $criteria, array $orderBy = null)
  193.     {
  194.         $persister = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName);
  196.         return $persister->load($criteria, null, null, [], null, 1, $orderBy);
  197.     }
  199.     /**
  200.      * Counts entities by a set of criteria.
  201.      *
  202.      * @todo Add this method to `ObjectRepository` interface in the next major release
  203.      *
  204.      * @param array $criteria
  205.      *
  206.      * @return int The cardinality of the objects that match the given criteria.
  207.      */
  208.     public function count(array $criteria)
  209.     {
  210.         return $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName)->count($criteria);
  211.     }
  213.     /**
  214.      * Adds support for magic method calls.
  215.      *
  216.      * @param string $method
  217.      * @param array  $arguments
  218.      *
  219.      * @return mixed The returned value from the resolved method.
  220.      *
  221.      * @throws ORMException
  222.      * @throws \BadMethodCallException If the method called is invalid
  223.      */
  224.     public function __call($method, $arguments)
  225.     {
  226.         if (0 === strpos($method, 'findBy')) {
  227.             return $this->resolveMagicCall('findBy', substr($method, 6), $arguments);
  228.         }
  230.         if (0 === strpos($method, 'findOneBy')) {
  231.             return $this->resolveMagicCall('findOneBy', substr($method, 9), $arguments);
  232.         }
  234.         if (0 === strpos($method, 'countBy')) {
  235.             return $this->resolveMagicCall('count', substr($method, 7), $arguments);
  236.         }
  238.         throw new \BadMethodCallException(
  239.             "Undefined method '$method'. The method name must start with ".
  240.             "either findBy, findOneBy or countBy!"
  241.         );
  242.     }
  244.     /**
  245.      * @return string
  246.      */
  247.     protected function getEntityName()
  248.     {
  249.         return $this->_entityName;
  250.     }
  252.     /**
  253.      * @return string
  254.      */
  255.     public function getClassName()
  256.     {
  257.         return $this->getEntityName();
  258.     }
  260.     /**
  261.      * @return EntityManager
  262.      */
  263.     protected function getEntityManager()
  264.     {
  265.         return $this->_em;
  266.     }
  268.     /**
  269.      * @return Mapping\ClassMetadata
  270.      */
  271.     protected function getClassMetadata()
  272.     {
  273.         return $this->_class;
  274.     }
  276.     /**
  277.      * Select all elements from a selectable that match the expression and
  278.      * return a new collection containing these elements.
  279.      *
  280.      * @param \Doctrine\Common\Collections\Criteria $criteria
  281.      *
  282.      * @return \Doctrine\Common\Collections\Collection
  283.      */
  284.     public function matching(Criteria $criteria)
  285.     {
  286.         $persister = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName);
  288.         return new LazyCriteriaCollection($persister, $criteria);
  289.     }
  291.     /**
  292.      * Resolves a magic method call to the proper existent method at `EntityRepository`.
  293.      *
  294.      * @param string $method    The method to call
  295.      * @param string $by        The property name used as condition
  296.      * @param array  $arguments The arguments to pass at method call
  297.      *
  298.      * @throws ORMException If the method called is invalid or the requested field/association does not exist
  299.      *
  300.      * @return mixed
  301.      */
  302.     private function resolveMagicCall($method, $by, array $arguments)
  303.     {
  304.         if (! $arguments) {
  305.             throw ORMException::findByRequiresParameter($method . $by);
  306.         }
  308.         $fieldName = lcfirst(Inflector::classify($by));
  310.         if (! ($this->_class->hasField($fieldName) || $this->_class->hasAssociation($fieldName))) {
  311.             throw ORMException::invalidMagicCall($this->_entityName, $fieldName, $method . $by);
  312.         }
  314.         return $this->$method([$fieldName => $arguments[0]], ...array_slice($arguments, 1));
  315.     }
  316. }