Major changes in the replication environment and in the behavior of applications can result from using row-based logging (RBL) or row-based replication (RBR) rather than statement-based logging or replication. This section describes a number of issues known to exist when using row-based logging or replication, and discusses some best practices for taking advantage of row-based logging and replication.
For additional information, see Section 17.1.2, “Replication Formats”, and Section 184.108.40.206, “Advantages and Disadvantages of Statement-Based and Row-Based Replication”.
For information about issues specific to NDB Cluster Replication (which depends on row-based replication), see Section 18.6.3, “Known Issues in NDB Cluster Replication”.
RBL, RBR, and temporary tables. As noted in Section 220.127.116.11, “Replication and Temporary Tables”, temporary tables are not replicated when using row-based format. When mixed format is in effect, “safe” statements involving temporary tables are logged using statement-based format. For more information, see Section 18.104.22.168, “Advantages and Disadvantages of Statement-Based and Row-Based Replication”.
Temporary tables are not replicated when using row-based format because there is no need. In addition, because temporary tables can be read only from the thread which created them, there is seldom if ever any benefit obtained from replicating them, even when using statement-based format.
Beginning with MySQL 5.5.5, you can switch from statement-based to row-based binary logging mode even when temporary tables have been created. However, while using the row-based format, the MySQL server cannot determine the logging mode that was in effect when a given temporary table was created. For this reason, the server in such cases logs a
DROP TEMPORARY TABLE IF EXISTSstatement for each temporary table that still exists for a given client session when that session ends. (Bug #11760229, Bug #11762267) While this means that it is possible that an unnecessary
DROP TEMPORARY TABLEstatement might be logged in some cases, the statement is harmless, and does not cause an error even if the table does not exist, due to the presence of the
RBL and synchronization of nontransactional tables. When many rows are affected, the set of changes is split into several events; when the statement commits, all of these events are written to the binary log. When executing on the slave, a table lock is taken on all tables involved, and then the rows are applied in batch mode. (This may or may not be effective, depending on the engine used for the slave's copy of the table.)
Latency and binary log size. Because RBL writes changes for each row to the binary log, its size can increase quite rapidly. In a replication environment, this can significantly increase the time required to make changes on the slave that match those on the master. You should be aware of the potential for this delay in your applications.
Reading the binary log. mysqlbinlog displays row-based events in the binary log using the
BINLOGstatement (see Section 22.214.171.124, “BINLOG Syntax”). This statement displays an event in printable form, but as a base 64-encoded string the meaning of which is not evident. When invoked with the
--verboseoptions, mysqlbinlog formats the contents of the binary log in a manner that is easily human readable. This is helpful when binary log events were written in row-based format if you want to read or recover from a replication or database failure using the contents of the binary log. For more information, see Section 126.96.36.199, “mysqlbinlog Row Event Display”.
Binary log execution errors and slave_exec_mode. If
IDEMPOTENT, a failure to apply changes from RBL because the original row cannot be found does not trigger an error or cause replication to fail. This means that it is possible that updates are not applied on the slave, so that the master and slave are no longer synchronized. Latency issues and use of nontransactional tables with RBR when
IDEMPOTENTcan cause the master and slave to diverge even further. For more information about
slave_exec_mode, see Section 5.1.7, “Server System Variables”.Note
slave_exec_mode=IDEMPOTENTis generally useful only for circular replication or multi-master replication with NDB Cluster, for which
IDEMPOTENTis the default value (see Section 18.6, “NDB Cluster Replication”).
Lack of binary log checksums. RBL uses no checksums. This means that network, disk, and other errors may not be identified when processing the binary log. To ensure that data is transmitted without network corruption, you may want to consider using SSL, which adds another layer of checksumming, for replication connections. The
CHANGE MASTER TOstatement has options to enable replication over SSL. See also Section 188.8.131.52, “CHANGE MASTER TO Syntax”, for general information about setting up MySQL with SSL.
This is not an issue in MySQL 5.6 and later, which support checksums for the binary log; see Checksum options.
Filtering based on server ID not supported. A common practice is to filter out changes on some slaves by using a
WHEREclause that includes the relation
@@server_id <>clause with
DELETEstatements, a simple example of such a clause being
WHERE @@server_id <> 1. However, this does not work correctly with row-based logging. If you must use the
server_idsystem variable for statement filtering, you must also use
In MySQL 5.5, you can do filtering based on server ID by using the
IGNORE_SERVER_IDSoption for the
CHANGE MASTER TOstatement. This option works with the statement-based and row-based logging formats.
Database-level replication options. The effects of the
--replicate-rewrite-dboptions differ considerably depending on whether row-based or statement-based logging is used. Because of this, it is recommended to avoid database-level options and instead use table-level options such as
--replicate-ignore-table. For more information about these options and the impact that your choice of replication format has on how they operate, see Section 17.1.3, “Replication and Binary Logging Options and Variables”.
RBL, nontransactional tables, and stopped slaves. When using row-based logging, if the slave server is stopped while a slave thread is updating a nontransactional table, the slave database may reaches an inconsistent state. For this reason, it is recommended that you use a transactional storage engine such as
InnoDBfor all tables replicated using the row-based format.
STOP SLAVE SQL_THREADin MySQL 5.5.9 and later) prior to shutting down the slave MySQL server helps prevent such issues from occurring, and is always recommended regardless of the logging format or storage engines employed.