vendor/doctrine/orm/lib/Doctrine/ORM/Query/QueryException.php line 41

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\Query;
  23. use Doctrine\ORM\ORMException;
  24. use Doctrine\ORM\Query\AST\PathExpression;
  25. use Exception;
  27. /**
  28.  * Description of QueryException.
  29.  *
  30.  * @link    www.doctrine-project.org
  31.  */
  32. class QueryException extends ORMException
  33. {
  34.     /**
  35.      * @param string $dql
  36.      *
  37.      * @return QueryException
  38.      */
  39.     public static function dqlError($dql)
  40.     {
  41.         return new self($dql);
  42.     }
  44.     /**
  45.      * @param string         $message
  46.      * @param Exception|null $previous
  47.      *
  48.      * @return QueryException
  49.      */
  50.     public static function syntaxError($message, $previous = null)
  51.     {
  52.         return new self('[Syntax Error] ' . $message, 0, $previous);
  53.     }
  55.     /**
  56.      * @param string         $message
  57.      * @param Exception|null $previous
  58.      *
  59.      * @return QueryException
  60.      */
  61.     public static function semanticalError($message, $previous = null)
  62.     {
  63.         return new self('[Semantical Error] ' . $message, 0, $previous);
  64.     }
  66.     /**
  67.      * @return QueryException
  68.      */
  69.     public static function invalidLockMode()
  70.     {
  71.         return new self('Invalid lock mode hint provided.');
  72.     }
  74.     /**
  75.      * @param string $expected
  76.      * @param string $received
  77.      *
  78.      * @return QueryException
  79.      */
  80.     public static function invalidParameterType($expected, $received)
  81.     {
  82.         return new self('Invalid parameter type, ' . $received . ' given, but ' . $expected . ' expected.');
  83.     }
  85.     /**
  86.      * @param string $pos
  87.      *
  88.      * @return QueryException
  89.      */
  90.     public static function invalidParameterPosition($pos)
  91.     {
  92.         return new self('Invalid parameter position: ' . $pos);
  93.     }
  95.     /**
  96.      * @param int $expected
  97.      * @param int $received
  98.      *
  99.      * @return QueryException
  100.      */
  101.     public static function tooManyParameters($expected, $received)
  102.     {
  103.         return new self('Too many parameters: the query defines ' . $expected . ' parameters and you bound ' . $received);
  104.     }
  106.     /**
  107.      * @param int $expected
  108.      * @param int $received
  109.      *
  110.      * @return QueryException
  111.      */
  112.     public static function tooFewParameters($expected, $received)
  113.     {
  114.         return new self('Too few parameters: the query defines ' . $expected . ' parameters but you only bound ' . $received);
  115.     }
  117.     /**
  118.      * @param string $value
  119.      *
  120.      * @return QueryException
  121.      */
  122.     public static function invalidParameterFormat($value)
  123.     {
  124.         return new self('Invalid parameter format, ' . $value . ' given, but :<name> or ?<num> expected.');
  125.     }
  127.     /**
  128.      * @param string $key
  129.      *
  130.      * @return QueryException
  131.      */
  132.     public static function unknownParameter($key)
  133.     {
  134.         return new self('Invalid parameter: token ' . $key . ' is not defined in the query.');
  135.     }
  137.     /**
  138.      * @return QueryException
  139.      */
  140.     public static function parameterTypeMismatch()
  141.     {
  142.         return new self('DQL Query parameter and type numbers mismatch, but have to be exactly equal.');
  143.     }
  145.     /**
  146.      * @param object $pathExpr
  147.      *
  148.      * @return QueryException
  149.      */
  150.     public static function invalidPathExpression($pathExpr)
  151.     {
  152.         return new self(
  153.             "Invalid PathExpression '" . $pathExpr->identificationVariable . '.' . $pathExpr->field . "'."
  154.         );
  155.     }
  157.     /**
  158.      * @param string $literal
  159.      *
  160.      * @return QueryException
  161.      */
  162.     public static function invalidLiteral($literal)
  163.     {
  164.         return new self("Invalid literal '" . $literal . "'");
  165.     }
  167.     /**
  168.      * @return QueryException
  169.      *
  170.      * @psalm-param array<string, string> $assoc
  171.      */
  172.     public static function iterateWithFetchJoinCollectionNotAllowed($assoc)
  173.     {
  174.         return new self(
  175.             'Invalid query operation: Not allowed to iterate over fetch join collections ' .
  176.             'in class ' . $assoc['sourceEntity'] . ' association ' . $assoc['fieldName']
  177.         );
  178.     }
  180.     /**
  181.      * @return QueryException
  182.      */
  183.     public static function partialObjectsAreDangerous()
  184.     {
  185.         return new self(
  186.             'Loading partial objects is dangerous. Fetch full objects or consider ' .
  187.             'using a different fetch mode. If you really want partial objects, ' .
  188.             'set the doctrine.forcePartialLoad query hint to TRUE.'
  189.         );
  190.     }
  192.     /**
  193.      * @return QueryException
  194.      *
  195.      * @psalm-param array<string, string> $assoc
  196.      */
  197.     public static function overwritingJoinConditionsNotYetSupported($assoc)
  198.     {
  199.         return new self(
  200.             'Unsupported query operation: It is not yet possible to overwrite the join ' .
  201.             'conditions in class ' . $assoc['sourceEntityName'] . ' association ' . $assoc['fieldName'] . '. ' .
  202.             'Use WITH to append additional join conditions to the association.'
  203.         );
  204.     }
  206.     /**
  207.      * @return QueryException
  208.      */
  209.     public static function associationPathInverseSideNotSupported(PathExpression $pathExpr)
  210.     {
  211.         return new self(
  212.             'A single-valued association path expression to an inverse side is not supported in DQL queries. ' .
  213.             'Instead of "' . $pathExpr->identificationVariable . '.' . $pathExpr->field . '" use an explicit join.'
  214.         );
  215.     }
  217.     /**
  218.      * @return QueryException
  219.      *
  220.      * @psalm-param array<string, string> $assoc
  221.      */
  222.     public static function iterateWithFetchJoinNotAllowed($assoc)
  223.     {
  224.         return new self(
  225.             'Iterate with fetch join in class ' . $assoc['sourceEntity'] .
  226.             ' using association ' . $assoc['fieldName'] . ' not allowed.'
  227.         );
  228.     }
  230.     public static function iterateWithMixedResultNotAllowed(): QueryException
  231.     {
  232.         return new self('Iterating a query with mixed results (using scalars) is not supported.');
  233.     }
  235.     /**
  236.      * @return QueryException
  237.      */
  238.     public static function associationPathCompositeKeyNotSupported()
  239.     {
  240.         return new self(
  241.             'A single-valued association path expression to an entity with a composite primary ' .
  242.             'key is not supported. Explicitly name the components of the composite primary key ' .
  243.             'in the query.'
  244.         );
  245.     }
  247.     /**
  248.      * @param string $className
  249.      * @param string $rootClass
  250.      *
  251.      * @return QueryException
  252.      */
  253.     public static function instanceOfUnrelatedClass($className, $rootClass)
  254.     {
  255.         return new self("Cannot check if a child of '" . $rootClass . "' is instanceof '" . $className . "', " .
  256.             'inheritance hierarchy does not exists between these two classes.');
  257.     }
  259.     /**
  260.      * @param string $dqlAlias
  261.      *
  262.      * @return QueryException
  263.      */
  264.     public static function invalidQueryComponent($dqlAlias)
  265.     {
  266.         return new self(
  267.             "Invalid query component given for DQL alias '" . $dqlAlias . "', " .
  268.             "requires 'metadata', 'parent', 'relation', 'map', 'nestingLevel' and 'token' keys."
  269.         );
  270.     }
  271. }