Django Rest框架：如何在验证序列化程序时忽略唯一主键约束？

Question

我试图在PostgreSQL数据库中存储大量传输数据，客户端一次上传多个记录（数万条）。我只需要一个到达时间，每站，每条路线，每趟行程和唯一的标识符为该站，路线，行程是我的表的主键（和一个外键在不同的表）。我正在尝试在我的序列化器中使用Django的update_or_create来创建到达时间的条目，或者使用已经存在的最新数据更新到达时间。不幸的是，在我的序列化程序上调用is_valid（）时，它发现重复记录违反了主键的唯一性约束（这是有意义的），给我这个错误消息：

'real_id': [ErrorDetail(string='actual with this real id already exists.', code='unique')]

我想重写这个行为，因为如果主键不是唯一的，它只会更新条目。我已经尝试过循环并删除验证程序，如下所示：

    def run_validators(self, value):
        for validator in self.validators:
            self.validators.remove(validator)
        super(ActualSerializer, self).run_validators(value)

我还尝试使用序列化器元类的extra_kwargs字段删除所有验证器，如下所示：

extra_kwargs = {
            'name': {'validators': []}
        }

我真的不想在我的视图中进行插入，因为理想情况下，序列化器正在解析值并验证其他约束。

但这些解决方案都没有改变任何事情。我找不到其他可以解决我问题的东西（但如果有人找到我错过的答案，那将是天赐良机）。我想我的问题与这个问题有些相似，但那个问题没有一个好的答案。

作为参考，我的序列化程序文件：

from .models import Future, Actual
from rest_framework import serializers


class ActualSerializer(serializers.ModelSerializer):

    def create(self, validated_data):
        actual, created = Actual.objects.update_or_create(
            real_id=validated_data['real_id'],
            defaults={'arrival': validated_data.get('arrival', None)}
        )
        return actual

    class Meta:
        model = Actual
        fields = ['real_id', 'arrival']


class FutureSerializer(serializers.ModelSerializer):

    class Meta:
        model = Future
        fields = ['row_id', 'stop_id', 'route_id', 'record_time', 'predicted_arrival', 'delay', 'real_id']

我的模型：

from django.db import models
import json


class Actual(models.Model):
    real_id = models.CharField(max_length=100, primary_key=True)
    arrival = models.BigIntegerField(null=True)

    def __str__(self):
        return json.dumps([self.real_id, self.arrival])


class Future(models.Model):
    row_id = models.BigAutoField(primary_key=True)
    stop_id = models.CharField(max_length=20)
    route_id = models.CharField(max_length=10)
    record_time = models.BigIntegerField()
    predicted_arrival = models.IntegerField(null=True)
    delay = models.IntegerField()
    real_id = models.ForeignKey(Actual, on_delete=models.CASCADE)

    def __str__(self):
        return json.dumps([self.row_id,
                           self.stop_id,
                           self.route_id,
                           self.record_time,
                           self.predicted_arrival,
                           self.delay,
                           self.real_id])

最后，我的观点是：

class ArrivalData(APIView):

    queryset = Future.objects.all()
    permission_classes = [OperationAllowed]

    def post(self, request: Request, format=None) -> Response:
        parsed_data = json.loads(request.data['data'])
        actual_arrivals = []
        for datum in parsed_data:
            saved_time = None
            if datum['predicted_arrival'] is not None and -200 < datum['predicted_arrival'] - datum['record_time'] < 0:
                saved_time = datum['predicted_arrival']

            actual_arrivals.append({
                'real_id': datum['real_id'],
                'arrival': saved_time,
            })

        actual_serializer = ActualSerializer(data=actual_arrivals, many=True)
        if actual_serializer.is_valid(raise_exception=False):
            actual_serializer.save()
        future_serializer = FutureSerializer(data=parsed_data, many=True)

        if future_serializer.is_valid():

            future_serializer.save()
            return Response("Data saved")
        
        return Response(str(actual_serializer.errors))

Answer 1

因此，唯一的约束是字段级别的验证器，这就是为什么试图在类级别删除它不起作用。

我在serializer类中显式声明了字段，但没有任何验证器real\u id=serializers.CharField（validators=[]），这解决了问题。

如果其他人有这个问题，这个页面最终帮助了我。