AUTO-INC Locks

An AUTO-INC lock is a special table-level lock taken by transactions inserting into tables with AUTO_INCREMENT columns. In the simplest case, if one transaction is inserting values into the table, any other transactions must wait to do their own inserts into that table, so that rows inserted by the first transaction receive consecutive primary key values.
The innodb_autoinc_lock_mode configuration option controls the algorithm used for auto-increment locking. It allows you to choose how to trade off between predictable sequences of auto-increment values and maximum concurrency for insert operations.

AUTO-INC鎖是當向使用含有AUTO_INCREMENT列的表中插入數據時需要獲取的一種特殊的表級鎖

在最簡單的情況下，如果一個事務正在向表中插入值，則任何其他事務必須等待對該表執行自己的插入操作，以便第一個事務插入的行的值是連續的。
innodb_autoinc_lock_mode配置選項控制用于自動增量鎖定的算法。 它允許您選擇如何在可預測的自動遞增值序列和插入操作的最大并發性之間進行權衡。

AUTO_INCREMENT Handling in InnoDB

InnoDB提供了一個可配置的鎖定機制，可以顯著提高使用AUTO_INCREMENT列向表中添加行的SQL語句的可伸縮性和性能。 要對InnoDB表使用AUTO_INCREMENT機制，必須將AUTO_INCREMENT列定義為索引的一部分，以便可以對表執行相當于索引的SELECT MAX（ai_col）查找以獲取最大列值。 通常，這是通過使列成為某些表索引的第一列來實現的。
本節介紹AUTO_INCREMENT鎖定模式的行為，對不同AUTO_INCREMENT鎖定模式設置的使用含義，以及InnoDB如何初始化AUTO_INCREMENT計數器。

SESSION_A>DROP TABLE IF EXISTS t;
Query OK, 0 rows affected (0.00 sec)
SESSION_A>CREATE TABLE t (a bigint unsigned auto_increment primary key) ENGINE=InnoDB;
Query OK, 0 rows affected (0.01 sec)
SESSION_A>insert into t values(1),(3),(4),(5),(6),(7);
Query OK, 6 rows affected (0.01 sec)
Records: 6  Duplicates: 0  Warnings: 0
SESSION_A>select * from t;
+---+
| a |
+---+
| 1 |
| 3 |
| 4 |
| 5 |
| 6 |
| 7 |
+---+
6 rows in set (0.00 sec)
SESSION_A>select @@innodb_autoinc_lock_mode;
+----------------------------+
| @@innodb_autoinc_lock_mode |
+----------------------------+
|                          0 |
+----------------------------+
1 row in set (0.00 sec)
A B C 三個會話事務隔離級別都是 RR
SESSION_A>select @@global.tx_isolation,@@session.tx_isolation;
+-----------------------+------------------------+
| @@global.tx_isolation | @@session.tx_isolation |
+-----------------------+------------------------+
| REPEATABLE-READ       | REPEATABLE-READ        |
+-----------------------+------------------------+
SESSION_A>begin;
Query OK, 0 rows affected (0.00 sec)
SESSION_A>delete from t where a>4;
Query OK, 3 rows affected (0.00 sec)
B會話被鎖,這是由于會話 A 產生的 gap lock
SESSION_B>begin;
Query OK, 0 rows affected (0.00 sec)
SESSION_B>insert into t values(null); --注意這里因為是 null, 鎖需要在內存中分配 AUTO-INCREMENT 值
C 會話被阻塞
SESSION_C>begin;
Query OK, 0 rows affected (0.00 sec)
SESSION_C>insert into t values(2);  --這里插入2,沒有 gap lock 也被鎖了
(mysql@localhost) [fandb]> (mysql@localhost) [fandb]> select trx_id,trx_state,trx_requested_lock_id,trx_weight,trx_mysql_thread_id,trx_query, trx_operation_state from information_schema.INNODB_TRX;
+--------+-----------+-----------------------+------------+---------------------+----------------------------+-----------------------+
| trx_id | trx_state | trx_requested_lock_id | trx_weight | trx_mysql_thread_id | trx_query                  | trx_operation_state   |
+--------+-----------+-----------------------+------------+---------------------+----------------------------+-----------------------+
| 321912 | LOCK WAIT | 321912:701            |          3 |                   7 | insert into t values(2)    | setting auto-inc lock |
| 321911 | LOCK WAIT | 321911:690:3:1        |          3 |                   2 | insert into t values(null) | inserting             |
| 321906 | RUNNING   | NULL                  |          5 |                   1 | NULL                       | NULL                  |
+--------+-----------+-----------------------+------------+---------------------+----------------------------+-----------------------+
3 rows in set (0.00 sec)
可以看到,SESSION_C是等待自增鎖，一直處于setting auto-inc lock狀態
(mysql@localhost) [fandb]> select * from information_schema.INNODB_LOCKS;
+----------------+-------------+-----------+-----------+-------------+------------+------------+-----------+----------+------------------------+
| lock_id        | lock_trx_id | lock_mode | lock_type | lock_table  | lock_index | lock_space | lock_page | lock_rec | lock_data              |
+----------------+-------------+-----------+-----------+-------------+------------+------------+-----------+----------+------------------------+
| 321912:701     | 321912      | AUTO_INC  | TABLE     | `fandb`.`t` | NULL       |       NULL |      NULL |     NULL | NULL                   |
| 321911:701     | 321911      | AUTO_INC  | TABLE     | `fandb`.`t` | NULL       |       NULL |      NULL |     NULL | NULL                   |
| 321911:690:3:1 | 321911      | X         | RECORD    | `fandb`.`t` | PRIMARY    |        690 |         3 |        1 | supremum pseudo-record |
| 321906:690:3:1 | 321906      | X         | RECORD    | `fandb`.`t` | PRIMARY    |        690 |         3 |        1 | supremum pseudo-record |
+----------------+-------------+-----------+-----------+-------------+------------+------------+-----------+----------+------------------------+
4 rows in set (0.00 sec)

