MySQL · 内核分析 · InnoDB主键约束和唯一约束的实现分析

概述

关系数据库通过约束机制来指定插入数据的规则，从而确保数据的完整性和一致性。MySQL的约束主要包括: 主键约束、唯一约束、非空约束以及外键约束。主键约束指定表中的一列或者几列的组合的值在表中不能出现空值和重复值，即唯一的标识一行记录。唯一约束指定表中某一列或多个列不能有相同的两行或者两行以上的数据存在，和主键约束不同，唯一约束允许为NULL，只是只能有一行。 InnoDB主要通过锁机制来实现主键约束和唯一约束，锁类型包括表锁和行锁，而行锁还细分为记录锁(RK)、间隙锁(GK)、插入意向锁(IK)、Next-Key(NK)等更细的子类型，锁兼容矩阵如下：

行是已经存在的锁，列是要加的锁RKGKIKNK
RK0110
GK1111
IK1010
NK0110

主键约束

以插入为例，实现主键约束的主要过程如下：

  1.   |-Sql_cmd_insert_values::execute_inner() // Insert one or more rows from a VALUES list into a table
  2.     |-write_record
  3.       |-handler::ha_write_row() // 调用存储引擎的接口
  4.         |-ha_innobase::write_row()
  5.           |-row_insert_for_mysql
  6.             |-row_insert_for_mysql_using_ins_graph
  7.               |-trx_start_if_not_started_xa
  8.                 |-trx_start_low // 激活事务，事务状态由 not_active 变为 active
  9.               |-row_get_prebuilt_insert_row // Gets pointer to a prebuilt dtuple used in insertions
  10.               |-row_mysql_convert_row_to_innobase // 记录格式从MySQL转换成InnoDB, 不同数据类型处理方式不同，比如整形server端是小端存储，innodb是大端存储
  11.               |-row_ins_step
  12.                 |-trx_write_trx_id(node->trx_id_buf, trx->id)
  13.                 |-lock_table // 给表加IX锁
  14.                 |-row_ins // 插入记录
  15.                   |-while (node->index != NULL)
  16.                     |-row_ins_index_entry_step // 向索引中插入记录,把 innobase format field 的值赋给对应的index entry field
  17.                       |-row_ins_index_entry_set_vals // 根据该索引以及原记录，将组成索引的列的值组成一个记录
  18.                       |-dtuple_check_typed // 检查组成的记录的有效性
  19.                       |-row_ins_index_entry // 插入索引项
  20.                         |-row_ins_clust_index_entry // 插入聚集索引
  21.                           |-row_ins_clust_index_entry_low // 先尝试乐观插入，修改叶子节点 BTR_MODIFY_LEAF
  22.                             |-mtr_t::mtr_t()
  23.                             |-mtr_t::start()
  24.                             |-btr_pcur_t::open()
  25.                               |-btr_cur_search_to_nth_level // 将cursor移动到索引上待插入的位置
  26.                                 |-buf_page_get_gen //取得本层页面，首次为根页面
  27.                                 |-page_cur_search_with_match_bytes // 在本层页面进行游标定位
  28.                             |-row_ins_duplicate_error_in_clust // 判断插入项是否存在唯一键冲突
  29.                               |-row_ins_set_shared_rec_lock // 对cursor 对应的已有记录加S锁（可能会等待）保证记录上的操作，包括：Insert/Update/Delete 已经提交或者回滚
  30.                                 |-lock_clust_rec_read_check_and_lock // 判断cursor对应的记录上是否存在隐式锁, 若存在，则将隐式锁转化为显示锁
  31.                                   |-lock_rec_convert_impl_to_expl // 隐式锁转换
  32.                                   |-lock_rec_lock //如果上面的隐式锁转化成功，此处加S锁将会等待，直到活跃事务释放锁。
  33.                               |-row_ins_dupl_err_with_rec // S锁加锁完成之后，可以再次做判断，最终决定是否存在唯一键冲突, 
  34.                                 // 1. 判断insert记录与cursor对应的记录取值是否相同, 
  35.                                 // 2. 二级唯一键值锁引，可以存在多个 NULL 值, 
  36.                                 // 3. 最后判断记录的delete flag状态，判断记录是否被删除提交
  37.                                 |-return !rec_get_deleted_flag();
  38.                             |-btr_cur_optimistic_insert // 乐观插入
  39.                             |-btr_cur_pessimistic_insert // 乐观插入失败则进行悲观插入
  40.                             |-mtr_t::commit() mtr_commit //Commit a mini-transaction.
  41.                             |-btr_pcur_t::close()

