Validate in Model

Django 提供了model的实例validate（也就是数据库表的一行的验证）， 这个功能由下面三块组成

1 Validate the model fields - Model.clean_fields()//验证每个field
2 Validate the model as a whole - Model.clean()// 验证整个model,这个是我们可以自己定制的
3 Validate the field uniqueness - Model.validate_unique() //验证field的唯一性

你可以通过显示调用实例的full_clean()方法调用上面三个验证,如果只调用了实例的save()方法，将不会调用验证

Model.full_clean(exclude=None, validate_unique=True)
该方法依次调用Model.clean_fields()，Model.clean()，Model.validate_unique()(validate_unique=True情况下才会调用validate_unique，默认是True)
如果验证过程中出现问题， 会产生ValidationError异常，该异常的属性message_dict包含以上三步中的所有异常
exclude 参数提供一个列表，该列表中列出的field会调过验证，默认是None
//下面直接上代码

 

      def full_clean(self, exclude=None, validate_unique=True):
        """
        Calls clean_fields, clean, and validate_unique, on the model,
        and raises a ``ValidationError`` for any errors that occurred.
        """
        errors = {}
        if exclude is None:
            exclude = []
        else:
            exclude = list(exclude)

        try:
            self.clean_fields(exclude=exclude)   //调用clean_fields
        except ValidationError as e:
            errors = e.update_error_dict(errors)

        # Form.clean() is run even if other validation fails, so do the
        # same with Model.clean() for consistency.
        try:
            self.clean()    //调用clean
        except ValidationError as e:
            errors = e.update_error_dict(errors)

        # Run unique checks, but only for fields that passed validation.
        if validate_unique:
            for name in errors.keys():
                if name != NON_FIELD_ERRORS and name not in exclude:  //对通过clean_fields的fields进行unique的检查
                    exclude.append(name)
            try:
                self.validate_unique(exclude=exclude)
            except ValidationError as e:
                errors = e.update_error_dict(errors)

        if errors:
            raise ValidationError(errors)

 

Step1:clean_fields：
对每一个field进行clean，exclude包含不包括clean的field，可以看到本质上是对每一个field调用field.clean()

    def clean_fields(self, exclude=None):
        """
        Cleans all fields and raises a ValidationError containing a dict
        of all validation errors if any occur.
        """
        if exclude is None:
            exclude = []

        errors = {}
        for f in self._meta.fields:  //取出每一个fiels
            if f.name in exclude:   //调过exclude
                continue
            # Skip validation for empty fields with blank=True. The developer
            # is responsible for making sure they have a valid value.
            raw_value = getattr(self, f.attname)  //取出原始值
            if f.blank and raw_value in f.empty_values:  //如果该field是可以空的，并且raw_value是空的，则过
                continue
            try:
                setattr(self, f.attname, f.clean(raw_value, self))  //调用field.clean() 并将clean之后的值放到f.attname，此处意味着如果有些clean会改变属性的值比如+1，那么调用两次就会+2,感觉这地方是个bug
            except ValidationError as e:
                errors[f.name] = e.error_list  //{'field_name':'field_error_list'}

        if errors:
            raise ValidationError(errors)

 

我们再看一下fields.clean() 这个方法

 

    def clean(self, value):
        """
        Validates the given value and returns its "cleaned" value as an
        appropriate Python object.

        Raises ValidationError for any errors.
        """
        value = self.to_python(value)  //将raw_value 转化为python类型
        self.validate(value)  //运行field.validate()
        self.run_validators(value)  //运行feild.run_validators()
        return value
        
    
    def to_python(self, value):   //感觉这个方法什么事情都没做
        return value

    def validate(self, value):            //仅仅检测了对于必须的field是否为空，注意为空的判断self.empty_values
        if value in self.empty_values and self.required:
            raise ValidationError(self.error_messages['required'], code='required')

    def run_validators(self, value):        //对提供的validators进行验证。validators是field定义的时候定义的
        if value in self.empty_values:
            return
        errors = []
        for v in self.validators:
            try:
                v(value)
            except ValidationError as e:
                if hasattr(e, 'code') and e.code in self.error_messages:
                    e.message = self.error_messages[e.code]
                errors.extend(e.error_list)
        if errors:
            raise ValidationError(errors)    

 

 

Step2:Model.clean()
该方法由用户定制，进行模型的clean，代码里面也是空的

 

Step3.validate_unique
验证唯一性

 

    def validate_unique(self, exclude=None):
        """
        Checks unique constraints on the model and raises ``ValidationError``
        if any failed.
        """
        unique_checks, date_checks = self._get_unique_checks(exclude=exclude)  //可以看到分为unique_checks, date_checks

        errors = self._perform_unique_checks(unique_checks)
        date_errors = self._perform_date_checks(date_checks)

        for k, v in date_errors.items():
            errors.setdefault(k, []).extend(v)

        if errors:
            raise ValidationError(errors)

 

