Originally Posted 10/21/2014
Last blog post I started to explore some of, what I found to be, the interesting behaviors surrounding the AUTO_INCREMENT attribute in MySQL. With strict mode not set it does some really strange things. Like allowing you to add the max value in the range over and over again as long as you delete the record that used to hold that value. This could cause some pretty interesting issues in applications that are not storing their foreign key relationships in the database. But I wanted to see how strict mode would impact the behavior. So I rebuilt the environment using the following script file.
CREATE DATABASE IF NOT EXISTS moderndba;
USE moderndba;
DROP TABLE IF EXISTS autofun;
CREATE TABLE IF NOT EXISTS autofun
(
employee_id TINYINT SIGNED NOT NULL AUTO_INCREMENT
, employee_name VARCHAR(150) NOT NULL
, employee_level TINYINT UNSIGNED NULL
, PRIMARY KEY (employee_id)
);
INSERT INTO autofun (employee_name, employee_level)
VALUES
('Joe Smith', 0)
, ('Tim Bradford', 1)
, ('Betty Stafford', 1);
Notice, I changed the data type for the employee_id field from an unsigned int to a signed tiny int. This was just to make the math a little easier for me as this brings the max value in the range down to a easy to remember (and type) 127. Last time we saw that if you inserted a row and provided a value for employee_id at the end of the range you can not insert another row without specifying a value for employee_id that is not already used in the table. If you insert a row and do not provide an employee_id, or provide 0, or provide NULL, the row will not insert. But the error is not that the value is out of range. Instead the error is that there is a conflict in the primary key. This is because MySQL is noticing that the next value in the sequence is outside the range and picking the closest value in the range and trying to insert it. But, I know that STRICT_ALL_TABLES mode makes MySQL less forgiving with range values as well as in other ways. So, I ran the following to see what would happen with script mode turned on.
mysql> USE moderndba;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A
Database changed
mysql> SELECT *
-> FROM autofun;
+-------------+----------------+----------------+
| employee_id | employee_name | employee_level |
+-------------+----------------+----------------+
| 1 | Joe Smith | 0 |
| 2 | Tim Bradford | 1 |
| 3 | Betty Stafford | 1 |
+-------------+----------------+----------------+
3 rows in set (0.00 sec)
mysql> SET sql_mode='STRICT_ALL_TABLES';
Query OK, 0 rows affected (0.04 sec)
mysql> INSERT INTO autofun
-> (employee_id, empoyee_name)
-> VALUES
-> (127, 'John Wiley');
Query OK, 1 row affected (0.03 sec)
mysql> SELECT *
-> FROM autofun;
+-------------+----------------+----------------+
| employee_id | employee_name | employee_level |
+-------------+----------------+----------------+
| 1 | Joe Smith | 0 |
| 2 | Tim Bradford | 1 |
| 3 | Betty Stafford | 1 |
| 127 | John Wiley | NULL |
+-------------+----------------+----------------+
4 rows in set (0.00 sec)
mysql> INSERT INTO autofun (empoyee_name)
-> VALUES ('Amanda King');
ERROR 1062 (23000): Duplicate entry '127' for key 'PRIMARY'
Oh well. So much for strict mode helping us get a better error message. It still is only chocking because of the duplicate key. I was hoping we would get a message that the next value was out of range, but no such luck.
Last time we saw that if you delete the last row and then perform an insert without specifying the employee_id that you will get the max value again. But while reading up more on the AUTO_INCREMENT attribute, I found this documentation on how it works on an InnoDB table. I thought this was interesting. So to test it our I ran the following statement to remove the last row in the table.
mysql> DELETE FROM autofun WHERE employee_id = 127; Query OK, 1 row affected (0.09 sec) mysql> SELECT * -> FROM autofun; +-------------+----------------+----------------+ | employee_id | employee_name | employee_level | +-------------+----------------+----------------+ | 1 | Joe Smith | 0 | | 2 | Tim Bradford | 1 | | 3 | Betty Stafford | 1 | +-------------+----------------+----------------+ 3 rows in set (0.00 sec)
So last time when we performed the insert we would get an employee_id of 127. But what happens if the server bounces between the delete and the subsequent insert. To find out I exited out of the MySQL prompt and ran the following from the shell prompt.
[student@percona56 ~]$ sudo service mysql restart
Then after the restart I ran the following.
mysql> INSERT INTO autofun (empoyee_name)
-> VALUES ('Amanda King');
Query OK, 1 row affected (0.03 sec)
mysql> SELECT *
-> FROM autofun;
+-------------+----------------+----------------+
| employee_id | employee_name | employee_level |
+-------------+----------------+----------------+
| 1 | Joe Smith | 0 |
| 2 | Tim Bradford | 1 |
| 3 | Betty Stafford | 1 |
| 4 | Amanda King | NULL |
+-------------+----------------+----------------+
4 rows in set (0.00 sec)
So if the server is restarted the next value in the sequence is recalculated based on the maximum value stored in the column. This could be both beneficial (if you need to resolve the situation where you have removed some values you want to reuse) or not so beneficial (if you are not managing your foreign key relationships carefully). I still have a lot more questions about the AUTO_INCREMENT attribute in MySQL, but I think this is enough for the moment. I hope you are finding this behavior just as interesting as I am.
moderndba 