主键判重主函数

row_ins_duplicate_error_in_clust是主键判重的主函数，关键代码如下：

  1. static MY_ATTRIBUTE((warn_unused_result)) dberr_t
  2.     row_ins_duplicate_error_in_clust(
  3.         ulint flags,           /*!< in: undo logging and locking flags */
  4.         btr_cur_t *cursor,     /*!< in: B-tree cursor */
  5.         const dtuple_t *entry, /*!< in: entry to insert */
  6.         que_thr_t *thr,        /*!< in: query thread */
  7.         mtr_t *mtr)            /*!< in: mtr */
  8. {
  9.   dberr_t err;
  10.   rec_t *rec;
  11.   ulint n_unique;
  12.   trx_t *trx = thr_get_trx(thr);
  13.   mem_heap_t *heap = NULL;
  14.   ulint offsets_[REC_OFFS_NORMAL_SIZE];
  15.   ulint *offsets = offsets_;
  16.   rec_offs_init(offsets_);
  18.   n_unique = dict_index_get_n_unique(cursor->index);
  20.   if (cursor->low_match >= n_unique) {
  21.     rec = btr_cur_get_rec(cursor);
  23.     if (!page_rec_is_infimum(rec)) {
  24.       offsets =
  25.           rec_get_offsets(rec, cursor->index, offsets, ULINT_UNDEFINED, &heap);
  27.       ulint lock_type;
  29.       lock_type = ((trx->isolation_level <= TRX_ISO_READ_COMMITTED) ||
  30.                    (cursor->index->table->skip_gap_locks()))
  31.                       ? LOCK_REC_NOT_GAP
  32.                       : LOCK_ORDINARY;
  34.       if (flags & BTR_NO_LOCKING_FLAG) {
  35.         /* Do nothing if no-locking is set */
  36.         err = DB_SUCCESS;
  37.       } else if (trx->duplicates) {
  38.         err =
  39.             row_ins_set_exclusive_rec_lock(lock_type, btr_cur_get_block(cursor),
  40.                                            rec, cursor->index, offsets, thr);
  41.       } else {
  42.         // 对cursor对应的已有记录加S锁（可能会等待）保证记录上的操作，
  43.         // 包括：Insert/Update/Delete 已经提交或者回滚
  44.         err = row_ins_set_shared_rec_lock(lock_type, btr_cur_get_block(cursor),
  45.                                           rec, cursor->index, offsets, thr);
  46.       }
  48.       switch (err) {
  49.         case DB_SUCCESS_LOCKED_REC:
  50.         case DB_SUCCESS:
  51.           break;
  52.         default:
  53.           goto func_exit;
  54.       }
  56.       // S锁加锁完成之后，可以再次做判断，最终决定是否存在唯一键冲突
  57.       if (row_ins_dupl_error_with_rec(rec, entry, cursor->index, offsets)) {
  58.       duplicate:
  59.         trx->error_info = cursor->index;
  60.         err = DB_DUPLICATE_KEY;
  61.         goto func_exit;
  62.       }
  63.     }
  64.   }
  66.   if (cursor->up_match >= n_unique) {
  67.     rec = page_rec_get_next(btr_cur_get_rec(cursor));
  69.     if (!page_rec_is_supremum(rec)) {
  70.       offsets =
  71.           rec_get_offsets(rec, cursor->index, offsets, ULINT_UNDEFINED, &heap);
  73.       if (trx->duplicates) {
  74.         err = row_ins_set_exclusive_rec_lock(LOCK_REC_NOT_GAP,
  75.                                              btr_cur_get_block(cursor), rec,
  76.                                              cursor->index, offsets, thr);
  77.       } else {
  78.         err = row_ins_set_shared_rec_lock(LOCK_REC_NOT_GAP,
  79.                                           btr_cur_get_block(cursor), rec,
  80.                                           cursor->index, offsets, thr);
  81.       }
  83.       switch (err) {
  84.         case DB_SUCCESS_LOCKED_REC:
  85.         case DB_SUCCESS:
  86.           break;
  87.         default:
  88.           goto func_exit;
  89.       }
  91.       if (row_ins_dupl_error_with_rec(rec, entry, cursor->index, offsets)) {
  92.         goto duplicate;
  93.       }
  94.     }
  96.     /* This should never happen */
  97.     ut_error;
  98.   }
  100.   err = DB_SUCCESS;
  101. func_exit:
  102.   if (UNIV_LIKELY_NULL(heap)) {
  103.     mem_heap_free(heap);
  104.   }
  105.   return (err);
  106. }

