Why MySQL does not recommend using null columns with default values

The answer you often hear is that using a NULL value in a column will invalidate the index, but if you actually test it, you will know that IS NULL will use the index. So the above statement has a loophole.

Those who are anxious can scroll to the bottom to see the conclusion

Preface

Null is a special constraint of columns.
The columns in table will be added null constrain if you do not define the column with "not null" key words explicitly
when creating the table.Many programmers like to define columns by default
because of the conveniences (reducing the judgement code of nullibility) what consequently
cause some uncertainty of query and poor performance of database.

The NULL value is a special constraint on a column. When we create a new column, if we do not explicitly use the keyword not null to declare the data column, Mysql will add the NULL constraint for us by default.
Some developers use the default recommended settings of MySQL directly when creating data tables due to laziness (i.e. allowing fields to use NULL values). This bad habit can easily lead to uncertain query results and degrade database performance in scenarios where NULL is used.

Introduce

Null is null means it is not anything at all, we cannot think of null is equal to '' and they are totally different.
MySQL provides three operators to handle null value: "IS NULL", "IS NOT NULL", "<=>" and a function ifnull().
IS NULL: It returns true, if the column value is null.
IS NOT NULL: It returns true, if the columns value is not null.
<=>: It's a compare operator similar with "=" but not the same. It returns true even for the two null values.
(eg. null <=> null is legal)
IFNULL(): Specify two input parameters, if the first is null value then returns the second one.
It's similar with Oracle's NVL() function.

NULL does not mean nothing. We should note that NULL and '' (null value) are two completely different values. There are three main operators that can operate NULL values in MySQL.

IS NULL
IS NOT NULL
<=> Spaceship operator, this operator is very similar to =, select NULL<=>NULL can return true, but select NULL=NULL returns false.
IFNULL is a function. You can find out how to use it yourself... Anyway, I know how to use it.

Example

Null never returns true when comparing with any other values except null with "<=>".
Comparing NULL to any other value with any operator yields NULL except <=>.

(root@localhost mysql3306.sock)[zlm]>create table test_null(
    -> id int not null,
    -> name varchar(10)
    -> );
Query OK, 0 rows affected (0.02 sec)

(root@localhost mysql3306.sock)[zlm]>insert into test_null values(1,'zlm');
Query OK, 1 row affected (0.00 sec)

(root@localhost mysql3306.sock)[zlm]>insert into test_null values(2,null);
Query OK, 1 row affected (0.00 sec)

(root@localhost mysql3306.sock)[zlm]>select * from test_null;
+----+------+
| id | name |
+----+------+
| 1 | zlm |
| 2 | NULL |
+----+------+
2 rows in set (0.00 sec)

(root@localhost mysql3306.sock)[zlm]>select * from test_null where name=null;
Empty set (0.00 sec)

(root@localhost mysql3306.sock)[zlm]>select * from test_null where name is null;
+----+------+
| id | name |
+----+------+
| 2 | NULL |
+----+------+
1 row in set (0.00 sec)

(root@localhost mysql3306.sock)[zlm]>select * from test_null where name is not null;
+----+------+
| id | name |
+----+------+
| 1 | zlm |
+----+------+
1 row in set (0.00 sec)

(root@localhost mysql3306.sock)[zlm]>select * from test_null where null=null;
Empty set (0.00 sec)

(root@localhost mysql3306.sock)[zlm]>select * from test_null where null<>null;
Empty set (0.00 sec)

(root@localhost mysql3306.sock)[zlm]>select * from test_null where null<=>null;
+----+------+
| id | name |
+----+------+
| 1 | zlm |
| 2 | NULL |
+----+------+
2 rows in set (0.00 sec)

//null<=>null always return true, it's equal to "where 1=1".

