constraints.py 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683
  1. import warnings
  2. from enum import Enum
  3. from types import NoneType
  4. from django.core import checks
  5. from django.core.exceptions import FieldDoesNotExist, FieldError, ValidationError
  6. from django.db import connections
  7. from django.db.models.constants import LOOKUP_SEP
  8. from django.db.models.expressions import Exists, ExpressionList, F, RawSQL
  9. from django.db.models.indexes import IndexExpression
  10. from django.db.models.lookups import Exact, IsNull
  11. from django.db.models.query_utils import Q
  12. from django.db.models.sql.query import Query
  13. from django.db.utils import DEFAULT_DB_ALIAS
  14. from django.utils.deprecation import RemovedInDjango60Warning
  15. from django.utils.translation import gettext_lazy as _
  16. __all__ = ["BaseConstraint", "CheckConstraint", "Deferrable", "UniqueConstraint"]
  17. class BaseConstraint:
  18. default_violation_error_message = _("Constraint “%(name)s” is violated.")
  19. violation_error_code = None
  20. violation_error_message = None
  21. # RemovedInDjango60Warning: When the deprecation ends, replace with:
  22. # def __init__(
  23. # self, *, name, violation_error_code=None, violation_error_message=None
  24. # ):
  25. def __init__(
  26. self, *args, name=None, violation_error_code=None, violation_error_message=None
  27. ):
  28. # RemovedInDjango60Warning.
  29. if name is None and not args:
  30. raise TypeError(
  31. f"{self.__class__.__name__}.__init__() missing 1 required keyword-only "
  32. f"argument: 'name'"
  33. )
  34. self.name = name
  35. if violation_error_code is not None:
  36. self.violation_error_code = violation_error_code
  37. if violation_error_message is not None:
  38. self.violation_error_message = violation_error_message
  39. else:
  40. self.violation_error_message = self.default_violation_error_message
  41. # RemovedInDjango60Warning.
  42. if args:
  43. warnings.warn(
  44. f"Passing positional arguments to {self.__class__.__name__} is "
  45. f"deprecated.",
  46. RemovedInDjango60Warning,
  47. stacklevel=2,
  48. )
  49. for arg, attr in zip(args, ["name", "violation_error_message"]):
  50. if arg:
  51. setattr(self, attr, arg)
  52. @property
  53. def contains_expressions(self):
  54. return False
  55. def constraint_sql(self, model, schema_editor):
  56. raise NotImplementedError("This method must be implemented by a subclass.")
  57. def create_sql(self, model, schema_editor):
  58. raise NotImplementedError("This method must be implemented by a subclass.")
  59. def remove_sql(self, model, schema_editor):
  60. raise NotImplementedError("This method must be implemented by a subclass.")
  61. def validate(self, model, instance, exclude=None, using=DEFAULT_DB_ALIAS):
  62. raise NotImplementedError("This method must be implemented by a subclass.")
  63. def get_violation_error_message(self):
  64. return self.violation_error_message % {"name": self.name}
  65. def _check(self, model, connection):
  66. return []
  67. def _check_references(self, model, references):
  68. errors = []
  69. fields = set()
  70. for field_name, *lookups in references:
  71. # pk is an alias that won't be found by opts.get_field.
  72. if field_name != "pk":
  73. fields.add(field_name)
  74. if not lookups:
  75. # If it has no lookups it cannot result in a JOIN.
  76. continue
  77. try:
  78. if field_name == "pk":
  79. field = model._meta.pk
  80. else:
  81. field = model._meta.get_field(field_name)
  82. if not field.is_relation or field.many_to_many or field.one_to_many:
  83. continue
  84. except FieldDoesNotExist:
  85. continue
  86. # JOIN must happen at the first lookup.
  87. first_lookup = lookups[0]
  88. if (
  89. hasattr(field, "get_transform")
  90. and hasattr(field, "get_lookup")
  91. and field.get_transform(first_lookup) is None
  92. and field.get_lookup(first_lookup) is None
  93. ):
  94. errors.append(
  95. checks.Error(
  96. "'constraints' refers to the joined field '%s'."
  97. % LOOKUP_SEP.join([field_name] + lookups),
  98. obj=model,
  99. id="models.E041",
  100. )
  101. )
  102. errors.extend(model._check_local_fields(fields, "constraints"))
  103. return errors
  104. def deconstruct(self):
  105. path = "%s.%s" % (self.__class__.__module__, self.__class__.__name__)
  106. path = path.replace("django.db.models.constraints", "django.db.models")
  107. kwargs = {"name": self.name}
  108. if (
  109. self.violation_error_message is not None
  110. and self.violation_error_message != self.default_violation_error_message
  111. ):
  112. kwargs["violation_error_message"] = self.violation_error_message
  113. if self.violation_error_code is not None:
  114. kwargs["violation_error_code"] = self.violation_error_code
  115. return (path, (), kwargs)
  116. def clone(self):
  117. _, args, kwargs = self.deconstruct()
  118. return self.__class__(*args, **kwargs)
  119. class CheckConstraint(BaseConstraint):
  120. # RemovedInDjango60Warning: when the deprecation ends, replace with
  121. # def __init__(
  122. # self, *, condition, name, violation_error_code=None, violation_error_message=None
  123. # )
  124. def __init__(
  125. self,
  126. *,
  127. name,
  128. condition=None,
  129. check=None,
  130. violation_error_code=None,
  131. violation_error_message=None,
  132. ):
  133. if check is not None:
  134. warnings.warn(
  135. "CheckConstraint.check is deprecated in favor of `.condition`.",
  136. RemovedInDjango60Warning,
  137. stacklevel=2,
  138. )
  139. condition = check
  140. self.condition = condition
  141. if not getattr(condition, "conditional", False):
  142. raise TypeError(
  143. "CheckConstraint.condition must be a Q instance or boolean expression."
  144. )
  145. super().__init__(
  146. name=name,
  147. violation_error_code=violation_error_code,
  148. violation_error_message=violation_error_message,
  149. )
  150. def _get_check(self):
  151. warnings.warn(
  152. "CheckConstraint.check is deprecated in favor of `.condition`.",
  153. RemovedInDjango60Warning,
  154. stacklevel=2,
  155. )
  156. return self.condition
  157. def _set_check(self, value):
  158. warnings.warn(
  159. "CheckConstraint.check is deprecated in favor of `.condition`.",
  160. RemovedInDjango60Warning,
  161. stacklevel=2,
  162. )
  163. self.condition = value
  164. check = property(_get_check, _set_check)
  165. def _check(self, model, connection):
  166. errors = []
  167. if not (
  168. connection.features.supports_table_check_constraints
  169. or "supports_table_check_constraints" in model._meta.required_db_features
  170. ):
  171. errors.append(
  172. checks.Warning(
  173. f"{connection.display_name} does not support check constraints.",
  174. hint=(
  175. "A constraint won't be created. Silence this warning if you "
  176. "don't care about it."
  177. ),
  178. obj=model,
  179. id="models.W027",
  180. )
  181. )
  182. elif (
  183. connection.features.supports_table_check_constraints
  184. or "supports_table_check_constraints"
  185. not in model._meta.required_db_features
  186. ):
  187. references = set()
  188. condition = self.condition
  189. if isinstance(condition, Q):
  190. references.update(model._get_expr_references(condition))
  191. if any(isinstance(expr, RawSQL) for expr in condition.flatten()):
  192. errors.append(
  193. checks.Warning(
  194. f"Check constraint {self.name!r} contains RawSQL() expression "
  195. "and won't be validated during the model full_clean().",
  196. hint="Silence this warning if you don't care about it.",
  197. obj=model,
  198. id="models.W045",
  199. ),
  200. )
  201. errors.extend(self._check_references(model, references))
  202. return errors
  203. def _get_check_sql(self, model, schema_editor):
  204. query = Query(model=model, alias_cols=False)
  205. where = query.build_where(self.condition)
  206. compiler = query.get_compiler(connection=schema_editor.connection)
  207. sql, params = where.as_sql(compiler, schema_editor.connection)
  208. return sql % tuple(schema_editor.quote_value(p) for p in params)
  209. def constraint_sql(self, model, schema_editor):
  210. check = self._get_check_sql(model, schema_editor)
  211. return schema_editor._check_sql(self.name, check)
  212. def create_sql(self, model, schema_editor):
  213. check = self._get_check_sql(model, schema_editor)
  214. return schema_editor._create_check_sql(model, self.name, check)
  215. def remove_sql(self, model, schema_editor):
  216. return schema_editor._delete_check_sql(model, self.name)
  217. def validate(self, model, instance, exclude=None, using=DEFAULT_DB_ALIAS):
  218. against = instance._get_field_expression_map(meta=model._meta, exclude=exclude)
  219. try:
  220. if not Q(self.condition).check(against, using=using):
  221. raise ValidationError(
  222. self.get_violation_error_message(), code=self.violation_error_code
  223. )
  224. except FieldError:
  225. pass
  226. def __repr__(self):
  227. return "<%s: condition=%s name=%s%s%s>" % (
  228. self.__class__.__qualname__,
  229. self.condition,
  230. repr(self.name),
  231. (
  232. ""
  233. if self.violation_error_code is None
  234. else " violation_error_code=%r" % self.violation_error_code
  235. ),
  236. (
  237. ""
  238. if self.violation_error_message is None
  239. or self.violation_error_message == self.default_violation_error_message
  240. else " violation_error_message=%r" % self.violation_error_message
  241. ),
  242. )
  243. def __eq__(self, other):
  244. if isinstance(other, CheckConstraint):
  245. return (
  246. self.name == other.name
  247. and self.condition == other.condition
  248. and self.violation_error_code == other.violation_error_code
  249. and self.violation_error_message == other.violation_error_message
  250. )
  251. return super().__eq__(other)
  252. def deconstruct(self):
  253. path, args, kwargs = super().deconstruct()
  254. kwargs["condition"] = self.condition
  255. return path, args, kwargs
  256. class Deferrable(Enum):
  257. DEFERRED = "deferred"
  258. IMMEDIATE = "immediate"
  259. # A similar format was proposed for Python 3.10.
  260. def __repr__(self):
  261. return f"{self.__class__.__qualname__}.{self._name_}"
  262. class UniqueConstraint(BaseConstraint):
  263. def __init__(
  264. self,
  265. *expressions,
  266. fields=(),
  267. name=None,
  268. condition=None,
  269. deferrable=None,
  270. include=None,
  271. opclasses=(),
  272. nulls_distinct=None,
  273. violation_error_code=None,
  274. violation_error_message=None,
  275. ):
  276. if not name:
  277. raise ValueError("A unique constraint must be named.")
  278. if not expressions and not fields:
  279. raise ValueError(
  280. "At least one field or expression is required to define a "
  281. "unique constraint."
  282. )
  283. if expressions and fields:
  284. raise ValueError(
  285. "UniqueConstraint.fields and expressions are mutually exclusive."
  286. )
  287. if not isinstance(condition, (NoneType, Q)):
  288. raise ValueError("UniqueConstraint.condition must be a Q instance.")
  289. if condition and deferrable:
  290. raise ValueError("UniqueConstraint with conditions cannot be deferred.")
  291. if include and deferrable:
  292. raise ValueError("UniqueConstraint with include fields cannot be deferred.")
  293. if opclasses and deferrable:
  294. raise ValueError("UniqueConstraint with opclasses cannot be deferred.")
  295. if expressions and deferrable:
  296. raise ValueError("UniqueConstraint with expressions cannot be deferred.")
  297. if expressions and opclasses:
  298. raise ValueError(
  299. "UniqueConstraint.opclasses cannot be used with expressions. "
  300. "Use django.contrib.postgres.indexes.OpClass() instead."
  301. )
  302. if not isinstance(deferrable, (NoneType, Deferrable)):
  303. raise TypeError(
  304. "UniqueConstraint.deferrable must be a Deferrable instance."
  305. )
  306. if not isinstance(include, (NoneType, list, tuple)):
  307. raise TypeError("UniqueConstraint.include must be a list or tuple.")
  308. if not isinstance(opclasses, (list, tuple)):
  309. raise TypeError("UniqueConstraint.opclasses must be a list or tuple.")
  310. if not isinstance(nulls_distinct, (NoneType, bool)):
  311. raise TypeError("UniqueConstraint.nulls_distinct must be a bool.")
  312. if opclasses and len(fields) != len(opclasses):
  313. raise ValueError(
  314. "UniqueConstraint.fields and UniqueConstraint.opclasses must "
  315. "have the same number of elements."
  316. )
  317. self.fields = tuple(fields)
  318. self.condition = condition
  319. self.deferrable = deferrable
  320. self.include = tuple(include) if include else ()
  321. self.opclasses = opclasses
  322. self.nulls_distinct = nulls_distinct
  323. self.expressions = tuple(
  324. F(expression) if isinstance(expression, str) else expression
  325. for expression in expressions
  326. )
  327. super().__init__(
  328. name=name,
  329. violation_error_code=violation_error_code,
  330. violation_error_message=violation_error_message,
  331. )
  332. @property
  333. def contains_expressions(self):
  334. return bool(self.expressions)
  335. def _check(self, model, connection):
  336. errors = model._check_local_fields({*self.fields, *self.include}, "constraints")
  337. required_db_features = model._meta.required_db_features
  338. if self.condition is not None and not (
  339. connection.features.supports_partial_indexes
  340. or "supports_partial_indexes" in required_db_features
  341. ):
  342. errors.append(
  343. checks.Warning(
  344. f"{connection.display_name} does not support unique constraints "
  345. "with conditions.",
  346. hint=(
  347. "A constraint won't be created. Silence this warning if you "
  348. "don't care about it."
  349. ),
  350. obj=model,
  351. id="models.W036",
  352. )
  353. )
  354. if self.deferrable is not None and not (
  355. connection.features.supports_deferrable_unique_constraints
  356. or "supports_deferrable_unique_constraints" in required_db_features
  357. ):
  358. errors.append(
  359. checks.Warning(
  360. f"{connection.display_name} does not support deferrable unique "
  361. "constraints.",
  362. hint=(
  363. "A constraint won't be created. Silence this warning if you "
  364. "don't care about it."
  365. ),
  366. obj=model,
  367. id="models.W038",
  368. )
  369. )
  370. if self.include and not (
  371. connection.features.supports_covering_indexes
  372. or "supports_covering_indexes" in required_db_features
  373. ):
  374. errors.append(
  375. checks.Warning(
  376. f"{connection.display_name} does not support unique constraints "
  377. "with non-key columns.",
  378. hint=(
  379. "A constraint won't be created. Silence this warning if you "
  380. "don't care about it."
  381. ),
  382. obj=model,
  383. id="models.W039",
  384. )
  385. )
  386. if self.contains_expressions and not (
  387. connection.features.supports_expression_indexes
  388. or "supports_expression_indexes" in required_db_features
  389. ):
  390. errors.append(
  391. checks.Warning(
  392. f"{connection.display_name} does not support unique constraints on "
  393. "expressions.",
  394. hint=(
  395. "A constraint won't be created. Silence this warning if you "
  396. "don't care about it."
  397. ),
  398. obj=model,
  399. id="models.W044",
  400. )
  401. )
  402. if self.nulls_distinct is not None and not (
  403. connection.features.supports_nulls_distinct_unique_constraints
  404. or "supports_nulls_distinct_unique_constraints" in required_db_features
  405. ):
  406. errors.append(
  407. checks.Warning(
  408. f"{connection.display_name} does not support unique constraints "
  409. "with nulls distinct.",
  410. hint=(
  411. "A constraint won't be created. Silence this warning if you "
  412. "don't care about it."
  413. ),
  414. obj=model,
  415. id="models.W047",
  416. )
  417. )
  418. references = set()
  419. if (
  420. connection.features.supports_partial_indexes
  421. or "supports_partial_indexes" not in required_db_features
  422. ) and isinstance(self.condition, Q):
  423. references.update(model._get_expr_references(self.condition))
  424. if self.contains_expressions and (
  425. connection.features.supports_expression_indexes
  426. or "supports_expression_indexes" not in required_db_features
  427. ):
  428. for expression in self.expressions:
  429. references.update(model._get_expr_references(expression))
  430. errors.extend(self._check_references(model, references))
  431. return errors
  432. def _get_condition_sql(self, model, schema_editor):
  433. if self.condition is None:
  434. return None
  435. query = Query(model=model, alias_cols=False)
  436. where = query.build_where(self.condition)
  437. compiler = query.get_compiler(connection=schema_editor.connection)
  438. sql, params = where.as_sql(compiler, schema_editor.connection)
  439. return sql % tuple(schema_editor.quote_value(p) for p in params)
  440. def _get_index_expressions(self, model, schema_editor):
  441. if not self.expressions:
  442. return None
  443. index_expressions = []
  444. for expression in self.expressions:
  445. index_expression = IndexExpression(expression)
  446. index_expression.set_wrapper_classes(schema_editor.connection)
  447. index_expressions.append(index_expression)
  448. return ExpressionList(*index_expressions).resolve_expression(
  449. Query(model, alias_cols=False),
  450. )
  451. def constraint_sql(self, model, schema_editor):
  452. fields = [model._meta.get_field(field_name) for field_name in self.fields]
  453. include = [
  454. model._meta.get_field(field_name).column for field_name in self.include
  455. ]
  456. condition = self._get_condition_sql(model, schema_editor)
  457. expressions = self._get_index_expressions(model, schema_editor)
  458. return schema_editor._unique_sql(
  459. model,
  460. fields,
  461. self.name,
  462. condition=condition,
  463. deferrable=self.deferrable,
  464. include=include,
  465. opclasses=self.opclasses,
  466. expressions=expressions,
  467. nulls_distinct=self.nulls_distinct,
  468. )
  469. def create_sql(self, model, schema_editor):
  470. fields = [model._meta.get_field(field_name) for field_name in self.fields]
  471. include = [
  472. model._meta.get_field(field_name).column for field_name in self.include
  473. ]
  474. condition = self._get_condition_sql(model, schema_editor)
  475. expressions = self._get_index_expressions(model, schema_editor)
  476. return schema_editor._create_unique_sql(
  477. model,
  478. fields,
  479. self.name,
  480. condition=condition,
  481. deferrable=self.deferrable,
  482. include=include,
  483. opclasses=self.opclasses,
  484. expressions=expressions,
  485. nulls_distinct=self.nulls_distinct,
  486. )
  487. def remove_sql(self, model, schema_editor):
  488. condition = self._get_condition_sql(model, schema_editor)
  489. include = [
  490. model._meta.get_field(field_name).column for field_name in self.include
  491. ]
  492. expressions = self._get_index_expressions(model, schema_editor)
  493. return schema_editor._delete_unique_sql(
  494. model,
  495. self.name,
  496. condition=condition,
  497. deferrable=self.deferrable,
  498. include=include,
  499. opclasses=self.opclasses,
  500. expressions=expressions,
  501. nulls_distinct=self.nulls_distinct,
  502. )
  503. def __repr__(self):
  504. return "<%s:%s%s%s%s%s%s%s%s%s%s>" % (
  505. self.__class__.__qualname__,
  506. "" if not self.fields else " fields=%s" % repr(self.fields),
  507. "" if not self.expressions else " expressions=%s" % repr(self.expressions),
  508. " name=%s" % repr(self.name),
  509. "" if self.condition is None else " condition=%s" % self.condition,
  510. "" if self.deferrable is None else " deferrable=%r" % self.deferrable,
  511. "" if not self.include else " include=%s" % repr(self.include),
  512. "" if not self.opclasses else " opclasses=%s" % repr(self.opclasses),
  513. (
  514. ""
  515. if self.nulls_distinct is None
  516. else " nulls_distinct=%r" % self.nulls_distinct
  517. ),
  518. (
  519. ""
  520. if self.violation_error_code is None
  521. else " violation_error_code=%r" % self.violation_error_code
  522. ),
  523. (
  524. ""
  525. if self.violation_error_message is None
  526. or self.violation_error_message == self.default_violation_error_message
  527. else " violation_error_message=%r" % self.violation_error_message
  528. ),
  529. )
  530. def __eq__(self, other):
  531. if isinstance(other, UniqueConstraint):
  532. return (
  533. self.name == other.name
  534. and self.fields == other.fields
  535. and self.condition == other.condition
  536. and self.deferrable == other.deferrable
  537. and self.include == other.include
  538. and self.opclasses == other.opclasses
  539. and self.expressions == other.expressions
  540. and self.nulls_distinct is other.nulls_distinct
  541. and self.violation_error_code == other.violation_error_code
  542. and self.violation_error_message == other.violation_error_message
  543. )
  544. return super().__eq__(other)
  545. def deconstruct(self):
  546. path, args, kwargs = super().deconstruct()
  547. if self.fields:
  548. kwargs["fields"] = self.fields
  549. if self.condition:
  550. kwargs["condition"] = self.condition
  551. if self.deferrable:
  552. kwargs["deferrable"] = self.deferrable
  553. if self.include:
  554. kwargs["include"] = self.include
  555. if self.opclasses:
  556. kwargs["opclasses"] = self.opclasses
  557. if self.nulls_distinct is not None:
  558. kwargs["nulls_distinct"] = self.nulls_distinct
  559. return path, self.expressions, kwargs
  560. def validate(self, model, instance, exclude=None, using=DEFAULT_DB_ALIAS):
  561. queryset = model._default_manager.using(using)
  562. if self.fields:
  563. lookup_kwargs = {}
  564. for field_name in self.fields:
  565. if exclude and field_name in exclude:
  566. return
  567. field = model._meta.get_field(field_name)
  568. lookup_value = getattr(instance, field.attname)
  569. if (
  570. self.nulls_distinct is not False
  571. and lookup_value is None
  572. or (
  573. lookup_value == ""
  574. and connections[
  575. using
  576. ].features.interprets_empty_strings_as_nulls
  577. )
  578. ):
  579. # A composite constraint containing NULL value cannot cause
  580. # a violation since NULL != NULL in SQL.
  581. return
  582. lookup_kwargs[field.name] = lookup_value
  583. queryset = queryset.filter(**lookup_kwargs)
  584. else:
  585. # Ignore constraints with excluded fields.
  586. if exclude:
  587. for expression in self.expressions:
  588. if hasattr(expression, "flatten"):
  589. for expr in expression.flatten():
  590. if isinstance(expr, F) and expr.name in exclude:
  591. return
  592. elif isinstance(expression, F) and expression.name in exclude:
  593. return
  594. replacements = {
  595. F(field): value
  596. for field, value in instance._get_field_expression_map(
  597. meta=model._meta, exclude=exclude
  598. ).items()
  599. }
  600. filters = []
  601. for expr in self.expressions:
  602. if hasattr(expr, "get_expression_for_validation"):
  603. expr = expr.get_expression_for_validation()
  604. rhs = expr.replace_expressions(replacements)
  605. condition = Exact(expr, rhs)
  606. if self.nulls_distinct is False:
  607. condition = Q(condition) | Q(IsNull(expr, True), IsNull(rhs, True))
  608. filters.append(condition)
  609. queryset = queryset.filter(*filters)
  610. model_class_pk = instance._get_pk_val(model._meta)
  611. if not instance._state.adding and model_class_pk is not None:
  612. queryset = queryset.exclude(pk=model_class_pk)
  613. if not self.condition:
  614. if queryset.exists():
  615. if self.fields:
  616. # When fields are defined, use the unique_error_message() for
  617. # backward compatibility.
  618. raise ValidationError(
  619. instance.unique_error_message(model, self.fields),
  620. )
  621. raise ValidationError(
  622. self.get_violation_error_message(),
  623. code=self.violation_error_code,
  624. )
  625. else:
  626. against = instance._get_field_expression_map(
  627. meta=model._meta, exclude=exclude
  628. )
  629. try:
  630. if (self.condition & Exists(queryset.filter(self.condition))).check(
  631. against, using=using
  632. ):
  633. raise ValidationError(
  634. self.get_violation_error_message(),
  635. code=self.violation_error_code,
  636. )
  637. except FieldError:
  638. pass