对cursor对应的已有记录加锁

通常MySQL的插入操作是不加锁的，但如果在插入或更新记录时，检查到存在重复记录（有可能被标记为删除），对于普通的INSERT/UPDATE，会加S锁，而对于类似REPLACE INTO或者INSERT … ON DUPLICATE这种SQL加的则是X锁。如果是RC隔离级别，加的是LOCK_REC_NOT_GAP类型的锁，如果是RR隔离级别，加的则是next-key类型的锁。以S锁为例，调用的函数是lock_clust_rec_read_check_and_lock，其关键代码如下:

  1. dberr_t lock_clust_rec_read_check_and_lock(
  2.     ulint flags, const buf_block_t *block, const rec_t *rec,
  3.     dict_index_t *index, const ulint *offsets, select_mode sel_mode,
  4.     lock_mode mode, ulint gap_mode, que_thr_t *thr) {
  5.   dberr_t err;
  6.   ulint heap_no;
  8.   if ((flags & BTR_NO_LOCKING_FLAG) || srv_read_only_mode ||
  9.       index->table->is_temporary()) {
  10.     return (DB_SUCCESS);
  11.   }
  13.   heap_no = page_rec_get_heap_no(rec);
  15.   // 判断记录上是否存在隐式锁，如果存在则将其转换为显示锁
  16.   if (heap_no != PAGE_HEAP_NO_SUPREMUM) {
  17.     lock_rec_convert_impl_to_expl(block, rec, index, offsets);
  18.   }
  20.   LockSysGuard lock_guard(LOCK_REC_SHARD, block);
  22.   // 加S锁, 如果上面的隐式锁转化成功, 此处加锁将会等待, 直到活跃事务释放锁
  23.   err = lock_rec_lock(false, sel_mode, mode | gap_mode, block, heap_no, index,
  24.                       thr, &lock_guard);
  26.   lock_guard.release();
  27.   DEBUG_SYNC_C("after_lock_clust_rec_read_check_and_lock");
  28.   ut_ad(err == DB_SUCCESS || err == DB_SUCCESS_LOCKED_REC ||
  29.         err == DB_LOCK_WAIT || err == DB_DEADLOCK || err == DB_SKIP_LOCKED ||
  30.         err == DB_LOCK_NOWAIT);
  31.   return (err);
  32. }

隐式锁转换的相关资料可以参考文章《InnoDB隐式锁功能解析》http://mysql.taobao.org/monthly/2020/09/06/

二级索引唯一约束

继续以插入为例，二级索引唯一约束的主要实现过程如下：

  1.   |-Sql_cmd_insert_values::execute_inner
  2.     |-write_record
  3.       |-handler::ha_write_row
  4.         |-ha_innobase::write_row
  5.           |-row_insert_for_mysql
  6.             |-row_insert_for_mysql_using_ins_graph
  7.               |-trx_start_if_not_started_xa
  8.                   |-trx_start_low // 激活事务，事务状态由 not_active 变为 active
  9.                 |-row_get_prebuilt_insert_row // Gets pointer to a prebuilt dtuple used in insertions
  10.               |-row_mysql_convert_row_to_innobase // 记录格式从MySQL转换成InnoDB
  11.               |-row_ins_step
  12.                 |-trx_write_trx_id(node->trx_id_buf, trx->id)
  13.                 |-lock_table // 给表加IX锁
  14.                 |-row_ins // 插入记录
  15.                   |-while (node->index != NULL)
  16.                     |-row_ins_index_entry_step // 向索引中插入记录,把 innobase format field 的值赋给对应的index entry field
  17.                       |-row_ins_index_entry_set_vals // 根据该索引以及原记录，将组成索引的列的值组成一个记录
  18.                       |-dtuple_check_typed // 检查组成的记录的有效性
  19.                       |-row_ins_index_entry // 插入索引项
  20.                         |-row_ins_sec_index_entry // 插入二级索引
  21.                           |-row_ins_sec_index_entry_low // 先尝试乐观插入，修改叶子节点 BTR_MODIFY_LEAF
  22.                             |-mtr_t::mtr_t()
  23.                             |-mtr_t::start()
  24.                             |-btr_cur_search_to_nth_level // 将cursor移动到索引上待插入的位置, PAGE_CUR_LE(<=), BTR_MODIFY_LEAF, dtuple带主键
  25.                               |-buf_page_get_gen //取得本层页面，首次为根页面
  26.                               |-page_cur_search_with_match_bytes // 在本层页面进行游标定位
  27.                             |-if (dict_index_is_unique(index) && // 先做粗略判断，跳过不需要判重的情况
  28.                               (cursor.low_match >= n_unique || cursor.up_match >= n_unique))
  29.                               |-mtr_commit(&mtr); // 释放latch
  30.                               |-row_ins_scan_sec_index_for_duplicate
  31.                                 |-n_fields_cmp = dtuple_get_n_fields_cmp(entry);
  32.                                 |-dtuple_set_n_fields_cmp(entry, n_unique); // 只包含二级索引唯一键
  33.                                 |-btr_pcur_open_low // 只包含二级索引唯一键, 返回时持有第一个满足条件记录所在的page latch
  34.                                   |-btr_cur_search_to_nth_level // PAGE_CUR_GE(>=), BTR_SEARCH_LEAF, dtuple只包含二级索引唯一键
  35.                                     |-page_cur_search_with_match
  36.                                 |-do
  37.                                   |-const rec_t* rec = btr_pcur_get_rec(&pcur);
  38.                                   |-row_ins_set_shared_rec_lock // 加行锁，包括deleted record
  39.                                   |-row_ins_dupl_error_with_rec // 判断是否重复
  40.                                 |-while (btr_pcur_move_to_next(&pcur, mtr)) // 扫描下一个记录
  41.                               |-mtr_commit(&mtr); // 释放page latch
  42.                             |-btr_cur_optimistic_insert // 乐观插入
  43.                             |-btr_cur_pessimistic_insert // 乐观插入失败则进行悲观插入
  44.                             |-mtr_t::commit() mtr_commit // Commit a mini-transaction.
  45.                             |-btr_pcur_t::close()

