Python Django Rest框架：如何忽略'；独特的'；验证序列化程序时的主键约束？

我试图将大量的传输数据存储在PostgreSQL数据库中，在该数据库中，客户端一次上载多条记录（成千上万条记录）。我只希望每个站点、每个路线、每个行程有一个到达时间，并且该站点、路线和行程的唯一标识符是我的表的主键（以及其他表中的外键）。我正在尝试在序列化程序中使用Django的update_或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 = {
            'name': {'validators': []}
        }

我还尝试使用序列化器元类的

extra_kwargs

字段删除所有验证器，如下所示：

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

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))

类到达数据（APIView）：
queryset=Future.objects.all（）
权限\u类=[OperationAllowed]
def post（自我，请求：请求，格式=无）->响应：
parsed_data=json.load（request.data['data']）
实际到达人数=[]
对于解析的_数据中的数据：
节省的时间=无
如果基准['predicted_arrival']不是无且-200<基准['predicted_arrival']-基准['record_time']<0：
保存的时间=基准['预计到达']
实际到达量({
“真实id”：数据[“真实id”]，
“到达”：节省时间，
})
实际_序列化程序=实际序列化程序（数据=实际_到达，多个=真）
如果实际的序列化程序有效（raise\U exception=False）：
实际_序列化程序.save（）
future\u serializer=FutureSerializer（数据=解析的\u数据，多个=真）
如果将来的\u序列化程序.是否有效（）：
future_序列化程序.save（）
返回响应（“数据已保存”）
返回响应（str（实际_序列化程序.错误））

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

我在serializer类中显式声明了字段，但没有任何验证器

real\u id=serializers.CharField（validators=[]）

，这解决了问题

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