When we add a database field in django we generally write:
models.CharField(max_length=100, null=True, blank=True)
The same is done with ForeignKey
, DecimalField
etc. What is the basic difference in having
null=True
onlyblank=True
onlynull=True
, blank=True
in respect to different (CharField
, ForeignKey
, ManyToManyField
, DateTimeField
) fields. What are the advantages/disadvantages of using 1/2/3?
This question is related to
python
django
django-models
Here is an example of the field with blank= True
and null=True
description = models.TextField(blank=True, null= True)
In this case:
blank = True
: tells our form that it is ok to leave the description field blank
and
null = True
: tells our database that it is ok to record a null value in our db field and not give an error.
If you set null=True
, it will allow the value of your database column to be set as NULL
. If you only set blank=True
, django will set the default new value for the column equal to ""
.
There's one point where null=True
would be necessary even on a CharField
or TextField
and that is when the database has the unique
flag set for the column. In this case you'll need to use this:
a_unique_string = models.CharField(blank=True, null=True, unique=True)
Preferrably skip the null=True
for non-unique CharField
or TextField
. Otherwise some fields will be set as NULL
while others as ""
, and you'll have to check the field value for NULL
everytime.
This table below demonstrates the main differences:
+--------------------------------------------------------------------+
| Purpose | null=True | blank = True |
|--------------------------|------------------|----------------------|
| Field can be empty in DB | Do this | Unaffected |
|--------------------------|------------------|----------------------|
| ModelForm(required field)| Unaffected | field not required |
|--------------------------|------------------|----------------------|
| Form Validation | Unaffected | field not required |
|--------------------------|------------------|----------------------|
| on_delete=SET_NULL | Need this | Unaffected |
+--------------------------------------------------------------------+
This is how the ORM maps blank
& null
fields for Django 1.8
class Test(models.Model):
charNull = models.CharField(max_length=10, null=True)
charBlank = models.CharField(max_length=10, blank=True)
charNullBlank = models.CharField(max_length=10, null=True, blank=True)
intNull = models.IntegerField(null=True)
intBlank = models.IntegerField(blank=True)
intNullBlank = models.IntegerField(null=True, blank=True)
dateNull = models.DateTimeField(null=True)
dateBlank = models.DateTimeField(blank=True)
dateNullBlank = models.DateTimeField(null=True, blank=True)
The database fields created for PostgreSQL 9.4 are :
CREATE TABLE Test (
id serial NOT NULL,
"charNull" character varying(10),
"charBlank" character varying(10) NOT NULL,
"charNullBlank" character varying(10),
"intNull" integer,
"intBlank" integer NOT NULL,
"intNullBlank" integer,
"dateNull" timestamp with time zone,
"dateBlank" timestamp with time zone NOT NULL,
"dateNullBlank" timestamp with time zone,
CONSTRAINT Test_pkey PRIMARY KEY (id)
)
The database fields created for MySQL 5.6 are :
CREATE TABLE Test (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`charNull` VARCHAR(10) NULL DEFAULT NULL,
`charBlank` VARCHAR(10) NOT NULL,
`charNullBlank` VARCHAR(10) NULL DEFAULT NULL,
`intNull` INT(11) NULL DEFAULT NULL,
`intBlank` INT(11) NOT NULL,
`intNullBlank` INT(11) NULL DEFAULT NULL,
`dateNull` DATETIME NULL DEFAULT NULL,
`dateBlank` DATETIME NOT NULL,
`dateNullBlank` DATETIME NULL DEFAULT NULL
)
null is for database and blank is for fields validation that you want to show on user interface like textfield to get the last name of person. If lastname=models.charfield (blank=true) it didnot ask user to enter last name as this is the optional field now. If lastname=models.charfield (null=true) then it means that if this field doesnot get any value from user then it will store in database as an empty string " ".
In Very simple words,
Blank is different than null.
null is purely database-related, whereas blank is validation-related(required in form).
If null=True
, Django will store empty values as NULL in the database
. 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.
As said in Django Model Field reference: Link
Field options
The following arguments are available to all field types. All are optional.
null
Field.null
IfTrue
, Django will store empty values asNULL
in the database. Default isFalse
.Avoid using
null
on string-based fields such asCharField
andTextField
because empty string values will always be stored as empty strings, not asNULL
. If a string-based field hasnull=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"; the Django convention is to use the empty string, notNULL
.For both string-based and non-string-based fields, you will also need to set
blank=True
if you wish to permit empty values in forms, as thenull
parameter only affects database storage (seeblank
).Note
When using the Oracle database backend, the value NULL will be stored to denote the empty string regardless of this attribute
blank
Field.blank
If
True
, the field is allowed to be blank. Default isFalse
.Note that this is different than
null
.null
is purely database-related, whereasblank
is validation-related. If a field hasblank=True
, form validation will allow entry of an empty value. If a field hasblank=False
, the field will be required.
When we save anything in Django admin two steps validation happens, on Django level and on Database level. We can't save text in a number field.
Database has data type NULL, it's nothing. When Django creates columns in the database it specifies that they can't be empty. And if you will try to save NULL you will get the database error.
Also on Django-Admin level, all fields are required by default, you can't save blank field, Django will throw you an error.
So, if you want to save blank field you need to allow it on Django and Database level. blank=True - will allow empty field in admin panel null=True - will allow saving NULL to the database column.
null = True
Means there is no constraint of database for the field to be filled, so you can have an object with null value for the filled that has this option.
blank = True
Means there is no constraint of validation in django forms. so when you fill a modelForm
for this model you can leave field with this option unfilled.
Simply null=True
defines database should accept NULL
values, on other hand blank=True
defines on form validation this field should accept blank values or not(If blank=True
it accept form without a value in that field and blank=False
[default value] on form validation it will show This field is required error.
null=True/False
related to database
blank=True/False
related to form validation
When you set null=true
it will set null
in your database if the field is not filled. If
you set blank='true
it will not set any value to the field.
Simple answer would be: Null is for Database tables while Blank is for Django Forms.
null - default is False if True, Django will store empty as null in the database.
blank - default is False if true that field is allowed to be blank
more, goto https://docs.djangoproject.com/en/3.0/topics/db/models/
Blank=False # this field is required.
Null=False # this field should not be null
Blank=True # this field is optional.
Null=True # Django uses empty string (''), not NULL.
Note:
Avoid using null=True
on string-based fields such as CharField
and TextField
and FileField
/ImageField
.
Ref: Django null , Django blank
The meaning of null=True and blank=True in the model also depends on how these fields were defined in the form class.
Suppose you have defined the following class:
class Client (models.Model):
name = models.CharField (max_length=100, blank=True)
address = models.CharField (max_length=100, blank=False)
If the form class has been defined like this:
class ClientForm (ModelForm):
class Meta:
model = Client
fields = ['name', 'address']
widgets = {
'name': forms.TextInput (attrs = {'class': 'form-control form-control-sm'}),
'address': forms.TextInput (attrs = {'class': 'form-control form-control-sm'})
}
Then, the 'name' field will not be mandatory (due to the blank=True in the model) and the 'address' field will be mandatory (due to the blank=False in the model).
However, if the ClientForm class has been defined like this:
class ClientForm (ModelForm):
class Meta:
model = Client
fields = ['name', 'address']
name = forms.CharField (
widget = forms.TextInput (attrs = {'class': 'form-control form-control-sm'}),
)
address = forms.CharField (
widget = forms.TextInput (attrs = {'class': 'form-control form-control-sm'}),
)
Then, both fields ('name' and 'address') will be mandatory, "since fields defined declaratively are left as-is" (https://docs.djangoproject.com/en/3.0/topics/forms/modelforms/), i.e. the default for the 'required' attribute of the form field is True and this will require that the fields 'name' and 'address' are filled, even if, in the model, the field has been set to blank=True.
Here, is the main difference of null=True
and blank=True
:
The default value of both null
and blank
is False. Both of these values work at field level i.e., whether we want to keep a field null
or blank
.
null=True
will set the field’s value to NULL
i.e., no data. It is basically for the databases column value.
date = models.DateTimeField(null=True)
blank=True
determines whether the field will be required in forms. This includes the admin and your own custom forms.
title = models.CharField(blank=True) // title can be kept blank.
In the database ("")
will be stored.
null=True
blank=True
This means that the field is optional in all circumstances.
epic = models.ForeignKey(null=True, blank=True)
// The exception is CharFields() and TextFields(), which in Django are never saved as NULL. Blank values a
The default values of null and blank are False.
Null: It is database-related. Defines if a given database column will accept null values or not.
Blank: It is validation-related. It will be used during forms validation, when calling form.is_valid().
That being said, it is perfectly fine to have a field with null=True and blank=False. Meaning on the database level the field can be NULL, but in the application level it is a required field.
Now, where most developers get it wrong: Defining null=True for string-based fields such as CharField and TextField. Avoid doing that. Otherwise, you will end up having two possible values for “no data”, that is: None and an empty string. Having two possible values for “no data” is redundant. The Django convention is to use the empty string, not NULL.
You may have your answer however till this day it's difficult to judge whether to put null=True or blank=True or both to a field. I personally think it's pretty useless and confusing to provide so many options to developers. Let the handle the nulls or blanks however they want.
I follow this table, from Two Scoops of Django:
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
It's crucial to understand that the options in a Django model field definition serve (at least) two purposes: defining the database tables, and defining the default format and validation of model forms. (I say "default" because the values can always be overridden by providing a custom form.) Some options affect the database, some options affect forms, and some affect both.
When it comes to null
and blank
, other answers have already made clear that the former affects the database table definition and the latter affects model validation. I think the distinction can be made even clearer by looking at use cases for all four possible configurations:
null=False
, blank=False
: This is the default configuration and means that the value is required in all circumstances.
null=True
, blank=True
: This means that the field is optional in all circumstances. (As noted below, though, this is not the recommended way to make string-based fields optional.)
null=False
, blank=True
: This means that the form doesn't require a value but the database does. There are a number of use cases for this:
The most common use is for optional string-based fields. As noted in the documentation, the Django idiom is to use the empty string to indicate a missing value. If NULL
was also allowed you would end up with two different ways to indicate a missing value.
Another common situation is that you want to calculate one field automatically based on the value of another (in your save()
method, say). You don't want the user to provide the value in a form (hence blank=True
), but you do want the database to enforce that a value is always provided (null=False
).
Another use is when you want to indicate that a ManyToManyField
is optional. Because this field is implemented as a separate table rather than a database column, null
is meaningless. The value of blank
will still affect forms, though, controlling whether or not validation will succeed when there are no relations.
null=True
, blank=False
: This means that the form requires a value but the database doesn't. This may be the most infrequently used configuration, but there are some use cases for it:
It's perfectly reasonable to require your users to always include a value even if it's not actually required by your business logic. After all, forms are only one way of adding and editing data. You may have code that is generating data which doesn't need the same stringent validation that you want to require of a human editor.
Another use case that I've seen is when you have a ForeignKey
for which you don't wish to allow cascade deletion. That is, in normal use the relation should always be there (blank=False
), but if the thing it points to happens to be deleted, you don't want this object to be deleted too. In that case you can use null=True
and on_delete=models.SET_NULL
to implement a simple kind of soft deletion.
Source: Stackoverflow.com