唯一二级索引判重主函数

row_ins_scan_sec_index_for_duplicate是唯一二级索引判重的主函数，关键代码如下：

  1. static MY_ATTRIBUTE((warn_unused_result)) dberr_t
  2.     row_ins_scan_sec_index_for_duplicate(
  3.         ulint flags,         /*!< in: undo logging and locking flags */
  4.         dict_index_t *index, /*!< in: non-clustered unique index */
  5.         dtuple_t *entry,     /*!< in: index entry */
  6.         que_thr_t *thr,      /*!< in: query thread */
  7.         bool s_latch,        /*!< in: whether index->lock is being held */
  8.         mtr_t *mtr,          /*!< in/out: mini-transaction */
  9.         mem_heap_t *offsets_heap)
  10. {
  11.   n_unique = dict_index_get_n_unique(index);
  13.   n_fields_cmp = dtuple_get_n_fields_cmp(entry);
  15.   // 只包含二级索引唯一键，不包括主键字段
  16.   dtuple_set_n_fields_cmp(entry, n_unique);
  18.   // 只包含二级索引唯一键, 返回时持有第一个满足条件记录所在的page latch
  19.   btr_pcur_open(
  20.       index, entry, PAGE_CUR_GE,
  21.       s_latch ? BTR_SEARCH_LEAF | BTR_ALREADY_S_LATCHED : BTR_SEARCH_LEAF,
  22.       &pcur, mtr);
  24.   allow_duplicates = thr_get_trx(thr)->duplicates;
  26.   do {
  27.     const rec_t *rec = btr_pcur_get_rec(&pcur);
  28.     const buf_block_t *block = btr_pcur_get_block(&pcur);
  30.     // 无论是RC还是RR隔离级别，均将加锁类型设置为LOCK_ORDINARY
  31.     const ulint lock_type =
  32.         index->table->skip_gap_locks() ? LOCK_REC_NOT_GAP : LOCK_ORDINARY;
  34.     if (page_rec_is_infimum(rec)) {
  35.       continue;
  36.     }
  38.     offsets =
  39.         rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, &offsets_heap);
  41.     if (flags & BTR_NO_LOCKING_FLAG) {
  42.     } else if (allow_duplicates) {
  43.       // 加X锁
  44.       err = row_ins_set_exclusive_rec_lock(lock_type, block, rec, index,
  45.                                            offsets, thr);
  46.     } else {
  47.       if (index->table->skip_gap_locks()) {
  48.         if (page_rec_is_supremum(rec)) {
  49.           continue;
  50.         }
  52.         if (cmp_dtuple_rec(entry, rec, index, offsets) < 0) {
  53.           goto end_scan;
  54.         }
  55.       }
  56.       // 加S锁
  57.       err = row_ins_set_shared_rec_lock(lock_type, block, rec, index, offsets,
  58.                                         thr);
  59.     }
  61.     switch (err) {
  62.       case DB_SUCCESS_LOCKED_REC:
  63.         err = DB_SUCCESS;
  64.       case DB_SUCCESS:
  65.         break;
  66.       default:
  67.         goto end_scan;
  68.     }
  70.     if (page_rec_is_supremum(rec)) {
  71.       continue;
  72.     }
  74.     cmp = cmp_dtuple_rec(entry, rec, index, offsets);
  76.     if (cmp == 0 && !index->allow_duplicates) {
  77.       // 加锁成功后判断是否重复
  78.       if (row_ins_dupl_error_with_rec(rec, entry, index, offsets)) {
  79.         err = DB_DUPLICATE_KEY;
  80.         thr_get_trx(thr)->error_info = index;
  81.         goto end_scan;
  82.       }
  83.     } else {
  84.       ut_a(cmp < 0 || index->allow_duplicates);
  85.       goto end_scan;
  86.     }
  87.     // 扫描下一个记录，直到遇到第一个不同的记录
  88.   } while (btr_pcur_move_to_next(&pcur, mtr));
  90. end_scan:
  91.   dtuple_set_n_fields_cmp(entry, n_fields_cmp);
  93.   DBUG_RETURN(err);
  94. }

