答读者问：唯一索引冲突，为什么主键的 Supremum 记录会加 Next-Key 锁？

// storage/innobase/row/row0ins.cc
[[nodiscard]] static dberr_t row_ins_scan_sec_index_for_duplicate(...)
{
  ...
  // SQL 语句能否包括牵制主键、独一索引矛盾的逻辑
  allow_duplicates = row_allow_duplicates(thr);
  ...
  do {
    ...
    if (flags & BTR_NO_LOCKING_FLAG) {
      /* Set no locks when applying log in online table rebuild. */
    } else if (allow_duplicates) {
      ...
      // 若何怎样 SQL 语句包括管理主键、惟一索引抵触的逻辑
      // 给矛盾记实添排他锁（LOCK_X）
      err = row_ins_set_rec_lock(LOCK_X, lock_type, block, rec, index, offsets,
                                 thr);
    } else /* else_1 */ {
      if (skip_gap_locks) {
        // 若是是数据字典表、SDI 表
        // 决议添甚么锁，纰漏
        ...
      } else if (is_supremum) {
        /* We use next key lock to possibly combine the locks in bitmap.
        Equivalent to LOCK_GAP. */
        // next-key 锁
        lock_type = LOCK_ORDINARY;
      } else if (is_next) {
        /* Only gap lock is required on next record. */
        // gap 锁
        lock_type = LOCK_GAP;
      } else /* else_二 */ {
        /* Next key lock for all equal keys. */
        // next-key 锁
        lock_type = LOCK_ORDINARY;
      }
      ...
      // SQL 语句【没有蕴含】打点主键、惟一索引矛盾的逻辑
      // 给抵触记载添同享锁（LOCK_S）
      err = row_ins_set_rec_lock(LOCK_S, lock_type, block, rec, index, offsets,
                                 thr);
    }
    ...
    if (is_supremum) {
      continue;
    }
    // !index->allow_duplicates = true
    // 即 index->allow_duplicates = false 
    // 暗示没有容许索引外具有反复纪录
    // 挪用 row_ins_dupl_error_with_rec()
    // 确定新拔出记载能否会招致索引矛盾
    if (!is_next && !index->allow_duplicates) {
      if (row_ins_dupl_error_with_rec(rec, entry, index, offsets)) {
        // 返归 true，分析会招致索引抵牾
        // 把错误码赋值给 err 变质
        // 做为办法的返归值
        err = DB_DUPLICATE_KEY;
        ...
        goto end_scan;
      }
    } else /* else_3 */ {
      ut_a(is_next || index->allow_duplicates);
      goto end_scan;
    }
  } while (pcur.move_to_next(mtr));

end_scan:
  /* Restore old value */
  dtuple_set_n_fields_cmp(entry, n_fields_cmp);

  return err;
}

下列 3 种 SQL，allow_duplicates = true，表现 SQL 蕴含管理主键、惟一索引抵触的逻辑：

• load datafile replace
• replace into
• insert ... on duplicate key update

管教矛盾的体式格局：

• load datafile replace、replace into，增除了表外的矛盾记载，拔出新记载。
• insert ... on duplicate key update，用 update 反面的各字段值更新表外抵触记载对于应的字段。

怎样 SQL 蕴含经管主键、惟一索引抵触的逻辑，会更新或者增除了抵牾记载，以是必要添排他锁（LOCK_X）。

对于于事例 SQL，allow_duplicates = false，执止流程会入进 else_1 分收。

由于事例 SQL 没有包罗料理主键、独一索引抵触的逻辑，没有会更新、增除了抵触记载，以是，只要要对于抵牾记实添同享锁（LOCK_S），添锁的大略模式为 next-key 锁（对于应 else_两 分收）。

以及变质 allow_duplicates 的寄义差异，if (!is_next && !index->allow_duplicates) 外的 index->allow_duplicates 显示独一索引能否容许具有反复记载：

• 对于于 MySQL 外部姑且表的两级索引，index->allow_duplicates = true。
• 对于于别的表，index->allow_duplicates = false。

