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

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