vendor/doctrine/orm/lib/Doctrine/ORM/ORMException.php line 310

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 Doctrine\Common\Cache\Cache as CacheDriver;
  24. use Doctrine\Persistence\ObjectRepository;
  25. use Exception;
  27. use function get_class;
  28. use function implode;
  29. use function sprintf;
  31. /**
  32.  * Base exception class for all ORM exceptions.
  33.  */
  34. class ORMException extends Exception
  35. {
  36.     /**
  37.      * @return ORMException
  38.      */
  39.     public static function missingMappingDriverImpl()
  40.     {
  41.         return new self("It's a requirement to specify a Metadata Driver and pass it " .
  42.             'to Doctrine\\ORM\\Configuration::setMetadataDriverImpl().');
  43.     }
  45.     /**
  46.      * @param string $queryName
  47.      *
  48.      * @return ORMException
  49.      */
  50.     public static function namedQueryNotFound($queryName)
  51.     {
  52.         return new self('Could not find a named query by the name "' . $queryName . '"');
  53.     }
  55.     /**
  56.      * @param string $nativeQueryName
  57.      *
  58.      * @return ORMException
  59.      */
  60.     public static function namedNativeQueryNotFound($nativeQueryName)
  61.     {
  62.         return new self('Could not find a named native query by the name "' . $nativeQueryName . '"');
  63.     }
  65.     /**
  66.      * @param object $entity
  67.      * @param object $relatedEntity
  68.      *
  69.      * @return ORMException
  70.      */
  71.     public static function entityMissingForeignAssignedId($entity, $relatedEntity)
  72.     {
  73.         return new self(
  74.             'Entity of type ' . get_class($entity) . ' has identity through a foreign entity ' . get_class($relatedEntity) . ', ' .
  75.             'however this entity has no identity itself. You have to call EntityManager#persist() on the related entity ' .
  76.             "and make sure that an identifier was generated before trying to persist '" . get_class($entity) . "'. In case " .
  77.             'of Post Insert ID Generation (such as MySQL Auto-Increment) this means you have to call ' .
  78.             'EntityManager#flush() between both persist operations.'
  79.         );
  80.     }
  82.     /**
  83.      * @param object $entity
  84.      * @param string $field
  85.      *
  86.      * @return ORMException
  87.      */
  88.     public static function entityMissingAssignedIdForField($entity, $field)
  89.     {
  90.         return new self('Entity of type ' . get_class($entity) . " is missing an assigned ID for field  '" . $field . "'. " .
  91.             'The identifier generation strategy for this entity requires the ID field to be populated before ' .
  92.             'EntityManager#persist() is called. If you want automatically generated identifiers instead ' .
  93.             'you need to adjust the metadata mapping accordingly.');
  94.     }
  96.     /**
  97.      * @param string $field
  98.      *
  99.      * @return ORMException
  100.      */
  101.     public static function unrecognizedField($field)
  102.     {
  103.         return new self(sprintf('Unrecognized field: %s', $field));
  104.     }
  106.     /**
  107.      * @param string $class
  108.      * @param string $association
  109.      * @param string $given
  110.      * @param string $expected
  111.      *
  112.      * @return ORMException
  113.      */
  114.     public static function unexpectedAssociationValue($class, $association, $given, $expected)
  115.     {
  116.         return new self(sprintf('Found entity of type %s on association %s#%s, but expecting %s', $given, $class, $association, $expected));
  117.     }
  119.     /**
  120.      * @param string $className
  121.      * @param string $field
  122.      *
  123.      * @return ORMException
  124.      */
  125.     public static function invalidOrientation($className, $field)
  126.     {
  127.         return new self('Invalid order by orientation specified for ' . $className . '#' . $field);
  128.     }
  130.     /**
  131.      * @param string $mode
  132.      *
  133.      * @return ORMException
  134.      */
  135.     public static function invalidFlushMode($mode)
  136.     {
  137.         return new self(sprintf("'%s' is an invalid flush mode.", $mode));
  138.     }
  140.     /**
  141.      * @return ORMException
  142.      */
  143.     public static function entityManagerClosed()
  144.     {
  145.         return new self('The EntityManager is closed.');
  146.     }
  148.     /**
  149.      * @param string $mode
  150.      *
  151.      * @return ORMException
  152.      */
  153.     public static function invalidHydrationMode($mode)
  154.     {
  155.         return new self(sprintf("'%s' is an invalid hydration mode.", $mode));
  156.     }
  158.     /**
  159.      * @return ORMException
  160.      */
  161.     public static function mismatchedEventManager()
  162.     {
  163.         return new self('Cannot use different EventManager instances for EntityManager and Connection.');
  164.     }
  166.     /**
  167.      * @param string $methodName
  168.      *
  169.      * @return ORMException
  170.      */
  171.     public static function findByRequiresParameter($methodName)
  172.     {
  173.         return new self("You need to pass a parameter to '" . $methodName . "'");
  174.     }
  176.     /**
  177.      * @param string $entityName
  178.      * @param string $fieldName
  179.      * @param string $method
  180.      *
  181.      * @return ORMException
  182.      */
  183.     public static function invalidFindByCall($entityName, $fieldName, $method)
  184.     {
  185.         return new self(
  186.             "Entity '" . $entityName . "' has no field '" . $fieldName . "'. " .
  187.             "You can therefore not call '" . $method . "' on the entities' repository"
  188.         );
  189.     }
  191.     /**
  192.      * @param string $entityName
  193.      * @param string $fieldName
  194.      * @param string $method
  195.      *
  196.      * @return ORMException
  197.      */
  198.     public static function invalidMagicCall($entityName, $fieldName, $method)
  199.     {
  200.         return new self(
  201.             "Entity '" . $entityName . "' has no field '" . $fieldName . "'. " .
  202.             "You can therefore not call '" . $method . "' on the entities' repository"
  203.         );
  204.     }
  206.     /**
  207.      * @param string $entityName
  208.      * @param string $associationFieldName
  209.      *
  210.      * @return ORMException
  211.      */
  212.     public static function invalidFindByInverseAssociation($entityName, $associationFieldName)
  213.     {
  214.         return new self(
  215.             "You cannot search for the association field '" . $entityName . '#' . $associationFieldName . "', " .
  216.             'because it is the inverse side of an association. Find methods only work on owning side associations.'
  217.         );
  218.     }
  220.     /**
  221.      * @return ORMException
  222.      */
  223.     public static function invalidResultCacheDriver()
  224.     {
  225.         return new self('Invalid result cache driver; it must implement Doctrine\\Common\\Cache\\Cache.');
  226.     }
  228.     /**
  229.      * @return ORMException
  230.      */
  231.     public static function notSupported()
  232.     {
  233.         return new self('This behaviour is (currently) not supported by Doctrine 2');
  234.     }
  236.     /**
  237.      * @return ORMException
  238.      */
  239.     public static function queryCacheNotConfigured()
  240.     {
  241.         return new self('Query Cache is not configured.');
  242.     }
  244.     /**
  245.      * @return ORMException
  246.      */
  247.     public static function metadataCacheNotConfigured()
  248.     {
  249.         return new self('Class Metadata Cache is not configured.');
  250.     }
  252.     /**
  253.      * @return ORMException
  254.      */
  255.     public static function queryCacheUsesNonPersistentCache(CacheDriver $cache)
  256.     {
  257.         return new self('Query Cache uses a non-persistent cache driver, ' . get_class($cache) . '.');
  258.     }
  260.     /**
  261.      * @return ORMException
  262.      */
  263.     public static function metadataCacheUsesNonPersistentCache(CacheDriver $cache)
  264.     {
  265.         return new self('Metadata Cache uses a non-persistent cache driver, ' . get_class($cache) . '.');
  266.     }
  268.     /**
  269.      * @return ORMException
  270.      */
  271.     public static function proxyClassesAlwaysRegenerating()
  272.     {
  273.         return new self('Proxy Classes are always regenerating.');
  274.     }
  276.     /**
  277.      * @param string $entityNamespaceAlias
  278.      *
  279.      * @return ORMException
  280.      */
  281.     public static function unknownEntityNamespace($entityNamespaceAlias)
  282.     {
  283.         return new self(
  284.             sprintf("Unknown Entity namespace alias '%s'.", $entityNamespaceAlias)
  285.         );
  286.     }
  288.     /**
  289.      * @param string $className
  290.      *
  291.      * @return ORMException
  292.      */
  293.     public static function invalidEntityRepository($className)
  294.     {
  295.         return new self(sprintf(
  296.             "Invalid repository class '%s'. It must be a %s.",
  297.             $className,
  298.             ObjectRepository::class
  299.         ));
  300.     }
  302.     /**
  303.      * @param string $className
  304.      * @param string $fieldName
  305.      *
  306.      * @return ORMException
  307.      */
  308.     public static function missingIdentifierField($className, $fieldName)
  309.     {
  310.         return new self(sprintf('The identifier %s is missing for a query of %s', $fieldName, $className));
  311.     }
  313.     /**
  314.      * @param string   $className
  315.      * @param string[] $fieldNames
  316.      *
  317.      * @return ORMException
  318.      */
  319.     public static function unrecognizedIdentifierFields($className, $fieldNames)
  320.     {
  321.         return new self(
  322.             "Unrecognized identifier fields: '" . implode("', '", $fieldNames) . "' " .
  323.             "are not present on class '" . $className . "'."
  324.         );
  325.     }
  327.     /**
  328.      * @return ORMException
  329.      */
  330.     public static function cantUseInOperatorOnCompositeKeys()
  331.     {
  332.         return new self("Can't use IN operator on entities that have composite keys.");
  333.     }
  334. }