唯一二级索引判重时的加锁逻辑

在函数row_ins_scan_sec_index_for_duplicate中，无论是RR还是RC隔离级别，当插入一条带唯一约束的记录时，如果表上已经存在了这条记录，或者有一条标记删除的相同键值记录时，就需要对这条记录加S LOCK_ORDINARY锁。在MySQL 5.6.12版本之后，有人认为RC隔离级别下无需加LOCK_ORDINARY锁, 只需要加LOCK_REC_NOT_GAP类型的S锁，这个改动导致了非常严重的二级索引唯一约束失效问题(bug#68021)。

  1. 二级索引唯一约束失效重现步骤：
  3. 修改row0ins.cc 函数row_ins_scan_sec_index_for_duplicate:
  4.     const ulint lock_type =
  5.         index->table->skip_gap_locks() ? LOCK_REC_NOT_GAP : LOCK_ORDINARY;
  6.     const ulint lock_type = LOCK_REC_NOT_GAP;
  8. CREATE TABLE t1 (
  9.    c1 int(11) NOT NULL AUTO_INCREMENT,
  10.    c2 int(11) DEFAULT NULL,
  11.    PRIMARY KEY (c1),
  12.    UNIQUE KEY k_c2 (c2)
  13.  ) ENGINE=InnoDB AUTO_INCREMENT=5;
  15. insert into t1 values (3, 5), (9, 10);
  17. Transaction 1:
  18. begin;
  19. delete from t1 where c2 = 5;
  21. Transaction 2:
  22. insert into t1 select 1,5; // wait
  24. Transaction 3:
  25. insert into t1 select 2,5; // wait
  27. Transaction 1:
  28. commit;
  30. root@localhost : test 10:31:03> select * from t1; // 二级索引唯一约束失效, trx2和trx3均插入成功
  31. +----+------+
  32. | c1 | c2   |
  33. +----+------+
  34. |  1 |    5 |
  35. |  2 |    5 |
  36. |  9 |   10 |
  37. +----+------+
  38. 3 rows in set (0.00 sec)

二级索引唯一约束失效的原因

  1. Transaction 1:
  2. begin;
  3. delete from t1 where c2 = 5; // 加X NOT_GAP lock，成功
  5. Transaction 2:
  6. insert into t1 select 1,5; // 加S NOT_GAP lock，等待
  8. Transaction 3:
  9. insert into t1 select 2,5; // 加S NOT_GAP lock，等待
  11. Transaction 1:
  12. commit;
  13. T1 释放X NOT_GAP lock
  14. T2 加S NOT_GAP lock成功
  15. T3 加S NOT_GAP lock成功（S锁互相兼容）
  16. T2 加X insert intention lock成功（X IK和S RK兼容）
  17. T3 加X insert intention lock成功（X IK和S RK,X IK均兼容）
  18. T2 插入记录成功
  19. T3 插入记录成功

官方发现这个问题后又把RK改成了NK，如果T2,T3加的是LOCK_ORDINARY lock，由于LOCK_ORDINARY lock与insert intention lock不兼容，在插入阶段T2和T3会发生死锁，其中一个事务会回滚，因此不会出现二级索引唯一约束失效的问题。