UniqueTogetherValidator does not comply to Database standards

[gabn88]

Checklist

• This cannot be dealt with as a third party library. (We prefer new functionality to be in the form of third party libraries where possible.)
• I have reduced the issue to the simplest possible case.

If you have a database unique constraint that includes a nullable field, DRF will still raise an 'field_A and field_B must make a unique set' validationerror when you try to post a new nullable field. Whereas on database level every NULL is considered unique.

Could be fixed maybe here in the code:

django-rest-framework/rest_framework/validators.py

Line 123 in 63063da

def filter_queryset(self, attrs, queryset, serializer):

[gabn88]

While working around this issue I might have found another (possibly related) issue. The validator uses UniqueTogetherValidator.fields, but bypasses the build_field method, whereas the UniqueTogetherValidator.filter_queryset method uses serializer.fields, which did go through the build_field method. Thereby creating an inconsistency.

See the code below for an example.

class NullableUniqueTogetherValidator(UniqueTogetherValidator):
    def filter_queryset(self, attrs, queryset, serializer):
        """
        Filter the queryset to all instances matching the given attributes.
        """

        # field names => field sources
        sources = [serializer.fields[field_name].source for field_name in self.fields]

        # If this is an update, then any unprovided field should
        # have it's value set based on the existing instance attribute.
        if serializer.instance is not None:
            for source in sources:
                if source not in attrs:
                    attrs[source] = getattr(serializer.instance, source)

        # Determine the filter keyword arguments and filter the queryset.
        filter_kwargs = {source: attrs[source] for source in sources}
        return qs_filter(queryset, **filter_kwargs)


class UIDModelSerializer(ModelSerializer):
    serializer_related_field = UIDRelatedField

    def get_field_names(self, declared_fields, info):
        forward_relations = info.forward_relations
        reverse_relations = info.reverse_relations

        forward_names = []
        self._names_to_add_uid = []
        for field_name, field_info in forward_relations.items():
            if not field_info.to_many:
                forward_names.append(field_name)
        for name in forward_names:
            forward_relations[name + "_uid"] = forward_relations.pop(name)
            self._names_to_add_uid += [name]

        reverse_names = []
        for field_name, field_info in reverse_relations.items():
            if not field_info.to_many:
                reverse_names.append(field_name)
        for name in reverse_names:
            reverse_relations[name + "_uid"] = reverse_relations.pop(name)
            self._names_to_add_uid += [name]
        return super().get_field_names(declared_fields, info)

    def get_extra_kwargs(self):
        """
        Return a dictionary mapping field names to a dictionary of
        additional keyword arguments.
        """
        extra_kwargs = copy.deepcopy(getattr(self.Meta, 'extra_kwargs', {}))

        if hasattr(self, '_names_to_add_uid'):
            for name in self._names_to_add_uid:
                kwargs = extra_kwargs.get(name + '_uid', {})
                kwargs.update({'source': name})
                extra_kwargs.update({name + '_uid': kwargs})

        read_only_fields = getattr(self.Meta, 'read_only_fields', None)
        if read_only_fields is not None:
            if not isinstance(read_only_fields, (list, tuple)):
                raise TypeError(
                    'The `read_only_fields` option must be a list or tuple. '
                    'Got %s.' % type(read_only_fields).__name__
                )
            for field_name in read_only_fields:
                kwargs = extra_kwargs.get(field_name, {})
                kwargs['read_only'] = True
                extra_kwargs[field_name] = kwargs

        else:
            # Guard against the possible misspelling `readonly_fields` (used
            # by the Django admin and others).
            assert not hasattr(self.Meta, 'readonly_fields'), (
                'Serializer `%s.%s` has field `readonly_fields`; '
                'the correct spelling for the option is `read_only_fields`.'
                % (self.__class__.__module__, self.__class__.__name__)
            )

        return extra_kwargs



class MyModelSerializer(UIDModelSerializer)
        validators = [
            NullableUniqueTogetherValidator(queryset=Invitation.objects.all(), fields=['contact_uid', 'invitee_email']),
        ]