我们看一下self._get_unique_checks(exclude=exclude) 这个方法，这个方法返回unique_checks和date_checks

 

 def _get_unique_checks(self, exclude=None):
        """
        Gather a list of checks to perform. Since validate_unique could be
        called from a ModelForm, some fields may have been excluded; we can't
        perform a unique check on a model that is missing fields involved
        in that check.
        Fields that did not validate should also be excluded, but they need
        to be passed in via the exclude argument.
        """
        if exclude is None:
            exclude = []
        unique_checks = []

        unique_togethers = [(self.__class__, self._meta.unique_together)]   //(class_name,uniq_list) unique_together不包括单独的field作为唯一性
        for parent_class in self._meta.get_parent_list():
            if parent_class._meta.unique_together:
                unique_togethers.append((parent_class, parent_class._meta.unique_together))   //[(class1,uniq1),(class2,uniq_2)]

        for model_class, unique_together in unique_togethers:
            for check in unique_together:                                                // uniq = [(uniq1,uniq2)] 其中uniq1=(file1,filed2,filed3),如果一个uniq的组里面有一个filed是exclude的则调过
                for name in check:
                    # If this is an excluded field, don't add this check.
                    if name in exclude:
                        break
                else:
                    unique_checks.append((model_class, tuple(check)))   //check = (field1,field2...) 

        # These are checks for the unique_for_<date/year/month>.
        date_checks = []

        # Gather a list of checks for fields declared as unique and add them to
        # the list of checks.

        fields_with_class = [(self.__class__, self._meta.local_fields)]
        for parent_class in self._meta.get_parent_list():
            fields_with_class.append((parent_class, parent_class._meta.local_fields))

        for model_class, fields in fields_with_class:
            for f in fields:
                name = f.name
                if name in exclude:
                    continue
                if f.unique:
                    unique_checks.append((model_class, (name,)))            //增加单独的唯一性的fields
                if f.unique_for_date and f.unique_for_date not in exclude:
                    date_checks.append((model_class, 'date', name, f.unique_for_date))
                if f.unique_for_year and f.unique_for_year not in exclude:
                    date_checks.append((model_class, 'year', name, f.unique_for_year))
                if f.unique_for_month and f.unique_for_month not in exclude:
                    date_checks.append((model_class, 'month', name, f.unique_for_month))
        return unique_checks, date_checks

  

 

  执行uniq的check

 

     def _perform_unique_checks(self, unique_checks):
        errors = {}

        for model_class, unique_check in unique_checks:
            # Try to look up an existing object with the same values as this
            # object's values for all the unique field.

            lookup_kwargs = {}
            for field_name in unique_check:
                f = self._meta.get_field(field_name)  //获取field名称对应的field，这地方为什么不直接传field呢？
                lookup_value = getattr(self, f.attname)
                if lookup_value is None:
                    # no value, skip the lookup
                    continue
                if f.primary_key and not self._state.adding:   //如果其中有一个field是主键并且是editing的话则不需要检测，因为主键是不可更改的
                    # no need to check for unique primary key when editing
                    continue
                lookup_kwargs[str(field_name)] = lookup_value

            # some fields were skipped, no reason to do the check  //前面某个field有continue的分支产生
            if len(unique_check) != len(lookup_kwargs):
                continue

            qs = model_class._default_manager.filter(**lookup_kwargs)  //构建查询对象

            # Exclude the current object from the query if we are editing an
            # instance (as opposed to creating a new one)
            # Note that we need to use the pk as defined by model_class, not
            # self.pk. These can be different fields because model inheritance
            # allows single model to have effectively multiple primary keys.
            # Refs #17615.
            model_class_pk = self._get_pk_val(model_class._meta)
            if not self._state.adding and model_class_pk is not None:
                qs = qs.exclude(pk=model_class_pk)
            if qs.exists():                                //如果qs存在，则表示有重复
                if len(unique_check) == 1:
                    key = unique_check[0]
                else:
                    key = NON_FIELD_ERRORS
                errors.setdefault(key, []).append(self.unique_error_message(model_class, unique_check))

        return errors

 

#检测日期是否相同

 

    def _perform_date_checks(self, date_checks):
        errors = {}
        for model_class, lookup_type, field, unique_for in date_checks:
            lookup_kwargs = {}
            # there's a ticket to add a date lookup, we can remove this special
            # case if that makes it's way in
            date = getattr(self, unique_for)
            if date is None:
                continue
            if lookup_type == 'date':
                lookup_kwargs['%s__day' % unique_for] = date.day
                lookup_kwargs['%s__month' % unique_for] = date.month
                lookup_kwargs['%s__year' % unique_for] = date.year
            else:
                lookup_kwargs['%s__%s' % (unique_for, lookup_type)] = getattr(date, lookup_type)
            lookup_kwargs[field] = getattr(self, field)

            qs = model_class._default_manager.filter(**lookup_kwargs)
            # Exclude the current object from the query if we are editing an
            # instance (as opposed to creating a new one)
            if not self._state.adding and self.pk is not None:
                qs = qs.exclude(pk=self.pk)

            if qs.exists():
                errors.setdefault(field, []).append(
                    self.date_error_message(lookup_type, field, unique_for)
                )
        return errors

 

可以看到，在做validate的时候避免的很多不必要的validate，比如update的时候，当field是主键的时候就没有去做uniq的检查