Null means "a missing and unknown value". Let's see details below.
NULL represents an indeterminate value. Even if there are two NULLs, they are not necessarily equal. (It's like an uninitialized local variable in C.)

(root@localhost mysql3306.sock)[zlm]>SELECT 0 IS NULL, 0 IS NOT NULL, '' IS NULL, '' IS NOT NULL;
+-----------+--------------+------------+----------------+
| 0 IS NULL | 0 IS NOT NULL | '' IS NULL | '' IS NOT NULL |
+-----------+--------------+------------+----------------+
| 0 | 1 | 0 | 1 |
+-----------+--------------+------------+----------------+
1 row in set (0.00 sec)

//It's not equal to zero number or vacant string.
//In MySQL, 0 means false, 1 means true.

(root@localhost mysql3306.sock)[zlm]>SELECT 1 = NULL, 1 <> NULL, 1 < NULL, 1 > NULL;
+----------+-----------+----------+----------+
| 1 = NULL | 1 <> NULL | 1 < NULL | 1 > NULL |
+----------+-----------+----------+----------+
| NULL | NULL | NULL | NULL |
+----------+-----------+----------+----------+
1 row in set (0.00 sec)

//It cannot be compared with number.
//In MySQL, null means false, too.

It truns null as a result if any expression contains a null value.
Any expression that returns a value that contains NULL will result in another NULL value.

(root@localhost mysql3306.sock)[zlm]>select ifnull(null,'First is null'),ifnull(null+10,'First is null'),ifnull(concat('abc',null),'First is null');
+------------------------------+---------------------------------+--------------------------------------------+
| ifnull(null,'First is null') | ifnull(null+10,'First is null') | ifnull(concat('abc',null),'First is null') |
+------------------------------+---------------------------------+--------------------------------------------+
| First is null | First is null | First is null |
+------------------------------+---------------------------------+--------------------------------------------+
1 row in set (0.00 sec)

//null value needs to be disposed with ifnull() function, what usually causes sql statement more complex.
//As we all know,MySQL does not support funcion index.Therefore,indexes on the column may not be used.That's really worse.

It's diffrent when using count(*) & count(null column).
The results of using count(*) or count(null column) are different, count(null column)<=count(*).

(root@localhost mysql3306.sock)[zlm]>select count(*),count(name) from test_null;
+----------+-------------+
| count(*) | count(name) |
+----------+-------------+
| 2 | 1 |
+----------+-------------+
1 row in set (0.00 sec)

//count(*) returns all rows ignore the null while count(name) returns the non-null rows in column "name".
//This will also lead to uncertainty if someone is unaware of the details above.

If the user is not familiar with the NULL attribute, it is easy to get wrong statistical results.

When using distinct, group by, order by, all null values are considered as the same value.
Although the result of select NULL=NULL is false, when we use distinct, group by, and order by, NULL is considered to be the same value.

(root@localhost mysql3306.sock)[zlm]>insert into test_null values(3,null);
Query OK, 1 row affected (0.00 sec)

(root@localhost mysql3306.sock)[zlm]>select distinct name from test_null;
+------+
| name |
+------+
| zlm |
| NULL |
+------+
2 rows in set (0.00 sec)

//Two rows of null value returned one and the result became two.

(root@localhost mysql3306.sock)[zlm]>select name from test_null group by name;
+------+
| name |
+------+
| NULL |
| zlm |
+------+
2 rows in set (0.00 sec)

//Two rows of null value were put into the same group.
//By default, group by will also sort the result (null row showed first).

(root@localhost mysql3306.sock)[zlm]>select id,name from test_null order by name;
+----+------+
| id | name |
+----+------+
| 2 | NULL |
| 3 | NULL |
| 1 | zlm |
+----+------+
3 rows in set (0.00 sec)

//Three rows were sorted (two null rows showed first).

MySQL supports to use index on column which contains null value (what's different from oracle).
MySQL supports the use of indexes on columns containing NULL values, but Oracle does not. This is what we usually say that if a column contains NULL, the index will be invalid.
Strictly speaking, this statement is not accurate for MySQL.

(root@localhost mysql3306.sock)[sysbench]>show tables;
+--------------------+
| Tables_in_sysbench |
+--------------------+
|sbtest1|
|sbtest10|
|sbtest2|
|sbtest3|
|sbtest4|
|sbtest5|
|sbtest6|
|sbtest7|
|sbtest8|
|sbtest9|
+--------------------+
10 rows in set (0.00 sec)

(root@localhost mysql3306.sock)[sysbench]>show create table sbtest1\G
*************************** 1. row ***************************
       Table: sbtest1
Create Table: CREATE TABLE `sbtest1` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `k` int(11) NOT NULL DEFAULT '0',
  `c` char(120) NOT NULL DEFAULT '',
  `pad` char(60) NOT NULL DEFAULT '',
  PRIMARY KEY (`id`),
  KEY `k_1` (`k`)
) ENGINE=InnoDB AUTO_INCREMENT=100001 DEFAULT CHARSET=utf8
1 row in set (0.00 sec)

(root@localhost mysql3306.sock)[sysbench]>alter table sbtest1 modify k int null,modify c char(120) null,modify pad char(60) null;
Query OK, 0 rows affected (4.14 sec)
Records: 0 Duplicates: 0 Warnings: 0

(root@localhost mysql3306.sock)[sysbench]>insert into sbtest1 values(100001,null,null,null);
Query OK, 1 row affected (0.00 sec)

(root@localhost mysql3306.sock)[sysbench]>explain select id,k from sbtest1 where id=100001;
+----+-------------+---------+------------+-------+---------------+---------+---------+-------+------+------+------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+-------+---------------+---------+---------+-------+------+------+------+
| 1 | SIMPLE | sbtest1 | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL |
+----+-------------+---------+------------+-------+---------------+---------+---------+-------+------+------+------+
1 row in set, 1 warning (0.00 sec)

(root@localhost mysql3306.sock)[sysbench]>explain select id,k from sbtest1 where k is null;
+----+-------------+---------+------------+------+---------------+-----+---------+-------+------+----------+--------------------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+------+---------------+-----+---------+-------+------+----------+--------------------------+
| 1 | SIMPLE | sbtest1 | NULL | ref | k_1 | k_1 | 5 | const | 1 | 100.00 | Using where; Using index |
+----+-------------+---------+------------+------+---------------+-----+---------+-------+------+----------+--------------------------+
1 row in set, 1 warning (0.00 sec)

//In the first query, the newly added row is retrieved by primary key.
//In the second query, the newly added row is retrieved by secondary key "k_1"
//It has been proved that indexes can be used on the columns which contain null value.
//column "k" is int datatype which occupies 4 bytes, but the value of "key_len" turn out to be 5. what's happy? Because null value needs 1 byte to store the null flag in the rows.

This is an example I tested myself.

mysql> select * from test_1;
+-----------+------+------+
| name | code | id |
+-----------+------+------+
| gaoyi | wo | 1 |
| gaoyi | w | 2 |
| chuzhong | wo | 3 |
| chuzhong | w | 4 |
| xiaoxue | dd | 5 |
| xiaoxue | dfdf | 6 |
| sujianhui | su | 99 |
| sujianhui | NULL | 99 |
+-----------+------+------+
8 rows in set (0.00 sec)

mysql> explain select * from test_1 where code is NULL;
+----+-------------+--------+------------+------+---------------+------------+---------+-------+------+----------+-----------------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+--------+------------+------+---------------+------------+---------+-------+------+----------+-----------------------+
| 1 | SIMPLE | test_1 | NULL | ref | index_code | index_code | 161 | const | 1 | 100.00 | Using index condition |
+----+-------------+--------+------------+------+---------------+------------+---------+-------+------+----------+-----------------------+
1 row in set, 1 warning (0.00 sec)

mysql> explain select * from test_1 where code is not NULL;
+----+-------------+--------+------------+-------+---------------+------------+---------+------+------+----------+----------------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+--------+------------+-------+---------------+------------+---------+------+------+----------+----------------------+
| 1 | SIMPLE | test_1 | NULL | range | index_code | index_code | 161 | NULL | 7 | 100.00 | Using index condition |
+----+-------------+--------+------------+-------+---------------+------------+---------+------+------+----------+----------------------+
1 row in set, 1 warning (0.00 sec)

mysql> explain select * from test_1 where code='dd';
+----+-------------+--------+------------+------+---------------+------------+---------+-------+------+----------+-----------------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+--------+------------+------+---------------+------------+---------+-------+------+----------+-----------------------+
| 1 | SIMPLE | test_1 | NULL | ref | index_code | index_code | 161 | const | 1 | 100.00 | Using index condition |
+----+-------------+--------+------------+------+---------------+------------+---------+-------+------+----------+-----------------------+
1 row in set, 1 warning (0.00 sec)

mysql> explain select * from test_1 where code like "dd%";
+----+-------------+--------+------------+-------+---------------+------------+---------+------+------+----------+----------------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+--------+------------+-------+---------------+------------+---------+------+------+----------+----------------------+
| 1 | SIMPLE | test_1 | NULL | range | index_code | index_code | 161 | NULL | 1 | 100.00 | Using index condition |
+----+-------------+--------+------------+-------+---------------+------------+---------+------+------+----------+----------------------+
1 row in set, 1 warning (0.00 sec)

Summary

Null value always leads to many uncertainties when disposing sql statement. It may cause bad performance accidentally.

Using NULL values in columns can easily cause uncontrolled behavior and sometimes seriously slow down system performance.

For example:

null value will not be estimated in aggregate function() which may cause inaccurate results.
When performing statistical calculations on columns containing NULL values, such as count(), max(), and min(), the results do not meet our expectations.

null value will influence the behavior of the operations such as "distinct", "group by", "order by" which causes wrong sort.
Interfere with sorting, grouping, and deduplication results.

Null value needs ifnull() function to do judgement which makes the program code more complex.
Sometimes, in order to eliminate the technical debt caused by NULL, we need to use IFNULL() in SQL to ensure that the results are controllable, but this complicates the program.
A null value needs an extra 1 byte to store the null information in the rows.

The NULL value does not occupy the original field space for storage, but an additional byte is applied for marking. This field adds a NULL constraint. (Just like an additional flag bit)
As these above drawbacks, it's not recommended to define columns with default null.
We recommand to define "not null" on all columns and use zero number & vacant string to substitute relevant data type of null.

Based on the above disadvantages, we do not recommend setting NULL as the default value in a column. You can use NOT NULL to eliminate the default setting and use 0 or '' empty string instead of NULL.

References

https://www.cnblogs.com/aaron8219/p/9259379.html

This concludes this article on why MySQL does not recommend using columns with default values of null. For more information about MySQL default values of null, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope you will support 123WORDPRESS.COM in the future!

You may also be interested in:

A convenient way to configure multiple data sources and Mysql databases in the springboot backend
Detailed explanation of MySQL DEFINER usage
In-depth explanation of MySQL isolation level and locking mechanism
Django production environment construction (uWSGI+django+nginx+python+MySQL)
A brief analysis of whether MySQL primary key uses numbers or uuids for faster query
MySQL permissions and database design case study
How to connect to MySQL database using Node-Red
Detailed explanation of group by and having in MySQL

<<: HTML multimedia application: inserting flash animation and music into web pages

>>: Nginx configuration file detailed explanation and optimization suggestions guide