Debian Codegraph @

tests/postgres_tests/test_constraints.py

raw
1 import datetime
2 from unittest import mock
3
4 from django.contrib.postgres.indexes import OpClass
5 from django.core.checks import Error
6 from django.core.exceptions import ValidationError
7 from django.db import IntegrityError, connection, transaction
8 from django.db.models import (
9 CASCADE,
10 CharField,
11 CheckConstraint,
12 DateField,
13 Deferrable,
14 F,
15 ForeignKey,
16 Func,
17 GeneratedField,
18 IntegerField,
19 Model,
20 Q,
21 UniqueConstraint,
22 )
23 from django.db.models.fields.json import KeyTextTransform
24 from django.db.models.functions import Cast, Left, Lower
25 from django.test import skipUnlessDBFeature
26 from django.test.utils import isolate_apps
27 from django.utils import timezone
28
29 from . import PostgreSQLTestCase
30 from .models import HotelReservation, IntegerArrayModel, RangesModel, Room, Scene
31
32 try:
33 from django.contrib.postgres.constraints import ExclusionConstraint
34 from django.contrib.postgres.fields import (
35 DateTimeRangeField,
36 IntegerRangeField,
37 RangeBoundary,
38 RangeOperators,
39 )
40 from django.db.backends.postgresql.psycopg_any import DateRange, NumericRange
41 except ImportError:
42 pass
43
44
45 class SchemaTests(PostgreSQLTestCase):
46 get_opclass_query = """
47 SELECT opcname, c.relname FROM pg_opclass AS oc
48 JOIN pg_index as i on oc.oid = ANY(i.indclass)
49 JOIN pg_class as c on c.oid = i.indexrelid
50 WHERE c.relname = %s
51 """
52
53 def get_constraints(self, table):
54 """Get the constraints on the table using a new cursor."""
55 with connection.cursor() as cursor:
56 return connection.introspection.get_constraints(cursor, table)
57
58 def test_check_constraint_range_value(self):
59 constraint_name = "ints_between"
60 self.assertNotIn(
61 constraint_name, self.get_constraints(RangesModel._meta.db_table)
62 )
63 constraint = CheckConstraint(
64 condition=Q(ints__contained_by=NumericRange(10, 30)),
65 name=constraint_name,
66 )
67 with connection.schema_editor() as editor:
68 editor.add_constraint(RangesModel, constraint)
69 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
70 with self.assertRaises(IntegrityError), transaction.atomic():
71 RangesModel.objects.create(ints=(20, 50))
72 RangesModel.objects.create(ints=(10, 30))
73
74 def test_check_constraint_array_contains(self):
75 constraint = CheckConstraint(
76 condition=Q(field__contains=[1]),
77 name="array_contains",
78 )
79 msg = f"Constraint “{constraint.name}” is violated."
80 with self.assertRaisesMessage(ValidationError, msg):
81 constraint.validate(IntegerArrayModel, IntegerArrayModel())
82 constraint.validate(IntegerArrayModel, IntegerArrayModel(field=[1]))
83
84 def test_check_constraint_array_length(self):
85 constraint = CheckConstraint(
86 condition=Q(field__len=1),
87 name="array_length",
88 )
89 msg = f"Constraint “{constraint.name}” is violated."
90 with self.assertRaisesMessage(ValidationError, msg):
91 constraint.validate(IntegerArrayModel, IntegerArrayModel())
92 constraint.validate(IntegerArrayModel, IntegerArrayModel(field=[1]))
93
94 def test_check_constraint_daterange_contains(self):
95 constraint_name = "dates_contains"
96 self.assertNotIn(
97 constraint_name, self.get_constraints(RangesModel._meta.db_table)
98 )
99 constraint = CheckConstraint(
100 condition=Q(dates__contains=F("dates_inner")),
101 name=constraint_name,
102 )
103 with connection.schema_editor() as editor:
104 editor.add_constraint(RangesModel, constraint)
105 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
106 date_1 = datetime.date(2016, 1, 1)
107 date_2 = datetime.date(2016, 1, 4)
108 with self.assertRaises(IntegrityError), transaction.atomic():
109 RangesModel.objects.create(
110 dates=(date_1, date_2),
111 dates_inner=(date_1, date_2.replace(day=5)),
112 )
113 RangesModel.objects.create(
114 dates=(date_1, date_2),
115 dates_inner=(date_1, date_2),
116 )
117
118 def test_check_constraint_datetimerange_contains(self):
119 constraint_name = "timestamps_contains"
120 self.assertNotIn(
121 constraint_name, self.get_constraints(RangesModel._meta.db_table)
122 )
123 constraint = CheckConstraint(
124 condition=Q(timestamps__contains=F("timestamps_inner")),
125 name=constraint_name,
126 )
127 with connection.schema_editor() as editor:
128 editor.add_constraint(RangesModel, constraint)
129 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
130 datetime_1 = datetime.datetime(2016, 1, 1)
131 datetime_2 = datetime.datetime(2016, 1, 2, 12)
132 with self.assertRaises(IntegrityError), transaction.atomic():
133 RangesModel.objects.create(
134 timestamps=(datetime_1, datetime_2),
135 timestamps_inner=(datetime_1, datetime_2.replace(hour=13)),
136 )
137 RangesModel.objects.create(
138 timestamps=(datetime_1, datetime_2),
139 timestamps_inner=(datetime_1, datetime_2),
140 )
141
142 def test_check_constraint_range_contains(self):
143 constraint = CheckConstraint(
144 condition=Q(ints__contains=(1, 5)),
145 name="ints_contains",
146 )
147 msg = f"Constraint “{constraint.name}” is violated."
148 with self.assertRaisesMessage(ValidationError, msg):
149 constraint.validate(RangesModel, RangesModel(ints=(6, 10)))
150
151 def test_check_constraint_range_lower_upper(self):
152 constraint = CheckConstraint(
153 condition=Q(ints__startswith__gte=0) & Q(ints__endswith__lte=99),
154 name="ints_range_lower_upper",
155 )
156 msg = f"Constraint “{constraint.name}” is violated."
157 with self.assertRaisesMessage(ValidationError, msg):
158 constraint.validate(RangesModel, RangesModel(ints=(-1, 20)))
159 with self.assertRaisesMessage(ValidationError, msg):
160 constraint.validate(RangesModel, RangesModel(ints=(0, 100)))
161 constraint.validate(RangesModel, RangesModel(ints=(0, 99)))
162
163 def test_check_constraint_range_lower_with_nulls(self):
164 constraint = CheckConstraint(
165 condition=Q(ints__isnull=True) | Q(ints__startswith__gte=0),
166 name="ints_optional_positive_range",
167 )
168 constraint.validate(RangesModel, RangesModel())
169 constraint = CheckConstraint(
170 condition=Q(ints__startswith__gte=0),
171 name="ints_positive_range",
172 )
173 constraint.validate(RangesModel, RangesModel())
174
175 def test_opclass(self):
176 constraint = UniqueConstraint(
177 name="test_opclass",
178 fields=["scene"],
179 opclasses=["varchar_pattern_ops"],
180 )
181 with connection.schema_editor() as editor:
182 editor.add_constraint(Scene, constraint)
183 self.assertIn(constraint.name, self.get_constraints(Scene._meta.db_table))
184 with editor.connection.cursor() as cursor:
185 cursor.execute(self.get_opclass_query, [constraint.name])
186 self.assertEqual(
187 cursor.fetchall(),
188 [("varchar_pattern_ops", constraint.name)],
189 )
190 # Drop the constraint.
191 with connection.schema_editor() as editor:
192 editor.remove_constraint(Scene, constraint)
193 self.assertNotIn(constraint.name, self.get_constraints(Scene._meta.db_table))
194
195 def test_opclass_multiple_columns(self):
196 constraint = UniqueConstraint(
197 name="test_opclass_multiple",
198 fields=["scene", "setting"],
199 opclasses=["varchar_pattern_ops", "text_pattern_ops"],
200 )
201 with connection.schema_editor() as editor:
202 editor.add_constraint(Scene, constraint)
203 with editor.connection.cursor() as cursor:
204 cursor.execute(self.get_opclass_query, [constraint.name])
205 expected_opclasses = (
206 ("varchar_pattern_ops", constraint.name),
207 ("text_pattern_ops", constraint.name),
208 )
209 self.assertCountEqual(cursor.fetchall(), expected_opclasses)
210
211 def test_opclass_partial(self):
212 constraint = UniqueConstraint(
213 name="test_opclass_partial",
214 fields=["scene"],
215 opclasses=["varchar_pattern_ops"],
216 condition=Q(setting__contains="Sir Bedemir's Castle"),
217 )
218 with connection.schema_editor() as editor:
219 editor.add_constraint(Scene, constraint)
220 with editor.connection.cursor() as cursor:
221 cursor.execute(self.get_opclass_query, [constraint.name])
222 self.assertCountEqual(
223 cursor.fetchall(),
224 [("varchar_pattern_ops", constraint.name)],
225 )
226
227 @skipUnlessDBFeature("supports_covering_indexes")
228 def test_opclass_include(self):
229 constraint = UniqueConstraint(
230 name="test_opclass_include",
231 fields=["scene"],
232 opclasses=["varchar_pattern_ops"],
233 include=["setting"],
234 )
235 with connection.schema_editor() as editor:
236 editor.add_constraint(Scene, constraint)
237 with editor.connection.cursor() as cursor:
238 cursor.execute(self.get_opclass_query, [constraint.name])
239 self.assertCountEqual(
240 cursor.fetchall(),
241 [("varchar_pattern_ops", constraint.name)],
242 )
243
244 @skipUnlessDBFeature("supports_expression_indexes")
245 def test_opclass_func(self):
246 constraint = UniqueConstraint(
247 OpClass(Lower("scene"), name="text_pattern_ops"),
248 name="test_opclass_func",
249 )
250 with connection.schema_editor() as editor:
251 editor.add_constraint(Scene, constraint)
252 constraints = self.get_constraints(Scene._meta.db_table)
253 self.assertIs(constraints[constraint.name]["unique"], True)
254 self.assertIn(constraint.name, constraints)
255 with editor.connection.cursor() as cursor:
256 cursor.execute(self.get_opclass_query, [constraint.name])
257 self.assertEqual(
258 cursor.fetchall(),
259 [("text_pattern_ops", constraint.name)],
260 )
261 Scene.objects.create(scene="Scene 10", setting="The dark forest of Ewing")
262 with self.assertRaises(IntegrityError), transaction.atomic():
263 Scene.objects.create(scene="ScEnE 10", setting="Sir Bedemir's Castle")
264 Scene.objects.create(scene="Scene 5", setting="Sir Bedemir's Castle")
265 # Drop the constraint.
266 with connection.schema_editor() as editor:
267 editor.remove_constraint(Scene, constraint)
268 self.assertNotIn(constraint.name, self.get_constraints(Scene._meta.db_table))
269 Scene.objects.create(scene="ScEnE 10", setting="Sir Bedemir's Castle")
270
271 def test_opclass_func_validate_constraints(self):
272 constraint_name = "test_opclass_func_validate_constraints"
273 constraint = UniqueConstraint(
274 OpClass(Lower("scene"), name="text_pattern_ops"),
275 name="test_opclass_func_validate_constraints",
276 )
277 Scene.objects.create(scene="First scene")
278 # Non-unique scene.
279 msg = f"Constraint “{constraint_name}” is violated."
280 with self.assertRaisesMessage(ValidationError, msg):
281 constraint.validate(Scene, Scene(scene="first Scene"))
282 constraint.validate(Scene, Scene(scene="second Scene"))
283
284
285 class ExclusionConstraintTests(PostgreSQLTestCase):
286 def get_constraints(self, table):
287 """Get the constraints on the table using a new cursor."""
288 with connection.cursor() as cursor:
289 return connection.introspection.get_constraints(cursor, table)
290
291 def test_invalid_condition(self):
292 msg = "ExclusionConstraint.condition must be a Q instance."
293 with self.assertRaisesMessage(ValueError, msg):
294 ExclusionConstraint(
295 index_type="GIST",
296 name="exclude_invalid_condition",
297 expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
298 condition=F("invalid"),
299 )
300
301 def test_invalid_index_type(self):
302 msg = "Exclusion constraints only support GiST or SP-GiST indexes."
303 with self.assertRaisesMessage(ValueError, msg):
304 ExclusionConstraint(
305 index_type="gin",
306 name="exclude_invalid_index_type",
307 expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
308 )
309
310 def test_invalid_expressions(self):
311 msg = "The expressions must be a list of 2-tuples."
312 for expressions in (["foo"], ["foo"], [("foo_1", "foo_2", "foo_3")]):
313 with self.subTest(expressions), self.assertRaisesMessage(ValueError, msg):
314 ExclusionConstraint(
315 index_type="GIST",
316 name="exclude_invalid_expressions",
317 expressions=expressions,
318 )
319
320 def test_empty_expressions(self):
321 msg = "At least one expression is required to define an exclusion constraint."
322 for empty_expressions in (None, []):
323 with (
324 self.subTest(empty_expressions),
325 self.assertRaisesMessage(ValueError, msg),
326 ):
327 ExclusionConstraint(
328 index_type="GIST",
329 name="exclude_empty_expressions",
330 expressions=empty_expressions,
331 )
332
333 def test_invalid_deferrable(self):
334 msg = "ExclusionConstraint.deferrable must be a Deferrable instance."
335 with self.assertRaisesMessage(ValueError, msg):
336 ExclusionConstraint(
337 name="exclude_invalid_deferrable",
338 expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
339 deferrable="invalid",
340 )
341
342 def test_invalid_include_type(self):
343 msg = "ExclusionConstraint.include must be a list or tuple."
344 with self.assertRaisesMessage(ValueError, msg):
345 ExclusionConstraint(
346 name="exclude_invalid_include",
347 expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
348 include="invalid",
349 )
350
351 @isolate_apps("postgres_tests")
352 def test_check(self):
353 class Author(Model):
354 name = CharField(max_length=255)
355 alias = CharField(max_length=255)
356
357 class Meta:
358 app_label = "postgres_tests"
359
360 class Book(Model):
361 title = CharField(max_length=255)
362 published_date = DateField()
363 author = ForeignKey(Author, CASCADE)
364
365 class Meta:
366 app_label = "postgres_tests"
367 constraints = [
368 ExclusionConstraint(
369 name="exclude_check",
370 expressions=[
371 (F("title"), RangeOperators.EQUAL),
372 (F("published_date__year"), RangeOperators.EQUAL),
373 ("published_date__month", RangeOperators.EQUAL),
374 (F("author__name"), RangeOperators.EQUAL),
375 ("author__alias", RangeOperators.EQUAL),
376 ("nonexistent", RangeOperators.EQUAL),
377 ],
378 )
379 ]
380
381 self.assertCountEqual(
382 Book.check(databases=self.databases),
383 [
384 Error(
385 "'constraints' refers to the nonexistent field 'nonexistent'.",
386 obj=Book,
387 id="models.E012",
388 ),
389 Error(
390 "'constraints' refers to the joined field 'author__alias'.",
391 obj=Book,
392 id="models.E041",
393 ),
394 Error(
395 "'constraints' refers to the joined field 'author__name'.",
396 obj=Book,
397 id="models.E041",
398 ),
399 ],
400 )
401
402 def test_repr(self):
403 constraint = ExclusionConstraint(
404 name="exclude_overlapping",
405 expressions=[
406 (F("datespan"), RangeOperators.OVERLAPS),
407 (F("room"), RangeOperators.EQUAL),
408 ],
409 )
410 self.assertEqual(
411 repr(constraint),
412 "<ExclusionConstraint: index_type='GIST' expressions=["
413 "(F(datespan), '&&'), (F(room), '=')] name='exclude_overlapping'>",
414 )
415 constraint = ExclusionConstraint(
416 name="exclude_overlapping",
417 expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
418 condition=Q(cancelled=False),
419 index_type="SPGiST",
420 )
421 self.assertEqual(
422 repr(constraint),
423 "<ExclusionConstraint: index_type='SPGiST' expressions=["
424 "(F(datespan), '-|-')] name='exclude_overlapping' "
425 "condition=(AND: ('cancelled', False))>",
426 )
427 constraint = ExclusionConstraint(
428 name="exclude_overlapping",
429 expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
430 deferrable=Deferrable.IMMEDIATE,
431 )
432 self.assertEqual(
433 repr(constraint),
434 "<ExclusionConstraint: index_type='GIST' expressions=["
435 "(F(datespan), '-|-')] name='exclude_overlapping' "
436 "deferrable=Deferrable.IMMEDIATE>",
437 )
438 constraint = ExclusionConstraint(
439 name="exclude_overlapping",
440 expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
441 include=["cancelled", "room"],
442 )
443 self.assertEqual(
444 repr(constraint),
445 "<ExclusionConstraint: index_type='GIST' expressions=["
446 "(F(datespan), '-|-')] name='exclude_overlapping' "
447 "include=('cancelled', 'room')>",
448 )
449 constraint = ExclusionConstraint(
450 name="exclude_overlapping",
451 expressions=[
452 (OpClass("datespan", name="range_ops"), RangeOperators.ADJACENT_TO),
453 ],
454 )
455 self.assertEqual(
456 repr(constraint),
457 "<ExclusionConstraint: index_type='GIST' expressions=["
458 "(OpClass(F(datespan), name=range_ops), '-|-')] "
459 "name='exclude_overlapping'>",
460 )
461 constraint = ExclusionConstraint(
462 name="exclude_overlapping",
463 expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
464 violation_error_message="Overlapping must be excluded",
465 )
466 self.assertEqual(
467 repr(constraint),
468 "<ExclusionConstraint: index_type='GIST' expressions=["
469 "(F(datespan), '-|-')] name='exclude_overlapping' "
470 "violation_error_message='Overlapping must be excluded'>",
471 )
472 constraint = ExclusionConstraint(
473 name="exclude_overlapping",
474 expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
475 violation_error_code="overlapping_must_be_excluded",
476 )
477 self.assertEqual(
478 repr(constraint),
479 "<ExclusionConstraint: index_type='GIST' expressions=["
480 "(F(datespan), '-|-')] name='exclude_overlapping' "
481 "violation_error_code='overlapping_must_be_excluded'>",
482 )
483
484 def test_eq(self):
485 constraint_1 = ExclusionConstraint(
486 name="exclude_overlapping",
487 expressions=[
488 (F("datespan"), RangeOperators.OVERLAPS),
489 (F("room"), RangeOperators.EQUAL),
490 ],
491 condition=Q(cancelled=False),
492 )
493 constraint_2 = ExclusionConstraint(
494 name="exclude_overlapping",
495 expressions=[
496 ("datespan", RangeOperators.OVERLAPS),
497 ("room", RangeOperators.EQUAL),
498 ],
499 )
500 constraint_3 = ExclusionConstraint(
501 name="exclude_overlapping",
502 expressions=[("datespan", RangeOperators.OVERLAPS)],
503 condition=Q(cancelled=False),
504 )
505 constraint_4 = ExclusionConstraint(
506 name="exclude_overlapping",
507 expressions=[
508 ("datespan", RangeOperators.OVERLAPS),
509 ("room", RangeOperators.EQUAL),
510 ],
511 deferrable=Deferrable.DEFERRED,
512 )
513 constraint_5 = ExclusionConstraint(
514 name="exclude_overlapping",
515 expressions=[
516 ("datespan", RangeOperators.OVERLAPS),
517 ("room", RangeOperators.EQUAL),
518 ],
519 deferrable=Deferrable.IMMEDIATE,
520 )
521 constraint_6 = ExclusionConstraint(
522 name="exclude_overlapping",
523 expressions=[
524 ("datespan", RangeOperators.OVERLAPS),
525 ("room", RangeOperators.EQUAL),
526 ],
527 deferrable=Deferrable.IMMEDIATE,
528 include=["cancelled"],
529 )
530 constraint_7 = ExclusionConstraint(
531 name="exclude_overlapping",
532 expressions=[
533 ("datespan", RangeOperators.OVERLAPS),
534 ("room", RangeOperators.EQUAL),
535 ],
536 include=["cancelled"],
537 )
538 constraint_10 = ExclusionConstraint(
539 name="exclude_overlapping",
540 expressions=[
541 (F("datespan"), RangeOperators.OVERLAPS),
542 (F("room"), RangeOperators.EQUAL),
543 ],
544 condition=Q(cancelled=False),
545 violation_error_message="custom error",
546 )
547 constraint_11 = ExclusionConstraint(
548 name="exclude_overlapping",
549 expressions=[
550 (F("datespan"), RangeOperators.OVERLAPS),
551 (F("room"), RangeOperators.EQUAL),
552 ],
553 condition=Q(cancelled=False),
554 violation_error_message="other custom error",
555 )
556 constraint_12 = ExclusionConstraint(
557 name="exclude_overlapping",
558 expressions=[
559 (F("datespan"), RangeOperators.OVERLAPS),
560 (F("room"), RangeOperators.EQUAL),
561 ],
562 condition=Q(cancelled=False),
563 violation_error_code="custom_code",
564 violation_error_message="other custom error",
565 )
566 self.assertEqual(constraint_1, constraint_1)
567 self.assertEqual(constraint_1, mock.ANY)
568 self.assertNotEqual(constraint_1, constraint_2)
569 self.assertNotEqual(constraint_1, constraint_3)
570 self.assertNotEqual(constraint_1, constraint_4)
571 self.assertNotEqual(constraint_1, constraint_10)
572 self.assertNotEqual(constraint_2, constraint_3)
573 self.assertNotEqual(constraint_2, constraint_4)
574 self.assertNotEqual(constraint_2, constraint_7)
575 self.assertNotEqual(constraint_4, constraint_5)
576 self.assertNotEqual(constraint_5, constraint_6)
577 self.assertNotEqual(constraint_1, object())
578 self.assertNotEqual(constraint_10, constraint_11)
579 self.assertNotEqual(constraint_11, constraint_12)
580 self.assertEqual(constraint_10, constraint_10)
581 self.assertEqual(constraint_12, constraint_12)
582
583 def test_deconstruct(self):
584 constraint = ExclusionConstraint(
585 name="exclude_overlapping",
586 expressions=[
587 ("datespan", RangeOperators.OVERLAPS),
588 ("room", RangeOperators.EQUAL),
589 ],
590 )
591 path, args, kwargs = constraint.deconstruct()
592 self.assertEqual(
593 path, "django.contrib.postgres.constraints.ExclusionConstraint"
594 )
595 self.assertEqual(args, ())
596 self.assertEqual(
597 kwargs,
598 {
599 "name": "exclude_overlapping",
600 "expressions": [
601 ("datespan", RangeOperators.OVERLAPS),
602 ("room", RangeOperators.EQUAL),
603 ],
604 },
605 )
606
607 def test_deconstruct_index_type(self):
608 constraint = ExclusionConstraint(
609 name="exclude_overlapping",
610 index_type="SPGIST",
611 expressions=[
612 ("datespan", RangeOperators.OVERLAPS),
613 ("room", RangeOperators.EQUAL),
614 ],
615 )
616 path, args, kwargs = constraint.deconstruct()
617 self.assertEqual(
618 path, "django.contrib.postgres.constraints.ExclusionConstraint"
619 )
620 self.assertEqual(args, ())
621 self.assertEqual(
622 kwargs,
623 {
624 "name": "exclude_overlapping",
625 "index_type": "SPGIST",
626 "expressions": [
627 ("datespan", RangeOperators.OVERLAPS),
628 ("room", RangeOperators.EQUAL),
629 ],
630 },
631 )
632
633 def test_deconstruct_condition(self):
634 constraint = ExclusionConstraint(
635 name="exclude_overlapping",
636 expressions=[
637 ("datespan", RangeOperators.OVERLAPS),
638 ("room", RangeOperators.EQUAL),
639 ],
640 condition=Q(cancelled=False),
641 )
642 path, args, kwargs = constraint.deconstruct()
643 self.assertEqual(
644 path, "django.contrib.postgres.constraints.ExclusionConstraint"
645 )
646 self.assertEqual(args, ())
647 self.assertEqual(
648 kwargs,
649 {
650 "name": "exclude_overlapping",
651 "expressions": [
652 ("datespan", RangeOperators.OVERLAPS),
653 ("room", RangeOperators.EQUAL),
654 ],
655 "condition": Q(cancelled=False),
656 },
657 )
658
659 def test_deconstruct_deferrable(self):
660 constraint = ExclusionConstraint(
661 name="exclude_overlapping",
662 expressions=[("datespan", RangeOperators.OVERLAPS)],
663 deferrable=Deferrable.DEFERRED,
664 )
665 path, args, kwargs = constraint.deconstruct()
666 self.assertEqual(
667 path, "django.contrib.postgres.constraints.ExclusionConstraint"
668 )
669 self.assertEqual(args, ())
670 self.assertEqual(
671 kwargs,
672 {
673 "name": "exclude_overlapping",
674 "expressions": [("datespan", RangeOperators.OVERLAPS)],
675 "deferrable": Deferrable.DEFERRED,
676 },
677 )
678
679 def test_deconstruct_include(self):
680 constraint = ExclusionConstraint(
681 name="exclude_overlapping",
682 expressions=[("datespan", RangeOperators.OVERLAPS)],
683 include=["cancelled", "room"],
684 )
685 path, args, kwargs = constraint.deconstruct()
686 self.assertEqual(
687 path, "django.contrib.postgres.constraints.ExclusionConstraint"
688 )
689 self.assertEqual(args, ())
690 self.assertEqual(
691 kwargs,
692 {
693 "name": "exclude_overlapping",
694 "expressions": [("datespan", RangeOperators.OVERLAPS)],
695 "include": ("cancelled", "room"),
696 },
697 )
698
699 def _test_range_overlaps(self, constraint):
700 # Create exclusion constraint.
701 self.assertNotIn(
702 constraint.name, self.get_constraints(HotelReservation._meta.db_table)
703 )
704 with connection.schema_editor() as editor:
705 editor.add_constraint(HotelReservation, constraint)
706 self.assertIn(
707 constraint.name, self.get_constraints(HotelReservation._meta.db_table)
708 )
709 # Add initial reservations.
710 room101 = Room.objects.create(number=101)
711 room102 = Room.objects.create(number=102)
712 datetimes = [
713 timezone.datetime(2018, 6, 20),
714 timezone.datetime(2018, 6, 24),
715 timezone.datetime(2018, 6, 26),
716 timezone.datetime(2018, 6, 28),
717 timezone.datetime(2018, 6, 29),
718 ]
719 reservation = HotelReservation.objects.create(
720 datespan=DateRange(datetimes[0].date(), datetimes[1].date()),
721 start=datetimes[0],
722 end=datetimes[1],
723 room=room102,
724 )
725 constraint.validate(HotelReservation, reservation)
726 HotelReservation.objects.create(
727 datespan=DateRange(datetimes[1].date(), datetimes[3].date()),
728 start=datetimes[1],
729 end=datetimes[3],
730 room=room102,
731 )
732 HotelReservation.objects.create(
733 datespan=DateRange(datetimes[3].date(), datetimes[4].date()),
734 start=datetimes[3],
735 end=datetimes[4],
736 room=room102,
737 cancelled=True,
738 )
739 # Overlap dates.
740 with self.assertRaises(IntegrityError), transaction.atomic():
741 reservation = HotelReservation(
742 datespan=(datetimes[1].date(), datetimes[2].date()),
743 start=datetimes[1],
744 end=datetimes[2],
745 room=room102,
746 )
747 msg = f"Constraint “{constraint.name}” is violated."
748 with self.assertRaisesMessage(ValidationError, msg):
749 constraint.validate(HotelReservation, reservation)
750 reservation.save()
751 # Valid range.
752 other_valid_reservations = [
753 # Other room.
754 HotelReservation(
755 datespan=(datetimes[1].date(), datetimes[2].date()),
756 start=datetimes[1],
757 end=datetimes[2],
758 room=room101,
759 ),
760 # Cancelled reservation.
761 HotelReservation(
762 datespan=(datetimes[1].date(), datetimes[1].date()),
763 start=datetimes[1],
764 end=datetimes[2],
765 room=room102,
766 cancelled=True,
767 ),
768 # Other adjacent dates.
769 HotelReservation(
770 datespan=(datetimes[3].date(), datetimes[4].date()),
771 start=datetimes[3],
772 end=datetimes[4],
773 room=room102,
774 ),
775 ]
776 for reservation in other_valid_reservations:
777 constraint.validate(HotelReservation, reservation)
778 HotelReservation.objects.bulk_create(other_valid_reservations)
779 # Excluded fields.
780 constraint.validate(
781 HotelReservation,
782 HotelReservation(
783 datespan=(datetimes[1].date(), datetimes[2].date()),
784 start=datetimes[1],
785 end=datetimes[2],
786 room=room102,
787 ),
788 exclude={"room"},
789 )
790 constraint.validate(
791 HotelReservation,
792 HotelReservation(
793 datespan=(datetimes[1].date(), datetimes[2].date()),
794 start=datetimes[1],
795 end=datetimes[2],
796 room=room102,
797 ),
798 exclude={"datespan", "start", "end", "room"},
799 )
800
801 def test_range_overlaps_custom(self):
802 class TsTzRange(Func):
803 function = "TSTZRANGE"
804 output_field = DateTimeRangeField()
805
806 constraint = ExclusionConstraint(
807 name="exclude_overlapping_reservations_custom_opclass",
808 expressions=[
809 (
810 OpClass(TsTzRange("start", "end", RangeBoundary()), "range_ops"),
811 RangeOperators.OVERLAPS,
812 ),
813 (OpClass("room", "gist_int4_ops"), RangeOperators.EQUAL),
814 ],
815 condition=Q(cancelled=False),
816 )
817 self._test_range_overlaps(constraint)
818
819 def test_range_overlaps(self):
820 constraint = ExclusionConstraint(
821 name="exclude_overlapping_reservations",
822 expressions=[
823 (F("datespan"), RangeOperators.OVERLAPS),
824 ("room", RangeOperators.EQUAL),
825 ],
826 condition=Q(cancelled=False),
827 )
828 self._test_range_overlaps(constraint)
829
830 def test_range_adjacent(self):
831 constraint_name = "ints_adjacent"
832 self.assertNotIn(
833 constraint_name, self.get_constraints(RangesModel._meta.db_table)
834 )
835 constraint = ExclusionConstraint(
836 name=constraint_name,
837 expressions=[("ints", RangeOperators.ADJACENT_TO)],
838 )
839 with connection.schema_editor() as editor:
840 editor.add_constraint(RangesModel, constraint)
841 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
842 RangesModel.objects.create(ints=(20, 50))
843 with self.assertRaises(IntegrityError), transaction.atomic():
844 RangesModel.objects.create(ints=(10, 20))
845 RangesModel.objects.create(ints=(10, 19))
846 RangesModel.objects.create(ints=(51, 60))
847 # Drop the constraint.
848 with connection.schema_editor() as editor:
849 editor.remove_constraint(RangesModel, constraint)
850 self.assertNotIn(
851 constraint_name, self.get_constraints(RangesModel._meta.db_table)
852 )
853
854 def test_validate_range_adjacent(self):
855 constraint = ExclusionConstraint(
856 name="ints_adjacent",
857 expressions=[("ints", RangeOperators.ADJACENT_TO)],
858 violation_error_code="custom_code",
859 violation_error_message="Custom error message.",
860 )
861 range_obj = RangesModel.objects.create(ints=(20, 50))
862 constraint.validate(RangesModel, range_obj)
863 msg = "Custom error message."
864 with self.assertRaisesMessage(ValidationError, msg) as cm:
865 constraint.validate(RangesModel, RangesModel(ints=(10, 20)))
866 self.assertEqual(cm.exception.code, "custom_code")
867 constraint.validate(RangesModel, RangesModel(ints=(10, 19)))
868 constraint.validate(RangesModel, RangesModel(ints=(51, 60)))
869 constraint.validate(RangesModel, RangesModel(ints=(10, 20)), exclude={"ints"})
870
871 @skipUnlessDBFeature("supports_stored_generated_columns")
872 @isolate_apps("postgres_tests")
873 def test_validate_generated_field_range_adjacent(self):
874 class RangesModelGeneratedField(Model):
875 ints = IntegerRangeField(blank=True, null=True)
876 ints_generated = GeneratedField(
877 expression=F("ints"),
878 output_field=IntegerRangeField(null=True),
879 db_persist=True,
880 )
881
882 with connection.schema_editor() as editor:
883 editor.create_model(RangesModelGeneratedField)
884
885 constraint = ExclusionConstraint(
886 name="ints_adjacent",
887 expressions=[("ints_generated", RangeOperators.ADJACENT_TO)],
888 violation_error_code="custom_code",
889 violation_error_message="Custom error message.",
890 )
891 RangesModelGeneratedField.objects.create(ints=(20, 50))
892
893 range_obj = RangesModelGeneratedField(ints=(3, 20))
894 with self.assertRaisesMessage(ValidationError, "Custom error message."):
895 constraint.validate(RangesModelGeneratedField, range_obj)
896
897 # Excluding referenced or generated field should skip validation.
898 constraint.validate(RangesModelGeneratedField, range_obj, exclude={"ints"})
899 constraint.validate(
900 RangesModelGeneratedField, range_obj, exclude={"ints_generated"}
901 )
902
903 def test_validate_with_custom_code_and_condition(self):
904 constraint = ExclusionConstraint(
905 name="ints_adjacent",
906 expressions=[("ints", RangeOperators.ADJACENT_TO)],
907 violation_error_code="custom_code",
908 condition=Q(ints__lt=(100, 200)),
909 )
910 range_obj = RangesModel.objects.create(ints=(20, 50))
911 constraint.validate(RangesModel, range_obj)
912 with self.assertRaises(ValidationError) as cm:
913 constraint.validate(RangesModel, RangesModel(ints=(10, 20)))
914 self.assertEqual(cm.exception.code, "custom_code")
915
916 def test_expressions_with_params(self):
917 constraint_name = "scene_left_equal"
918 self.assertNotIn(constraint_name, self.get_constraints(Scene._meta.db_table))
919 constraint = ExclusionConstraint(
920 name=constraint_name,
921 expressions=[(Left("scene", 4), RangeOperators.EQUAL)],
922 )
923 with connection.schema_editor() as editor:
924 editor.add_constraint(Scene, constraint)
925 self.assertIn(constraint_name, self.get_constraints(Scene._meta.db_table))
926
927 def test_expressions_with_key_transform(self):
928 constraint_name = "exclude_overlapping_reservations_smoking"
929 constraint = ExclusionConstraint(
930 name=constraint_name,
931 expressions=[
932 (F("datespan"), RangeOperators.OVERLAPS),
933 (KeyTextTransform("smoking", "requirements"), RangeOperators.EQUAL),
934 ],
935 )
936 with connection.schema_editor() as editor:
937 editor.add_constraint(HotelReservation, constraint)
938 self.assertIn(
939 constraint_name,
940 self.get_constraints(HotelReservation._meta.db_table),
941 )
942
943 def test_index_transform(self):
944 constraint_name = "first_index_equal"
945 constraint = ExclusionConstraint(
946 name=constraint_name,
947 expressions=[("field__0", RangeOperators.EQUAL)],
948 )
949 with connection.schema_editor() as editor:
950 editor.add_constraint(IntegerArrayModel, constraint)
951 self.assertIn(
952 constraint_name,
953 self.get_constraints(IntegerArrayModel._meta.db_table),
954 )
955
956 def test_range_adjacent_initially_deferred(self):
957 constraint_name = "ints_adjacent_deferred"
958 self.assertNotIn(
959 constraint_name, self.get_constraints(RangesModel._meta.db_table)
960 )
961 constraint = ExclusionConstraint(
962 name=constraint_name,
963 expressions=[("ints", RangeOperators.ADJACENT_TO)],
964 deferrable=Deferrable.DEFERRED,
965 )
966 with connection.schema_editor() as editor:
967 editor.add_constraint(RangesModel, constraint)
968 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
969 RangesModel.objects.create(ints=(20, 50))
970 adjacent_range = RangesModel.objects.create(ints=(10, 20))
971 # Constraint behavior can be changed with SET CONSTRAINTS.
972 with self.assertRaises(IntegrityError):
973 with transaction.atomic(), connection.cursor() as cursor:
974 quoted_name = connection.ops.quote_name(constraint_name)
975 cursor.execute("SET CONSTRAINTS %s IMMEDIATE" % quoted_name)
976 # Remove adjacent range before the end of transaction.
977 adjacent_range.delete()
978 RangesModel.objects.create(ints=(10, 19))
979 RangesModel.objects.create(ints=(51, 60))
980
981 def test_range_adjacent_initially_deferred_with_condition(self):
982 constraint_name = "ints_adjacent_deferred_with_condition"
983 self.assertNotIn(
984 constraint_name, self.get_constraints(RangesModel._meta.db_table)
985 )
986 constraint = ExclusionConstraint(
987 name=constraint_name,
988 expressions=[("ints", RangeOperators.ADJACENT_TO)],
989 condition=Q(ints__lt=(100, 200)),
990 deferrable=Deferrable.DEFERRED,
991 )
992 with connection.schema_editor() as editor:
993 editor.add_constraint(RangesModel, constraint)
994 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
995 RangesModel.objects.create(ints=(20, 50))
996 adjacent_range = RangesModel.objects.create(ints=(10, 20))
997 # Constraint behavior can be changed with SET CONSTRAINTS.
998 with self.assertRaises(IntegrityError):
999 with transaction.atomic(), connection.cursor() as cursor:
1000 quoted_name = connection.ops.quote_name(constraint_name)
1001 cursor.execute(f"SET CONSTRAINTS {quoted_name} IMMEDIATE")
1002 # Remove adjacent range before the end of transaction.
1003 adjacent_range.delete()
1004 RangesModel.objects.create(ints=(10, 19))
1005 RangesModel.objects.create(ints=(51, 60))
1006 # Add adjacent range that doesn't match the condition.
1007 RangesModel.objects.create(ints=(200, 500))
1008 adjacent_range = RangesModel.objects.create(ints=(100, 200))
1009 # Constraint behavior can be changed with SET CONSTRAINTS.
1010 with transaction.atomic(), connection.cursor() as cursor:
1011 quoted_name = connection.ops.quote_name(constraint_name)
1012 cursor.execute(f"SET CONSTRAINTS {quoted_name} IMMEDIATE")
1013
1014 def test_range_adjacent_gist_include(self):
1015 constraint_name = "ints_adjacent_gist_include"
1016 self.assertNotIn(
1017 constraint_name, self.get_constraints(RangesModel._meta.db_table)
1018 )
1019 constraint = ExclusionConstraint(
1020 name=constraint_name,
1021 expressions=[("ints", RangeOperators.ADJACENT_TO)],
1022 index_type="gist",
1023 include=["decimals", "ints"],
1024 )
1025 with connection.schema_editor() as editor:
1026 editor.add_constraint(RangesModel, constraint)
1027 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
1028 RangesModel.objects.create(ints=(20, 50))
1029 with self.assertRaises(IntegrityError), transaction.atomic():
1030 RangesModel.objects.create(ints=(10, 20))
1031 RangesModel.objects.create(ints=(10, 19))
1032 RangesModel.objects.create(ints=(51, 60))
1033
1034 def test_range_adjacent_spgist_include(self):
1035 constraint_name = "ints_adjacent_spgist_include"
1036 self.assertNotIn(
1037 constraint_name, self.get_constraints(RangesModel._meta.db_table)
1038 )
1039 constraint = ExclusionConstraint(
1040 name=constraint_name,
1041 expressions=[("ints", RangeOperators.ADJACENT_TO)],
1042 index_type="spgist",
1043 include=["decimals", "ints"],
1044 )
1045 with connection.schema_editor() as editor:
1046 editor.add_constraint(RangesModel, constraint)
1047 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
1048 RangesModel.objects.create(ints=(20, 50))
1049 with self.assertRaises(IntegrityError), transaction.atomic():
1050 RangesModel.objects.create(ints=(10, 20))
1051 RangesModel.objects.create(ints=(10, 19))
1052 RangesModel.objects.create(ints=(51, 60))
1053
1054 def test_range_adjacent_gist_include_condition(self):
1055 constraint_name = "ints_adjacent_gist_include_condition"
1056 self.assertNotIn(
1057 constraint_name, self.get_constraints(RangesModel._meta.db_table)
1058 )
1059 constraint = ExclusionConstraint(
1060 name=constraint_name,
1061 expressions=[("ints", RangeOperators.ADJACENT_TO)],
1062 index_type="gist",
1063 include=["decimals"],
1064 condition=Q(id__gte=100),
1065 )
1066 with connection.schema_editor() as editor:
1067 editor.add_constraint(RangesModel, constraint)
1068 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
1069
1070 def test_range_adjacent_spgist_include_condition(self):
1071 constraint_name = "ints_adjacent_spgist_include_condition"
1072 self.assertNotIn(
1073 constraint_name, self.get_constraints(RangesModel._meta.db_table)
1074 )
1075 constraint = ExclusionConstraint(
1076 name=constraint_name,
1077 expressions=[("ints", RangeOperators.ADJACENT_TO)],
1078 index_type="spgist",
1079 include=["decimals"],
1080 condition=Q(id__gte=100),
1081 )
1082 with connection.schema_editor() as editor:
1083 editor.add_constraint(RangesModel, constraint)
1084 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
1085
1086 def test_range_adjacent_gist_include_deferrable(self):
1087 constraint_name = "ints_adjacent_gist_include_deferrable"
1088 self.assertNotIn(
1089 constraint_name, self.get_constraints(RangesModel._meta.db_table)
1090 )
1091 constraint = ExclusionConstraint(
1092 name=constraint_name,
1093 expressions=[("ints", RangeOperators.ADJACENT_TO)],
1094 index_type="gist",
1095 include=["decimals"],
1096 deferrable=Deferrable.DEFERRED,
1097 )
1098 with connection.schema_editor() as editor:
1099 editor.add_constraint(RangesModel, constraint)
1100 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
1101
1102 def test_range_adjacent_spgist_include_deferrable(self):
1103 constraint_name = "ints_adjacent_spgist_include_deferrable"
1104 self.assertNotIn(
1105 constraint_name, self.get_constraints(RangesModel._meta.db_table)
1106 )
1107 constraint = ExclusionConstraint(
1108 name=constraint_name,
1109 expressions=[("ints", RangeOperators.ADJACENT_TO)],
1110 index_type="spgist",
1111 include=["decimals"],
1112 deferrable=Deferrable.DEFERRED,
1113 )
1114 with connection.schema_editor() as editor:
1115 editor.add_constraint(RangesModel, constraint)
1116 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
1117
1118 def test_range_adjacent_opclass(self):
1119 constraint_name = "ints_adjacent_opclass"
1120 self.assertNotIn(
1121 constraint_name, self.get_constraints(RangesModel._meta.db_table)
1122 )
1123 constraint = ExclusionConstraint(
1124 name=constraint_name,
1125 expressions=[
1126 (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
1127 ],
1128 )
1129 with connection.schema_editor() as editor:
1130 editor.add_constraint(RangesModel, constraint)
1131 constraints = self.get_constraints(RangesModel._meta.db_table)
1132 self.assertIn(constraint_name, constraints)
1133 with editor.connection.cursor() as cursor:
1134 cursor.execute(SchemaTests.get_opclass_query, [constraint_name])
1135 self.assertEqual(
1136 cursor.fetchall(),
1137 [("range_ops", constraint_name)],
1138 )
1139 RangesModel.objects.create(ints=(20, 50))
1140 with self.assertRaises(IntegrityError), transaction.atomic():
1141 RangesModel.objects.create(ints=(10, 20))
1142 RangesModel.objects.create(ints=(10, 19))
1143 RangesModel.objects.create(ints=(51, 60))
1144 # Drop the constraint.
1145 with connection.schema_editor() as editor:
1146 editor.remove_constraint(RangesModel, constraint)
1147 self.assertNotIn(
1148 constraint_name, self.get_constraints(RangesModel._meta.db_table)
1149 )
1150
1151 def test_range_adjacent_opclass_condition(self):
1152 constraint_name = "ints_adjacent_opclass_condition"
1153 self.assertNotIn(
1154 constraint_name, self.get_constraints(RangesModel._meta.db_table)
1155 )
1156 constraint = ExclusionConstraint(
1157 name=constraint_name,
1158 expressions=[
1159 (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
1160 ],
1161 condition=Q(id__gte=100),
1162 )
1163 with connection.schema_editor() as editor:
1164 editor.add_constraint(RangesModel, constraint)
1165 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
1166
1167 def test_range_adjacent_opclass_deferrable(self):
1168 constraint_name = "ints_adjacent_opclass_deferrable"
1169 self.assertNotIn(
1170 constraint_name, self.get_constraints(RangesModel._meta.db_table)
1171 )
1172 constraint = ExclusionConstraint(
1173 name=constraint_name,
1174 expressions=[
1175 (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
1176 ],
1177 deferrable=Deferrable.DEFERRED,
1178 )
1179 with connection.schema_editor() as editor:
1180 editor.add_constraint(RangesModel, constraint)
1181 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
1182
1183 def test_range_adjacent_gist_opclass_include(self):
1184 constraint_name = "ints_adjacent_gist_opclass_include"
1185 self.assertNotIn(
1186 constraint_name, self.get_constraints(RangesModel._meta.db_table)
1187 )
1188 constraint = ExclusionConstraint(
1189 name=constraint_name,
1190 expressions=[
1191 (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
1192 ],
1193 index_type="gist",
1194 include=["decimals"],
1195 )
1196 with connection.schema_editor() as editor:
1197 editor.add_constraint(RangesModel, constraint)
1198 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
1199
1200 def test_range_adjacent_spgist_opclass_include(self):
1201 constraint_name = "ints_adjacent_spgist_opclass_include"
1202 self.assertNotIn(
1203 constraint_name, self.get_constraints(RangesModel._meta.db_table)
1204 )
1205 constraint = ExclusionConstraint(
1206 name=constraint_name,
1207 expressions=[
1208 (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
1209 ],
1210 index_type="spgist",
1211 include=["decimals"],
1212 )
1213 with connection.schema_editor() as editor:
1214 editor.add_constraint(RangesModel, constraint)
1215 self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
1216
1217 def test_range_equal_cast(self):
1218 constraint_name = "exclusion_equal_room_cast"
1219 self.assertNotIn(constraint_name, self.get_constraints(Room._meta.db_table))
1220 constraint = ExclusionConstraint(
1221 name=constraint_name,
1222 expressions=[(Cast("number", IntegerField()), RangeOperators.EQUAL)],
1223 )
1224 with connection.schema_editor() as editor:
1225 editor.add_constraint(Room, constraint)
1226 self.assertIn(constraint_name, self.get_constraints(Room._meta.db_table))
1227
1228 @isolate_apps("postgres_tests")
1229 def test_table_create(self):
1230 constraint_name = "exclusion_equal_number_tc"
1231
1232 class ModelWithExclusionConstraint(Model):
1233 number = IntegerField()
1234
1235 class Meta:
1236 app_label = "postgres_tests"
1237 constraints = [
1238 ExclusionConstraint(
1239 name=constraint_name,
1240 expressions=[("number", RangeOperators.EQUAL)],
1241 )
1242 ]
1243
1244 with connection.schema_editor() as editor:
1245 editor.create_model(ModelWithExclusionConstraint)
1246 self.assertIn(
1247 constraint_name,
1248 self.get_constraints(ModelWithExclusionConstraint._meta.db_table),
1249 )
1250
1251 def test_database_default(self):
1252 constraint = ExclusionConstraint(
1253 name="ints_equal", expressions=[("ints", RangeOperators.EQUAL)]
1254 )
1255 RangesModel.objects.create()
1256 msg = "Constraint “ints_equal” is violated."
1257 with self.assertRaisesMessage(ValidationError, msg):
1258 constraint.validate(RangesModel, RangesModel())