对于于事例 SQL，if (!is_next && !index->allow_duplicates) 前提成坐，挪用 row_ins_dupl_error_with_rec() 取得返归值 true，阐明新拔出纪录以及独一索引外的本有记实矛盾。

执止流程入进 if (row_ins_dupl_error_with_rec(rec, entry, index, offsets)) 分收，安排变质 err 的值为 DB_DUPLICATE_KEY。

那末，答题来了：拔出记载到独一索引时，创造拔出目的职位地方曾有一条类似的记载了，那不克不及分析新拔出记载以及独一索引华夏有纪录矛盾吗？

借实不克不及，由于惟一索引有个非凡场景要措置，这便是 NULL 值。

InnoDB 以为 NULL 暗示已知，NULL 以及 NULL 也是没有相称的，以是，独一索引外否以包罗多条字段值为 NULL 的纪录。

原文外，独一索引皆是指的2级索引。InnoDB 主键的字段值是没有容许为 NULL 的。

举个例子：对于于测试表 t6，要是某笔记录的 i1 字段值为 NULL，新纪录的 i1 字段值也为 NULL，就能够拔出顺遂，而没有会报 Duplicate key 错误。

（3）归滚语句

row_ins_step() 执止停止以后，row_insert_for_mysql_using_ins_graph() 从 trx->error_state 外获得错误码 DB_DUPLICATE_KEY，分析新拔出记实招致独一索引抵触，挪用 row_mysql_handle_errors() 处置矛盾的擅后逻辑，旅馆如高：

| > row_mysql_handle_errors(...) storage/innobase/row/row0mysql.cc:701
| + > // 拔出记载招致独一索引抵牾，须要归滚
| + > trx_rollback_to_savepoint(trx_t*, trx_savept_t*) storage/innobase/trx/trx0roll.cc:151
| + - > trx_rollback_to_savepoint_low(trx_t*, trx_savept_t*) storage/innobase/trx/trx0roll.cc:114
| + - x > que_run_threads(que_thr_t*) storage/innobase/que/que0que.cc:1001
| + - x = > que_run_threads_low(que_thr_t*) storage/innobase/que/que0que.cc:966
| + - x = | > que_thr_step(que_thr_t*) storage/innobase/que/que0que.cc:913
| + - x = | + > row_undo_step(que_thr_t*) storage/innobase/row/row0undo.cc:36两
| + - x = | + - > row_undo(undo_node_t*, que_thr_t*) storage/innobase/row/row0undo.cc:两96
| + - x = | + - x > row_undo_ins(undo_node_t*, que_thr_t*) storage/innobase/row/row0uins.cc:500
| + - x = | + - x = > row_undo_ins_remove_clust_rec(undo_node_t*) storage/innobase/row/row0uins.cc:118
| + - x = | + - x = | > row_convert_impl_to_expl_if_needed(btr_cur_t*, undo_node_t*) storage/innobase/row/row0undo.cc:338
| + - x = | + - x = | + > // 把主键索引记载上的显式锁转换为隐式锁
| + - x = | + - x = | + > lock_rec_convert_impl_to_expl(...) storage/innobase/lock/lock0lock.cc:5544
| + - x = | + - x = | + - > lock_rec_convert_impl_to_expl_for_trx(...) storage/innobase/lock/lock0lock.cc:5496
| + - x = | + - x = | + - x > lock_rec_add_to_queue(...) storage/innobase/lock/lock0lock.cc:1613
| + - x = | + - x = | + - x = > lock_rec_other_has_expl_req(...) storage/innobase/lock/lock0lock.cc:900
| + - x = | + - x = | + - x = > // 建立锁规划
| + - x = | + - x = | + - x = > RecLock::create(trx_t*, lock_prdt const*) storage/innobase/lock/lock0lock.cc:1356
| + - x = | + - x = | > // 进步前辈止乐不雅增除了，若何怎样乐不雅增除了掉败，反面会入止消极增除了
| + - x = | + - x = | > btr_cur_optimistic_delete(...) storage/innobase/include/btr0cur.h:466
| + - x = | + - x = | + > btr_cur_optimistic_delete_func(...) storage/innobase/btr/btr0cur.cc:456两
| + - x = | + - x = | + - > lock_update_delete(...) storage/innobase/lock/lock0lock.cc:3350
| + - x = | + - x = | + - x > // 刚才拔出的纪录，由于独一索引抵触必要增除了，让它的高一笔记录承继 GAP 锁
| + - x = | + - x = | + - x > lock_rec_inherit_to_gap(...) storage/innobase/lock/lock0lock.cc:两588
| + - x = | + - x = | + - x = > lock_rec_add_to_queue(...) storage/innobase/lock/lock0lock.cc:1681
| + - x = | + - x = | + - x = | > // 为被增除了的主键记载的高一笔记录建立锁构造
| + - x = | + - x = | + - x = | > RecLock::create(trx_t*, lock_prdt const*) storage/innobase/lock/lock0lock.cc:1356

