ModelSerializer uniqueness validation does not work for partial unique constraints

[elliot-wilson]

I have a model with a relatively common partial uniqueness constraint pattern: there can be many Person instances with a duplicate name value, as long as only one of them is_active: True.

However, when using a ModelSerializer to validate data for that model, the uniqueness validation returns False for otherwise valid data if there is already a Person with that name in the database, even if the data has is_active: False.

Here's a dummy example:

from django.db import models
from django.db.models import Q
from rest_framework import serializers

class Person(models.Model):
    name = models.CharField(max_length=100)
    is_active = models.BooleanField(default=False)

    class Meta:
        constraints = [
            models.UniqueConstraint(fields=["name"], condition=Q(is_active=True), name="unique_active_name"),
        ]

class PersonSerializer(serializers.ModelSerializer):
    class Meta:
        model = Person
        fields = "__all__"

Person.objects.create(name="John Doe", is_active=True)

data = {
    "name": "John Doe",
    "is_active": False,
}

Person.objects.create(**data)  # creates new user just fine

serializer = PersonSerializer(data=data)
serializer.is_valid(raise_exception=True)  # rest_framework.exceptions.ValidationError: {'name': [ErrorDetail(string='person with this name already exists.', code='unique')]}

The relevant source code is here:

django-rest-framework/rest_framework/utils/field_mapping.py

Lines 65 to 85 in 36d5c0e

	def get_unique_validators(field_name, model_field):
	"""
	Returns a list of UniqueValidators that should be applied to the field.
	"""
	field_set = set([field_name])
	conditions = {
	c.condition
	for c in model_field.model._meta.constraints
	if isinstance(c, models.UniqueConstraint) and set(c.fields) == field_set
	}
	if getattr(model_field, 'unique', False):
	conditions.add(None)
	if not conditions:
	return
	unique_error_message = get_unique_error_message(model_field)
	queryset = model_field.model._default_manager
	for condition in conditions:
	yield UniqueValidator(
	queryset=queryset if condition is None else queryset.filter(condition),
	message=unique_error_message
	)

and

django-rest-framework/rest_framework/validators.py

Lines 63 to 74 in 36d5c0e

	def __call__(self, value, serializer_field):
	# Determine the underlying model field name. This may not be the
	# same as the serializer field name if `source=<>` is set.
	field_name = serializer_field.source_attrs[-1]
	# Determine the existing instance, if this is an update operation.
	instance = getattr(serializer_field.parent, 'instance', None)
	queryset = self.queryset
	queryset = self.filter_queryset(value, queryset, field_name)
	queryset = self.exclude_current_instance(queryset, instance)
	if qs_exists(queryset):
	raise ValidationError(self.message, code='unique')

Basically, the code is asking, "Is there already an is_active: True Person with this name?", but I believe the correct question should be more like "Is there already a record in the database that matches the constraint condition AND does the current instance match the condition?"

[elliot-wilson]

As a quick workaround, I was able to do:

class PersonSerializer(serializers.ModelSerializer):
    provider = serializers.CharField(validators=[])

    class Meta:
        model = Person
        fields = "__all__"

    def validate(self, data):
        name = data.get("name")
        is_active = data.get("is_active")
        instance = self.instance

        if is_active:
            if Person.objects.filter(name=name, is_active=True).exclude(id=instance.id).exists():
                raise serializers.ValidationError({"name": "There is already an active person with this name."})

        return data

but it seems a little hacky to be reimplementing the constraint in the serializer when it already exists on the model.

I'd love to know what people think!

[browser-bug]

I'm experiencing the same issue. Has this been confirmed and will (potentially) get fixed or not? Thanks