数据库内核月报 － 2021 / 01

//协调者选择的逻辑
if (total_ha_2pc > 1 || (1 == total_ha_2pc && opt_bin_log))
{
  if (opt_bin_log)
    tc_log= &mysql_bin_log;
  else
    tc_log= &tc_log_mmap;
}
else
  tc_log= &tc_log_dummy

//binlog,tc_log_mmap和tc_log_dummy作为协调者的基本逻辑
binlog作为协调者：
prepare：ha_prepare_low
commit： write-binlog + ha_comit_low

tclog作为协调者：
prepare：ha_prepare_low
commit：wrtie-xid + ha_commit_low

tc_dummy作为协调者：
prepare：ha_prepare_low
commit：ha_commit_low 

//是否支持2PC，是否修改超过了1个以上的引擎
if (!trn_ctx->no_2pc(trx_scope) && (trn_ctx->rw_ha_count(trx_scope) > 1))
  error = tc_log->prepare(thd, all);

 struct THD_TRANS {                                         
   /* true is not all entries in the ht[] support 2pc */    
   bool m_no_2pc;    
   
   /* number of engine modify */
   int m_rw_ha_count; 
   
   /* storage engines that registered in this transaction */
   Ha_trx_info *m_ha_list;
 } 
 
//统计打标，是否涉及到多个引擎的修改。
ha_check_and_coalesce_trx_read_only(bool all) {
  //统计打标
  for (ha_info = ha_list; ha_info; ha_info = ha_info->next()) {
    if (ha_info->is_trx_read_write()) ++rw_ha_count;
    
    //语句级统计
    if (!all) {
      Ha_trx_info *ha_info_all =
          &thd->get_ha_data(ha_info->ht()->slot)->ha_info[1];
      DBUG_ASSERT(ha_info != ha_info_all);
      
      /*   
        Merge read-only/read-write information about statement
        transaction to its enclosing normal transaction. Do this
        only if in a real transaction -- that is, if we know
        that ha_info_all is registered in thd->transaction.all.
        Since otherwise we only clutter the normal transaction flags.
      */
      //将语句级的读写修改，同步到事务级的读写修改
      if (ha_info_all->is_started()) /* false if autocommit. */
        ha_info_all->coalesce_trx_with(ha_info);
    } else if (rw_ha_count > 1) { 
      /*   
        It is a normal transaction, so we don't need to merge read/write
        information up, and the need for two-phase commit has been
        already established. Break the loop prematurely.
      */
      break;
    }    
  }   
}

prepare逻辑：
ha_prepare(bool prepare_tx) 这里的prepare_tx由外面传递的all=true/false决定。
if (prepare_tx || (!my_core::thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) {
  tx->prepare
}

commit逻辑：
ha_commit(bool commit_tx) 这里的commit_tx由外面传递的all=true/false决定。
if (commit_tx || (!my_core::thd_test_options(thd, OPTION_NOT_AUTOCOMMIT |  OPTION_BEGIN))) {
  tx->commit
}

innobase_hton->commit = innobase_commit;
innobase_hton->rollback = innobase_rollback;
innobase_hton->prepare = innobase_xa_prepare;
innobase_hton->recover = innobase_xa_recover;
innobase_hton->commit_by_xid = innobase_commit_by_xid;
innobase_hton->rollback_by_xid = innobase_rollback_by_xid;

mysql_lock_tables
 lock_external
   handler::ha_external_lock
     ha_innobase::external_lock
       innobase_register_trx
         trans_register_ha
           Transaction_ctx::set_ha_trx_info

void xengine_register_tx(handlerton *const hton, THD *const thd,
                                       Xdb_transaction *const tx) {
  DBUG_ASSERT(tx != nullptr);
  //注册stmt的trx信息
  trans_register_ha(thd, FALSE, xengine_hton, NULL);
  
  //显示开启的事务，ddl默认将AUTOCOMMIT关掉，符合条件
  if (my_core::thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) {
    tx->start_stmt();
    trans_register_ha(thd, TRUE, xengine_hton, NULL);
  }
}

handler::ha_delete_row
handler::ha_write_row
handler::ha_update_row
   handler::mark_trx_read_write

/**
  A helper function to mark a transaction read-write,
  if it is started.
*/

void handler::mark_trx_read_write() {
  Ha_trx_info *ha_info = &ha_thd()->get_ha_data(ht->slot)->ha_info[0];
  /*
    When a storage engine method is called, the transaction must
    have been started, unless it's a DDL call, for which the
    storage engine starts the transaction internally, and commits
    it internally, without registering in the ha_list.
    Unfortunately here we can't know know for sure if the engine
    has registered the transaction or not, so we must check.
  */
  if (ha_info->is_started()) {
    DBUG_ASSERT(has_transactions());
    /*
      table_share can be NULL in ha_delete_table(). See implementation
      of standalone function ha_delete_table() in sql_base.cc.
    */
    if (table_share == NULL || table_share->tmp_table == NO_TMP_TABLE) {
      /* TempTable and Heap tables don't use/support transactions. */
      ha_info->set_trx_read_write();
    }
  }
}

/**
  Check if statement (typically DDL) needs auto-commit mode temporarily
  turned off.

  @note This is necessary to prevent InnoDB from automatically committing
        InnoDB transaction each time data-dictionary tables are closed
        after being updated.
*/
static bool sqlcom_needs_autocommit_off(const LEX *lex) {
  return (sql_command_flags[lex->sql_command] & CF_NEEDS_AUTOCOMMIT_OFF) ||
         (lex->sql_command == SQLCOM_CREATE_TABLE &&
          !(lex->create_info->options & HA_LEX_CREATE_TMP_TABLE)) ||
         (lex->sql_command == SQLCOM_DROP_TABLE && !lex->drop_temporary);
}

/*
  For statements which need this, prevent InnoDB from automatically
  committing InnoDB transaction each time data-dictionary tables are
  closed after being updated.
*/
Disable_autocommit_guard(THD *thd) {
  m_thd->variables.option_bits &= ~OPTION_AUTOCOMMIT;
  m_thd->variables.option_bits |= OPTION_NOT_AUTOCOMMIT;
}