// storage/innobase/row/row0mysql.cc
bool row_mysql_handle_errors(...)
{
  ...
  switch (err) {
    ...
    case DB_DUPLICATE_KEY:
    ...
      if (savept) {
        /* Roll back the latest, possibly incomplete insertion
        or update */

        trx_rollback_to_savepoint(trx, savept);
      }
      /* MySQL will roll back the latest SQL statement */
      break;
      ...
    }
    ...
}

// storage/innobase/row/row0uins.cc
[[nodiscard]] static dberr_t row_undo_ins_remove_clust_rec(
    undo_node_t *node) /*!< in: undo node */
{
  ...
  // 把新拔出到主键索引外的纪录上的显式锁
  // 转换为隐式锁
  row_convert_impl_to_expl_if_needed(btr_cur, node);
  // 进步前辈止乐不雅增除了
  if (btr_cur_optimistic_delete(btr_cur, 0, &mtr)) {
    err = DB_SUCCESS;
    goto func_exit;
  }
  ...
  // 若何乐不雅增除了失落败，再入止伤心增除了
  btr_cur_pessimistic_delete(&err, false, btr_cur, 0, true, node->trx->id,
                             node->undo_no, node->rec_type, &mtr, &node->pcur,
                             nullptr);
}

// storage/innobase/row/row0undo.cc
void row_convert_impl_to_expl_if_needed(btr_cur_t *cursor, undo_node_t *node) {
  ...
  // 餍足下列 3 种前提之一，没有须要把显式锁转换为隐式锁：
  // 1. !node->partial = true，即 node->partial = false
  //    暗示零个事务归滚
  // 两. node->trx == nullptr
  // 3. node->trx->isolation_level < trx_t::REPEATABLE_READ
  //    事务隔离级别为：读已提交（RU）、读未提交（RC）
  if (!node->partial || (node->trx == nullptr) ||
      node->trx->isolation_level < trx_t::REPEATABLE_READ) {
    return;
  }
  ...
  // 餍足下列 4 种前提，须要把显式锁转换隐式锁：
  // 1. heap_no 对于应的记载没有是 supremum
  // 二. 当前索引没有是空间索引
  // 3. 没有是用户权且表
  // 4. 没有是 MySQL 外部姑且表
  if (/* 1 */ heap_no != PAGE_HEAP_NO_SUPREMUM && 
      /* 两 */ !dict_index_is_spatial(index) &&
      /* 3 */ !index->table->is_temporary() && 
      /* 4 */ !index->table->is_intrinsic()) {
    lock_rec_convert_impl_to_expl(block, rec, index,
                                  Rec_offsets().compute(rec, index));
  }
}

