vendor/doctrine/orm/src/Query/QueryException.php line 23

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