CREATE TABLE t1 (
c1 INT(11) NOT NULL AUTO_INCREMENT,
c2 VARCHAR(10) DEFAULT NULL,
PRIMARY KEY (c1)
) ENGINE=InnoDB;

Tx1: INSERT INTO t1 (c2) SELECT 1000 rows from another table ...
Tx2: INSERT INTO t1 (c2) VALUES ('xxx');

SESSION_A>DROP TABLE IF EXISTS t;
Query OK, 0 rows affected (0.01 sec)
SESSION_A>CREATE TABLE t (a bigint unsigned auto_increment primary key) ENGINE=InnoDB;
Query OK, 0 rows affected (0.01 sec)
SESSION_A>insert into t values(1),(3),(4),(5),(6),(7);
Query OK, 6 rows affected (0.01 sec)
Records: 6  Duplicates: 0  Warnings: 0
SESSION_A>select @@innodb_autoinc_lock_mode;
+----------------------------+
| @@innodb_autoinc_lock_mode |
+----------------------------+
|                          1 |
+----------------------------+
1 row in set (0.00 sec)
SESSION_A>select * from t;
+---+
| a |
+---+
| 1 |
| 3 |
| 4 |
| 5 |
| 6 |
| 7 |
+---+
6 rows in set (0.00 sec)
SESSION_A>begin;
Query OK, 0 rows affected (0.00 sec)
SESSION_A>delete from t where a>4;
Query OK, 3 rows affected (0.00 sec)
會話 B, 被 GAP LOCK 阻塞
SESSION_B>begin;
Query OK, 0 rows affected (0.00 sec)
SESSION_B>insert into t values(null); --由于是`simple-insert`且`innodb_autoinc_lock_mode=1`,所以并不需要AUTO-INC表級鎖
會話 C 成功插入沒有阻塞
SESSION_C>begin;
Query OK, 0 rows affected (0.00 sec)
SESSION_C>insert into t values(2); --由于它也是`simple-insert`且`innodb_autoinc_lock_mode=1`所以不需要獲取AUTO-INC表級鎖,沒有阻塞成功插入
Query OK, 1 row affected (0.00 sec)
C會話rollback,B會話改為使用“Bulk inserts”
SESSION_C>rollback;
Query OK, 0 rows affected (0.00 sec)
SESSION_B>insert into t select null;
此時 C 會話又被阻塞了
SESSION_C>begin;
Query OK, 0 rows affected (0.00 sec)
SESSION_C>insert into t values(2); --這驗證了官方文檔中的說法`If another transaction holds an AUTO-INC lock, a “simple insert” waits for the AUTO-INC lock, as if it were a “bulk insert”.`
Query OK, 1 row affected (41.17 sec)

