Fixed #30062 -- Added support for unique conditional constraints.

2 files changed, 69 insertions, 6 deletions

diff --git a/tests/constraints/models.py b/tests/constraints/models.py
index b1645ecedb..f316b95161 100644
--- a/tests/constraints/models.py
+++ b/tests/constraints/models.py
@@ -3,6 +3,7 @@ from django.db import models
 
 class Product(models.Model):
     name = models.CharField(max_length=255)
+    color = models.CharField(max_length=32, null=True)
     price = models.IntegerField(null=True)
     discounted_price = models.IntegerField(null=True)
 
@@ -12,5 +13,10 @@ class Product(models.Model):
                 check=models.Q(price__gt=models.F('discounted_price')),
                 name='price_gt_discounted_price',
             ),
-            models.UniqueConstraint(fields=['name'], name='unique_name'),
+            models.UniqueConstraint(fields=['name', 'color'], name='name_color_uniq'),
+            models.UniqueConstraint(
+                fields=['name'],
+                name='name_without_color_uniq',
+                condition=models.Q(color__isnull=True),
+            ),
         ]
diff --git a/tests/constraints/tests.py b/tests/constraints/tests.py
index 0e769ba321..b7aeb1e7f0 100644
--- a/tests/constraints/tests.py
+++ b/tests/constraints/tests.py
@@ -83,7 +83,10 @@ class CheckConstraintTests(TestCase):
 class UniqueConstraintTests(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.p1 = Product.objects.create(name='p1')
+        cls.p1, cls.p2 = Product.objects.bulk_create([
+            Product(name='p1', color='red'),
+            Product(name='p2'),
+        ])
 
     def test_eq(self):
         self.assertEqual(
@@ -100,6 +103,29 @@ class UniqueConstraintTests(TestCase):
         )
         self.assertNotEqual(models.UniqueConstraint(fields=['foo', 'bar'], name='unique'), 1)
 
+    def test_eq_with_condition(self):
+        self.assertEqual(
+            models.UniqueConstraint(
+                fields=['foo', 'bar'], name='unique',
+                condition=models.Q(foo=models.F('bar'))
+            ),
+            models.UniqueConstraint(
+                fields=['foo', 'bar'], name='unique',
+                condition=models.Q(foo=models.F('bar'))),
+        )
+        self.assertNotEqual(
+            models.UniqueConstraint(
+                fields=['foo', 'bar'],
+                name='unique',
+                condition=models.Q(foo=models.F('bar'))
+            ),
+            models.UniqueConstraint(
+                fields=['foo', 'bar'],
+                name='unique',
+                condition=models.Q(foo=models.F('baz'))
+            ),
+        )
+
     def test_repr(self):
         fields = ['foo', 'bar']
         name = 'unique_fields'
@@ -109,6 +135,18 @@ class UniqueConstraintTests(TestCase):
             "<UniqueConstraint: fields=('foo', 'bar') name='unique_fields'>",
         )
 
+    def test_repr_with_condition(self):
+        constraint = models.UniqueConstraint(
+            fields=['foo', 'bar'],
+            name='unique_fields',
+            condition=models.Q(foo=models.F('bar')),
+        )
+        self.assertEqual(
+            repr(constraint),
+            "<UniqueConstraint: fields=('foo', 'bar') name='unique_fields' "
+            "condition=(AND: ('foo', F(bar)))>",
+        )
+
     def test_deconstruction(self):
         fields = ['foo', 'bar']
         name = 'unique_fields'
@@ -118,15 +156,34 @@ class UniqueConstraintTests(TestCase):
         self.assertEqual(args, ())
         self.assertEqual(kwargs, {'fields': tuple(fields), 'name': name})
 
+    def test_deconstruction_with_condition(self):
+        fields = ['foo', 'bar']
+        name = 'unique_fields'
+        condition = models.Q(foo=models.F('bar'))
+        constraint = models.UniqueConstraint(fields=fields, name=name, condition=condition)
+        path, args, kwargs = constraint.deconstruct()
+        self.assertEqual(path, 'django.db.models.UniqueConstraint')
+        self.assertEqual(args, ())
+        self.assertEqual(kwargs, {'fields': tuple(fields), 'name': name, 'condition': condition})
+
     def test_database_constraint(self):
         with self.assertRaises(IntegrityError):
-            Product.objects.create(name=self.p1.name)
+            Product.objects.create(name=self.p1.name, color=self.p1.color)
 
     def test_model_validation(self):
-        with self.assertRaisesMessage(ValidationError, 'Product with this Name already exists.'):
-            Product(name=self.p1.name).validate_unique()
+        with self.assertRaisesMessage(ValidationError, 'Product with this Name and Color already exists.'):
+            Product(name=self.p1.name, color=self.p1.color).validate_unique()
+
+    def test_model_validation_with_condition(self):
+        """Partial unique constraints are ignored by Model.validate_unique()."""
+        Product(name=self.p1.name, color='blue').validate_unique()
+        Product(name=self.p2.name).validate_unique()
 
     def test_name(self):
         constraints = get_constraints(Product._meta.db_table)
-        expected_name = 'unique_name'
+        expected_name = 'name_color_uniq'
         self.assertIn(expected_name, constraints)
+
+    def test_condition_must_be_q(self):
+        with self.assertRaisesMessage(ValueError, 'UniqueConstraint.condition must be a Q instance.'):
+            models.UniqueConstraint(name='uniq', fields=['name'], condition='invalid')