Function binlog_flush_cache

sql/log.cc:2112–2239

 */

static int
binlog_flush_cache(THD *thd, binlog_cache_mngr *cache_mngr,
                   Log_event *end_ev, bool all, bool using_stmt,
                   bool using_trx, bool is_ro_1pc= false)
{
  int error= 0;
  DBUG_ENTER("binlog_flush_cache");
  DBUG_PRINT("enter", ("end_ev: %p", end_ev));

  bool doing_stmt= using_stmt && !cache_mngr->stmt_cache.empty();
  bool doing_trx= using_trx && !cache_mngr->trx_cache.empty();
  if (doing_stmt || doing_trx || thd->transaction->xid_state.is_explicit_XA())
  {
    /*
      thd->binlog_flush_pending_rows_event() ensures that the pending row event
      is flushed into the respective IO cache. We also need to make sure that
      the IO cache is consistent where its data is stored, i.e. it should
      either be entirely in-memory or backed by a temporary file. So if
      necessary (i.e if the cache data exceeds its binlog_cache_size), flush
      the IO cache to its tmp file on disk.

      Technically, this reconciliation would happen automatically when writing
      the cache data to the actual binlog file. We pre-empt it though because:
        1) we write the GTID event separately to the binlog directly before
           moving the cache data, and if the reconciliation fails (e.g. if the
           directory storing the tmp file is full), the binlog would get
           corrupted with a standalone GTID event
        2) that happens during group commit with locks held, and other
           ready-to-commit (concurrent) transactions could be stalled
    */
    if (using_stmt && !thd->binlog_flush_pending_rows_event(TRUE, FALSE) &&
        flush_write_buffer_if_file_backed(
            cache_mngr->get_binlog_cache_log(FALSE)))
      DBUG_RETURN(1);

    /*
      See statment cache comment above.
    */
    if (using_trx && !thd->binlog_flush_pending_rows_event(TRUE, TRUE) &&
        flush_write_buffer_if_file_backed(
            cache_mngr->get_binlog_cache_log(TRUE)))
      DBUG_RETURN(1);

#ifdef WITH_WSREP
    /* Wsrep transaction was BF aborted but it must replay because certification
       succeeded. The transaction must not be written into binlog yet, it will
       be done during commit after the replay. */
    if (WSREP(thd) && wsrep_must_replay(thd))
    {
      DBUG_RETURN(0);
    }
#endif /* WITH_WSREP */

    if (opt_binlog_engine_hton &&
        likely(!(thd->lex->sql_command == SQLCOM_XA_COMMIT &&
                 thd->lex->xa_opt != XA_ONE_PHASE)))
    {
      /*