慢查询日志中的 Lock_Time 从哪里来？

if (lock_type == F_RDLCK) {
  ...
  // 奈何当前表是数据字典表
  // 或者者被标识为没有须要添锁（no_read_locking = true)
  // 设施添锁范例为 LOCK_NONE
  if (m_prebuilt->table->is_dd_table || m_prebuilt->no_read_locking) {
    m_prebuilt->select_lock_type = LOCK_NONE;
    m_stored_select_lock_type = LOCK_NONE;
  // 怎么事务隔离级别是否串止化
  } else if (trx->isolation_level == TRX_ISO_SERIALIZABLE &&
    // 而且当前 SQL 尚无确定添锁范例
    m_prebuilt->select_lock_type == LOCK_NONE &&
    // 而且当前事务须要脚动提交
    thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) {
    // 装置添锁范例为同享锁
    m_prebuilt->select_lock_type = LOCK_S;
    m_stored_select_lock_type = LOCK_S;
  } else {
    // Retain value set earlier for example via store_lock()
    // which is LOCK_S or LOCK_NONE
    ut_ad(m_prebuilt->select_lock_type == LOCK_S ||
          m_prebuilt->select_lock_type == LOCK_NONE);
  }
}

lock_type 即是 F_RDLCK，表现 server 层要供添读锁，对于应到 InnoDB 的锁范例，即是同享锁，分二种环境设施 InnoDB 的添锁范例：

• 对于于 ACL 表，m_prebuilt->no_read_locking 会被装置为 true，默示读与记实时没有添锁。
• 奈何事务隔离级别是否串止化，而且当前事务须要脚动执止 COMMIT 语句提交，和尚无确定读与该表记载时添甚么范例的止锁，设施 InnoDB 添锁范例为同享锁。

ACL 表用于拜访权限节制，蕴含如高那些表：

• user
• db
• tables_priv
• columns_priv
• procs_priv
• proxies_priv
• role_edges
• default_roles
• global_grants
• password_history

switch (m_prebuilt->table->quiesce) {
  case QUIESCE_START:
    /* Check for FLUSH TABLE t WITH READ LOCK; */
    if (!srv_read_only_mode && sql_co妹妹and == SQLCOM_FLUSH &&
        lock_type == F_RDLCK) {
      ...
      row_quiesce_table_start(m_prebuilt->table, trx);
      ...
    }
    break;
  ...
}

// storage/innobase/lock/lock0wait.cc
void lock_wait_suspend_thread(que_thr_t *thr) {
  srv_slot_t *slot;
  trx_t *trx;
  // 声亮变质，用于留存止锁期待的入手下手光阴
  std::chrono::steady_clock::time_point start_time;
  ...
  if (thr->lock_state == QUE_THR_LOCK_ROW) {
    srv_stats.n_lock_wait_count.inc();
    srv_stats.n_lock_wait_current_count.inc();
    // 配备止锁等候的入手下手功夫
    start_time = std::chrono::steady_clock::now();
  }
  ...
  // 等候止锁
  os_event_wait(slot->event);
  ...
  // 运转到那面，有2种环境：
  // 1. 锁等候超时
  // 二. 曾经猎取到止锁
  if (thr->lock_state == QUE_THR_LOCK_ROW) {
    // 用当前光阴减往止锁等候的入手下手光阴
    // 等于一笔记录的止锁等候光阴
    const auto diff_time = std::chrono::steady_clock::now() - start_time;
    ...
    /* Record the lock wait time for this thread */
    // 乏添线程的止锁守候工夫
    // 生存到 mysql_thd 线程外
    // mysql_thd 是 server 层的线程
    thd_set_lock_wait_time(trx->mysql_thd, diff_time);
    ...
  }
  ...
}

// storage/innobase/handler/ha_innodb.cc
void thd_set_lock_wait_time(THD *thd,
                            std::chrono::steady_clock::duration value) {
  if (thd) {
    thd_storage_lock_wait(
        thd,
        std::chrono::duration_cast<std::chrono::microseconds>(value).count());
  }
}

// sql/sql_thd_api.cc
void thd_storage_lock_wait(MYSQL_THD thd, long long value) {
  thd->inc_lock_usec(value);
}

// sql/sql_class.cc
void THD::inc_lock_usec(ulonglong lock_usec) {
  m_lock_usec += lock_usec;
  MYSQL_SET_STATEMENT_LOCK_TIME(m_statement_psi, m_lock_usec);
}

// sql/log.cc
bool Query_logger::slow_log_write(THD *thd, const char *query,
                                  size_t query_length, bool aggregate,
                                  ulonglong lock_usec, ulonglong exec_usec) {
  ...
  if (aggregate) {
    query_utime = exec_usec;
    lock_utime = lock_usec;
  } else if (thd->start_utime) {
    query_utime = (current_utime - thd->start_utime);
    lock_utime = thd->get_lock_usec();
  } else {
    query_utime = 0;
    lock_utime = 0;
  }
  ...
  bool error = false;
  for (Log_event_handler **current_handler = slow_log_handler_list;
       *current_handler;) {
    error |= (*current_handler++)->log_slow(
               thd, current_utime,
               (thd->start_time.tv_sec * 1000000ULL) +
               thd->start_time.tv_usec,
               user_host_buff, user_host_len, query_utime,
               lock_utime, is_co妹妹and, query, query_length);
  }
  ...
}

// sql/log.cc
bool Log_to_file_event_handler::log_slow(
    THD *thd, ulonglong current_utime, ulonglong query_start_utime,
    const char *user_host, size_t user_host_len, ulonglong query_utime,
    ulonglong lock_utime, bool is_co妹妹and, const char *sql_text,
    size_t sql_text_len) {
  if (!mysql_slow_log.is_open()) return false;

  Silence_log_table_errors error_handler;
  thd->push_internal_handler(&error_handler);
  bool retval = mysql_slow_log.write_slow(
      thd, current_utime, query_start_utime, user_host, user_host_len,
      query_utime, lock_utime, is_co妹妹and, sql_text, sql_text_len);
  thd->pop_internal_handler();
  return retval;
}

// sql/log.cc
bool File_query_log::write_slow(...) {
  ...
  if (!thd->copy_status_var_ptr) {
    if (my_b_printf(&log_file,
        "# Query_time: %s  Lock_time: %s"
        " Rows_sent: %lu  Rows_examined: %lu\n",
        query_time_buff, lock_time_buff,
        (ulong)thd->get_sent_row_count(),
        (ulong)thd->get_examined_row_count()) == (uint)-1)
      goto err; /* purecov: inspected */
  }
  ...
}

Query_time: %s  Lock_time: %s
Rows_sent: %lu  Rows_examined: %lu