WITH REPEATABLE READ

Problem and Analysis
--------------------

    Because of the use of MTS and/or XA transactions, the order statements
    from distinct transactions were originally applied on the master may not
    be the same order they are applied on the slave.

    On those cases, using RBR with a transaction isolation level other than
    READ COMMITTED might might lead to blocking conditions that didn't
    happened on the original workload (see BUG#25082593).

Fix
---

    We are now using a flag on the [Anonymous_gtid|Gtid]_log_event stating
    if the transaction might have changes logged with statements.

    When this flag is set (default for non-fixed servers) the slave will not
    change the applier thread transaction isolation level.

    When the flag is not set, the applier will set the transaction isolation
    level of the current transaction to READ COMMITTED if necessary (it will
    not change it when the applier session isolation level be equal or less
    restrictive than READ COMMITTED).

    In this way, we are forcing that all transactions replicated using row
    based replication will always use the READ COMMITTED transaction
    isolation level on the slave side, regardless of any server transaction
    isolation level configuration.

    The fix also restored the applier session transaction isolation level
    after applying a Xid_log_event (after committing a replicated
    transaction), a XA_prepare_log_event (after preparing a replicated
    transaction) and in the cases of aborted/failed transactions.

    The mysqlbinlog dump of a transaction flagged as "rbr_only" will also
    include a "SET TRANSACTION ISOLATION LEVEL" statement when dumping the
    GTID event.

Changed files:

    @ libbinlogevents/include/control_events.h

      We gave a meaning to the already logged flag information.

    @ libbinlogevents/src/control_events.cpp

      Processed the GTID flags, collecting the "might_have_sbr_stmts" info.

    @ plugin/replication_observers_example/replication_observers_example.cc
    @ rapid/plugin/group_replication/src/observer_trans.cc
    @ rapid/plugin/group_replication/src/handlers/certification_handler.cc

      Fixed calls to GTID constructor.

    @ sql/binlog.cc

      Created a new flag at "binlog_cache_data" named "with_sbr" that is
      set true when the cache is fed with non-terminal query event.

      Created a new flag at "binlog_cache_data" named "with_rbr" that is
      set true when the cache is fed with Table_map or Rows event.

      Created also the "might_have_sbr_stmts" function, that returns false
      for "pure RBR" transactions. This new function was implemented for
      the "binlog_cache_data".

      Added the logic to reset and set the new flags at
      "binlog_cache_data::reset" and "binlog_cache_data::write_event", and
      also to preserve the flags upon "SAVEPOINT/ROLLBACK TO SAVEPOINT".

      Made "MYSQL_BIN_LOG::write_gtid" to consider the cache information
      about the binary log content when creating the Gtid_log_event.

    @ sql/log_event.h

      Updated "Query_log_event::is_trans_keyword()" to recognize XA
      transactions terminal keywords that should not be considered as
      statements changing content.

      Created a new function "Log_event::is_sbr_logging_format()" that
      will return true if the event was/has to be logged using SBR and
      does not contains a transaction control statement.

      Created a new function "Log_event::is_rbr_logging_format()" that
      will return true if the event was/has to be logged using RBR.

    @ sql/log_event.cc

      We will stop the applier with an error when we assumed the
      transaction as "rbr_only" and some statement changing content be
      applied.

      Restored the applier session transaction isolation level
      after applying a Xid_log_event (after committing a replicated
      transaction), a XA_prepare_log_event (after preparing a replicated
      transaction) and in the cases of aborted/failed transactions.

      "Gtid_log_event::print" will now also print "rbr_only=[yes|no]" when
      dumping a Gtid_log_event with mysqlbinlog. It will also include a
      "SET TRANSACTION ISOLATION LEVEL READ COMMITTED" statement when
      dumping the GTID event with "rbr_only=yes".

      "Gtid_log_event::write_post_header_to_memory" now computes the GTID
      flags field instead of just writing "1" to it.

      "Gtid_log_event::do_apply_event" now set the transaction isolation
      level to READ COMMITTED when the "might_have_sbr_stmts" flag be false.
      Note that we don't change the isolation level for skipped GTID and
      when the isolation level be less restrictive than READ COMMITTED.