Question

我有一个django模型，我需要在保存之前比较字段的旧值和新值。

我尝试过save（）继承和pre_save信号。它被正确触发，但我找不到实际更改字段的列表，无法比较新旧值。有一种方法？我需要它来优化预先行动。

谢谢！

Answer 1

有很简单的django方法。

“记住”模型初始化中的值，如下所示：

def __init__(self, *args, **kwargs):
    super(MyClass, self).__init__(*args, **kwargs)
    self.initial_parametername = self.parametername
    ---
    self.initial_parameternameX = self.parameternameX

现实生活中的例子：

上课时间：

def __init__(self, *args, **kwargs):
    super(MyClass, self).__init__(*args, **kwargs)
    self.__important_fields = ['target_type', 'target_id', 'target_object', 'number', 'chain', 'expiration_date']
    for field in self.__important_fields:
        setattr(self, '__original_%s' % field, getattr(self, field))

def has_changed(self):
    for field in self.__important_fields:
        orig = '__original_%s' % field
        if getattr(self, orig) != getattr(self, field):
            return True
    return False

然后在modelform保存方法中：

def save(self, force_insert=False, force_update=False, commit=True):
    # Prep the data
    obj = super(MyClassForm, self).save(commit=False)

    if obj.has_changed():

        # If we're down with commitment, save this shit
        if commit:
            obj.save(force_insert=True)

    return obj

Answer 2

最好在 ModelForm级别执行此操作。

您可以在保存方法中获得比较所需的所有数据：

self.data ：传递给表单的实际数据。
self.cleaned_data ：验证后清理数据，包含有资格保存在模型中的数据
self.changed_data ：已更改的字段列表。如果没有任何改变，这将是空的

如果你想在Model级别执行此操作，那么你可以按照Odif的答案中指定的方法进行操作。

Answer 3

此外，您可以使用FieldTracker中的django-model-utils：

只需在您的模型中添加跟踪器字段：
```
tracker = FieldTracker()
```

现在在pre_save和post_save中你可以使用：

instance.tracker.previous('modelfield')     # get the previous value
instance.tracker.has_changed('modelfield')  # just check if it is changed

Answer 4

Django 1.8及更高版本（包括Django 2.x和3.x），有一个from_db类方法，可用于自数据库加载时自定义模型实例的创建。

注意：如果使用此方法，则还有否个数据库查询。

这是官方文档Model instance - Customize model loading

的链接

from django.db import Model

class MyClass(models.Model):
    
    @classmethod
    def from_db(cls, db, field_names, values):
        instance = super().from_db(db, field_names, values)
        
        # save original values, when model is loaded from database,
        # in a separate attribute on the model
        instance._loaded_values = dict(zip(field_names, values))
        
        return instance

因此，现在原始值在模型的_loaded_values属性中可用。您可以在save方法内访问此属性，以检查是否正在更新某些值。

class MyClass(models.Model):
    field_1 = models.CharField(max_length=1)

    @classmethod
    def from_db(cls, db, field_names, values):
        ...
        # use code from above

    def save(self, *args, **kwargs):

        # check if a new db row is being added
        # When this happens the `_loaded_values` attribute will not be available
        if not self._state.adding:

            # check if field_1 is being updated
            if self._loaded_values['field_1'] != self.field_1:
                # do something

        super().save(*args, **kwargs)

Answer 5

以下是一款应用，可让您在保存模型之前访问字段的上一个和当前值：django-smartfields

以下是如何在一个好的声明中解决这个问题：

from django.db import models
from smartfields import fields, processors
from smartfields.dependencies import Dependency

class ConditionalProcessor(processors.BaseProcessor):

    def process(self, value, stashed_value=None, **kwargs):
        if value != stashed_value:
            # do any necessary modifications to new value
            value = ... 
        return value

class MyModel(models.Model):
    my_field = fields.CharField(max_length=10, dependencies=[
        Dependency(processor=ConditionalProcessor())
    ])

此外，仅在字段值被替换的情况下才会调用此处理器

Answer 6

我的用例是，每当某个字段改变其值时，我需要在模型中设置非规范化值。但是，由于被监视的字段是m2m关系，我不想在调用save时进行数据库查找，以检查非规范化字段是否需要更新。所以，我写了这个小混音（使用@Odif Yitsaeb的答案作为灵感），以便只在必要时更新非规范化的字段。

class HasChangedMixin(object):
    """ this mixin gives subclasses the ability to set fields for which they want to monitor if the field value changes """
    monitor_fields = []

    def __init__(self, *args, **kwargs):
        super(HasChangedMixin, self).__init__(*args, **kwargs)
        self.field_trackers = {}

    def __setattr__(self, key, value):
        super(HasChangedMixin, self).__setattr__(key, value)
        if key in self.monitor_fields and key not in self.field_trackers:
            self.field_trackers[key] = value

    def changed_fields(self):
        """
        :return: `list` of `str` the names of all monitor_fields which have changed
        """
        changed_fields = []
        for field, initial_field_val in self.field_trackers.items():
            if getattr(self, field) != initial_field_val:
                changed_fields.append(field)

        return changed_fields

Answer 7

我同意Sahil的说法，使用ModelForm更好更容易。但是，您将自定义ModelForm的clean方法并在那里执行验证。就我而言，如果设置了模型上的字段，我想阻止对模型实例的更新。

我的代码看起来像这样：

from django.forms import ModelForm

class ExampleForm(ModelForm):
    def clean(self):
        cleaned_data = super(ExampleForm, self).clean()
        if self.instance.field:
            raise Exception
        return cleaned_data

Answer 8

类似的方法也适用：

class MyModel(models.Model):
    my_field = fields.IntegerField()

    def save(self, *args, **kwargs):
       # Compare old vs new
       if self.pk:
           obj = MyModel.objects.values('my_value').get(pk=self.pk)
           if obj['my_value'] != self.my_value:
               # Do stuff...
               pass
       super().save(*args, **kwargs)

Answer 9

在现代 Django 中，在上述答案中，一个非常重要的问题要添加到 the answer accepted 的内容中。当您使用 defer 或 only QuerySet API 时，您可能会陷入无限递归。

__get__() 的

django.db.models.query_utils.DeferredAttribute 方法调用 refresh_from_db() 的 django.db.models.Model 方法。 db_instance = db_instance_qs.get()中有一行refresh_from_db()，该行递归调用实例的__init__()方法。

所以，有必要添加确保目标属性不被延迟。

def __init__(self, *args, **kwargs):
    super(MyClass, self).__init__(*args, **kwargs)

    deferred_fields = self.get_deferred_fields()
    important_fields = ['target_type', 'target_id', 'target_object', 'number', 'chain', 'expiration_date']

    self.__important_fields = list(filter(lambda x: x not in deferred_fields, important_fields))
    for field in self.__important_fields:
        setattr(self, '__original_%s' % field, getattr(self, field))

django - 在保存之前比较新旧字段值

9 个答案: