Working with NULL in Databases. Turn Your Frustration Into Delight
Published: 2023-04-11 09:05:37

**NULL values are one of the most frequent frenemies of almost all database administrators. For many, they’re simply a symbol that no value exists in a column – for others, they’re a symbol of problems within their database instances. Join us as we explore them and tell you how best to act in specific scenarios.**

`NULL` values are some of the most popular values within database management systems: there’s no need to be a database expert to tell that `NULL` means nothing, and that’s exactly what `NULL` signifies – it’s a symbol to signify that no values exist in a column. That’s not to say that NULL cannot be problematic though.

## The Basics of NULL
Many database administrators set `NULL` as the default value of their columns when creating a table by running a query like so:
<br \>
![Assigning the default value of columns in DbVisualizer](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nzcnthu3i8cyx99mgj1a.png)
<figure><figcaption>Assigning the default value of columns in DbVisualizer</figcaption></figure>
<br \>
Now when any data is inserted into the column named column_1, the default – “pre-built” if you will – value will be `NULL`. Everything can also be done the other way around too, though – columns can be specified to not accept `NULL` values and have a default empty value like so:
<br \>
![Creating a column with a default value](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qxzzlwbc6yca4u8c5nlu.png)
<figure><figcaption>Creating a column with a default value</figcaption></figure>
<br \>
Now, when anything is inserted into the table that is a `NULL` value, the RDBMS will respond with an error that looks like the following – it will inform us that a column cannot be `NULL`:
<br \>
![Columns cannot be NULL - a message by DbVisualizer](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8hbbshtck5vnuxqbif7o.png)
<figure><figcaption>Columns cannot be NULL - a message by DbVisualizer</figcaption></figure>
<br \>
But that’s the least of our problems... Keep reading – we’ll tell you why in a second.

## Problems with NULL
To start with, the most frequent problem related to NULL values is related to the confusion of `NULL` values and empty strings (rows with no value.) Many newcomers to the SQL world think these two things are the same when in reality, they’re not. Take these two queries for an example:
<br \>
![INSERT INTO Queries in DbVisualizer](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8bj5mur9tg4jgdah2qkv.png)
<figure><figcaption>INSERT INTO Queries in DbVisualizer</figcaption></figure>
<br \>
The first query will insert an empty string into the email column, while the second query will insert `NULL`. Now look at the output of this query:
<br \>
![The results of the query in DbVisualizer](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/scu0jyvnxub01fwxznqp.png)
<figure><figcaption>The results of the query in DbVisualizer</figcaption></figure>
<br \>
The query above probably looks a little different than the queries you’re used to, doesn’t it? The `WHERE` clause doesn’t specify an equal (=) sign, but instead, it specifies `IS NULL`. Let’s try to do everything the ordinary way:
<br \>
![An empty result set in DbVisualizer](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/d864ae7axe85n54h59iu.png)
<figure><figcaption>An empty result set in DbVisualizer</figcaption></figure>
<br \>
“Empty result set fetched.” Why? Because something = nothing (NULL) is never true.

To test for null, we need to use the `IS [NOT] NULL` clause rather than search for a match – if we need a function, we should probably turn to `IFNULL()` instead. In the previous example, we’ve successfully confused MySQL– are we searching for an email with a value of `NULL`? Or are we searching for an email without a value, but with a default value of `NULL`? The question is not clear – so is the answer.

`NULL` also has a couple of things unique to itself – when using some data types (we’re talking about integers and floating-point values), if the column is specified to increment automatically, the next value is inserted into it. Look at the following example:
<br \>
![Inserting and selecting data in DbVisualizer](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vv79jook95nfak3haz89.png)
<figure><figcaption>Inserting and selecting data in DbVisualizer</figcaption></figure>
<br \>
Technically, 3 `NULL` values were inserted, but as the column was set to increment automatically, the values were populated with numbers.

As far as indexes are concerned, columns having `NULL` values can easily be indexed and that isn’t the cause of much problems, however, bear in mind that NULL values also occupy space within MySQL. Everything works like this:

When MyISAM is being used, a field set to `NOT NULL` will take up less space on the disk.
When MyISAM is in use, a field set to `NULL` as the default value, will take up more space on the disk.
`NULL` does take up storage space, but in order to see any real impact of storing `NULL` values within a database, you would literally have to have billions of such values (at that point `NULL` values are the least of your problems.) In other words, `NULL` values don’t require much storage space in and of itself for many storage engines within MySQL, however, if the NDB storage engine (or NDBCluster) is in use, things change a little – it reserves 4 bytes per row for NULL values. However, the impact of this is probably negligible.
However, if we come to partitions, that’s where `NULL` values cause the most problems for many advanced DBAs. We get into them below.

## Partitioning and NULL
One more problem with `NULL` values that is specific to MySQL and its associates is partitioning. MySQL as an RDBMS doesn’t exactly disallow or forbid the NULL value to be used, but it does treat the NULL value as being “less than any other value.” Here’s how everything works when our data is partitioned:

If you insert `NULL` values into a partition on a table partitioned by `RANGE`, the row is inserted into the lowest partition possible.
If `LIST` partitioning is in use, `NULL` values can only be inserted into the specific partition if `NULL` is specified in the list of possible values. Otherwise, we’ll get the error 1504: `ERROR 1504 (HY000): Table has no partition for value NULL`
<br \>
![Table has no partition for value NULL](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ynjqxdgljst5cyjwsvfd.png)
<figure><figcaption>Table has no partition for value NULL</figcaption></figure>
<br \>
If HASH or KEY partitioning is being used, `NULL` is treated the same as if the expression would return 0 (more information can be found over at [the documentation](https://dev.mysql.com/doc/refman/5.7/en/partitioning-handling-nulls.html).)

## Summary
In this blog, we’ve walked you through the concept of `NULL` values in relational database management systems, with the examples being based on MySQL. While the concept of `NULL` values might seem problematic and perhaps even frightening to some, it doesn’t have to be that way – when properly managed, NULL values can become a really good friend of yours.

We hope that you’ve enjoyed reading this blog, come back to [the DbVisualizer blog](https://www.dbvis.com/thetable/) in the future to learn even more about databases and how they work, and until next time!

## About the author
Lukas Vileikis is an ethical hacker and a frequent conference speaker. He runs one of the biggest & fastest data breach search engines in the world - [BreachDirectory.com](https://breachdirectory.com/), frequently speaks at conferences and blogs in multiple places including his blog over at [lukasvileikis.com](https://www.lukasvileikis.com/).