此鎖定模式確保,當行數不預先知道的INSERT存在時(并且自動遞增值在語句過程執行中分配)由任何“類INSERT”語句分配的所有自動遞增值是連續的，并且對于基于語句的復制(statement-based replication)操作是安全的。
這種鎖定模式顯著地提高了可擴展性,并且保證了對于基于語句的復制(statement-based replication)的安全性.此外，與“傳統”鎖定模式一樣，由任何給定語句分配的自動遞增數字是連續的。 與使用自動遞增的任何語句的“傳統”模式相比，語義沒有變化.
但有一個特例:

The exception is for “mixed-mode inserts”, where the user provides explicit values for an AUTO_INCREMENT column for some, but not all, rows in a multiple-row “simple insert”. For such inserts, InnoDB allocates more auto-increment values than the number of rows to be inserted. However, all values automatically assigned are consecutively generated (and thus higher than) the auto-increment value generated by the most recently executed previous statement. “Excess” numbers are lost.

• innodb_autoinc_lock_mode = 2 (“interleaved” lock mode)

  在這種鎖定模式下,所有類INSERT(“INSERT-like” )語句都不會使用表級AUTO-INC lock,并且可以同時執行多個語句。這是最快和最可擴展的鎖定模式，但是當使用基于語句的復制或恢復方案時，從二進制日志重播SQL語句時，這是不安全的。
  在此鎖定模式下，自動遞增值保證在所有并發執行的“類INSERT”語句中是唯一且單調遞增的。但是，由于多個語句可以同時生成數字（即，跨語句交叉編號），為任何給定語句插入的行生成的值可能不是連續的。
  如果執行的語句是“simple inserts”，其中要插入的行數已提前知道，則除了“混合模式插入”之外，為單個語句生成的數字不會有間隙。然而，當執行“批量插入”時，在由任何給定語句分配的自動遞增值中可能存在間隙。

  InnoDB AUTO_INCREMENT鎖定模式使用含義

• 在復制環節中使用自增列
  如果你在使用基于語句的復制(statement-based replication)請將innodb_autoinc_lock_mode設置為0或1，并在主從上使用相同的值。 如果使用innodb_autoinc_lock_mode = 2（“interleaved”）或主從不使用相同的鎖定模式的配置，自動遞增值不能保證在從機上與主機上相同。
  如果使用基于行的或混合模式的復制，則所有自動增量鎖定模式都是安全的，因為基于行的復制對SQL語句的執行順序不敏感（混合模式會在遇到不安全的語句是使用基于行的復制模式）。
• “Lost” auto-increment values and sequence gaps
  在所有鎖定模式（0,1和2）中，如果生成自動遞增值的事務回滾，那些自動遞增值將“丟失”。 一旦為自動增量列生成了值，無論是否完成“類似INSERT”語句以及包含事務是否回滾，都不能回滾。 這種丟失的值不被重用。 因此，存儲在表的AUTO_INCREMENT列中的值可能存在間隙。