// storage/innobase/lock/lock0lock.cc
void lock_rec_convert_impl_to_expl(...) {
  trx_t *trx;
  ...
  // 主键索引
  if (index->is_clustered()) {
    trx_id_t trx_id;
    // 猎取 rec 纪录外 DB_TRX_ID 字段的值
    // 拿到拔出 rec 记实的事务 ID
    trx_id = lock_clust_rec_some_has_impl(rec, index, offsets);
    // 鉴定事务可否处于生动形态
    // 怎么事务是生动形态，返归事务的 trx_t 器材
    // 如何事务未提交，返归 nullptr
    trx = trx_rw_is_active(trx_id, true);
  } else { // 2级索引
    ...
  }

  if (trx != nullptr) {
    ulint heap_no = page_rec_get_heap_no(rec);
    ...
    // 如何事务是活泼形态
    // 把 rec 记载上的显式锁转换为隐式锁
    lock_rec_convert_impl_to_expl_for_trx(block, rec, index, offsets, trx,
                                          heap_no);
  }
}

// storage/innobase/lock/lock0lock.cc
static void lock_rec_convert_impl_to_expl_for_trx(...)
{
  ...
  {
    locksys::Shard_latch_guard guard{UT_LOCATION_HERE, block->get_page_id()};
    ...
    trx_mutex_enter(trx);
    ...
    // 判定事务的状况没有是 TRX_STATE_COMMITTED_IN_MEMORY
    if (!trx_state_eq(trx, TRX_STATE_COMMITTED_IN_MEMORY) &&
        // heap_no 对于应记载上不隐式的排他锁
        !lock_rec_has_expl(LOCK_X | LOCK_REC_NOT_GAP, block, heap_no, trx)) {
      ulint type_mode;
      // 添锁粒度：纪录（LOCK_REC）
      // 添锁模式：写锁（LOCK_X）
      // 添锁的大略模式：记载（LOCK_REC_NOT_GAP）
      type_mode = (LOCK_REC | LOCK_X | LOCK_REC_NOT_GAP);
      lock_rec_add_to_queue(type_mode, block, heap_no, index, trx, true);
    }
    trx_mutex_exit(trx);
  }
  trx_release_reference(trx);
  ...
}

// storage/innobase/lock/lock0lock.cc
void lock_update_delete(const buf_block_t *block, const rec_t *rec) {
  ...
  if (page_is_comp(page)) {
    // 猎取行将被增除了的纪录的编号
    heap_no = rec_get_heap_no_new(rec);
    // 猎取行将被增除了记实的高一笔记录的编号
    next_heap_no = rec_get_heap_no_new(page + rec_get_next_offs(rec, true));
  } else {
    ...
  }
  ...
  /* Let the next record inherit the locks from rec, in gap mode */
  // 把行将被增除了记实上的锁转移到它的高一笔记录上
  lock_rec_inherit_to_gap(block, block, next_heap_no, heap_no);
  ...
}

// storage/innobase/lock/lock0lock.cc
static void lock_rec_inherit_to_gap(...)
{
  lock_t *lock;
  ...
  // heap_no 是主键索引外行将被增除了的记实编号
  for (lock = lock_rec_get_first(lock_sys->rec_hash, block, heap_no);
       lock != nullptr; lock = lock_rec_get_next(heap_no, lock)) {
    /* Skip inheriting lock if set */
    if (lock->trx->skip_lock_inheritance) {
      continue;
    }

    if (!lock_rec_get_insert_intention(lock) &&
        !lock->index->table->skip_gap_locks() &&
        (!lock->trx->skip_gap_locks() || lock->trx->lock.inherit_all.load())) {
      lock_rec_add_to_queue(LOCK_REC | LOCK_GAP | lock_get_mode(lock),
                            heir_block, heir_heap_no, lock->index, lock->trx);
    }
  }
}

// storage/innobase/lock/lock0lock.cc
static void lock_rec_add_to_queue(ulint type_mode, ...) {
  ...
  // 对于 supremum 伪记载入止非凡处置
  if (heap_no == PAGE_HEAP_NO_SUPREMUM) {
    ...
    // 往失落 LOCK_GAP、LOCK_REC_NOT_GAP
    type_mode &= ~(LOCK_GAP | LOCK_REC_NOT_GAP);
  }
  ...
  // 真例化锁器械
  RecLock rec_lock(index, block, heap_no, type_mode);
  ...
  // 把锁工具参与齐局锁器械 hash 表
  rec_lock.create(trx);
  ...
}