Difference Between Null=True and Blank=True in Django

What is the difference between null=True and blank=True in Django?

null=True sets NULL (versus NOT NULL) on the column in your DB. Blank values for Django field types such as DateTimeField or ForeignKey will be stored as NULL in the DB.

blank determines whether the field will be required in forms. This includes the admin and your custom forms. If blank=True then the field will not be required, whereas if it's False the field cannot be blank.

The combo of the two is so frequent because typically if you're going to allow a field to be blank in your form, you're going to also need your database to allow NULL values for that field. The exception is CharFields and TextFields, which in Django are never saved as NULL. Blank values are stored in the DB as an empty string ('').

A few examples:

models.DateTimeField(blank=True) # raises IntegrityError if blank

models.DateTimeField(null=True) # NULL allowed, but must be filled out in a form

Obviously, Those two options don't make logical sense to use (though there might be a use case for null=True, blank=False if you want a field to always be required in forms, optional when dealing with an object through something like the shell.)

models.CharField(blank=True) # No problem, blank is stored as ''

models.CharField(null=True) # NULL allowed, but will never be set as NULL

CHAR and TEXT types are never saved as NULL by Django, so null=True is unnecessary. However, you can manually set one of these fields to None to force set it as NULL. If you have a scenario where that might be necessary, you should still include null=True.

What is the difference between Null and Blank in django Model

blank=True is about validation, True means that field is not required. null=True allows you to save a null value.

Also you are not always need to define both of them when you want optional field. String value, like a CharField or a TextField are better be stored in an empty string, so you should use only blank=True.

In your case, with not required IntegerField you should use both blank and null

here the docs

In Django models.py, what's the difference between default, null, and blank?

Direct from Django model field reference:

Field.null

If True, Django will store empty values as NULL in the database. Default is False.

Note that empty string values will always get stored as empty strings, not as NULL. Only use null=True for non-string fields such as integers, booleans and dates. For both types of fields, you will also need to set blank=True if you wish to permit empty values in forms, as the null parameter only affects database storage (see blank).

Avoid using null on string-based fields such as CharField and TextField unless you have an excellent reason. If a string-based field has null=True, that means it has two possible values for “no data”: NULL, and the empty string. In most cases, it’s redundant to have two possible values for “no data;” Django convention is to use the empty string, not NULL.

Field.blank

If True, the field is allowed to be blank. Default is False.

Note that this is different than null. null is purely database-related, whereas blank is validation-related. If a field has blank=True, validation on Django’s admin site will allow entry of an empty value. If a field has blank=False, the field will be required.

Field.default

The default value for the field. This can be a value or a callable object. If callable it will be called every time a new object is created.

Django: Difference between blank=True and default=

Blank and Default arguments are not interchangeable. The resulting interaction will be different, depending on what combination you use. For example,

some_field = models.CharField(default='', max_length=20)

...will not allow you to save the model instance without entering data into some_field. The default empty string in this case is just allowing you to add that field to the model upon migration, since you aren't also allowing null with null=True.

some_field = models.CharField(blank=True, default='', max_length=20)

...will save without data, since blank=True.

Another way of putting this is that your default='' is allowing the non-nullable field to exist, and blank=True is allowing your non-nullable field to save() without data entry. If you try to migrate the following:

some_field = models.CharField(max_length=20)

...you'll get the following error:

You are trying to add a non-nullable field 'some_string' to YourModelName without a default; we can't do that (the database needs something to populate existing rows).
Please select a fix:
 1) Provide a one-off default now (will be set on all existing rows with a null value for this column)
 2) Quit, and let me add a default in models.py
Select an option:

...since a non-nullable field without a default can't exist on the database, but a blank=True field can. Note, I'm speaking here of PostgeSQL. This may or may not apply to any/every other DB out there.

Django, when using ForeignKey field, which is better blank=True or null=True?

It's different. See docs:

Note that this is different than null. null is purely database-related, whereas blank is validation-related. If a field has blank=True, form validation will allow entry of an empty value. If a field has blank=False, the field will be required.

So for ForeignKey you need to set both: null=True, blank=True.

Django why only string-based field can't have null = true?

Django allows the use of NULL in string-based fields, it is suggested to avoid it. In other words, Django as a convention recommend the use of '' to represent the empty value for string-based fields.

The reason of this recommendation, is to avoid redundancy because in most cases both values (NULL and '') represent the same thing for string-based fields.

Now, if in your case NULL and '' represent different things, then you should use NULL string-based fields.

So, don't confuse "Allow" with "Suggestion". The first one is a restriction, while the other is a good practice.

Will Django UUIDFIeld unique=True, blank=True and null=True behave correctly?

The Django documentation doesn't specify how UUIDField handles null values.

However, a look at the source code shows that it's not a subset of CharField, and that it has explicit support for handling null values.

So it appears that the field will indeed store None values as NULL, and since such values are always unique on PostgreSQL your approach should work on that database.

django python blank=True still required

You have to add the null=True argument on the field definition, preferably before a syncdb (or you can migrate with South)

skill = models.ForeignKey(Skill, blank=True, null=True)

In django model what are the pros and cons of setting null=True or blank=True?

Hi, it depends on what you want to achieve, you want to keep your data
clean in your DB tables, specially if you will need it for reporting
or dashboards. Anyway, for sake of your question and that the field is
a Charfield, null=True is unnecesary, this type is never stored or
saved as Null.