• Specifying NULL or 0 for the AUTO_INCREMENT column
  在所有鎖定模式（0,1和2）中，如果用戶在INSERT中為AUTO_INCREMENT列指定NULL或0，InnoDB會將該行視為未指定值，并為其生成新值。
• 為AUTO_INCREMENT列分配一個負值
  在所有鎖定模式（0,1和2）中，如果您為AUTO_INCREMENT列分配了一個負值，則不會定義自動增量機制的行為。
• 如果AUTO_INCREMENT值大于指定整數類型的最大整數
  在所有鎖定模式（0,1和2）中，如果值大于可以存儲在指定整數類型中的最大整數，則不定義自動遞增機制的行為。
• Gaps in auto-increment values for “bulk inserts”
  當innodb_autoinc_lock_mode設置為0（“traditional”）或1（“consecutive”）時,任何給定語句生成的自動遞增值是連續的，沒有間隙，因為表級AUTO-INC鎖會持續到 語句結束,并且一次只能執行一個這樣的語句。
  當innodb_autoinc_lock_mode設置為2（“interleaved”）時，在“bulk inserts”生成的自動遞增值中可能存在間隙，但只有在并發執行“INSERT-Like”語句時才會產生這種情況。
  對于鎖定模式1或2，在連續語句之間可能出現間隙，因為對于批量插入，每個語句所需的自動遞增值的確切數目可能不為人所知，并且可能進行過度估計。

select @@innodb_autoinc_lock_mode;
+----------------------------+
| @@innodb_autoinc_lock_mode |
+----------------------------+
|                          0 |
+----------------------------+
DROP TABLE IF EXISTS t;
CREATE TABLE t (a bigint unsigned auto_increment primary key) ENGINE=InnoDB SELECT NULL AS a;
/* #1 */ INSERT INTO t SELECT NULL FROM t;
/* #2 */ INSERT INTO t SELECT NULL FROM t;
/* #3 */ INSERT INTO t SELECT NULL FROM t;
/* #4 */ INSERT INTO t SELECT NULL FROM t;
SELECT * FROM t;
+----+
| a  |
+----+
|  1 |
|  2 |
|  3 |
|  4 |
|  5 |
|  6 |
|  7 |
|  8 |
|  9 |
| 10 |
| 11 |
| 12 |
| 13 |
| 14 |
| 15 |
| 16 |
+----+
當innodb_autoinc_lock_mode=0 類INSERT語句產生的自動遞增值都是連續的
select @@innodb_autoinc_lock_mode;
+----------------------------+
| @@innodb_autoinc_lock_mode |
+----------------------------+
|                          1 |
+----------------------------+
1 row in set (0.00 sec)
DROP TABLE IF EXISTS t;
CREATE TABLE t (a bigint unsigned auto_increment primary key) ENGINE=InnoDB SELECT NULL AS a;
/* #1 */ INSERT INTO t SELECT NULL FROM t;
/* #2 */ INSERT INTO t SELECT NULL FROM t;
/* #3 */ INSERT INTO t SELECT NULL FROM t;
/* #4 */ INSERT INTO t SELECT NULL FROM t;
SELECT * FROM t;
+----+
| a  |
+----+
|  1 |
|  2 |
|  3 |
|  4 |
|  6 |
|  7 |
|  8 |
|  9 |
| 13 |
| 14 |
| 15 |
| 16 |
| 17 |
| 18 |
| 19 |
| 20 |
+----+
出現了間隙gap, 5和10-12都沒了,下面來解釋產生這種情況的原因:
/* #1 */ 這是第一次INSERT,此時表中只有一行(創建表時的那一行),但是MySQL不知道有多少行.
然后MySQL Grab a chunk of auto_increment values 在chunk中有多少？ 一 只有一個,即'2',將其插入表中.
沒有更多的行插入，所以一切完成。
/* #2 */ 這是第二次INSERT,此時表中有兩行(1,2),但是MySQL不知道有多少行.
MySQL Grab a chunk of auto_increment values 在chunk中有多少？ 一 只有一個,即'3',將其插入表中.
還有需要插入的行,所以Grab another chunk,這次是前一次的兩倍大小 在chunk中有多少？ 一 兩個,'4'和'5'. 插入'4'.
沒有更多的行插入，所以一切完成,'5'被舍棄,但是此時 AUTO_INCREMENT的下一個值是6了
/* #3 */這是第三次INSERT,此時表中有四行(1,2,3,4),但是MySQL不知道有多少行.
- Grab a chunk of auto_increment values. How many in the chunk? One - the value '6'. Insert it (one row inserted).
- Still more rows to insert. Grab another chunk, twice as big as before - two values, '7' and '8'. Insert them (three rows inserted).
- Still more rows to insert. Grab another chunk, twice as big as before - four values, '9', '10', '11', '12'. Insert the '9' (four rows inserted).
- No more rows to insert. Discard the left over '10', '11', and '12'.
#4: Insert as many rows as there are in the table (it's eight rows, but MySQL doesn't know that.)
- Grab a chunk of auto_increment values. How many in the chunk? One - the value '13'. Insert it (one row inserted).
- Still more rows to insert. Grab another chunk, twice as big as before - two values, '14' and '15'. Insert them (three rows inserted).
- Still more rows to insert. Grab another chunk, twice as big as before - four values, '16', '17', '18', '19'. Insert them (seven rows inserted).
- Still more rows to insert. Grab another chunk, twice as big as before - eight values, '20', '21', '22', ..., '27'. Insert the '20' (eight rows inserted).
- No more rows to insert. Discard the left over '21', '22', etc.
所以這就是 gap 產生的原因

