InnoDB行锁兼容性矩阵

lock_rec_other_has_conflicting(unsigned long, buf_block_t const*, unsigned long, trx_t const*)
{
    /*检测要加锁的索引是否为supremum*/
    bool    is_supremum = (heap_no == PAGE_HEAP_NO_SUPREMUM); 
    /*从锁hash表中去查看对应到此索引记录的锁*/
    for (lock = lock_rec_get_first(lock_sys->rec_hash, block, heap_no);lock != NULL;lock = lock_rec_get_next_const(heap_no, lock)) 
    {
        /*检测检索到的锁结构与此事务要添加的锁是否冲突*/
       if (lock_rec_has_to_wait(trx, mode, lock, is_supremum)) 
       {
           return(lock);
      }     
   }    
}

UNIV_INLINE
ibool
lock_rec_has_to_wait(
/*=================*/
   const trx_t*   trx,   /*当前事务结构*/
   ulint     type_mode,/*将要添加的锁的精确模式，不仅包含了索引的类型，还有具体的范围，比如LOCK_S或者LOCK_X，以及LOCK_GAP或者是LOCK_REC_NOT_GAP，LOCK_INSERT_INTENTION*/
   const lock_t*  lock2, /*上层函数中寻找到的锁结构*/
   bool      lock_is_on_supremum)/*此事务当前要加锁的索引记录是否为supremum*/
{
   /*首先要判断这两个锁对象是否属于同一个事务，如果属于同一个事务，则不冲突；否则需要进行锁兼容性矩阵的初步检测*/ 
   if (trx != lock2->trx
       && !lock_mode_compatible(static_cast<lock_mode>(
                      LOCK_MODE_MASK & type_mode),
                 lock_get_mode(lock2))) {
      /*在锁兼容性矩阵显示不冲突的情况下，则不冲突，否则还需要进行如下判断*/  
      if ((lock_is_on_supremum || (type_mode & LOCK_GAP))
          && !(type_mode & LOCK_INSERT_INTENTION)) {


         /* Gap type locks without LOCK_INSERT_INTENTION flag
         do not need to wait for anything. This is because
         different users can have conflicting lock types
         on gaps. */


         return(FALSE);
      }


      if (!(type_mode & LOCK_INSERT_INTENTION)
          && lock_rec_get_gap(lock2)) {


         /* Record lock (LOCK_ORDINARY or LOCK_REC_NOT_GAP
         does not need to wait for a gap type lock */


         return(FALSE);
      }


      if ((type_mode & LOCK_GAP)
          && lock_rec_get_rec_not_gap(lock2)) {


         /* Lock on gap does not need to wait for
         a LOCK_REC_NOT_GAP type lock */


         return(FALSE);
      }
      if (lock_rec_get_insert_intention(lock2)) {
         return(FALSE);
      }


      return(TRUE);
   }


   return(FALSE);
}

UNIV_INLINE
ulint
lock_mode_compatible(
/*=================*/
   enum lock_mode mode1, *!< in: lock mode */
   enum lock_mode mode2) *!< in: lock mode */
{
   return(lock_compatibility_matrix[mode1][mode2]);
}

static const byte lock_compatibility_matrix[5][5] = {
 /**            IS         IX            S          X           AI */
 /* IS */ {  TRUE,  TRUE,  TRUE,  FALSE,  TRUE},
 /* IX */ {  TRUE,  TRUE,  FALSE, FALSE,  TRUE},
 /* S  */ {  TRUE,  FALSE, TRUE,  FALSE,  FALSE},
 /* X  */ {  FALSE, FALSE, FALSE, FALSE,  FALSE},
 /* AI */ {  TRUE,  TRUE,  FALSE, FALSE,  FALSE}
};