mysql> CREATE TABLE t1 (
-> c1 INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
-> c2 CHAR(1)
-> ) ENGINE = INNODB;

mysql> INSERT INTO t1 (c1,c2) VALUES (1,'a'), (NULL,'b'), (5,'c'), (NULL,'d');

mysql> SELECT c1, c2 FROM t1 ORDER BY c2;
+-----+------+
| c1  | c2   |
+-----+------+
|   1 | a    |
| 101 | b    |
|   5 | c    |
| 102 | d    |
+-----+------+

mysql> SELECT c1, c2 FROM t1 ORDER BY c2;
+-----+------+
| c1  | c2   |
+-----+------+
|   1 | a    |
| 101 | b    |
|   5 | c    |
| 102 | d    |
+-----+------+

mysql> SELECT c1, c2 FROM t1 ORDER BY c2;
+-----+------+
| c1  | c2   |
+-----+------+
|   1 | a    |
|   x | b    |
|   5 | c    |
|   y | d    |
+-----+------+

mysql> INSERT INTO t1 (c1,c2) VALUES (1,'a'), (NULL,'b'), (5,'c'), (NULL,'d');

mysql> CREATE TABLE t1 (
-> c1 INT NOT NULL AUTO_INCREMENT,
-> PRIMARY KEY (c1)
->  ) ENGINE = InnoDB;
mysql> INSERT INTO t1 VALUES(0), (0), (3); -- 0 0分配兩個值1,2. 手動指定3,則此時AUTO_INCREMENT為3,下一個值為4
mysql> SELECT c1 FROM t1;
+----+
| c1 |
+----+
|  1 |
|  2 |
|  3 |
+----+
mysql> UPDATE t1 SET c1 = 4 WHERE c1 = 1;
mysql> SELECT c1 FROM t1;
+----+
| c1 |
+----+
|  2 |
|  3 |
|  4 |
+----+
mysql> INSERT INTO t1 VALUES(0); --由于分配值為4,所以報錯duplicate key
ERROR 1062 (23000): Duplicate entry '4' for key 'PRIMARY'

SELECT MAX(ai_col) FROM table_name FOR UPDATE;

?