| List: | Commits | « Previous MessageNext Message » | |
| From: | rsomla | Date: | July 3 2007 6:04pm |
| Subject: | bk commit into 5.1 tree (rafal:1.2530) BUG#21842 | ||
| View as plain text | |||
Below is the list of changes that have just been committed into a local 5.1 repository of rafal. When rafal does a push these changes will be propagated to the main repository and, within 24 hours after the push, to the public repository. For information on how to access the public repository see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html ChangeSet@stripped, 2007-07-03 18:04:21+02:00, rafal@quant.(none) +6 -0 BUG#21842 (Cluster fails to replicate to innodb or myisam with err 134 using TPC-B): This is a preliminary patch in preparation for the bug fix. The main change is to make unpack_row() function non-destructive. That is, if a column is not present in the row it will be left as it is in the record to which we unpack (table->record[0]). If a caller of unpack_row() wants the missing columns to be initialized with default values, it must do it itself. Function prepare_record() is added for that purpose. Other changes in this changeset: - Change signature of unpack_row(): don't report errors and don't setup table's rw_set here. Errors are detected and reported when setting default values in prepare_record(). - In Rows_log_event and derived classes, don't pass arguments to the execution primitives (do_...() member functions) but use class members instead. - Factor-out code used for opening tables in a Rows event to a separate method open_and_lock_tables(). - The changes seems to fix rpl_ndb_extraCol test. Before it produced results different than the same test run on other storage engines. Now the results are identical. The result file is updated accordingly. mysql-test/r/rpl_ndb_extraCol.result@stripped, 2007-07-03 18:04:06+02:00, rafal@quant.(none) +27 -27 Correct results. Now the results of the NDB test are the same as for other engines. sql/log_event.cc@stripped, 2007-07-03 18:04:06+02:00, rafal@quant.(none) +308 -233 - Initialization of new Rows_log_event members. - Move table opening and locking code from Rows_log_event::do_apply_event() to a new open_and_lock_tables() method. - Change signatures of row processing methods of Rows_log_event and it descendants - now most arguments are taken from class members. - Use prepare_record() function to initialize each record with default values. - Move initialization of tables write/read sets outside the rows processing loop (and out of unpack_row() function). - Changes in documentation. sql/log_event.h@stripped, 2007-07-03 18:04:06+02:00, rafal@quant.(none) +39 -29 - Add Rows_log_event members describing the row being processed. - Add open_and_lock_tables() method. - Change signatures of do_...() methods (replace method arguments by class members). - Update method documentation. sql/log_event.h.orig@stripped, 2007-07-03 12:44:46+02:00, rafal@quant.(none) +0 -0 bk cp log_event.h log_event.h.orig sql/log_event.h.orig@stripped, 2007-06-05 01:15:00+02:00, lars@stripped +0 -0 Auto merged MERGE: 1.149.1.2 sql/log_event.h.orig@stripped, 2007-06-01 11:43:52+04:00, kostja@bodhi.(none) +0 -0 Auto merged MERGE: 1.149.1.1 sql/log_event.h.orig@stripped, 2007-05-31 20:06:04+02:00, mats@stripped +0 -0 Auto merged MERGE: 1.149.2.1 sql/log_event.h.orig@stripped, 2007-05-31 20:01:03+02:00, mats@stripped +2 -0 Adding functions Table_map_log_event::do_shall_skip() and Rows_log_event::do_shall_skip(). sql/log_event.h.orig@stripped, 2007-05-28 23:15:38+03:00, aelkin@stripped +0 -0 Auto merged MERGE: 1.122.1.13 sql/log_event.h.orig@stripped, 2007-05-28 22:20:19+03:00, aelkin@stripped +2 -1 default arg to the constructor with meaning of killed status of the query. if the arg is not explicitly provided the status of thd->killed will be snapshot inside of the constuctor, which is potentially incorrect (see bug#27571) sql/log_event.h.orig@stripped, 2007-05-10 12:59:28+03:00, monty@stripped +35 -34 Removed some old types Changed some buffers to be uchar* to avoid casts sql/log_event.h.orig@stripped, 2007-04-13 19:19:07+02:00, mats@stripped +4 -4 Restoring time_t instead of my_time_t since it causes warnings elsewhere. Renaming parameters to functions since they hide member variable (which causes warnings on Sun CC). sql/log_event.h.orig@stripped, 2007-04-13 15:40:16+02:00, mats@romeo.(none) +1 -1 Changing time_t to my_time_t. sql/log_event.h.orig@stripped, 2007-04-13 08:54:55+02:00, mats@romeo.(none) +0 -0 Auto merged MERGE: 1.145.1.1 sql/log_event.h.orig@stripped, 2007-04-12 15:50:46+02:00, mats@romeo.(none) +4 -2 Refactoring to support inheritance and including "old" events definitions. sql/log_event.h.orig@stripped, 2007-04-12 08:57:59+02:00, mats@romeo.(none) +2 -0 Adding Rows_log_event::do_update_pos(). sql/log_event.h.orig@stripped, 2007-03-30 15:29:27+02:00, mats@romeo.(none) +1 -1 Renaming exec_event() to do_apply_event(). sql/log_event.h.orig@stripped, 2007-03-29 22:32:19+02:00, mats@romeo.(none) +1 -1 Event number change sql/log_event.h.orig@stripped, 2007-03-29 20:51:46+02:00, mats@romeo.(none) +0 -0 Auto merged MERGE: 1.136.10.1 sql/log_event.h.orig@stripped, 2007-03-29 20:31:04+02:00, mats@romeo.(none) +97 -1 Adding incident log event. sql/log_event.h.orig@stripped, 2007-03-27 12:17:48+02:00, mats@romeo.(none) +35 -12 Moving implementation of Rows_log_event::get_data_size() into .cc file. Adding Update_rows_log_event constructor accepting both before image and after image COLS vector. Adding Update_rows_log_vector destructor. Adding fields m_bitbuf_ai and m_cols_ai to Rows_log_event. Fixing is_valid() to look at m_cols_ai as well. sql/log_event.h.orig@stripped, 2007-03-26 09:02:31+02:00, mats@romeo.(none) +0 -0 Auto merged MERGE: 1.139.1.1 sql/log_event.h.orig@stripped, 2007-03-22 17:32:43+01:00, mats@romeo.(none) +0 -0 Auto merged MERGE: 1.136.1.14 sql/log_event.h.orig@stripped, 2007-03-22 17:32:32+01:00, guilhem@stripped +0 -0 Auto merged MERGE: 1.136.9.1 sql/log_event.h.orig@stripped, 2007-03-22 17:31:37+01:00, guilhem@stripped +8 -0 small inline function to group two operations: copying an IO_CACHE to a FILE, and reinitializing this IO_CACHE for being filled again. sql/log_event.h.orig@stripped, 2007-03-22 09:05:06+01:00, mats@romeo.(none) +1 -0 Manual merge MERGE: 1.136.1.13 sql/log_event.h.orig@stripped, 2007-03-22 08:32:37+01:00, mats@romeo.(none) +191 -75 Adding enumeration for skip reason. Factoring out exec_event() into exec_relay_log_event(). Making public interface to event execution primitives. Adding documentation. Making some (internal) functions const-correct. sql/log_event.h.orig@stripped, 2007-03-07 12:15:33+01:00, mats@romeo.(none) +0 -0 Auto merged MERGE: 1.136.8.2 sql/log_event.h.orig@stripped, 2007-03-01 16:04:45+04:00, bar@stripped +0 -0 Auto merged MERGE: 1.122.1.12 sql/log_event.h.orig@stripped, 2007-02-28 17:09:33+04:00, bar@stripped +0 -0 Auto merged MERGE: 1.122.5.2 sql/log_event.h.orig@stripped, 2007-02-28 17:06:54+04:00, bar@stripped +4 -1 Adding declarations sql/log_event.h.orig@stripped, 2007-02-25 00:15:34+01:00, lars@stripped +0 -0 Auto merged MERGE: 1.122.1.11 sql/log_event.h.orig@stripped, 2007-02-25 00:10:46+01:00, lars@stripped +0 -0 Auto merged MERGE: 1.122.5.1 sql/log_event.h.orig@stripped, 2007-02-24 11:43:11+01:00, lars@stripped +0 -0 Auto merged MERGE: 1.136.6.3 sql/log_event.h.orig@stripped, 2007-02-23 22:21:53+01:00, gbichot@stripped +9 -6 removing strcpy() (one less function call). If we write to IO_CACHE more than can fit into its memory buffer, it will try to overflow into a file; for that to work, IO_CACHE must be inited via open_cached_file(). open_cached_file(), like init_io_cache(), can fail; we make sure to catch this constructor's problem via the init_ok() method. sql/log_event.h.orig@stripped, 2007-02-23 14:59:42+01:00, mats@romeo.(none) +0 -0 Auto merged MERGE: 1.136.8.1 sql/log_event.h.orig@stripped, 2007-02-21 13:52:39+01:00, mats@romeo.(none) +0 -0 Merging with mysql-5.1-new-rpl MERGE: 1.136.7.1 sql/log_event.h.orig@stripped, 2007-02-15 16:02:45+01:00, guilhem@stripped +0 -0 Auto merged MERGE: 1.122.5.1 sql/log_event.h.orig@stripped, 2007-02-12 16:46:37+01:00, mats@romeo.(none) +16 -3 Renumbering old row events and adding new codes. sql/log_event.h.orig@stripped, 2007-02-08 15:53:12+01:00, guilhem@stripped +2 -0 new member to hold the "split server version" (3 numbers X.Y.Z), and a method to compute this from the version string. sql/log_event.h.orig@stripped, 2007-01-26 20:56:39+01:00, mats@romeo.(none) +0 -0 Auto merged MERGE: 1.136.5.1 sql/log_event.h.orig@stripped, 2007-01-26 19:29:50+01:00, mats@romeo.(none) +23 -8 Doxygenifying comments. Copying error codes to Rows_log_event hierarchy since they are now used there as well. sql/log_event.h.orig@stripped, 2007-01-24 19:56:59+02:00, monty@stripped +0 -2 Auto merged MERGE: 1.122.1.10 sql/log_event.h.orig@stripped, 2007-01-22 14:10:40+02:00, monty@stripped +0 -0 Auto merged MERGE: 1.122.3.2 sql/log_event.h.orig@stripped, 2007-01-22 13:02:37+02:00, monty@stripped +0 -0 Auto merged MERGE: 1.122.3.1 sql/log_event.h.orig@stripped, 2007-01-17 19:45:39+01:00, lars@stripped +0 -8 Auto merged MERGE: 1.122.1.8 sql/log_event.h.orig@stripped, 2007-01-12 12:24:33+01:00, lars@stripped +0 -0 Auto merged MERGE: 1.136.4.2 sql/log_event.h.orig@stripped, 2007-01-12 12:22:49+01:00, lars@stripped +0 -0 Auto merged MERGE: 1.122.4.2 sql/log_event.h.orig@stripped, 2007-01-10 13:44:36-05:00, Chuck@stripped +8 -1 BUG#22645 - LC_TIME_NAMES: Statement not replicated This patch adds a new type definition to the Log_event class. The new type is typedef unsigned char Byte. It is used in place of the uchar and usigned char definitions in the Query_log_event constructor to eliminate type conversion problems encountere on SUSE 64-bit. sql/log_event.h.orig@stripped, 2007-01-10 12:20:08-05:00, cbell@stripped +8 -1 This patch adds a new type definition to the Log_event class. The new type is typedef unsigned char Byte. It is used in place of the uchar and usigned char definitions in the Query_log_event constructor to eliminate type conversion problems encountere on SUSE 64-bit. sql/log_event.h.orig@stripped, 2007-01-09 17:06:50+01:00, jani@stripped +0 -0 Auto merged MERGE: 1.122.4.2 sql/log_event.h.orig@stripped, 2006-12-31 01:06:35+01:00, kent@kent-amd64.(none) +0 -0 Auto merged MERGE: 1.122.4.2 sql/log_event.h.orig@stripped, 2006-12-30 21:02:07+01:00, kent@stripped +1 -1 Removed "MySQL Finland AB & TCX DataKonsult AB" from copyright header Adjusted year(s) in copyright header sql/log_event.h.orig@stripped, 2006-12-23 20:19:51+01:00, kent@kent-amd64.(none) +0 -0 Auto merged MERGE: 1.122.4.1 sql/log_event.h.orig@stripped, 2006-12-23 20:04:25+01:00, kent@stripped +1 -2 Changed header to GPL version 2 only sql/log_event.h.orig@stripped, 2006-12-21 19:29:46+01:00, mats@romeo.(none) +0 -0 Auto merged MERGE: 1.136.3.1 sql/log_event.h.orig@stripped, 2006-12-21 09:28:56+01:00, mats@romeo.(none) +9 -3 Replicating OPTION_NOT_AUTOCOMMIT flag (see changeset comment) sql/log_event.h.orig@stripped, 2006-12-15 00:51:32+02:00, monty@stripped +2 -0 Fixed compiler warnings sql/log_event.h.orig@stripped, 2006-12-14 16:42:25+04:00, bar@stripped +0 -0 Auto merged MERGE: 1.122.1.6 sql/log_event.h.orig@stripped, 2006-12-14 14:14:04+04:00, bar@stripped +0 -0 Auto merged MERGE: 1.122.2.1 sql/log_event.h.orig@stripped, 2006-12-08 23:34:44+01:00, lars@black.(none) +0 -0 Auto merged MERGE: 1.136.2.2 sql/log_event.h.orig@stripped, 2006-12-08 10:33:00+04:00, bar@stripped +0 -0 After merge fix MERGE: 1.122.1.5 sql/log_event.h.orig@stripped, 2006-12-07 09:18:28-05:00, cbell@stripped +3 -7 WL#3618 - Remove HAVE_ROW_BASED_REPLICATION from source code. Please see worklog for details on files changed. sql/log_event.h.orig@stripped, 2006-12-07 09:31:48+04:00, bar@stripped +6 -1 Adding new Q_*_CODE Adding "lc_time_names_number" members into Query_log_event and PRINT_EVENT_INFO sql/log_event.h.orig@stripped, 2006-11-30 03:40:30+02:00, monty@stripped +2 -0 Fixed compiler warning sql/log_event.h.orig@stripped, 2006-11-28 16:26:09+04:00, bar@stripped +2 -0 Adding new member to store delimiter. sql/log_event.h.orig@stripped, 2006-11-14 13:04:36+02:00, aelkin@stripped +0 -0 Auto merged MERGE: 1.122.1.4 sql/log_event.h.orig@stripped, 2006-11-14 12:48:12+02:00, aelkin@stripped +14 -4 MAX_SIZE_LOG_EVENT_STATUS as the max bytes of contribution of status vars into repl message; MAX_SIZE_LOG_EVENT_STATUS is getting more wrt to 4.1 version. sql/log_event.h.orig@stripped, 2006-11-13 17:58:25+01:00, lars@black.(none) +0 -0 Auto merged MERGE: 1.122.1.3 sql/log_event.h.orig@stripped, 2006-11-13 17:53:58+01:00, lars@stripped +2 -2 Manual merge MERGE: 1.90.1.11 sql/log_event.h.orig@stripped, 2006-11-12 20:01:55+02:00, aelkin@stripped +4 -2 fixing comments sql/log_event.h.orig@stripped, 2006-11-01 15:35:32+01:00, mats@romeo.(none) +171 -42 Renaming exec_event() to apply_event_impl() Addng new non-virtual exec_event() that will contain business logic for event execution. Adding new non-virtual skip_event() that will contain business logic for skipping an event. Adding new virtual advance_coord_impl() as primitive to advance binary/relay log coordinates according to the event's needs. sql/log_event.h.orig@stripped, 2006-10-06 15:29:31+02:00, mats@romeo.(none) +0 -0 Auto merged MERGE: 1.133.2.3 sql/log_event.h.orig@stripped, 2006-10-06 10:16:57+02:00, mats@romeo.(none) +26 -4 Changing signature of event printing functions print_header() and print_base64() to write to an IO_CACHE instead of a file. Changing row-based replication events to incrementally build one BINLOG statement for all events making up a statement. Adding a head_cache and a body_cache to cache statement comment and statement body respectively. In addition, the head_cache is used when printing other events than the RBR events. sql/log_event.h.orig@stripped, 2006-09-12 00:19:01+03:00, aelkin@stripped +6 -0 MAX value of the header of the replication packet, i.e the value of exceeding the query string part. sql/log_event.h.orig@stripped, 2006-08-21 10:51:37+02:00, mats@romeo.(none) +0 -0 Auto merged MERGE: 1.133.1.3 sql/log_event.h.orig@stripped, 2006-07-03 11:14:30-04:00, cmiller@zippy.(none) +0 -0 Auto merged MERGE: 1.122.1.2 sql/log_event.h.orig@stripped, 2006-06-15 15:38:08+04:00, petr@stripped +0 -0 Auto merged MERGE: 1.133.2.2 sql/log_event.h.orig@stripped, 2006-06-12 08:54:40-04:00, cmiller@zippy.(none) +21 -0 Add a new subclass of Query_log_event that doesn't write itself to the log, for cases where we only want to flush out the transaction and not also write about this event. sql/log_event.h.orig@stripped, 2006-05-31 18:48:47+02:00, serg@stripped +0 -0 Auto merged MERGE: 1.133.3.1 sql/log_event.h.orig@stripped, 2006-05-31 18:36:57+02:00, serg@stripped +4 -1 classes that are compiled conditionally in log_event.cc must be defined conditionally in log_event.h sql/log_event.h.orig@stripped, 2006-05-17 22:16:36+02:00, guilhem@stripped +0 -3 no more need to hide XID in tests output as we have replace-regex sql/log_event.h.orig@stripped, 2006-05-05 10:45:53+04:00, petr@stripped +1 -1 use MYSQL_BIN_LOG instead of MYSQL_LOG sql/log_event.h.orig@stripped, 2006-05-03 15:00:28+02:00, mats@stripped +21 -14 Adding field to table_map_log_event. Changing prototype for do_prepare_row(). sql/log_event.h.orig@stripped, 2006-04-15 18:17:25-07:00, brian@zim.(none) +0 -4 OS2 removal sql/log_event.h.orig@stripped, 2006-03-08 21:49:44+01:00, mats@stripped +0 -30 Removing dead code. sql/log_event.h.orig@stripped, 2006-03-03 09:51:26+01:00, mats@stripped +0 -0 Auto merged MERGE: 1.128.1.2 sql/log_event.h.orig@stripped, 2006-02-28 22:46:23+01:00, kent@stripped +0 -0 Auto merged MERGE: 1.128.2.2 sql/log_event.h.orig@stripped, 2006-02-28 09:53:05+01:00, mats@stripped +0 -0 Auto merged MERGE: 1.128.2.2 sql/log_event.h.orig@stripped, 2006-02-26 15:12:50+02:00, monty@stripped +0 -0 Auto merged MERGE: 1.128.3.1 sql/log_event.h.orig@stripped, 2006-02-25 22:20:53+01:00, guilhem@stripped +0 -8 this global variable not used anymore sql/log_event.h.orig@stripped, 2006-02-25 20:35:07+02:00, monty@stripped +0 -0 Auto merged MERGE: 1.122.1.1 sql/log_event.h.orig@stripped, 2006-02-25 17:46:25+02:00, monty@stripped +1 -0 Fixed compiler warnings from gcc 4.0.2 sql/log_event.h.orig@stripped, 2006-02-24 15:38:13+01:00, lars@stripped +3 -3 Name change to indicate new semantics sql/log_event.h.orig@stripped, 2006-02-16 08:44:10+01:00, mats@stripped +0 -0 Auto merged MERGE: 1.125.1.1 sql/log_event.h.orig@stripped, 2006-02-16 08:30:43+01:00, mats@stripped +9 -2 Minor interface changes. sql/log_event.h.orig@stripped, 2006-01-20 13:17:10+01:00, knielsen@stripped +1 -3 Back out errorneous Windows fix. sql/log_event.h.orig@stripped, 2006-01-17 15:45:29+01:00, knielsen@stripped +0 -0 Auto merged MERGE: 1.123.1.5 sql/log_event.h.orig@stripped, 2006-01-17 12:43:33+01:00, joerg@stripped +0 -1 Auto merged MERGE: 1.123.1.4 sql/log_event.h.orig@stripped, 2006-01-13 22:09:38+01:00, knielsen@stripped +3 -1 Windows/Visual Studio 2003 fixes for the 5.1.5 release. sql/log_event.h.orig@stripped, 2006-01-10 10:35:37+01:00, joerg@stripped +1 -1 Actually return a bool expression instead of assuming a pointer expression is boolean. (transferred from "2005/12/10 22:31:58-06:00 reggie@fedora.(none)") sql/log_event.h.orig@stripped, 2006-01-09 17:31:49-06:00, reggie@stripped +0 -0 Auto merged MERGE: 1.123.1.2 sql/log_event.h.orig@stripped, 2006-01-09 22:16:37+01:00, knielsen@stripped +1 -1 Complete missing part of Mats' HPUX NO_FLAGS fix sql/log_event.h.orig@stripped, 2006-01-09 16:37:14+01:00, mats@stripped +1 -1 Preprocessor symbol NO_FLAGS used by system on HP-UX. sql/log_event.h.orig@stripped, 2006-01-09 15:59:30+01:00, mats@stripped +4 -1 Adding enumeration constants since aCC (HP-UX) does not like empty enumerations. sql/log_event.h.orig@stripped, 2005-12-10 22:31:52-06:00, reggie@fedora.(none) +1 -1 actually return a bool expression instead of assuming a pointer expression is boolean sql/log_event.h.orig@stripped, 2005-12-22 05:10:55+01:00, lars@stripped +572 -24 Import patch wl1012.patch sql/log_event.h.orig@stripped, 2005-10-27 15:13:52+03:00, monty@stripped +2 -3 Remove number from last even to help future merges (all compilers I know of can handle this properly) sql/log_event.h.orig@stripped, 2005-10-25 00:23:06+02:00, lars@stripped +0 -0 Auto merged MERGE: 1.115.1.4 sql/log_event.h.orig@stripped, 2005-10-24 23:08:51+02:00, lars@stripped +21 -11 One enum value per line Fixed a mistake Added values to every line for strange compilers sql/log_event.h.orig@stripped, 2005-10-24 19:06:05+02:00, lars@stripped +10 -9 Added numbering of enum values sql/log_event.h.orig@stripped, 2005-10-19 19:42:06+02:00, lars@stripped +0 -0 Auto merged MERGE: 1.115.1.2 sql/log_event.h.orig@stripped, 2005-10-19 19:30:54+02:00, lars@stripped +38 -33 Rename last_event_info to print_event_info sql/log_event.h.orig@stripped, 2005-10-13 00:29:16+02:00, guilhem@stripped +0 -16 get_event_len() is not needed in 5.0, ZERO_LEN neither. sql/log_event.h.orig@stripped, 2005-10-12 23:36:58+02:00, lars@stripped +39 -49 Collapsing multiple arguments into last_event_info struct sql/log_event.h.orig@stripped, 2005-10-12 21:57:58+02:00, guilhem@stripped +7 -1 manual merge MERGE: 1.90.1.9 sql/log_event.h.orig@stripped, 2005-10-12 13:29:51+02:00, guilhem@stripped +18 -10 We now have a case where a Rotate_log_event is executed by the slave SQL thread while not being in the relay log, so it needs to pretend its length is 0: a ZERO_LEN flag for that; a flag DUP_NAME (replaces "bool alloced") to be able to choose if we want the constructor to duplicate the string argument or not. sql/log_event.h.orig@stripped, 2005-09-30 00:12:07+02:00, lars@stripped +23 -23 Fixes related to Guilhems review sql/log_event.h.orig@stripped, 2005-09-29 10:42:13+02:00, lars@stripped +45 -24 mysqlbinlog --hexdump augments each log entry with byte information sql/log_event.h.orig@stripped, 2005-09-03 03:13:09+04:00, konstantin@stripped +0 -3 - remove an extra copy of the previous sentence sql/log_event.h.orig@stripped, 2005-08-19 14:55:19-04:00, elliot@stripped +0 -0 Auto merged MERGE: 1.90.1.8 sql/log_event.h.orig@stripped, 2005-08-19 14:49:29-04:00, elliot@stripped +1 -1 Added prototype for str_to_hex (now used by item.cc) sql/log_event.h.orig@stripped, 2005-08-06 12:39:51+02:00, serg@stripped +4 -0 extra safety for OPTIONS_WRITTEN_TO_BIN_LOG sql/log_event.h.orig@stripped, 2005-07-01 07:05:35+03:00, bell@stripped +2 -1 Name resolution context added sql/log_event.h.orig@stripped, 2005-05-26 19:54:25+02:00, msvensson@neptunus.(none) +0 -0 Auto merged MERGE: 1.90.1.7 sql/log_event.h.orig@stripped, 2005-05-26 12:09:09+02:00, msvensson@neptunus.(none) +1 -1 USE_PRAGMA_INTERFACE sql/log_event.h.orig@stripped, 2005-05-05 14:20:46+02:00, gbichot@stripped +2 -3 comment sql/log_event.h.orig@stripped, 2005-03-30 23:41:38+03:00, monty@stripped +1 -1 Fix wrong ifdef from last push sql/log_event.h.orig@stripped, 2005-03-30 16:00:27+03:00, monty@stripped +2 -0 #ifdef-ed not used code sql/log_event.h.orig@stripped, 2005-03-25 14:51:05+01:00, gbichot@stripped +14 -2 We now store the catalog in Query_log_event in binlog WITHOUT its end zero. This saves one byte per Query_log_event on disk. This new storage for the catalog is denoted by Q_CATALOG_NZ_CODE (couldn't re-use Q_CATALOG_CODE as 5.0.3 slaves of this 5.0.4 master would segfault because it would expect a 0 when there is none. Renaming get_open_mode() to get_create_or_append() (see log_event.cc) sql/log_event.h.orig@stripped, 2005-03-22 00:24:59+01:00, gbichot@stripped +40 -5 replication of time zones: a place for tz info in Query_log_event, in LAST_EVENT_INFO. Plus if we are compiling a client, we don't need the ::write() methods, so keeping them out (of mysqlbinlog.cc; keeping them in, resulted in problem that mysqlbinlog does not know Timezone structure). sql/log_event.h.orig@stripped, 2005-03-16 04:32:41+03:00, dlenev@stripped +121 -5 New way of replicating LOAD DATA. Now we do it similarly to other queries. We store LOAD DATA query in new Execute_load_query event (which is last in the sequence of events representing LOAD DATA). When we are executing this event we simply rewrite part of query which holds name of file (we use name of temporary file) and then execute it as usual query. In the beggining of this sequence we use Begin_load_query event which is almost identical to Append_file event. sql/log_event.h.orig@stripped, 2005-02-23 18:26:33+01:00, serg@stripped +1 -1 comment sql/log_event.h.orig@stripped, 2005-02-17 13:52:07+01:00, serg@stripped +10 -20 post-review fixes. Now ROLLBACK is done in Format_description_log_event sql/log_event.h.orig@stripped, 2005-02-14 18:45:27+01:00, serg@stripped +0 -0 Auto merged MERGE: 1.99.1.4 sql/log_event.h.orig@stripped, 2005-02-09 20:04:15+01:00, serg@stripped +40 -17 more comments for LOG_EVENT_BINLOG_IN_USE_F LOG_EVENT_FORCE_ROLLBACK_F added sql/log_event.h.orig@stripped, 2005-02-03 16:21:58+01:00, guilhem@stripped +15 -4 binlogging of charset info in each Query_log_event. sql/log_event.h.orig@stripped, 2005-02-01 21:32:29+01:00, serg@stripped +13 -11 changed LOG_EVENT_BINLOG_CLOSED_F to LOG_EVENT_BINLOG_IN_USE_F sql/log_event.h.orig@stripped, 2005-01-27 22:38:46+01:00, serg@stripped +16 -7 more comments. sql/log_event.h.orig@stripped, 2005-01-16 13:16:12+01:00, serg@stripped +61 -25 Xid_log_event, LOG_EVENT_BINLOG_CLOSED_F flag sql/log_event.h.orig@stripped, 2005-01-03 22:14:11+02:00, monty@stripped +0 -0 Auto merged MERGE: 1.90.1.6 sql/log_event.h.orig@stripped, 2004-12-31 12:04:28+02:00, monty@stripped +2 -2 Remove DUP_IGNORE from enum_duplicates and instead use a separate ignore flag sql/log_event.h.orig@stripped, 2004-12-06 02:05:22+02:00, monty@stripped +13 -13 Auto merged MERGE: 1.90.1.5 sql/log_event.h.orig@stripped, 2004-12-03 11:25:13+01:00, mats@stripped +17 -3 Added new flag and parameter to suppress generation of USE statements. sql/log_event.h.orig@stripped, 2004-11-15 23:58:47+01:00, guilhem@stripped +0 -0 Auto merged MERGE: 1.90.1.4 sql/log_event.h.orig@stripped, 2004-11-15 17:03:21+01:00, lars@stripped +1 -1 Added db to set_fields function so that current db is used. sql/log_event.h.orig@stripped, 2004-10-29 19:26:42+03:00, monty@stripped +0 -0 merge with 4.1 MERGE: 1.90.1.3 sql/log_event.h.orig@stripped, 2004-10-14 18:03:39+03:00, monty@stripped +1 -1 true,false -> TRUE, FALSE sql/log_event.h.orig@stripped, 2004-09-15 22:10:11+03:00, monty@stripped +131 -125 Changed return type of write() functions to bool. (Before we returned -1 or 1 for errors) write_data() -> write() Added 'data_written' member to make it easier to get length of written event. Removed 'cached_event_len' and 'get_event_len()' Added usage of auto_increment_increment and auto_increment_offset Added 'artifical_event' to Start_log_event_v3, to hide logic that we in the binary log use log_pos=0 as a flag for an artifical event. sql/log_event.h.orig@stripped, 2004-07-26 19:42:51+02:00, guilhem@stripped +1 -1 catalog_len changed from uint to int to allow -1, which means "not inited" (I preferred to do it like this rather than create a new bool var Query_log_event::catalog_inited like we have in Query_log_event::sql_mode_inited; that's because catalog will not use the whole range of int, so it's allowed to pick -1 as a special value and have only one var. sql/log_event.h.orig@stripped, 2004-07-21 00:45:02+02:00, serg@stripped +104 -104 const bool is_valid() -> bool is_valid() const sql/log_event.h.orig@stripped, 2004-04-07 15:12:41+02:00, pem@stripped +0 -0 Auto merged MERGE: 1.90.1.2 sql/log_event.h.orig@stripped, 2004-02-16 10:03:47+02:00, monty@stripped +0 -0 Auto merged MERGE: 1.71.1.16 sql/log_event.h.orig@stripped, 2004-02-13 16:05:06+02:00, monty@stripped +5 -1 Free buffer sql/log_event.h.orig@stripped, 2004-02-11 00:06:42+01:00, monty@stripped +0 -0 Merge with 4.0.18 MERGE: 1.71.1.15 sql/log_event.h.orig@stripped, 2004-02-06 20:56:53+04:00, vva@stripped +3 -1 added special local_fname flag to Load_log_event for using in Load_log_event::check_fname_outside_temp_buf instead of ugly condition sql/log_event.h.orig@stripped, 2003-12-21 02:07:21+02:00, monty@stripped +3 -3 Changed sql_mode to ulong to match THD.variables.sql_mode (If they are not the same we get a lot of compiler warnings) sql/log_event.h.orig@stripped, 2003-12-19 23:04:52+01:00, guilhem@stripped +0 -0 Auto merged MERGE: 1.89.1.1 sql/log_event.h.orig@stripped, 2003-12-18 01:08:04+01:00, guilhem@stripped +377 -110 Binlog version is changed to 4. New classes (details in sql/log_event.cc). Removing some useless #defines. sql/log_event.h.orig@stripped, 2003-12-17 17:35:29+02:00, monty@stripped +0 -0 Merge with 4.0 MERGE: 1.71.1.14 sql/log_event.h.orig@stripped, 2003-12-08 16:17:01+01:00, guilhem@stripped +1 -1 The constructor of Rotate_log_event used when we are rotating our binlog or relay log, should not assume that there is a nonzero THD available. For example, when we are reacting to SIGHUP, the THD is 0. In fact we don't need to use the THD in this constructor; we can do like for Stop_log_event, and use the minimal Log_event constructor. This fixes BUG#2045 "Sending SIGHUP to mysqld crashes it if running with --log-bin" sql/log_event.h.orig@stripped, 2003-12-02 16:49:34+01:00, guilhem@stripped +1 -1 There is no reason that Intvar_log_event's constructor calls Log_event::Log_event() instead of Log_event::Log_event(THD*, ...) when the event is built in the master to be written in the binlog. Rand_log_event already used the good constructor, so there really is no reason for Intvar_log_event to be an exception. This fixes a test failure of last night (which appeared after I removed a useless e.server_id=thd->server_id in log.cc; in fact this line was not useless because it hid the bad constructor). sql/log_event.h.orig@stripped, 2003-11-04 01:29:56+02:00, monty@stripped +0 -0 Auto merged MERGE: 1.71.1.12 sql/log_event.h.orig@stripped, 2003-10-29 14:23:23+01:00, guilhem@stripped +8 -0 Query and Load need to carry a slave_proxy_id, like they carried a thread_id (to replicate temp tables well). sql/log_event.h.orig@stripped, 2003-08-29 04:21:40+03:00, monty@stripped +0 -0 Auto merged MERGE: 1.71.1.11 sql/log_event.h.orig@stripped, 2003-08-20 23:24:35+02:00, guilhem@stripped +21 -5 New member 'db' for Append_block et al. events. sql/log_event.h.orig@stripped, 2003-08-19 15:46:43+02:00, guilhem@stripped +1 -0 prototype sql/log_event.h.orig@stripped, 2003-08-11 22:44:33+03:00, monty@stripped +1 -8 merge with 4.0 MERGE: 1.71.1.9 sql/log_event.h.orig@stripped, 2003-07-04 16:36:20+03:00, monty@stripped +7 -2 Indentation fix sql/log_event.h.orig@stripped, 2003-07-04 16:06:01-04:00, vva@stripped +8 -0 fixed bug #670 sql/log_event.h.orig@stripped, 2003-07-01 14:40:13+03:00, monty@stripped +0 -0 Auto merged MERGE: 1.41.1.8 sql/log_event.h.orig@stripped, 2003-06-16 23:38:29+02:00, guilhem@stripped +11 -0 In Start_log_event, 'created' is always the same as 'when', or O. We didn't need 4 bytes for this, a bit would have been enough (O or "same as 'when'"). Possibly in 5.0 we will re-use the useless bytes. sql/log_event.h.orig@stripped, 2003-06-12 16:20:23+02:00, guilhem@stripped +108 -11 - Comments for future devs. - Removed LOG_EVENT_TIME_F and LOG_EVENT_FORCED_ROTATE_F. sql/log_event.h.orig@stripped, 2003-06-06 13:52:10+02:00, guilhem@stripped +9 -0 An explanation. sql/log_event.h.orig@stripped, 2003-05-19 16:35:45+03:00, monty@stripped +5 -5 Merge with 4.0.13 MERGE: 1.71.1.6 sql/log_event.h.orig@stripped, 2003-04-26 21:10:11+03:00, monty@stripped +1 -4 Merge with 3.23; Fix problem with timestamp on 64 bit systems MERGE: 1.41.1.6 sql/log_event.h.orig@stripped, 2003-04-23 17:59:55+05:00, gluh@stripped +18 -4 Task 761:'mysqlbinlog should not die when reading unknown event' The 'Unknown_log_event' class has been added. sql/log_event.h.orig@stripped, 2003-04-23 00:13:37+03:00, monty@stripped +4 -4 Fixed problem with timestamps in binary log on 64 bit machines sql/log_event.h.orig@stripped, 2003-03-16 18:09:02+02:00, monty@stripped +0 -0 Auto merged MERGE: 1.71.1.4 sql/log_event.h.orig@stripped, 2003-03-10 14:04:07+02:00, monty@stripped +0 -0 Auto merged MERGE: 1.71.2.1 sql/log_event.h.orig@stripped, 2003-03-10 12:48:42+02:00, monty@stripped +0 -1 merge MERGE: 1.41.1.5 sql/log_event.h.orig@stripped, 2003-03-07 01:20:54+02:00, monty@stripped +0 -1 Use local version MERGE: 1.41.1.5 sql/log_event.h.orig@stripped, 2003-03-05 15:34:55+02:00, Sinisa@stripped +1 -1 A better, but larger fix for server_id bug .. sql/log_event.h.orig@stripped, 2003-03-04 15:02:47+02:00, monty@stripped +2 -2 Portability fix sql/log_event.h.orig@stripped, 2003-02-14 11:47:38+02:00, monty@stripped +1 -1 Optimized type sql/log_event.h.orig@stripped, 2003-01-31 09:18:41+04:00, gluh@stripped +0 -0 Auto merged MERGE: 1.76.3.1 sql/log_event.h.orig@stripped, 2003-01-30 21:39:40+04:00, gluh@stripped +49 -1 'Replicate user variables' task sql/log_event.h.orig@stripped, 2003-01-20 18:50:39+04:00, hf@stripped +0 -0 Auto merged MERGE: 1.76.1.3 sql/log_event.h.orig@stripped, 2003-01-17 21:59:01+04:00, vva@stripped +0 -0 Auto merged MERGE: 1.76.2.1 sql/log_event.h.orig@stripped, 2003-01-17 21:52:46+04:00, vva@stripped +8 -0 converting 'load' to 'local load' sql/log_event.h.orig@stripped, 2003-01-15 13:15:34+04:00, hf@stripped +0 -0 conflicts MERGE: 1.76.1.2 sql/log_event.h.orig@stripped, 2003-01-15 12:11:39+04:00, hf@stripped +26 -30 #ifdef-s changed sql/log_event.h.orig@stripped, 2003-01-09 03:12:40+02:00, monty@stripped +0 -0 Auto merged MERGE: 1.71.1.2 sql/log_event.h.orig@stripped, 2003-01-08 11:24:37+02:00, monty@stripped +3 -2 Fix for bug in LOAD DATA INFILE sql/log_event.h.orig@stripped, 2002-12-30 01:59:03+04:00, vva@stripped +0 -0 Auto merged MERGE: 1.75.2.1 sql/log_event.h.orig@stripped, 2002-12-30 01:42:38+04:00, vva@stripped +4 -2 processing thread specific queries sql/log_event.h.orig@stripped, 2002-12-16 18:58:54+04:00, hf@stripped +4 -7 Merging MERGE: 1.75.1.1 sql/log_event.h.orig@stripped, 2002-12-16 17:33:24+04:00, hf@stripped +36 -3 #ifdef-ed parts of file which don't work in embedded case sql/log_event.h.orig@stripped, 2002-12-11 09:17:47+02:00, monty@stripped +13 -13 New protocol sql/log_event.h.orig@stripped, 2002-11-21 04:21:03+02:00, monty@stripped +0 -0 Auto merged MERGE: 1.71.1.1 sql/log_event.h.orig@stripped, 2002-11-07 04:02:33+02:00, monty@stripped +27 -23 Put temporary files in binlog cache when using BEGIN/COMMIT sql/log_event.h.orig@stripped, 2002-10-29 23:50:06-07:00, nick@stripped +97 -10 Added comments sql/log_event.h.orig@stripped, 2002-10-25 23:30:13+00:00, serg@stripped +1 -30 bad auto-merge fixed sql/log_event.h.orig@stripped, 2002-10-25 21:29:42+00:00, serg@stripped +0 -6 Auto merged MERGE: 1.70.1.1 sql/log_event.h.orig@stripped, 2002-10-24 16:48:33-06:00, nick@stripped +34 -1 Added Rand_log_event sql/log_event.h.orig@stripped, 2002-10-22 15:17:16-06:00, nick@stripped +35 -1 Added Rand_log_event sql/log_event.h.orig@stripped, 2002-09-11 06:40:06+03:00, monty@stripped +3 -4 Change ident_len to uint (more efficient) sql/log_event.h.orig@stripped, 2002-08-08 03:11:06+03:00, monty@stripped +2 -2 Query_log_event() now always takes query length. sql/log_event.h.orig@stripped, 2002-07-25 22:46:24+03:00, monty@stripped +0 -9 Merge with 3.23.51 MERGE: 1.41.1.4 sql/log_event.h.orig@stripped, 2002-07-23 18:31:15+03:00, monty@stripped +0 -2 Removed not needed var reference sql/log_event.h.orig@stripped, 2002-06-30 23:25:44+03:00, monty@stripped +9 -10 Fixed bug in binary log when using LOAD DATA INFILE without active database. sql/log_event.h.orig@stripped, 2002-06-29 20:26:31+03:00, monty@stripped +5 -6 cleanup sql/log_event.h.orig@stripped, 2002-06-11 11:20:21+03:00, monty@stripped +231 -248 Indentation and comment cleanup Merged #ifdef's into common blocks for better readability sql/log_event.h.orig@stripped, 2002-03-27 01:56:10+02:00, monty@stripped +0 -3 merge MERGE: 1.41.1.3 sql/log_event.h.orig@stripped, 2002-03-22 01:03:34+02:00, monty@stripped +3 -2 Fix for load data infile when no active database sql/log_event.h.orig@stripped, 2002-02-07 15:29:44-07:00, sasha@stripped +7 -4 fixes for slave backward compat sql/log_event.h.orig@stripped, 2002-01-29 18:32:14+02:00, monty@stripped +4 -4 Cleanup and portability fixes. sql/log_event.h.orig@stripped, 2002-01-19 22:46:23-07:00, sasha@stripped +150 -133 merge MERGE: 1.58.1.1 sql/log_event.h.orig@stripped, 2002-01-19 19:16:49-07:00, sasha@stripped +20 -20 new replication sql/log_event.h.orig@stripped, 2001-12-06 14:10:45+02:00, monty@stripped +11 -11 Update copyright sql/log_event.h.orig@stripped, 2001-12-05 13:02:59+02:00, monty@stripped +122 -143 Cleanup to make code more readable sql/log_event.h.orig@stripped, 2001-11-17 17:23:45-07:00, sasha@stripped +2 -1 fixes to slave off 3.23 master sql/log_event.h.orig@stripped, 2001-11-10 22:24:10-07:00, sasha@stripped +13 -11 work to enable reading 3.23 format sql/log_event.h.orig@stripped, 2001-09-21 03:38:34+03:00, monty@stripped +6 -4 Added error message handling to read_log_event() sql/log_event.h.orig@stripped, 2001-09-15 16:22:33+03:00, monty@stripped +2 -2 Portability fixes sql/log_event.h.orig@stripped, 2001-08-18 20:22:19-06:00, sasha@stripped +44 -11 make LOAD DATA INFILE replication work with multi-character delimiters/starters/terminators sql/log_event.h.orig@stripped, 2001-08-11 17:07:26-06:00, sasha@stripped +2 -1 fix bad merge sql/log_event.h.orig@stripped, 2001-08-09 19:16:13-06:00, sasha@stripped +0 -1 merged MERGE: 1.41.1.2 sql/log_event.h.orig@stripped, 2001-08-09 18:16:42-06:00, sasha@stripped +4 -0 removed pthread dependency in mysqlbinlog sql/log_event.h.orig@stripped, 2001-08-06 16:47:35-06:00, sasha@stripped +2 -0 fixed compile error with USING_TRANSACTIONS sql/log_event.h.orig@stripped, 2001-08-03 15:57:52-06:00, sasha@stripped +238 -166 added classes for file events added exec_event() method to all classes restructured/cleaned up event classes sql/log_event.h.orig@stripped, 2001-07-28 11:46:13-06:00, sasha@stripped +3 -0 do not log stray error codes sql/log_event.h.orig@stripped, 2001-07-23 14:35:24-06:00, sasha@stripped +4 -0 more work on LOAD DATA INFILE sql/log_event.h.orig@stripped, 2001-07-20 16:22:54-06:00, sasha@stripped +56 -6 clean-up plus start of new LOAD DATA INFILE events work sql/log_event.h.orig@stripped, 2001-07-10 15:52:33+03:00, monty@stripped +3 -3 cleanup sql/log_event.h.orig@stripped, 2001-06-26 17:02:32-06:00, sasha@stripped +13 -5 clean-up of rotate event, support for position force with rotate event sql/log_event.h.orig@stripped, 2001-06-23 19:37:23-06:00, sasha@stripped +1 -0 master forced rotation flag sql/log_event.h.orig@stripped, 2001-06-21 13:19:23-06:00, sasha@stripped +24 -3 SHOW BINLOG EVENTS sql/log_event.h.orig@stripped, 2001-06-19 15:03:48-06:00, sasha@stripped +85 -40 new binlog format sql/log_event.h.orig@stripped, 2001-06-14 14:12:39-06:00, sasha@stripped +30 -1 slave log event sql/log_event.h.orig@stripped, 2001-04-24 17:39:25-06:00, sasha@stripped +7 -7 fix for mysqlbinlog sql/log_event.h.orig@stripped, 2001-04-10 20:56:33-06:00, sasha@stripped +1 -1 mark killed partially completed updates with an error code sql/log_event.h.orig@stripped, 2001-02-19 23:08:23-07:00, sasha@stripped +1 -1 abolish MAX_EVENT_LEN sql/log_event.h.orig@stripped, 2001-01-27 01:20:55+02:00, monty@stripped +4 -0 Fixes for OS2 sql/log_event.h.orig@stripped, 2001-01-22 08:51:26-07:00, sasha@stripped +0 -0 Auto merged MERGE: 1.35.1.1 sql/log_event.h.orig@stripped, 2001-01-22 08:50:43-07:00, sasha@stripped +1 -1 fixed compiler error sql/log_event.h.orig@stripped, 2001-01-21 16:30:15+02:00, monty@stripped +2 -1 Changes for --with-server-suffix sql/log_event.h.orig@stripped, 2000-12-18 16:09:18+02:00, monty@stripped +18 -18 Cleanup sql/log_event.h.orig@stripped, 2000-12-12 04:34:56+02:00, monty@stripped +1 -1 portability fix sql/log_event.h.orig@stripped, 2000-12-11 14:21:46-07:00, sasha@stripped +4 -4 fixed load data infile replication for alpha sql/log_event.h.orig@stripped, 2000-12-11 12:06:34-07:00, sasha@stripped +10 -0 changed new/delete for Log_event to use my_malloc/my_free sql/log_event.h.orig@stripped, 2000-12-07 14:08:45+02:00, monty@stripped +6 -4 Only write full transactions to binary log sql/log_event.h.orig@stripped, 2000-11-25 23:30:02-07:00, sasha@stripped +2 -2 thread_id needs to be ulong sql/log_event.h.orig@stripped, 2000-11-18 02:15:06+02:00, monty@stripped +1 -1 Portability fixes sql/log_event.h.orig@stripped, 2000-11-17 02:36:36+02:00, monty@stripped +6 -14 Fixed non portable header in binary dump sql/log_event.h.orig@stripped, 2000-11-15 18:47:08-07:00, sasha@stripped +0 -0 Auto merged MERGE: 1.25.1.1 sql/log_event.h.orig@stripped, 2000-11-16 00:24:10+02:00, monty@stripped +0 -0 merge MERGE: 1.24.1.1 sql/log_event.h.orig@stripped, 2000-11-15 22:59:53+02:00, monty@stripped +31 -32 changed to use IO_CACHE instead of FILE sql/log_event.h.orig@stripped, 2000-11-13 23:43:01-07:00, sasha@stripped +1 -1 fixed () #define bug sql/log_event.h.orig@stripped, 2000-11-11 14:50:09-07:00, sasha@stripped +4 -4 max_buf -> event_len in read_log_event sql/log_event.h.orig@stripped, 2000-10-17 00:47:14+03:00, monty@stripped +1 -1 Portability fix sql/log_event.h.orig@stripped, 2000-10-05 17:58:14-06:00, sasha@stripped +2 -0 added magic number added LOG_READ_TRUNC error sql/log_event.h.orig@stripped, 2000-10-03 19:53:12-06:00, sasha@stripped +9 -3 added error_code for the query event sql/log_event.h.orig@stripped, 2000-09-29 17:20:25-06:00, sasha@stripped +13 -1 moved #defines from log_event.cc sql/log_event.h.orig@stripped, 2000-09-28 16:24:48-06:00, sasha@stripped +58 -18 added server id sql/log_event.h.orig@stripped, 2000-08-30 22:42:22+03:00, monty@stripped +0 -0 Turn off RCS flag sql/log_event.h.orig@stripped, 2000-08-23 13:27:32-06:00, sasha@stripped +13 -13 changed uint to uint32 in all places where the code depended on sizeof(uint) to be 4 sql/log_event.h.orig@stripped, 2000-08-23 15:02:26+03:00, monty@stripped +2 -2 Update for Ia64 sql/log_event.h.orig@stripped, 2000-08-22 00:18:30+03:00, monty@stripped +6 -6 Port to Ia64 sql/log_event.h.orig@stripped, 2000-07-01 23:52:46-00:00, sasha +1 -0 One more safety fix sql/log_event.h.orig@stripped, 2000-06-19 23:25:00-00:00, monty +15 -12 Change of copyright to GPL/LGPL sql/log_event.h.orig@stripped, 2000-06-16 01:15:55-00:00, sasha +2 -2 Fixed the big endian timestamp problem sql/log_event.h.orig@stripped, 2000-05-16 02:48:43-00:00, monty +2 -2 Update for 3.23.16 sql/log_event.h.orig@stripped, 2000-05-04 04:36:45-00:00, sasha +2 -2 Fixed ulonglong -> int problem in replication of last_insert_id sql/log_event.h.orig@stripped, 2000-04-28 19:03:38-00:00, sasha +93 -18 Load data in file update sql/log_event.h.orig@stripped, 2000-04-28 00:13:35-00:00, monty +1 -1 Update of 3.23.25 sql/log_event.h.orig@stripped, 2000-04-27 00:29:30-00:00, monty +28 -26 Update to 3.23.15 sql/log_event.h.orig@stripped, 2000-04-22 18:17:52-00:00, sasha +100 -8 Replication update sql/log_event.h.orig@stripped, 2000-04-11 20:13:08-00:00, sasha +30 -0 added COM_BINLOG_DUMP to the protocol sql/log_event.h.orig@stripped, 2000-04-07 15:46:48-00:00, monty +33 -1 Update to 3.23.14 sql/log_event.h.orig@stripped, 2000-04-01 22:12:55-00:00, monty +1 -1 Fix for binary log sql/log_event.h.orig@stripped, 2000-03-31 09:14:15-00:00, monty +59 -81 Optimization of binary log handling sql/log_event.h.orig@stripped, 2000-03-31 06:51:41-00:00, sasha +1 -1 fixed a typo on line 97, Tonu, hope you're happy now :-) sql/log_event.h.orig@stripped, 2000-03-30 23:31:38-00:00, sasha +141 -0 forgot these guys... log_event.cc log_event.h mybinlogdump.cc sql/log_event.h.orig@stripped, 1970-01-01 03:09:62, BK +0 -0 RCS to BitKeeper sql/rpl_record.cc@stripped, 2007-07-03 18:04:06+02:00, rafal@quant.(none) +35 -31 - Changed signature of unpack_row. - Make unpack_row non-destructive for columns not present in the row. - Move initialization of a record with default values to a separate function prepare_record(). - Don't fill read/write set here as it is done outside these functions. sql/rpl_record.h@stripped, 2007-07-03 18:04:06+02:00, rafal@quant.(none) +6 -5 - Change signature of unpack_row(). - Declare function prepare_record(). diff -Nrup a/mysql-test/r/rpl_ndb_extraCol.result b/mysql-test/r/rpl_ndb_extraCol.result --- a/mysql-test/r/rpl_ndb_extraCol.result 2007-06-11 22:15:19 +02:00 +++ b/mysql-test/r/rpl_ndb_extraCol.result 2007-07-03 18:04:06 +02:00 @@ -28,9 +28,9 @@ a b c *** Select from slave *** SELECT * FROM t1 ORDER BY a; a b c d e -1 2 TEXAS NULL NULL -2 1 AUSTIN NULL NULL -3 4 QA NULL NULL +1 2 TEXAS 2 TEST +2 1 AUSTIN 2 TEST +3 4 QA 2 TEST *** Drop t1 *** DROP TABLE t1; *** Create t3 on slave *** @@ -309,9 +309,9 @@ a b c *** Select from slave *** SELECT * FROM t7 ORDER BY a; a b c d e -1 b1b1 Kyle NULL NULL -2 b1b1 JOE NULL NULL -3 b1b1 QA NULL NULL +1 b1b1 Kyle 0000-00-00 00:00:00 Extra Column Testing +2 b1b1 JOE 0000-00-00 00:00:00 Extra Column Testing +3 b1b1 QA 0000-00-00 00:00:00 Extra Column Testing *** Drop t7 *** DROP TABLE t7; *** Create t8 on slave *** @@ -477,9 +477,9 @@ a b c *** Select on Slave *** SELECT * FROM t12 ORDER BY a; a b f c e -1 b1b1b1b1b1b1b1b1 Kyle NULL NULL -2 b1b1b1b1b1b1b1b1 JOE NULL NULL -3 b1b1b1b1b1b1b1b1 QA NULL NULL +1 b1b1b1b1b1b1b1b1 Kyle test 1 +2 b1b1b1b1b1b1b1b1 JOE test 1 +3 b1b1b1b1b1b1b1b1 QA test 1 *** Drop t12 *** DROP TABLE t12; **** Extra Colums End **** @@ -509,9 +509,9 @@ a b c *** Select on Slave **** SELECT * FROM t13 ORDER BY a; a b c d e -1 b1b1b1b1b1b1b1b1 Kyle NULL CURRENT_TIMESTAMP -2 b1b1b1b1b1b1b1b1 JOE NULL CURRENT_TIMESTAMP -3 b1b1b1b1b1b1b1b1 QA NULL CURRENT_TIMESTAMP +1 b1b1b1b1b1b1b1b1 Kyle 1 CURRENT_TIMESTAMP +2 b1b1b1b1b1b1b1b1 JOE 1 CURRENT_TIMESTAMP +3 b1b1b1b1b1b1b1b1 QA 1 CURRENT_TIMESTAMP *** Drop t13 *** DROP TABLE t13; *** 22117 END *** @@ -545,9 +545,9 @@ c1 c2 c3 c4 c5 *** Select on Slave **** SELECT * FROM t14 ORDER BY c1; c1 c2 c3 c4 c5 c6 c7 -1 1.00 Replication Testing Extra Col b1b1b1b1b1b1b1b1 Kyle NULL CURRENT_TIMESTAMP -2 2.00 This Test Should work b1b1b1b1b1b1b1b1 JOE NULL CURRENT_TIMESTAMP -3 3.00 If is does not, I will open a bug b1b1b1b1b1b1b1b1 QA NULL CURRENT_TIMESTAMP +1 1.00 Replication Testing Extra Col b1b1b1b1b1b1b1b1 Kyle 1 CURRENT_TIMESTAMP +2 2.00 This Test Should work b1b1b1b1b1b1b1b1 JOE 1 CURRENT_TIMESTAMP +3 3.00 If is does not, I will open a bug b1b1b1b1b1b1b1b1 QA 1 CURRENT_TIMESTAMP *** connect to master and drop columns *** ALTER TABLE t14 DROP COLUMN c2; ALTER TABLE t14 DROP COLUMN c4; @@ -560,9 +560,9 @@ c1 c3 c5 *** Select from Slave *** SELECT * FROM t14 ORDER BY c1; c1 c3 c5 c6 c7 -1 Replication Testing Extra Col Kyle NULL CURRENT_TIMESTAMP -2 This Test Should work JOE NULL CURRENT_TIMESTAMP -3 If is does not, I will open a bug QA NULL CURRENT_TIMESTAMP +1 Replication Testing Extra Col Kyle 1 CURRENT_TIMESTAMP +2 This Test Should work JOE 1 CURRENT_TIMESTAMP +3 If is does not, I will open a bug QA 1 CURRENT_TIMESTAMP *** Drop t14 *** DROP TABLE t14; *** Create t15 on slave *** @@ -593,9 +593,9 @@ c1 c2 c3 c4 c5 *** Select on Slave **** SELECT * FROM t15 ORDER BY c1; c1 c2 c3 c4 c5 c6 c7 -1 1.00 Replication Testing Extra Col b1b1b1b1b1b1b1b1 Kyle NULL CURRENT_TIMESTAMP -2 2.00 This Test Should work b1b1b1b1b1b1b1b1 JOE NULL CURRENT_TIMESTAMP -3 3.00 If is does not, I will open a bug b1b1b1b1b1b1b1b1 QA NULL CURRENT_TIMESTAMP +1 1.00 Replication Testing Extra Col b1b1b1b1b1b1b1b1 Kyle 1 CURRENT_TIMESTAMP +2 2.00 This Test Should work b1b1b1b1b1b1b1b1 JOE 1 CURRENT_TIMESTAMP +3 3.00 If is does not, I will open a bug b1b1b1b1b1b1b1b1 QA 1 CURRENT_TIMESTAMP *** Add column on master that is a Extra on Slave *** ALTER TABLE t15 ADD COLUMN c6 INT AFTER c5; ******************************************** @@ -653,9 +653,9 @@ c1 c2 c3 c4 c5 c6 *** Try to select from slave **** SELECT * FROM t15 ORDER BY c1; c1 c2 c3 c4 c5 c6 c7 -1 1.00 Replication Testing Extra Col b1b1b1b1b1b1b1b1 Kyle NULL CURRENT_TIMESTAMP -2 2.00 This Test Should work b1b1b1b1b1b1b1b1 JOE NULL CURRENT_TIMESTAMP -3 3.00 If is does not, I will open a bug b1b1b1b1b1b1b1b1 QA NULL CURRENT_TIMESTAMP +1 1.00 Replication Testing Extra Col b1b1b1b1b1b1b1b1 Kyle 1 CURRENT_TIMESTAMP +2 2.00 This Test Should work b1b1b1b1b1b1b1b1 JOE 1 CURRENT_TIMESTAMP +3 3.00 If is does not, I will open a bug b1b1b1b1b1b1b1b1 QA 1 CURRENT_TIMESTAMP 5 2.00 Replication Testing b1b1b1b1b1b1b1b1 Buda 2 CURRENT_TIMESTAMP *** DROP TABLE t15 *** DROP TABLE t15; @@ -687,9 +687,9 @@ c1 c2 c3 c4 c5 *** Select on Slave **** SELECT * FROM t16 ORDER BY c1; c1 c2 c3 c4 c5 c6 c7 -1 1.00 Replication Testing Extra Col b1b1b1b1b1b1b1b1 Kyle NULL CURRENT_TIMESTAMP -2 2.00 This Test Should work b1b1b1b1b1b1b1b1 JOE NULL CURRENT_TIMESTAMP -3 3.00 If is does not, I will open a bug b1b1b1b1b1b1b1b1 QA NULL CURRENT_TIMESTAMP +1 1.00 Replication Testing Extra Col b1b1b1b1b1b1b1b1 Kyle 1 CURRENT_TIMESTAMP +2 2.00 This Test Should work b1b1b1b1b1b1b1b1 JOE 1 CURRENT_TIMESTAMP +3 3.00 If is does not, I will open a bug b1b1b1b1b1b1b1b1 QA 1 CURRENT_TIMESTAMP *** Add Partition on master *** ALTER TABLE t16 PARTITION BY KEY(c1) PARTITIONS 4; INSERT INTO t16 () VALUES(4,1.00,'Replication Rocks',@b1,'Omer'); diff -Nrup a/sql/log_event.cc b/sql/log_event.cc --- a/sql/log_event.cc 2007-06-28 15:07:53 +02:00 +++ b/sql/log_event.cc 2007-07-03 18:04:06 +02:00 @@ -5635,6 +5635,7 @@ Rows_log_event::Rows_log_event(THD *thd_ m_table_id(tid), m_width(tbl_arg ? tbl_arg->s->fields : 1), m_rows_buf(0), m_rows_cur(0), m_rows_end(0), + m_curr_row(NULL), m_curr_row_end(NULL), m_flags(0) { /* @@ -5674,7 +5675,8 @@ Rows_log_event::Rows_log_event(const cha *description_event) : Log_event(buf, description_event), m_row_count(0), - m_rows_buf(0), m_rows_cur(0), m_rows_end(0) + m_rows_buf(0), m_rows_cur(0), m_rows_end(0), + m_curr_row(NULL), m_curr_row_end(NULL) { DBUG_ENTER("Rows_log_event::Rows_log_event(const char*,...)"); uint8 const common_header_len= description_event->common_header_len; @@ -5761,6 +5763,7 @@ Rows_log_event::Rows_log_event(const cha m_rows_buf= (uchar*) my_malloc(data_size, MYF(MY_WME)); if (likely((bool)m_rows_buf)) { + m_curr_row= m_rows_buf; m_rows_end= m_rows_buf + data_size; m_rows_cur= m_rows_end; memcpy(m_rows_buf, ptr_rows_data, data_size); @@ -5865,7 +5868,6 @@ int Rows_log_event::do_apply_event(RELAY { DBUG_ENTER("Rows_log_event::do_apply_event(st_relay_log_info*)"); int error= 0; - uchar const *row_start= m_rows_buf; /* If m_table_id == ~0UL, then we have a dummy event that does not @@ -5901,134 +5903,16 @@ int Rows_log_event::do_apply_event(RELAY event. */ if (!thd->lock) - { - bool need_reopen= 1; /* To execute the first lap of the loop below */ - - /* - lock_tables() reads the contents of thd->lex, so they must be - initialized. Contrary to in - Table_map_log_event::do_apply_event() we don't call - mysql_init_query() as that may reset the binlog format. - */ - lex_start(thd); - - while ((error= lock_tables(thd, rli->tables_to_lock, - rli->tables_to_lock_count, &need_reopen))) - { - if (!need_reopen) - { - if (thd->query_error || thd->is_fatal_error) - { - /* - Error reporting borrowed from Query_log_event with many excessive - simplifications (we don't honour --slave-skip-errors) - */ - uint actual_error= thd->net.last_errno; - rli->report(ERROR_LEVEL, actual_error, - "Error '%s' in %s event: when locking tables", - (actual_error ? thd->net.last_error : - "unexpected success or fatal error"), - get_type_str()); - thd->is_fatal_error= 1; - } - else - { - rli->report(ERROR_LEVEL, error, - "Error in %s event: when locking tables", - get_type_str()); - } - const_cast<RELAY_LOG_INFO*>(rli)->clear_tables_to_lock(); - DBUG_RETURN(error); - } - - /* - So we need to reopen the tables. - - We need to flush the pending RBR event, since it keeps a - pointer to an open table. - - ALTERNATIVE SOLUTION (not implemented): Extract a pointer to - the pending RBR event and reset the table pointer after the - tables has been reopened. - - NOTE: For this new scheme there should be no pending event: - need to add code to assert that is the case. - */ - thd->binlog_flush_pending_rows_event(false); - TABLE_LIST *tables= rli->tables_to_lock; - close_tables_for_reopen(thd, &tables); - - uint tables_count= rli->tables_to_lock_count; - if ((error= open_tables(thd, &tables, &tables_count, 0))) - { - if (thd->query_error || thd->is_fatal_error) - { - /* - Error reporting borrowed from Query_log_event with many excessive - simplifications (we don't honour --slave-skip-errors) - */ - uint actual_error= thd->net.last_errno; - rli->report(ERROR_LEVEL, actual_error, - "Error '%s' on reopening tables", - (actual_error ? thd->net.last_error : - "unexpected success or fatal error")); - thd->query_error= 1; - } - const_cast<RELAY_LOG_INFO*>(rli)->clear_tables_to_lock(); - DBUG_RETURN(error); - } - } - - /* - When the open and locking succeeded, we check all tables to - ensure that they still have the correct type. - - We can use a down cast here since we know that every table added - to the tables_to_lock is a RPL_TABLE_LIST. - */ - - { - RPL_TABLE_LIST *ptr= rli->tables_to_lock; - for ( ; ptr ; ptr= static_cast<RPL_TABLE_LIST*>(ptr->next_global)) - { - if (ptr->m_tabledef.compatible_with(rli, ptr->table)) - { - mysql_unlock_tables(thd, thd->lock); - thd->lock= 0; - thd->query_error= 1; - const_cast<RELAY_LOG_INFO*>(rli)->clear_tables_to_lock(); - DBUG_RETURN(ERR_BAD_TABLE_DEF); - } - } - } - - /* - ... and then we add all the tables to the table map and remove - them from tables to lock. - - We also invalidate the query cache for all the tables, since - they will now be changed. + error= open_and_lock_tables(const_cast<RELAY_LOG_INFO*>(rli)); - TODO [/Matz]: Maybe the query cache should not be invalidated - here? It might be that a table is not changed, even though it - was locked for the statement. We do know that each - Rows_log_event contain at least one row, so after processing one - Rows_log_event, we can invalidate the query cache for the - associated table. - */ - for (TABLE_LIST *ptr= rli->tables_to_lock ; ptr ; ptr= ptr->next_global) - { - const_cast<RELAY_LOG_INFO*>(rli)->m_table_map.set_table(ptr->table_id, ptr->table); - } -#ifdef HAVE_QUERY_CACHE - query_cache.invalidate_locked_for_write(rli->tables_to_lock); -#endif - const_cast<RELAY_LOG_INFO*>(rli)->clear_tables_to_lock(); - } + if (error) + DBUG_RETURN(error); DBUG_ASSERT(rli->tables_to_lock == NULL && rli->tables_to_lock_count == 0); - TABLE* table= const_cast<RELAY_LOG_INFO*>(rli)->m_table_map.get_table(m_table_id); + TABLE* + table= + m_table= const_cast<RELAY_LOG_INFO*>(rli)->m_table_map.get_table(m_table_id); if (table) { @@ -6075,22 +5959,48 @@ int Rows_log_event::do_apply_event(RELAY */ const_cast<RELAY_LOG_INFO*>(rli)->set_flag(RELAY_LOG_INFO::IN_STMT); - error= do_before_row_operations(table); - while (error == 0 && row_start < m_rows_end) + /* + Initialize table's write and read sets. Extra columns are included + as they will be filled with default values. + + bit pos: 0 1 2 3 4 ... N-1 | N N+1 ... M | + bit val: X X X X X .... X | 1 1 ... 1 | + + N = number of columns on master (m_witdth) + M = number of columns on slave + X = bits from the row's column set (m_cols) + */ + + // TODO: consider doing this inside Table_map event + + bitmap_set_all(table->write_set); + + // Note: I (Rafal) couldn't find any bitmap function which would + // copy bits from m_cols to a prefix of write_set. + + for (uint bit=0 ; bit < m_width ; ++bit) + if (!bitmap_is_set(&m_cols,bit)) + bitmap_clear_bit(table->write_set,bit); + + bitmap_copy(table->read_set, table->write_set); + + error= do_before_row_operations(thd); + + // row processing loop + + while (error == 0 && m_curr_row < m_rows_end) { - uchar const *row_end= NULL; - if ((error= do_prepare_row(thd, rli, table, row_start, &row_end))) + if ((error= do_prepare_row(thd,rli))) break; // We should perform the after-row operation even in // the case of error - DBUG_ASSERT(row_end != NULL); // cannot happen - DBUG_ASSERT(row_end <= m_rows_end); - /* in_use can have been set to NULL in close_tables_for_reopen */ THD* old_thd= table->in_use; if (!table->in_use) table->in_use= thd; - error= do_exec_row(table); + + error= do_exec_row(thd); + table->in_use = old_thd; switch (error) { @@ -6109,18 +6019,27 @@ int Rows_log_event::do_apply_event(RELAY thd->query_error= 1; break; } + + // at this moment m_curr_row_end should be set + DBUG_ASSERT(m_curr_row_end != NULL); + DBUG_ASSERT(m_curr_row < m_curr_row_end); + DBUG_ASSERT(m_curr_row_end <= m_rows_end); + + m_curr_row= m_curr_row_end; + + } // row processing loop - row_start= row_end; - } DBUG_EXECUTE_IF("STOP_SLAVE_after_first_Rows_event", const_cast<RELAY_LOG_INFO*>(rli)->abort_slave= 1;); - error= do_after_row_operations(table, error); + + error= do_after_row_operations(thd, error); + if (!cache_stmt) { DBUG_PRINT("info", ("Marked that we need to keep log")); thd->options|= OPTION_KEEP_LOG; } - } + } // if (table) if (error) { /* error has occured during the transaction */ @@ -6191,6 +6110,147 @@ Rows_log_event::do_shall_skip(RELAY_LOG_ return Log_event::do_shall_skip(rli); } +/** + Open tables needed for Row events. + + This function is called after a sequence of Table_map events in the first + following Rows event. It opens and locks tables collected in the rli + structure while processing Table_map events. + + @returns Non-zero error code in case of an error. + */ +int Rows_log_event::open_and_lock_tables(RELAY_LOG_INFO *const rli) +{ + DBUG_ENTER("Rows_log_event::open_and_lock_tables"); + + int error; + bool need_reopen= 1; /* To execute the first lap of the loop below */ + + /* + lock_tables() reads the contents of thd->lex, so they must be + initialized. Contrary to in + Table_map_log_event::do_apply_event() we don't call + mysql_init_query() as that may reset the binlog format. + */ + lex_start(thd); + + while ((error= lock_tables(thd, rli->tables_to_lock, + rli->tables_to_lock_count, &need_reopen))) + { + if (!need_reopen) + { + if (thd->query_error || thd->is_fatal_error) + { + /* + Error reporting borrowed from Query_log_event with many excessive + simplifications (we don't honour --slave-skip-errors) + */ + uint actual_error= thd->net.last_errno; + rli->report(ERROR_LEVEL, actual_error, + "Error '%s' in %s event: when locking tables", + (actual_error ? thd->net.last_error : + "unexpected success or fatal error"), + get_type_str()); + thd->is_fatal_error= 1; + } + else + { + rli->report(ERROR_LEVEL, error, + "Error in %s event: when locking tables", + get_type_str()); + } + const_cast<RELAY_LOG_INFO*>(rli)->clear_tables_to_lock(); + DBUG_RETURN(error); + } + + /* + So we need to reopen the tables. + + We need to flush the pending RBR event, since it keeps a + pointer to an open table. + + ALTERNATIVE SOLUTION (not implemented): Extract a pointer to + the pending RBR event and reset the table pointer after the + tables has been reopened. + + NOTE: For this new scheme there should be no pending event: + need to add code to assert that is the case. + */ + thd->binlog_flush_pending_rows_event(false); + TABLE_LIST *tables= rli->tables_to_lock; + close_tables_for_reopen(thd, &tables); + + uint tables_count= rli->tables_to_lock_count; + if ((error= open_tables(thd, &tables, &tables_count, 0))) + { + if (thd->query_error || thd->is_fatal_error) + { + /* + Error reporting borrowed from Query_log_event with many excessive + simplifications (we don't honour --slave-skip-errors) + */ + uint actual_error= thd->net.last_errno; + rli->report(ERROR_LEVEL, actual_error, + "Error '%s' on reopening tables", + (actual_error ? thd->net.last_error : + "unexpected success or fatal error")); + thd->query_error= 1; + } + const_cast<RELAY_LOG_INFO*>(rli)->clear_tables_to_lock(); + DBUG_RETURN(error); + } + } + + /* + When the open and locking succeeded, we check all tables to + ensure that they still have the correct type. + + We can use a down cast here since we know that every table added + to the tables_to_lock is a RPL_TABLE_LIST. + */ + + { + RPL_TABLE_LIST *ptr= rli->tables_to_lock; + for ( ; ptr ; ptr= static_cast<RPL_TABLE_LIST*>(ptr->next_global)) + { + if (ptr->m_tabledef.compatible_with(rli, ptr->table)) + { + mysql_unlock_tables(thd, thd->lock); + thd->lock= 0; + thd->query_error= 1; + const_cast<RELAY_LOG_INFO*>(rli)->clear_tables_to_lock(); + DBUG_RETURN(ERR_BAD_TABLE_DEF); + } + } + } + + /* + ... and then we add all the tables to the table map and remove + them from tables to lock. + + We also invalidate the query cache for all the tables, since + they will now be changed. + + TODO [/Matz]: Maybe the query cache should not be invalidated + here? It might be that a table is not changed, even though it + was locked for the statement. We do know that each + Rows_log_event contain at least one row, so after processing one + Rows_log_event, we can invalidate the query cache for the + associated table. + */ + for (TABLE_LIST *ptr= rli->tables_to_lock ; ptr ; ptr= ptr->next_global) + { + const_cast<RELAY_LOG_INFO*>(rli)->m_table_map.set_table(ptr->table_id, ptr->table); + } +#ifdef HAVE_QUERY_CACHE + query_cache.invalidate_locked_for_write(rli->tables_to_lock); +#endif + const_cast<RELAY_LOG_INFO*>(rli)->clear_tables_to_lock(); + + DBUG_RETURN(0); +} + + int Rows_log_event::do_update_pos(RELAY_LOG_INFO *rli) { @@ -6786,7 +6846,7 @@ Write_rows_log_event::Write_rows_log_eve #endif #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) -int Write_rows_log_event::do_before_row_operations(TABLE *table) +int Write_rows_log_event::do_before_row_operations(THD *thd) { int error= 0; @@ -6808,26 +6868,26 @@ int Write_rows_log_event::do_before_row_ /* Do not raise the error flag in case of hitting to an unique attribute */ - table->file->extra(HA_EXTRA_IGNORE_DUP_KEY); + m_table->file->extra(HA_EXTRA_IGNORE_DUP_KEY); /* NDB specific: update from ndb master wrapped as Write_rows */ /* so that the event should be applied to replace slave's row */ - table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE); + m_table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE); /* NDB specific: if update from ndb master wrapped as Write_rows does not find the row it's assumed idempotent binlog applying is taking place; don't raise the error. */ - table->file->extra(HA_EXTRA_IGNORE_NO_KEY); + m_table->file->extra(HA_EXTRA_IGNORE_NO_KEY); /* TODO: the cluster team (Tomas?) says that it's better if the engine knows how many rows are going to be inserted, then it can allocate needed memory from the start. */ - table->file->ha_start_bulk_insert(0); + m_table->file->ha_start_bulk_insert(0); /* We need TIMESTAMP_NO_AUTO_SET otherwise ha_write_row() will not use fill any TIMESTAMP column with data from the row but instead will use @@ -6843,44 +6903,39 @@ int Write_rows_log_event::do_before_row_ some cases we won't want TIMESTAMP_NO_AUTO_SET (will require some code to analyze if explicit data is provided for slave's TIMESTAMP columns). */ - table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET; + m_table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET; return error; } -int Write_rows_log_event::do_after_row_operations(TABLE *table, int error) +int Write_rows_log_event::do_after_row_operations(THD *thd, int error) { int local_error= 0; - table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY); - table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE); + m_table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY); + m_table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE); /* reseting the extra with - table->file->extra(HA_EXTRA_NO_IGNORE_NO_KEY); + m_table->file->extra(HA_EXTRA_NO_IGNORE_NO_KEY); fires bug#27077 todo: explain or fix */ - if ((local_error= table->file->ha_end_bulk_insert())) + if ((local_error= m_table->file->ha_end_bulk_insert())) { - table->file->print_error(local_error, MYF(0)); + m_table->file->print_error(local_error, MYF(0)); } return error? error : local_error; } -int Write_rows_log_event::do_prepare_row(THD *thd, RELAY_LOG_INFO const *rli, - TABLE *table, - uchar const *const row_start, - uchar const **const row_end) +int Write_rows_log_event::do_prepare_row(THD *thd, + const RELAY_LOG_INFO *const rli) { - DBUG_ASSERT(table != NULL); - DBUG_ASSERT(row_start && row_end); + DBUG_ASSERT(m_table != NULL); - if (int error= unpack_row(rli, table, m_width, row_start, &m_cols, row_end, - &m_master_reclength, table->write_set, WRITE_ROWS_EVENT)) - { - thd->net.last_errno= error; - return error; - } - bitmap_copy(table->read_set, table->write_set); - return 0; + int error1, error2; + error1= prepare_record(rli,m_table,m_width,TRUE /* check errors */); + error2= unpack_row(m_table, m_width, m_curr_row, &m_cols, + &m_curr_row_end, &m_master_reclength); + + return thd->net.last_errno= error2 ? error2 : error1; } /* @@ -6925,14 +6980,27 @@ namespace { } - /* Copy "extra" columns from record[1] to record[0]. - Copy the extra fields that are not present on the master but are - present on the slave from record[1] to record[0]. This is used - after fetching a record that are to be updated, either inside - replace_record() or as part of executing an update_row(). + Both records belong to @c table which is slave's copy of a master table. + This table can contain more columns than the master's counterpart. It is + assumed that record[0] contains data sent from master and thus + the extra fields are not filled. Record[1] should contain a record + from slave's table (corresponding to master's record[0]) and the function + copies the extra columns from here to record[0]. + + Note: this function assumes that all master's columns are filled in + record[0] - it should not contain any "holes". + + SYNOPIS + copy_extra_record_fields() + table The table defining record columns. + table->record[0] Target (master) record. + table->record[1] Source (slave) record. + master_reclength Length of master record. + master_fields Number of fields in master record (i.e. number of columns + on master) */ static int copy_extra_record_fields(TABLE *table, @@ -7046,16 +7114,20 @@ is_duplicate_key_error(int errcode) /* - Replace the provided record in the database. + Write a record to a table, replacing old record if it already exists there + (i.e. a record with the same primary key value is replaced by the new record). SYNOPSIS replace_record() thd Thread context for writing the record. table Table to which record should be written. + table->record[0] + The record to be written. + table->write_set + Set of columns in record[0] to be updated on replace. master_reclength Offset to first column that is not present on the master, - alternatively the length of the record on the master - side. + alternatively the length of the record on master. RETURN VALUE Error code on failure, 0 on success. @@ -7151,6 +7223,12 @@ replace_record(THD *thd, TABLE *table, */ copy_extra_record_fields(table, master_reclength, master_fields); +#ifndef DBUG_OFF + DBUG_PRINT("debug",("preparing for update: before and after image")); + DBUG_DUMP("record[1] (before)", table->record[1], table->s->reclength); + DBUG_DUMP("record[0] (after)", table->record[0], table->s->reclength); +#endif + /* REPLACE is defined as either INSERT or DELETE + INSERT. If possible, we can replace it with an UPDATE, but that will not @@ -7191,10 +7269,10 @@ replace_record(THD *thd, TABLE *table, DBUG_RETURN(error); } -int Write_rows_log_event::do_exec_row(TABLE *table) +int Write_rows_log_event::do_exec_row(THD *thd) { - DBUG_ASSERT(table != NULL); - int error= replace_record(thd, table, m_master_reclength, m_width); + DBUG_ASSERT(m_table != NULL); + int error= replace_record(thd, m_table, m_master_reclength, m_width); return error; } #endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */ @@ -7536,12 +7614,12 @@ Delete_rows_log_event::Delete_rows_log_e #endif #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) -int Delete_rows_log_event::do_before_row_operations(TABLE *table) +int Delete_rows_log_event::do_before_row_operations(THD *thd) { DBUG_ASSERT(m_memory == NULL); - if ((table->file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_POSITION) && - table->s->primary_key < MAX_KEY) + if ((m_table->file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_POSITION) && + m_table->s->primary_key < MAX_KEY) { /* We don't need to allocate any memory for m_after_image and @@ -7552,18 +7630,18 @@ int Delete_rows_log_event::do_before_row int error= 0; - if (table->s->keys > 0) + if (m_table->s->keys > 0) { m_memory= (uchar*) my_multi_malloc(MYF(MY_WME), &m_after_image, - (uint) table->s->reclength, + (uint) m_table->s->reclength, &m_key, - (uint) table->key_info->key_length, + (uint) m_table->key_info->key_length, NullS); } else { - m_after_image= (uchar*) my_malloc(table->s->reclength, MYF(MY_WME)); + m_after_image= (uchar*) my_malloc(m_table->s->reclength, MYF(MY_WME)); m_memory= (uchar*)m_after_image; m_key= NULL; } @@ -7573,10 +7651,10 @@ int Delete_rows_log_event::do_before_row return error; } -int Delete_rows_log_event::do_after_row_operations(TABLE *table, int error) +int Delete_rows_log_event::do_after_row_operations(THD *thd, int error) { /*error= ToDo:find out what this should really be, this triggers close_scan in nbd, returning error?*/ - table->file->ha_index_or_rnd_end(); + m_table->file->ha_index_or_rnd_end(); my_free(m_memory, MYF(MY_ALLOW_ZERO_PTR)); // Free for multi_malloc m_memory= NULL; m_after_image= NULL; @@ -7585,20 +7663,18 @@ int Delete_rows_log_event::do_after_row_ return error; } -int Delete_rows_log_event::do_prepare_row(THD *thd, RELAY_LOG_INFO const *rli, - TABLE *table, - uchar const *const row_start, - uchar const **const row_end) +int Delete_rows_log_event::do_prepare_row(THD *thd, + const RELAY_LOG_INFO *const rli) { - DBUG_ASSERT(row_start && row_end); /* This assertion actually checks that there is at least as many columns on the slave as on the master. */ - DBUG_ASSERT(table->s->fields >= m_width); + DBUG_ASSERT(m_table->s->fields >= m_width); - if (int error= unpack_row(rli, table, m_width, row_start, &m_cols, row_end, - &m_master_reclength, table->read_set, DELETE_ROWS_EVENT)) + prepare_record(rli,m_table,m_width); + if (int error= unpack_row(m_table, m_width, m_curr_row, &m_cols, + &m_curr_row_end, &m_master_reclength)) { thd->net.last_errno= error; return error; @@ -7610,27 +7686,27 @@ int Delete_rows_log_event::do_prepare_ro */ if (m_key) { - KEY *const key_info= table->key_info; + KEY *const key_info= m_table->key_info; - key_copy(m_key, table->record[0], key_info, 0); + key_copy(m_key, m_table->record[0], key_info, 0); } return 0; } -int Delete_rows_log_event::do_exec_row(TABLE *table) +int Delete_rows_log_event::do_exec_row(THD *thd) { int error; - DBUG_ASSERT(table != NULL); + DBUG_ASSERT(m_table != NULL); - if (!(error= find_and_fetch_row(table, m_key))) + if (!(error= find_and_fetch_row(m_table, m_key))) { /* Now we should have the right row to delete. We are using record[0] since it is guaranteed to point to a record with the correct value. */ - error= table->file->ha_delete_row(table->record[0]); + error= m_table->file->ha_delete_row(m_table->record[0]); } return error; } @@ -7723,39 +7799,39 @@ Update_rows_log_event::Update_rows_log_e #endif #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) -int Update_rows_log_event::do_before_row_operations(TABLE *table) +int Update_rows_log_event::do_before_row_operations(THD *thd) { DBUG_ASSERT(m_memory == NULL); int error= 0; - if (table->s->keys > 0) + if (m_table->s->keys > 0) { m_memory= (uchar*) my_multi_malloc(MYF(MY_WME), &m_after_image, - (uint) table->s->reclength, + (uint) m_table->s->reclength, &m_key, - (uint) table->key_info->key_length, + (uint) m_table->key_info->key_length, NullS); } else { - m_after_image= (uchar*) my_malloc(table->s->reclength, MYF(MY_WME)); + m_after_image= (uchar*) my_malloc(m_table->s->reclength, MYF(MY_WME)); m_memory= m_after_image; m_key= NULL; } if (!m_memory) return HA_ERR_OUT_OF_MEM; - table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET; + m_table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET; return error; } -int Update_rows_log_event::do_after_row_operations(TABLE *table, int error) +int Update_rows_log_event::do_after_row_operations(THD *thd, int error) { /*error= ToDo:find out what this should really be, this triggers close_scan in nbd, returning error?*/ - table->file->ha_index_or_rnd_end(); + m_table->file->ha_index_or_rnd_end(); my_free(m_memory, MYF(MY_ALLOW_ZERO_PTR)); m_memory= NULL; m_after_image= NULL; @@ -7764,53 +7840,52 @@ int Update_rows_log_event::do_after_row_ return error; } -int Update_rows_log_event::do_prepare_row(THD *thd, RELAY_LOG_INFO const *rli, - TABLE *table, - uchar const *const row_start, - uchar const **const row_end) +int Update_rows_log_event::do_prepare_row(THD *thd, + const RELAY_LOG_INFO *const rli) { int error; - DBUG_ASSERT(row_start && row_end); /* This assertion actually checks that there is at least as many columns on the slave as on the master. */ - DBUG_ASSERT(table->s->fields >= m_width); + DBUG_ASSERT(m_table->s->fields >= m_width); /* We need to perform some juggling below since unpack_row() always - unpacks into table->record[0]. For more information, see the + unpacks into m_table->record[0]. For more information, see the comments for unpack_row(). */ /* record[0] is the before image for the update */ - if ((error= unpack_row(rli, table, m_width, row_start, &m_cols, row_end, - &m_master_reclength, table->read_set, UPDATE_ROWS_EVENT))) + prepare_record(rli,m_table,m_width); + if ((error= unpack_row(m_table, m_width, m_curr_row, &m_cols, + &m_curr_row_end, &m_master_reclength))) { thd->net.last_errno= error; return error; } + store_record(m_table, record[1]); - store_record(table, record[1]); - uchar const *next_start = *row_end; - /* m_after_image is the after image for the update */ - if ((error= unpack_row(rli, table, m_width, next_start, &m_cols_ai, row_end, - &m_master_reclength, table->write_set, UPDATE_ROWS_EVENT))) + const uchar *next_start = m_curr_row_end; + + prepare_record(rli,m_table,m_width); + if((error= unpack_row(m_table, m_width, next_start, &m_cols_ai, + &m_curr_row_end, &m_master_reclength))) { thd->net.last_errno= error; return error; } - - bmove_align(m_after_image, table->record[0], table->s->reclength); - restore_record(table, record[1]); + /* m_after_image is the after image for the update */ + bmove_align(m_after_image, m_table->record[0], m_table->s->reclength); + restore_record(m_table, record[1]); /* Don't print debug messages when running valgrind since they can trigger false warnings. */ #ifndef HAVE_purify - DBUG_DUMP("record[0]", table->record[0], table->s->reclength); - DBUG_DUMP("m_after_image", m_after_image, table->s->reclength); + DBUG_DUMP("record[0]", m_table->record[0], m_table->s->reclength); + DBUG_DUMP("m_after_image", m_after_image, m_table->s->reclength); #endif /* @@ -7819,19 +7894,19 @@ int Update_rows_log_event::do_prepare_ro */ if (m_key) { - KEY *const key_info= table->key_info; + KEY *const key_info= m_table->key_info; - key_copy(m_key, table->record[0], key_info, 0); + key_copy(m_key, m_table->record[0], key_info, 0); } return error; } -int Update_rows_log_event::do_exec_row(TABLE *table) +int Update_rows_log_event::do_exec_row(THD *thd) { - DBUG_ASSERT(table != NULL); + DBUG_ASSERT(m_table != NULL); - int error= find_and_fetch_row(table, m_key); + int error= find_and_fetch_row(m_table, m_key); if (error) return error; @@ -7848,8 +7923,8 @@ int Update_rows_log_event::do_exec_row(T overwriting the default values that where put there by the unpack_row() function. */ - bmove_align(table->record[0], m_after_image, table->s->reclength); - copy_extra_record_fields(table, m_master_reclength, m_width); + bmove_align(m_table->record[0], m_after_image, m_table->s->reclength); + copy_extra_record_fields(m_table, m_master_reclength, m_width); /* Now we have the right row to update. The old row (the one we're @@ -7857,7 +7932,7 @@ int Update_rows_log_event::do_exec_row(T We also have copied the original values already in the slave's database into the after image delivered from the master. */ - error= table->file->ha_update_row(table->record[1], table->record[0]); + error= m_table->file->ha_update_row(m_table->record[1], m_table->record[0]); if (error == HA_ERR_RECORD_IS_THE_SAME) error= 0; diff -Nrup a/sql/log_event.h b/sql/log_event.h --- a/sql/log_event.h 2007-06-05 01:15:00 +02:00 +++ b/sql/log_event.h 2007-07-03 18:04:06 +02:00 @@ -2239,11 +2239,21 @@ protected: uchar *m_rows_cur; /* One-after the end of the data */ uchar *m_rows_end; /* One-after the end of the allocated space */ + const uchar *m_curr_row; /* Start of the row being processed */ + const uchar *m_curr_row_end; /* One-after the end of the current row */ + flag_set m_flags; /* Flags for row-level events */ private: #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + + /* + Used in a first event which comes after Table_map event to open + and lock tables needed for row operations. + */ + int open_and_lock_tables(RELAY_LOG_INFO *const); + virtual int do_apply_event(RELAY_LOG_INFO const *rli); virtual int do_update_pos(RELAY_LOG_INFO *rli); virtual enum_skip_reason do_shall_skip(RELAY_LOG_INFO *rli); @@ -2264,7 +2274,7 @@ private: The member function will return 0 if all went OK, or a non-zero error code otherwise. */ - virtual int do_before_row_operations(TABLE *table) = 0; + virtual int do_before_row_operations(THD*) = 0; /* Primitive to clean up after a sequence of row executions. @@ -2274,8 +2284,14 @@ private: After doing a sequence of do_prepare_row() and do_exec_row(), this member function should be called to clean up and release any allocated buffers. + + The error argument, if non-zero, indicates error which happened + while processing rows (or in the do_before_row_operations() function) + before calling this function. In that case this function should return + non-zero error code (the same error which was passed as an argument + if no errors were encountered here). */ - virtual int do_after_row_operations(TABLE *table, int error) = 0; + virtual int do_after_row_operations(THD*,int error) = 0; /* Primitive to prepare for handling one row in a row-level event. @@ -2283,33 +2299,30 @@ private: DESCRIPTION The member function prepares for execution of operations needed for one - row in a row-level event by reading up data from the buffer containing - the row. No specific interpretation of the data is normally done here, - since SQL thread specific data is not available: that data is made - available for the do_exec function. - - A pointer to the start of the next row, or NULL if the preparation - failed. Currently, preparation cannot fail, but don't rely on this - behavior. + row in a row-level event. The row is located at m_curr_row. The end of + the row might be unknown (in which case m_curr_row_end == m_curr_row) as + it is discovered only when the row data is unpacked and that can happen + later in do_exec_row(). RETURN VALUE Error code, if something went wrong, 0 otherwise. */ - virtual int do_prepare_row(THD*, RELAY_LOG_INFO const*, TABLE*, - uchar const *row_start, - uchar const **row_end) = 0; + virtual int do_prepare_row(THD*, const RELAY_LOG_INFO *const) =0; /* Primitive to do the actual execution necessary for a row. DESCRIPTION The member function will do the actual execution needed to handle a row. + The row is located at m_curr_row. When the function returns, + m_curr_row_end should point at the next row (one byte after the end + of the current row). RETURN VALUE 0 if execution succeeded, 1 if execution failed. */ - virtual int do_exec_row(TABLE *table) = 0; + virtual int do_exec_row(THD*) = 0; #endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */ }; @@ -2365,11 +2378,10 @@ private: uchar *m_memory; uchar *m_after_image; - virtual int do_before_row_operations(TABLE *table); - virtual int do_after_row_operations(TABLE *table, int error); - virtual int do_prepare_row(THD*, RELAY_LOG_INFO const*, TABLE*, - uchar const *row_start, uchar const **row_end); - virtual int do_exec_row(TABLE *table); + virtual int do_before_row_operations(THD*); + virtual int do_after_row_operations(THD*,int); + virtual int do_prepare_row(THD*, const RELAY_LOG_INFO *const); + virtual int do_exec_row(THD*); #endif }; @@ -2445,11 +2457,10 @@ protected: uchar *m_key; uchar *m_after_image; - virtual int do_before_row_operations(TABLE *table); - virtual int do_after_row_operations(TABLE *table, int error); - virtual int do_prepare_row(THD*, RELAY_LOG_INFO const*, TABLE*, - uchar const *row_start, uchar const **row_end); - virtual int do_exec_row(TABLE *table); + virtual int do_before_row_operations(THD*); + virtual int do_after_row_operations(THD*,int); + virtual int do_prepare_row(THD*, const RELAY_LOG_INFO *const); + virtual int do_exec_row(THD*); #endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */ }; @@ -2516,11 +2527,10 @@ protected: uchar *m_key; uchar *m_after_image; - virtual int do_before_row_operations(TABLE *table); - virtual int do_after_row_operations(TABLE *table, int error); - virtual int do_prepare_row(THD*, RELAY_LOG_INFO const*, TABLE*, - uchar const *row_start, uchar const **row_end); - virtual int do_exec_row(TABLE *table); + virtual int do_before_row_operations(THD*); + virtual int do_after_row_operations(THD*,int); + virtual int do_prepare_row(THD*, const RELAY_LOG_INFO *const); + virtual int do_exec_row(THD*); #endif }; diff -Nrup a/sql/log_event.h.orig b/sql/log_event.h.orig --- /dev/null Wed Dec 31 16:00:00 196900 +++ b/sql/log_event.h.orig 2007-07-03 12:44:46 +02:00 @@ -0,0 +1,2627 @@ +/* Copyright (C) 2000-2006 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +#ifndef _log_event_h +#define _log_event_h + +#if defined(USE_PRAGMA_INTERFACE) && !defined(MYSQL_CLIENT) +#pragma interface /* gcc class implementation */ +#endif + +#include <my_bitmap.h> +#include "rpl_constants.h" + +#define LOG_READ_EOF -1 +#define LOG_READ_BOGUS -2 +#define LOG_READ_IO -3 +#define LOG_READ_MEM -5 +#define LOG_READ_TRUNC -6 +#define LOG_READ_TOO_LARGE -7 + +#define LOG_EVENT_OFFSET 4 + +/* + 3 is MySQL 4.x; 4 is MySQL 5.0.0. + Compared to version 3, version 4 has: + - a different Start_log_event, which includes info about the binary log + (sizes of headers); this info is included for better compatibility if the + master's MySQL version is different from the slave's. + - all events have a unique ID (the triplet (server_id, timestamp at server + start, other) to be sure an event is not executed more than once in a + multimaster setup, example: + M1 + / \ + v v + M2 M3 + \ / + v v + S + if a query is run on M1, it will arrive twice on S, so we need that S + remembers the last unique ID it has processed, to compare and know if the + event should be skipped or not. Example of ID: we already have the server id + (4 bytes), plus: + timestamp_when_the_master_started (4 bytes), a counter (a sequence number + which increments every time we write an event to the binlog) (3 bytes). + Q: how do we handle when the counter is overflowed and restarts from 0 ? + + - Query and Load (Create or Execute) events may have a more precise timestamp + (with microseconds), number of matched/affected/warnings rows + and fields of session variables: SQL_MODE, + FOREIGN_KEY_CHECKS, UNIQUE_CHECKS, SQL_AUTO_IS_NULL, the collations and + charsets, the PASSWORD() version (old/new/...). +*/ +#define BINLOG_VERSION 4 + +/* + We could have used SERVER_VERSION_LENGTH, but this introduces an + obscure dependency - if somebody decided to change SERVER_VERSION_LENGTH + this would break the replication protocol +*/ +#define ST_SERVER_VER_LEN 50 + +/* + These are flags and structs to handle all the LOAD DATA INFILE options (LINES + TERMINATED etc). +*/ + +/* + These are flags and structs to handle all the LOAD DATA INFILE options (LINES + TERMINATED etc). + DUMPFILE_FLAG is probably useless (DUMPFILE is a clause of SELECT, not of LOAD + DATA). +*/ +#define DUMPFILE_FLAG 0x1 +#define OPT_ENCLOSED_FLAG 0x2 +#define REPLACE_FLAG 0x4 +#define IGNORE_FLAG 0x8 + +#define FIELD_TERM_EMPTY 0x1 +#define ENCLOSED_EMPTY 0x2 +#define LINE_TERM_EMPTY 0x4 +#define LINE_START_EMPTY 0x8 +#define ESCAPED_EMPTY 0x10 + +/***************************************************************************** + + old_sql_ex struct + + ****************************************************************************/ +struct old_sql_ex +{ + char field_term; + char enclosed; + char line_term; + char line_start; + char escaped; + char opt_flags; + char empty_flags; +}; + +#define NUM_LOAD_DELIM_STRS 5 + +/***************************************************************************** + + sql_ex_info struct + + ****************************************************************************/ +struct sql_ex_info +{ + sql_ex_info() {} /* Remove gcc warning */ + char* field_term; + char* enclosed; + char* line_term; + char* line_start; + char* escaped; + int cached_new_format; + uint8 field_term_len,enclosed_len,line_term_len,line_start_len, escaped_len; + char opt_flags; + char empty_flags; + + // store in new format even if old is possible + void force_new_format() { cached_new_format = 1;} + int data_size() + { + return (new_format() ? + field_term_len + enclosed_len + line_term_len + + line_start_len + escaped_len + 6 : 7); + } + bool write_data(IO_CACHE* file); + char* init(char* buf,char* buf_end,bool use_new_format); + bool new_format() + { + return ((cached_new_format != -1) ? cached_new_format : + (cached_new_format=(field_term_len > 1 || + enclosed_len > 1 || + line_term_len > 1 || line_start_len > 1 || + escaped_len > 1))); + } +}; + +/***************************************************************************** + + MySQL Binary Log + + This log consists of events. Each event has a fixed-length header, + possibly followed by a variable length data body. + + The data body consists of an optional fixed length segment (post-header) + and an optional variable length segment. + + See the #defines below for the format specifics. + + The events which really update data are Query_log_event, + Execute_load_query_log_event and old Load_log_event and + Execute_load_log_event events (Execute_load_query is used together with + Begin_load_query and Append_block events to replicate LOAD DATA INFILE. + Create_file/Append_block/Execute_load (which includes Load_log_event) + were used to replicate LOAD DATA before the 5.0.3). + + ****************************************************************************/ + +#define LOG_EVENT_HEADER_LEN 19 /* the fixed header length */ +#define OLD_HEADER_LEN 13 /* the fixed header length in 3.23 */ +/* + Fixed header length, where 4.x and 5.0 agree. That is, 5.0 may have a longer + header (it will for sure when we have the unique event's ID), but at least + the first 19 bytes are the same in 4.x and 5.0. So when we have the unique + event's ID, LOG_EVENT_HEADER_LEN will be something like 26, but + LOG_EVENT_MINIMAL_HEADER_LEN will remain 19. +*/ +#define LOG_EVENT_MINIMAL_HEADER_LEN 19 + +/* event-specific post-header sizes */ +// where 3.23, 4.x and 5.0 agree +#define QUERY_HEADER_MINIMAL_LEN (4 + 4 + 1 + 2) +// where 5.0 differs: 2 for len of N-bytes vars. +#define QUERY_HEADER_LEN (QUERY_HEADER_MINIMAL_LEN + 2) +#define LOAD_HEADER_LEN (4 + 4 + 4 + 1 +1 + 4) +#define START_V3_HEADER_LEN (2 + ST_SERVER_VER_LEN + 4) +#define ROTATE_HEADER_LEN 8 // this is FROZEN (the Rotate post-header is frozen) +#define CREATE_FILE_HEADER_LEN 4 +#define APPEND_BLOCK_HEADER_LEN 4 +#define EXEC_LOAD_HEADER_LEN 4 +#define DELETE_FILE_HEADER_LEN 4 +#define FORMAT_DESCRIPTION_HEADER_LEN (START_V3_HEADER_LEN+1+LOG_EVENT_TYPES) +#define ROWS_HEADER_LEN 8 +#define TABLE_MAP_HEADER_LEN 8 +#define EXECUTE_LOAD_QUERY_EXTRA_HEADER_LEN (4 + 4 + 4 + 1) +#define EXECUTE_LOAD_QUERY_HEADER_LEN (QUERY_HEADER_LEN + EXECUTE_LOAD_QUERY_EXTRA_HEADER_LEN) +#define INCIDENT_HEADER_LEN 2 +/* + Max number of possible extra bytes in a replication event compared to a + packet (i.e. a query) sent from client to master; + First, an auxiliary log_event status vars estimation: +*/ +#define MAX_SIZE_LOG_EVENT_STATUS (4 /* flags2 */ + \ + 8 /* sql mode */ + \ + 1 + 1 + 255 /* catalog */ + \ + 4 /* autoinc */ + \ + 6 /* charset */ + \ + MAX_TIME_ZONE_NAME_LENGTH) +#define MAX_LOG_EVENT_HEADER ( /* in order of Query_log_event::write */ \ + LOG_EVENT_HEADER_LEN + /* write_header */ \ + QUERY_HEADER_LEN + /* write_data */ \ + EXECUTE_LOAD_QUERY_EXTRA_HEADER_LEN + /*write_post_header_for_derived */ \ + MAX_SIZE_LOG_EVENT_STATUS + /* status */ \ + NAME_LEN + 1) + +/* + Event header offsets; + these point to places inside the fixed header. +*/ + +#define EVENT_TYPE_OFFSET 4 +#define SERVER_ID_OFFSET 5 +#define EVENT_LEN_OFFSET 9 +#define LOG_POS_OFFSET 13 +#define FLAGS_OFFSET 17 + +/* start event post-header (for v3 and v4) */ + +#define ST_BINLOG_VER_OFFSET 0 +#define ST_SERVER_VER_OFFSET 2 +#define ST_CREATED_OFFSET (ST_SERVER_VER_OFFSET + ST_SERVER_VER_LEN) +#define ST_COMMON_HEADER_LEN_OFFSET (ST_CREATED_OFFSET + 4) + +/* slave event post-header (this event is never written) */ + +#define SL_MASTER_PORT_OFFSET 8 +#define SL_MASTER_POS_OFFSET 0 +#define SL_MASTER_HOST_OFFSET 10 + +/* query event post-header */ + +#define Q_THREAD_ID_OFFSET 0 +#define Q_EXEC_TIME_OFFSET 4 +#define Q_DB_LEN_OFFSET 8 +#define Q_ERR_CODE_OFFSET 9 +#define Q_STATUS_VARS_LEN_OFFSET 11 +#define Q_DATA_OFFSET QUERY_HEADER_LEN +/* these are codes, not offsets; not more than 256 values (1 byte). */ +#define Q_FLAGS2_CODE 0 +#define Q_SQL_MODE_CODE 1 +/* + Q_CATALOG_CODE is catalog with end zero stored; it is used only by MySQL + 5.0.x where 0<=x<=3. We have to keep it to be able to replicate these + old masters. +*/ +#define Q_CATALOG_CODE 2 +#define Q_AUTO_INCREMENT 3 +#define Q_CHARSET_CODE 4 +#define Q_TIME_ZONE_CODE 5 +/* + Q_CATALOG_NZ_CODE is catalog withOUT end zero stored; it is used by MySQL + 5.0.x where x>=4. Saves one byte in every Query_log_event in binlog, + compared to Q_CATALOG_CODE. The reason we didn't simply re-use + Q_CATALOG_CODE is that then a 5.0.3 slave of this 5.0.x (x>=4) master would + crash (segfault etc) because it would expect a 0 when there is none. +*/ +#define Q_CATALOG_NZ_CODE 6 + +#define Q_LC_TIME_NAMES_CODE 7 + +#define Q_CHARSET_DATABASE_CODE 8 +/* Intvar event post-header */ + +#define I_TYPE_OFFSET 0 +#define I_VAL_OFFSET 1 + +/* Rand event post-header */ + +#define RAND_SEED1_OFFSET 0 +#define RAND_SEED2_OFFSET 8 + +/* User_var event post-header */ + +#define UV_VAL_LEN_SIZE 4 +#define UV_VAL_IS_NULL 1 +#define UV_VAL_TYPE_SIZE 1 +#define UV_NAME_LEN_SIZE 4 +#define UV_CHARSET_NUMBER_SIZE 4 + +/* Load event post-header */ + +#define L_THREAD_ID_OFFSET 0 +#define L_EXEC_TIME_OFFSET 4 +#define L_SKIP_LINES_OFFSET 8 +#define L_TBL_LEN_OFFSET 12 +#define L_DB_LEN_OFFSET 13 +#define L_NUM_FIELDS_OFFSET 14 +#define L_SQL_EX_OFFSET 18 +#define L_DATA_OFFSET LOAD_HEADER_LEN + +/* Rotate event post-header */ + +#define R_POS_OFFSET 0 +#define R_IDENT_OFFSET 8 + +/* CF to DF handle LOAD DATA INFILE */ + +/* CF = "Create File" */ +#define CF_FILE_ID_OFFSET 0 +#define CF_DATA_OFFSET CREATE_FILE_HEADER_LEN + +/* AB = "Append Block" */ +#define AB_FILE_ID_OFFSET 0 +#define AB_DATA_OFFSET APPEND_BLOCK_HEADER_LEN + +/* EL = "Execute Load" */ +#define EL_FILE_ID_OFFSET 0 + +/* DF = "Delete File" */ +#define DF_FILE_ID_OFFSET 0 + +/* TM = "Table Map" */ +#define TM_MAPID_OFFSET 0 +#define TM_FLAGS_OFFSET 6 + +/* RW = "RoWs" */ +#define RW_MAPID_OFFSET 0 +#define RW_FLAGS_OFFSET 6 + +/* ELQ = "Execute Load Query" */ +#define ELQ_FILE_ID_OFFSET QUERY_HEADER_LEN +#define ELQ_FN_POS_START_OFFSET ELQ_FILE_ID_OFFSET + 4 +#define ELQ_FN_POS_END_OFFSET ELQ_FILE_ID_OFFSET + 8 +#define ELQ_DUP_HANDLING_OFFSET ELQ_FILE_ID_OFFSET + 12 + +/* 4 bytes which all binlogs should begin with */ +#define BINLOG_MAGIC "\xfe\x62\x69\x6e" + +/* + The 2 flags below were useless : + - the first one was never set + - the second one was set in all Rotate events on the master, but not used for + anything useful. + So they are now removed and their place may later be reused for other + flags. Then one must remember that Rotate events in 4.x have + LOG_EVENT_FORCED_ROTATE_F set, so one should not rely on the value of the + replacing flag when reading a Rotate event. + I keep the defines here just to remember what they were. +*/ +#ifdef TO_BE_REMOVED +#define LOG_EVENT_TIME_F 0x1 +#define LOG_EVENT_FORCED_ROTATE_F 0x2 +#endif + +/* + This flag only makes sense for Format_description_log_event. It is set + when the event is written, and *reset* when a binlog file is + closed (yes, it's the only case when MySQL modifies already written + part of binlog). Thus it is a reliable indicator that binlog was + closed correctly. (Stop_log_event is not enough, there's always a + small chance that mysqld crashes in the middle of insert and end of + the binlog would look like a Stop_log_event). + + This flag is used to detect a restart after a crash, and to provide + "unbreakable" binlog. The problem is that on a crash storage engines + rollback automatically, while binlog does not. To solve this we use this + flag and automatically append ROLLBACK to every non-closed binlog (append + virtually, on reading, file itself is not changed). If this flag is found, + mysqlbinlog simply prints "ROLLBACK" Replication master does not abort on + binlog corruption, but takes it as EOF, and replication slave forces a + rollback in this case. + + Note, that old binlogs does not have this flag set, so we get a + a backward-compatible behaviour. +*/ + +#define LOG_EVENT_BINLOG_IN_USE_F 0x1 + +/* + If the query depends on the thread (for example: TEMPORARY TABLE). + Currently this is used by mysqlbinlog to know it must print + SET @@PSEUDO_THREAD_ID=xx; before the query (it would not hurt to print it + for every query but this would be slow). +*/ +#define LOG_EVENT_THREAD_SPECIFIC_F 0x4 + +/* + Suppress the generation of 'USE' statements before the actual + statement. This flag should be set for any events that does not need + the current database set to function correctly. Most notable cases + are 'CREATE DATABASE' and 'DROP DATABASE'. + + This flags should only be used in exceptional circumstances, since + it introduce a significant change in behaviour regarding the + replication logic together with the flags --binlog-do-db and + --replicated-do-db. + */ +#define LOG_EVENT_SUPPRESS_USE_F 0x8 + +/* + The table map version internal to the log should be increased after + the event has been written to the binary log. + */ +#define LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F 0x10 + +/* + OPTIONS_WRITTEN_TO_BIN_LOG are the bits of thd->options which must be + written to the binlog. OPTIONS_WRITTEN_TO_BINLOG could be written + into the Format_description_log_event, so that if later we don't want + to replicate a variable we did replicate, or the contrary, it's + doable. But it should not be too hard to decide once for all of what + we replicate and what we don't, among the fixed 32 bits of + thd->options. + I (Guilhem) have read through every option's usage, and it looks like + OPTION_AUTO_IS_NULL and OPTION_NO_FOREIGN_KEYS are the only ones + which alter how the query modifies the table. It's good to replicate + OPTION_RELAXED_UNIQUE_CHECKS too because otherwise, the slave may + insert data slower than the master, in InnoDB. + OPTION_BIG_SELECTS is not needed (the slave thread runs with + max_join_size=HA_POS_ERROR) and OPTION_BIG_TABLES is not needed + either, as the manual says (because a too big in-memory temp table is + automatically written to disk). +*/ +#define OPTIONS_WRITTEN_TO_BIN_LOG \ + (OPTION_AUTO_IS_NULL | OPTION_NO_FOREIGN_KEY_CHECKS | \ + OPTION_RELAXED_UNIQUE_CHECKS | OPTION_NOT_AUTOCOMMIT) + +/* Shouldn't be defined before */ +#define EXPECTED_OPTIONS \ + ((ULL(1) << 14) | (ULL(1) << 26) | (ULL(1) << 27) | (ULL(1) << 19)) + +#if OPTIONS_WRITTEN_TO_BIN_LOG != EXPECTED_OPTIONS +#error OPTIONS_WRITTEN_TO_BIN_LOG must NOT change their values! +#endif +#undef EXPECTED_OPTIONS /* You shouldn't use this one */ + +enum Log_event_type +{ + /* + Every time you update this enum (when you add a type), you have to + fix Format_description_log_event::Format_description_log_event(). + */ + UNKNOWN_EVENT= 0, + START_EVENT_V3= 1, + QUERY_EVENT= 2, + STOP_EVENT= 3, + ROTATE_EVENT= 4, + INTVAR_EVENT= 5, + LOAD_EVENT= 6, + SLAVE_EVENT= 7, + CREATE_FILE_EVENT= 8, + APPEND_BLOCK_EVENT= 9, + EXEC_LOAD_EVENT= 10, + DELETE_FILE_EVENT= 11, + /* + NEW_LOAD_EVENT is like LOAD_EVENT except that it has a longer + sql_ex, allowing multibyte TERMINATED BY etc; both types share the + same class (Load_log_event) + */ + NEW_LOAD_EVENT= 12, + RAND_EVENT= 13, + USER_VAR_EVENT= 14, + FORMAT_DESCRIPTION_EVENT= 15, + XID_EVENT= 16, + BEGIN_LOAD_QUERY_EVENT= 17, + EXECUTE_LOAD_QUERY_EVENT= 18, + + TABLE_MAP_EVENT = 19, + + /* + These event numbers were used for 5.1.0 to 5.1.15 and are + therefore obsolete. + */ + PRE_GA_WRITE_ROWS_EVENT = 20, + PRE_GA_UPDATE_ROWS_EVENT = 21, + PRE_GA_DELETE_ROWS_EVENT = 22, + + /* + These event numbers are used from 5.1.16 and forward + */ + WRITE_ROWS_EVENT = 23, + UPDATE_ROWS_EVENT = 24, + DELETE_ROWS_EVENT = 25, + + /* + Something out of the ordinary happened on the master + */ + INCIDENT_EVENT= 26, + + /* + Add new events here - right above this comment! + Existing events (except ENUM_END_EVENT) should never change their numbers + */ + + ENUM_END_EVENT /* end marker */ +}; + +/* + The number of types we handle in Format_description_log_event (UNKNOWN_EVENT + is not to be handled, it does not exist in binlogs, it does not have a + format). +*/ +#define LOG_EVENT_TYPES (ENUM_END_EVENT-1) + +enum Int_event_type +{ + INVALID_INT_EVENT = 0, LAST_INSERT_ID_EVENT = 1, INSERT_ID_EVENT = 2 +}; + + +#ifndef MYSQL_CLIENT +class String; +class MYSQL_BIN_LOG; +class THD; +#endif + +class Format_description_log_event; + +struct st_relay_log_info; +typedef st_relay_log_info RELAY_LOG_INFO; + +#ifdef MYSQL_CLIENT +/* + A structure for mysqlbinlog to know how to print events + + This structure is passed to the event's print() methods, + + There are two types of settings stored here: + 1. Last db, flags2, sql_mode etc comes from the last printed event. + They are stored so that only the necessary USE and SET commands + are printed. + 2. Other information on how to print the events, e.g. short_form, + hexdump_from. These are not dependent on the last event. +*/ +typedef struct st_print_event_info +{ + /* + Settings for database, sql_mode etc that comes from the last event + that was printed. + */ + // TODO: have the last catalog here ?? + char db[FN_REFLEN+1]; // TODO: make this a LEX_STRING when thd->db is + bool flags2_inited; + uint32 flags2; + bool sql_mode_inited; + ulong sql_mode; /* must be same as THD.variables.sql_mode */ + ulong auto_increment_increment, auto_increment_offset; + bool charset_inited; + char charset[6]; // 3 variables, each of them storable in 2 bytes + char time_zone_str[MAX_TIME_ZONE_NAME_LENGTH]; + uint lc_time_names_number; + uint charset_database_number; + st_print_event_info() + :flags2_inited(0), sql_mode_inited(0), + auto_increment_increment(1),auto_increment_offset(1), charset_inited(0), + lc_time_names_number(0), charset_database_number(0) + { + /* + Currently we only use static PRINT_EVENT_INFO objects, so zeroed at + program's startup, but these explicit bzero() is for the day someone + creates dynamic instances. + */ + bzero(db, sizeof(db)); + bzero(charset, sizeof(charset)); + bzero(time_zone_str, sizeof(time_zone_str)); + delimiter[0]= ';'; + delimiter[1]= 0; + myf const flags = MYF(MY_WME | MY_NABP); + open_cached_file(&head_cache, NULL, NULL, 0, flags); + open_cached_file(&body_cache, NULL, NULL, 0, flags); + } + + ~st_print_event_info() { + close_cached_file(&head_cache); + close_cached_file(&body_cache); + } + bool init_ok() /* tells if construction was successful */ + { return my_b_inited(&head_cache) && my_b_inited(&body_cache); } + + + /* Settings on how to print the events */ + bool short_form; + bool base64_output; + my_off_t hexdump_from; + uint8 common_header_len; + char delimiter[16]; + + /* + These two caches are used by the row-based replication events to + collect the header information and the main body of the events + making up a statement. + */ + IO_CACHE head_cache; + IO_CACHE body_cache; +} PRINT_EVENT_INFO; +#endif + + +/***************************************************************************** + + Log_event class + + This is the abstract base class for binary log events. + + ****************************************************************************/ +class Log_event +{ +public: + /** + Enumeration of what kinds of skipping (and non-skipping) that can + occur when the slave executes an event. + + @see shall_skip + @see do_shall_skip + */ + enum enum_skip_reason { + /** + Don't skip event. + */ + EVENT_SKIP_NOT, + + /** + Skip event by ignoring it. + + This means that the slave skip counter will not be changed. + */ + EVENT_SKIP_IGNORE, + + /** + Skip event and decrease skip counter. + */ + EVENT_SKIP_COUNT + }; + + + /* + The following type definition is to be used whenever data is placed + and manipulated in a common buffer. Use this typedef for buffers + that contain data containing binary and character data. + */ + typedef unsigned char Byte; + + /* + The offset in the log where this event originally appeared (it is + preserved in relay logs, making SHOW SLAVE STATUS able to print + coordinates of the event in the master's binlog). Note: when a + transaction is written by the master to its binlog (wrapped in + BEGIN/COMMIT) the log_pos of all the queries it contains is the + one of the BEGIN (this way, when one does SHOW SLAVE STATUS it + sees the offset of the BEGIN, which is logical as rollback may + occur), except the COMMIT query which has its real offset. + */ + my_off_t log_pos; + /* + A temp buffer for read_log_event; it is later analysed according to the + event's type, and its content is distributed in the event-specific fields. + */ + char *temp_buf; + /* + Timestamp on the master(for debugging and replication of + NOW()/TIMESTAMP). It is important for queries and LOAD DATA + INFILE. This is set at the event's creation time, except for Query + and Load (et al.) events where this is set at the query's + execution time, which guarantees good replication (otherwise, we + could have a query and its event with different timestamps). + */ + time_t when; + /* The number of seconds the query took to run on the master. */ + ulong exec_time; + /* Number of bytes written by write() function */ + ulong data_written; + + /* + The master's server id (is preserved in the relay log; used to + prevent from infinite loops in circular replication). + */ + uint32 server_id; + + /* + Some 16 flags. Look above for LOG_EVENT_TIME_F, + LOG_EVENT_FORCED_ROTATE_F, LOG_EVENT_THREAD_SPECIFIC_F, and + LOG_EVENT_SUPPRESS_USE_F for notes. + */ + uint16 flags; + + bool cache_stmt; + +#ifndef MYSQL_CLIENT + THD* thd; + + Log_event(); + Log_event(THD* thd_arg, uint16 flags_arg, bool cache_stmt); + /* + read_log_event() functions read an event from a binlog or relay + log; used by SHOW BINLOG EVENTS, the binlog_dump thread on the + master (reads master's binlog), the slave IO thread (reads the + event sent by binlog_dump), the slave SQL thread (reads the event + from the relay log). If mutex is 0, the read will proceed without + mutex. We need the description_event to be able to parse the + event (to know the post-header's size); in fact in read_log_event + we detect the event's type, then call the specific event's + constructor and pass description_event as an argument. + */ + static Log_event* read_log_event(IO_CACHE* file, + pthread_mutex_t* log_lock, + const Format_description_log_event *description_event); + static int read_log_event(IO_CACHE* file, String* packet, + pthread_mutex_t* log_lock); + /* + init_show_field_list() prepares the column names and types for the + output of SHOW BINLOG EVENTS; it is used only by SHOW BINLOG + EVENTS. + */ + static void init_show_field_list(List<Item>* field_list); +#ifdef HAVE_REPLICATION + int net_send(Protocol *protocol, const char* log_name, my_off_t pos); + + /* + pack_info() is used by SHOW BINLOG EVENTS; as print() it prepares and sends + a string to display to the user, so it resembles print(). + */ + + virtual void pack_info(Protocol *protocol); + +#endif /* HAVE_REPLICATION */ + virtual const char* get_db() + { + return thd ? thd->db : 0; + } +#else + Log_event() : temp_buf(0) {} + /* avoid having to link mysqlbinlog against libpthread */ + static Log_event* read_log_event(IO_CACHE* file, + const Format_description_log_event *description_event); + /* print*() functions are used by mysqlbinlog */ + virtual void print(FILE* file, PRINT_EVENT_INFO* print_event_info) = 0; + void print_timestamp(IO_CACHE* file, time_t *ts = 0); + void print_header(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info, + bool is_more); + void print_base64(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info, + bool is_more); +#endif + + static void *operator new(size_t size) + { + return (void*) my_malloc((uint)size, MYF(MY_WME|MY_FAE)); + } + + static void operator delete(void *ptr, size_t size) + { + my_free((uchar*) ptr, MYF(MY_WME|MY_ALLOW_ZERO_PTR)); + } + + /* Placement version of the above operators */ + static void *operator new(size_t, void* ptr) { return ptr; } + static void operator delete(void*, void*) { } + +#ifndef MYSQL_CLIENT + bool write_header(IO_CACHE* file, ulong data_length); + virtual bool write(IO_CACHE* file) + { + return (write_header(file, get_data_size()) || + write_data_header(file) || + write_data_body(file)); + } + virtual bool write_data_header(IO_CACHE* file) + { return 0; } + virtual bool write_data_body(IO_CACHE* file __attribute__((unused))) + { return 0; } +#endif + virtual Log_event_type get_type_code() = 0; + virtual bool is_valid() const = 0; + virtual bool is_artificial_event() { return 0; } + inline bool get_cache_stmt() const { return cache_stmt; } + Log_event(const char* buf, const Format_description_log_event* description_event); + virtual ~Log_event() { free_temp_buf();} + void register_temp_buf(char* buf) { temp_buf = buf; } + void free_temp_buf() + { + if (temp_buf) + { + my_free(temp_buf, MYF(0)); + temp_buf = 0; + } + } + /* + Get event length for simple events. For complicated events the length + is calculated during write() + */ + virtual int get_data_size() { return 0;} + static Log_event* read_log_event(const char* buf, uint event_len, + const char **error, + const Format_description_log_event + *description_event); + /* returns the human readable name of the event's type */ + const char* get_type_str(); + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) +public: + + /** + Apply the event to the database. + + This function represents the public interface for applying an + event. + + @see do_apply_event + */ + int apply_event(RELAY_LOG_INFO const *rli) { + return do_apply_event(rli); + } + + + /** + Update the relay log position. + + This function represents the public interface for "stepping over" + the event and will update the relay log information. + + @see do_update_pos + */ + int update_pos(RELAY_LOG_INFO *rli) + { + return do_update_pos(rli); + } + + /** + Decide if the event shall be skipped, and the reason for skipping + it. + + @see do_shall_skip + */ + enum_skip_reason shall_skip(RELAY_LOG_INFO *rli) + { + return do_shall_skip(rli); + } + +protected: + + /** + Primitive to apply an event to the database. + + This is where the change to the database is made. + + @note The primitive is protected instead of private, since there + is a hierarchy of actions to be performed in some cases. + + @see Format_description_log_event::do_apply_event() + + @param rli Pointer to relay log info structure + + @retval 0 Event applied successfully + @retval errno Error code if event application failed + */ + virtual int do_apply_event(RELAY_LOG_INFO const *rli) + { + return 0; /* Default implementation does nothing */ + } + + + /** + Advance relay log coordinates. + + This function is called to advance the relay log coordinates to + just after the event. It is essential that both the relay log + coordinate and the group log position is updated correctly, since + this function is used also for skipping events. + + Normally, each implementation of do_update_pos() shall: + + - Update the event position to refer to the position just after + the event. + + - Update the group log position to refer to the position just + after the event <em>if the event is last in a group</em> + + @param rli Pointer to relay log info structure + + @retval 0 Coordinates changed successfully + @retval errno Error code if advancing failed (usually just + 1). Observe that handler errors are returned by the + do_apply_event() function, and not by this one. + */ + virtual int do_update_pos(RELAY_LOG_INFO *rli); + + + /** + Decide if this event shall be skipped or not and the reason for + skipping it. + + The default implementation decide that the event shall be skipped + if either: + + - the server id of the event is the same as the server id of the + server and <code>rli->replicate_same_server_id</code> is true, + or + + - if <code>rli->slave_skip_counter</code> is greater than zero. + + @see do_apply_event + @see do_update_pos + + @retval Log_event::EVENT_SKIP_NOT + The event shall not be skipped and should be applied. + + @retval Log_event::EVENT_SKIP_IGNORE + The event shall be skipped by just ignoring it, i.e., the slave + skip counter shall not be changed. This happends if, for example, + the originating server id of the event is the same as the server + id of the slave. + + @retval Log_event::EVENT_SKIP_COUNT + The event shall be skipped because the slave skip counter was + non-zero. The caller shall decrease the counter by one. + */ + virtual enum_skip_reason do_shall_skip(RELAY_LOG_INFO *rli); + +#endif +}; + +/* + One class for each type of event. + Two constructors for each class: + - one to create the event for logging (when the server acts as a master), + called after an update to the database is done, + which accepts parameters like the query, the database, the options for LOAD + DATA INFILE... + - one to create the event from a packet (when the server acts as a slave), + called before reproducing the update, which accepts parameters (like a + buffer). Used to read from the master, from the relay log, and in + mysqlbinlog. This constructor must be format-tolerant. +*/ + +/***************************************************************************** + + Query Log Event class + + Logs SQL queries + + ****************************************************************************/ +class Query_log_event: public Log_event +{ +protected: + Log_event::Byte* data_buf; +public: + const char* query; + const char* catalog; + const char* db; + /* + If we already know the length of the query string + we pass it with q_len, so we would not have to call strlen() + otherwise, set it to 0, in which case, we compute it with strlen() + */ + uint32 q_len; + uint32 db_len; + uint16 error_code; + ulong thread_id; + /* + For events created by Query_log_event::do_apply_event (and + Load_log_event::do_apply_event()) we need the *original* thread + id, to be able to log the event with the original (=master's) + thread id (fix for BUG#1686). + */ + ulong slave_proxy_id; + + /* + Binlog format 3 and 4 start to differ (as far as class members are + concerned) from here. + */ + + uint catalog_len; // <= 255 char; 0 means uninited + + /* + We want to be able to store a variable number of N-bit status vars: + (generally N=32; but N=64 for SQL_MODE) a user may want to log the number + of affected rows (for debugging) while another does not want to lose 4 + bytes in this. + The storage on disk is the following: + status_vars_len is part of the post-header, + status_vars are in the variable-length part, after the post-header, before + the db & query. + status_vars on disk is a sequence of pairs (code, value) where 'code' means + 'sql_mode', 'affected' etc. Sometimes 'value' must be a short string, so + its first byte is its length. For now the order of status vars is: + flags2 - sql_mode - catalog - autoinc - charset + We should add the same thing to Load_log_event, but in fact + LOAD DATA INFILE is going to be logged with a new type of event (logging of + the plain text query), so Load_log_event would be frozen, so no need. The + new way of logging LOAD DATA INFILE would use a derived class of + Query_log_event, so automatically benefit from the work already done for + status variables in Query_log_event. + */ + uint16 status_vars_len; + + /* + 'flags2' is a second set of flags (on top of those in Log_event), for + session variables. These are thd->options which is & against a mask + (OPTIONS_WRITTEN_TO_BINLOG). + flags2_inited helps make a difference between flags2==0 (3.23 or 4.x + master, we don't know flags2, so use the slave server's global options) and + flags2==0 (5.0 master, we know this has a meaning of flags all down which + must influence the query). + */ + bool flags2_inited; + bool sql_mode_inited; + bool charset_inited; + + uint32 flags2; + /* In connections sql_mode is 32 bits now but will be 64 bits soon */ + ulong sql_mode; + ulong auto_increment_increment, auto_increment_offset; + char charset[6]; + uint time_zone_len; /* 0 means uninited */ + const char *time_zone_str; + uint lc_time_names_number; /* 0 means en_US */ + uint charset_database_number; + +#ifndef MYSQL_CLIENT + + Query_log_event(THD* thd_arg, const char* query_arg, ulong query_length, + bool using_trans, bool suppress_use, + THD::killed_state killed_err_arg= THD::KILLED_NO_VALUE); + const char* get_db() { return db; } +#ifdef HAVE_REPLICATION + void pack_info(Protocol* protocol); +#endif /* HAVE_REPLICATION */ +#else + void print_query_header(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info); + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); +#endif + + Query_log_event(); + Query_log_event(const char* buf, uint event_len, + const Format_description_log_event *description_event, + Log_event_type event_type); + ~Query_log_event() + { + if (data_buf) + my_free((uchar*) data_buf, MYF(0)); + } + Log_event_type get_type_code() { return QUERY_EVENT; } +#ifndef MYSQL_CLIENT + bool write(IO_CACHE* file); + virtual bool write_post_header_for_derived(IO_CACHE* file) { return FALSE; } +#endif + bool is_valid() const { return query != 0; } + + /* + Returns number of bytes additionaly written to post header by derived + events (so far it is only Execute_load_query event). + */ + virtual ulong get_post_header_size_for_derived() { return 0; } + /* Writes derived event-specific part of post header. */ + +public: /* !!! Public in this patch to allow old usage */ +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); + virtual int do_update_pos(RELAY_LOG_INFO *rli); + + int do_apply_event(RELAY_LOG_INFO const *rli, + const char *query_arg, + uint32 q_len_arg); +#endif /* HAVE_REPLICATION */ +}; + + +/***************************************************************************** + + Muted Query Log Event class + + Pretends to Log SQL queries, but doesn't actually do so. + + ****************************************************************************/ +class Muted_query_log_event: public Query_log_event +{ +public: +#ifndef MYSQL_CLIENT + Muted_query_log_event(); + + bool write(IO_CACHE* file) { return(false); }; + virtual bool write_post_header_for_derived(IO_CACHE* file) { return FALSE; } +#else + Muted_query_log_event() {} +#endif +}; + + +#ifdef HAVE_REPLICATION + +/***************************************************************************** + + Slave Log Event class + Note that this class is currently not used at all; no code writes a + Slave_log_event (though some code in repl_failsafe.cc reads Slave_log_event). + So it's not a problem if this code is not maintained. + + ****************************************************************************/ +class Slave_log_event: public Log_event +{ +protected: + char* mem_pool; + void init_from_mem_pool(int data_size); +public: + my_off_t master_pos; + char* master_host; + char* master_log; + int master_host_len; + int master_log_len; + uint16 master_port; + +#ifndef MYSQL_CLIENT + Slave_log_event(THD* thd_arg, RELAY_LOG_INFO* rli); + void pack_info(Protocol* protocol); +#else + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); +#endif + + Slave_log_event(const char* buf, uint event_len); + ~Slave_log_event(); + int get_data_size(); + bool is_valid() const { return master_host != 0; } + Log_event_type get_type_code() { return SLAVE_EVENT; } +#ifndef MYSQL_CLIENT + bool write(IO_CACHE* file); +#endif + +private: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const* rli); +#endif +}; + +#endif /* HAVE_REPLICATION */ + + +/***************************************************************************** + + Load Log Event class + + ****************************************************************************/ +class Load_log_event: public Log_event +{ +private: + uint get_query_buffer_length(); + void print_query(bool need_db, char *buf, char **end, + char **fn_start, char **fn_end); +protected: + int copy_log_event(const char *buf, ulong event_len, + int body_offset, const Format_description_log_event* description_event); + +public: + ulong thread_id; + ulong slave_proxy_id; + uint32 table_name_len; + /* + No need to have a catalog, as these events can only come from 4.x. + TODO: this may become false if Dmitri pushes his new LOAD DATA INFILE in + 5.0 only (not in 4.x). + */ + uint32 db_len; + uint32 fname_len; + uint32 num_fields; + const char* fields; + const uchar* field_lens; + uint32 field_block_len; + + const char* table_name; + const char* db; + const char* fname; + uint32 skip_lines; + sql_ex_info sql_ex; + bool local_fname; + + /* fname doesn't point to memory inside Log_event::temp_buf */ + void set_fname_outside_temp_buf(const char *afname, uint alen) + { + fname= afname; + fname_len= alen; + local_fname= TRUE; + } + /* fname doesn't point to memory inside Log_event::temp_buf */ + int check_fname_outside_temp_buf() + { + return local_fname; + } + +#ifndef MYSQL_CLIENT + String field_lens_buf; + String fields_buf; + + Load_log_event(THD* thd, sql_exchange* ex, const char* db_arg, + const char* table_name_arg, + List<Item>& fields_arg, enum enum_duplicates handle_dup, bool ignore, + bool using_trans); + void set_fields(const char* db, List<Item> &fields_arg, + Name_resolution_context *context); + const char* get_db() { return db; } +#ifdef HAVE_REPLICATION + void pack_info(Protocol* protocol); +#endif /* HAVE_REPLICATION */ +#else + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); + void print(FILE* file, PRINT_EVENT_INFO* print_event_info, bool commented); +#endif + + /* + Note that for all the events related to LOAD DATA (Load_log_event, + Create_file/Append/Exec/Delete, we pass description_event; however as + logging of LOAD DATA is going to be changed in 4.1 or 5.0, this is only used + for the common_header_len (post_header_len will not be changed). + */ + Load_log_event(const char* buf, uint event_len, + const Format_description_log_event* description_event); + ~Load_log_event() + {} + Log_event_type get_type_code() + { + return sql_ex.new_format() ? NEW_LOAD_EVENT: LOAD_EVENT; + } +#ifndef MYSQL_CLIENT + bool write_data_header(IO_CACHE* file); + bool write_data_body(IO_CACHE* file); +#endif + bool is_valid() const { return table_name != 0; } + int get_data_size() + { + return (table_name_len + db_len + 2 + fname_len + + LOAD_HEADER_LEN + + sql_ex.data_size() + field_block_len + num_fields); + } + +public: /* !!! Public in this patch to allow old usage */ +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const* rli) + { + return do_apply_event(thd->slave_net,rli,0); + } + + int do_apply_event(NET *net, RELAY_LOG_INFO const *rli, + bool use_rli_only_for_errors); +#endif +}; + +extern char server_version[SERVER_VERSION_LENGTH]; + +/***************************************************************************** + + Start Log Event_v3 class + + Start_log_event_v3 is the Start_log_event of binlog format 3 (MySQL 3.23 and + 4.x). + Format_description_log_event derives from Start_log_event_v3; it is the + Start_log_event of binlog format 4 (MySQL 5.0), that is, the event that + describes the other events' header/postheader lengths. This event is sent by + MySQL 5.0 whenever it starts sending a new binlog if the requested position + is >4 (otherwise if ==4 the event will be sent naturally). + + ****************************************************************************/ + +class Start_log_event_v3: public Log_event +{ +public: + /* + If this event is at the start of the first binary log since server + startup 'created' should be the timestamp when the event (and the + binary log) was created. In the other case (i.e. this event is at + the start of a binary log created by FLUSH LOGS or automatic + rotation), 'created' should be 0. This "trick" is used by MySQL + >=4.0.14 slaves to know whether they must drop stale temporary + tables and whether they should abort unfinished transaction. + + Note that when 'created'!=0, it is always equal to the event's + timestamp; indeed Start_log_event is written only in log.cc where + the first constructor below is called, in which 'created' is set + to 'when'. So in fact 'created' is a useless variable. When it is + 0 we can read the actual value from timestamp ('when') and when it + is non-zero we can read the same value from timestamp + ('when'). Conclusion: + - we use timestamp to print when the binlog was created. + - we use 'created' only to know if this is a first binlog or not. + In 3.23.57 we did not pay attention to this identity, so mysqlbinlog in + 3.23.57 does not print 'created the_date' if created was zero. This is now + fixed. + */ + time_t created; + uint16 binlog_version; + char server_version[ST_SERVER_VER_LEN]; + /* + artifical_event is 1 in the case where this is a generated event that + should not case any cleanup actions. We handle this in the log by + setting log_event == 0 (for now). + */ + bool artificial_event; + +#ifndef MYSQL_CLIENT + Start_log_event_v3(); +#ifdef HAVE_REPLICATION + void pack_info(Protocol* protocol); +#endif /* HAVE_REPLICATION */ +#else + Start_log_event_v3() {} + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); +#endif + + Start_log_event_v3(const char* buf, + const Format_description_log_event* description_event); + ~Start_log_event_v3() {} + Log_event_type get_type_code() { return START_EVENT_V3;} +#ifndef MYSQL_CLIENT + bool write(IO_CACHE* file); +#endif + bool is_valid() const { return 1; } + int get_data_size() + { + return START_V3_HEADER_LEN; //no variable-sized part + } + virtual bool is_artificial_event() { return artificial_event; } + +protected: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); + virtual enum_skip_reason do_shall_skip(RELAY_LOG_INFO*) + { + /* + Events from ourself should be skipped, but they should not + decrease the slave skip counter. + */ + if (this->server_id == ::server_id) + return Log_event::EVENT_SKIP_IGNORE; + else + return Log_event::EVENT_SKIP_NOT; + } +#endif +}; + + +/* + For binlog version 4. + This event is saved by threads which read it, as they need it for future + use (to decode the ordinary events). +*/ + +class Format_description_log_event: public Start_log_event_v3 +{ +public: + /* + The size of the fixed header which _all_ events have + (for binlogs written by this version, this is equal to + LOG_EVENT_HEADER_LEN), except FORMAT_DESCRIPTION_EVENT and ROTATE_EVENT + (those have a header of size LOG_EVENT_MINIMAL_HEADER_LEN). + */ + uint8 common_header_len; + uint8 number_of_event_types; + /* The list of post-headers' lengthes */ + uint8 *post_header_len; + uchar server_version_split[3]; + + Format_description_log_event(uint8 binlog_ver, const char* server_ver=0); + Format_description_log_event(const char* buf, uint event_len, + const Format_description_log_event* description_event); + ~Format_description_log_event() { my_free((uchar*)post_header_len, MYF(0)); } + Log_event_type get_type_code() { return FORMAT_DESCRIPTION_EVENT;} +#ifndef MYSQL_CLIENT + bool write(IO_CACHE* file); +#endif + bool is_valid() const + { + return ((common_header_len >= ((binlog_version==1) ? OLD_HEADER_LEN : + LOG_EVENT_MINIMAL_HEADER_LEN)) && + (post_header_len != NULL)); + } + int get_data_size() + { + /* + The vector of post-header lengths is considered as part of the + post-header, because in a given version it never changes (contrary to the + query in a Query_log_event). + */ + return FORMAT_DESCRIPTION_HEADER_LEN; + } + + void calc_server_version_split(); + +protected: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); + virtual int do_update_pos(RELAY_LOG_INFO *rli); + virtual enum_skip_reason do_shall_skip(RELAY_LOG_INFO *rli); +#endif +}; + + +/***************************************************************************** + + Intvar Log Event class + + Logs special variables such as auto_increment values + + ****************************************************************************/ + +class Intvar_log_event: public Log_event +{ +public: + ulonglong val; + uchar type; + +#ifndef MYSQL_CLIENT + Intvar_log_event(THD* thd_arg,uchar type_arg, ulonglong val_arg) + :Log_event(thd_arg,0,0),val(val_arg),type(type_arg) + {} +#ifdef HAVE_REPLICATION + void pack_info(Protocol* protocol); +#endif /* HAVE_REPLICATION */ +#else + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); +#endif + + Intvar_log_event(const char* buf, const Format_description_log_event* description_event); + ~Intvar_log_event() {} + Log_event_type get_type_code() { return INTVAR_EVENT;} + const char* get_var_type_name(); + int get_data_size() { return 9; /* sizeof(type) + sizeof(val) */;} +#ifndef MYSQL_CLIENT + bool write(IO_CACHE* file); +#endif + bool is_valid() const { return 1; } + +private: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); + virtual int do_update_pos(RELAY_LOG_INFO *rli); + virtual enum_skip_reason do_shall_skip(RELAY_LOG_INFO *rli); +#endif +}; + + +/***************************************************************************** + + Rand Log Event class + + Logs random seed used by the next RAND(), and by PASSWORD() in 4.1.0. + 4.1.1 does not need it (it's repeatable again) so this event needn't be + written in 4.1.1 for PASSWORD() (but the fact that it is written is just a + waste, it does not cause bugs). + + ****************************************************************************/ + +class Rand_log_event: public Log_event +{ + public: + ulonglong seed1; + ulonglong seed2; + +#ifndef MYSQL_CLIENT + Rand_log_event(THD* thd_arg, ulonglong seed1_arg, ulonglong seed2_arg) + :Log_event(thd_arg,0,0),seed1(seed1_arg),seed2(seed2_arg) + {} +#ifdef HAVE_REPLICATION + void pack_info(Protocol* protocol); +#endif /* HAVE_REPLICATION */ +#else + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); +#endif + + Rand_log_event(const char* buf, const Format_description_log_event* description_event); + ~Rand_log_event() {} + Log_event_type get_type_code() { return RAND_EVENT;} + int get_data_size() { return 16; /* sizeof(ulonglong) * 2*/ } +#ifndef MYSQL_CLIENT + bool write(IO_CACHE* file); +#endif + bool is_valid() const { return 1; } + +private: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); + virtual int do_update_pos(RELAY_LOG_INFO *rli); + virtual enum_skip_reason do_shall_skip(RELAY_LOG_INFO *rli); +#endif +}; + +/***************************************************************************** + + Xid Log Event class + + Logs xid of the transaction-to-be-committed in the 2pc protocol. + Has no meaning in replication, slaves ignore it. + + ****************************************************************************/ +#ifdef MYSQL_CLIENT +typedef ulonglong my_xid; // this line is the same as in handler.h +#endif + +class Xid_log_event: public Log_event +{ + public: + my_xid xid; + +#ifndef MYSQL_CLIENT + Xid_log_event(THD* thd_arg, my_xid x): Log_event(thd_arg,0,0), xid(x) {} +#ifdef HAVE_REPLICATION + void pack_info(Protocol* protocol); +#endif /* HAVE_REPLICATION */ +#else + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); +#endif + + Xid_log_event(const char* buf, const Format_description_log_event* description_event); + ~Xid_log_event() {} + Log_event_type get_type_code() { return XID_EVENT;} + int get_data_size() { return sizeof(xid); } +#ifndef MYSQL_CLIENT + bool write(IO_CACHE* file); +#endif + bool is_valid() const { return 1; } + +private: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); +#endif +}; + +/***************************************************************************** + + User var Log Event class + + Every time a query uses the value of a user variable, a User_var_log_event is + written before the Query_log_event, to set the user variable. + + ****************************************************************************/ + +class User_var_log_event: public Log_event +{ +public: + char *name; + uint name_len; + char *val; + ulong val_len; + Item_result type; + uint charset_number; + bool is_null; +#ifndef MYSQL_CLIENT + User_var_log_event(THD* thd_arg, char *name_arg, uint name_len_arg, + char *val_arg, ulong val_len_arg, Item_result type_arg, + uint charset_number_arg) + :Log_event(), name(name_arg), name_len(name_len_arg), val(val_arg), + val_len(val_len_arg), type(type_arg), charset_number(charset_number_arg) + { is_null= !val; } + void pack_info(Protocol* protocol); +#else + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); +#endif + + User_var_log_event(const char* buf, const Format_description_log_event* description_event); + ~User_var_log_event() {} + Log_event_type get_type_code() { return USER_VAR_EVENT;} +#ifndef MYSQL_CLIENT + bool write(IO_CACHE* file); +#endif + bool is_valid() const { return 1; } + +private: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); + virtual int do_update_pos(RELAY_LOG_INFO *rli); + virtual enum_skip_reason do_shall_skip(RELAY_LOG_INFO *rli); +#endif +}; + + +/***************************************************************************** + + Stop Log Event class + + ****************************************************************************/ +class Stop_log_event: public Log_event +{ +public: +#ifndef MYSQL_CLIENT + Stop_log_event() :Log_event() + {} +#else + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); +#endif + + Stop_log_event(const char* buf, const Format_description_log_event* description_event): + Log_event(buf, description_event) + {} + ~Stop_log_event() {} + Log_event_type get_type_code() { return STOP_EVENT;} + bool is_valid() const { return 1; } + +private: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_update_pos(RELAY_LOG_INFO *rli); + virtual enum_skip_reason do_shall_skip(RELAY_LOG_INFO *rli) + { + /* + Events from ourself should be skipped, but they should not + decrease the slave skip counter. + */ + if (this->server_id == ::server_id) + return Log_event::EVENT_SKIP_IGNORE; + else + return Log_event::EVENT_SKIP_NOT; + } +#endif +}; + +/***************************************************************************** + + Rotate Log Event class + + This will be deprecated when we move to using sequence ids. + + ****************************************************************************/ + +class Rotate_log_event: public Log_event +{ +public: + enum { + DUP_NAME= 2 // if constructor should dup the string argument + }; + const char* new_log_ident; + ulonglong pos; + uint ident_len; + uint flags; +#ifndef MYSQL_CLIENT + Rotate_log_event(const char* new_log_ident_arg, + uint ident_len_arg, + ulonglong pos_arg, uint flags); +#ifdef HAVE_REPLICATION + void pack_info(Protocol* protocol); +#endif /* HAVE_REPLICATION */ +#else + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); +#endif + + Rotate_log_event(const char* buf, uint event_len, + const Format_description_log_event* description_event); + ~Rotate_log_event() + { + if (flags & DUP_NAME) + my_free((uchar*) new_log_ident, MYF(MY_ALLOW_ZERO_PTR)); + } + Log_event_type get_type_code() { return ROTATE_EVENT;} + int get_data_size() { return ident_len + ROTATE_HEADER_LEN;} + bool is_valid() const { return new_log_ident != 0; } +#ifndef MYSQL_CLIENT + bool write(IO_CACHE* file); +#endif + +private: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_update_pos(RELAY_LOG_INFO *rli); + virtual enum_skip_reason do_shall_skip(RELAY_LOG_INFO *rli); +#endif +}; + + +/* the classes below are for the new LOAD DATA INFILE logging */ + +/***************************************************************************** + Create File Log Event class + ****************************************************************************/ + +class Create_file_log_event: public Load_log_event +{ +protected: + /* + Pretend we are Load event, so we can write out just + our Load part - used on the slave when writing event out to + SQL_LOAD-*.info file + */ + bool fake_base; +public: + char* block; + const char *event_buf; + uint block_len; + uint file_id; + bool inited_from_old; + +#ifndef MYSQL_CLIENT + Create_file_log_event(THD* thd, sql_exchange* ex, const char* db_arg, + const char* table_name_arg, + List<Item>& fields_arg, + enum enum_duplicates handle_dup, bool ignore, + char* block_arg, uint block_len_arg, + bool using_trans); +#ifdef HAVE_REPLICATION + void pack_info(Protocol* protocol); +#endif /* HAVE_REPLICATION */ +#else + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); + void print(FILE* file, PRINT_EVENT_INFO* print_event_info, bool enable_local); +#endif + + Create_file_log_event(const char* buf, uint event_len, + const Format_description_log_event* description_event); + ~Create_file_log_event() + { + my_free((char*) event_buf, MYF(MY_ALLOW_ZERO_PTR)); + } + + Log_event_type get_type_code() + { + return fake_base ? Load_log_event::get_type_code() : CREATE_FILE_EVENT; + } + int get_data_size() + { + return (fake_base ? Load_log_event::get_data_size() : + Load_log_event::get_data_size() + + 4 + 1 + block_len); + } + bool is_valid() const { return inited_from_old || block != 0; } +#ifndef MYSQL_CLIENT + bool write_data_header(IO_CACHE* file); + bool write_data_body(IO_CACHE* file); + /* + Cut out Create_file extentions and + write it as Load event - used on the slave + */ + bool write_base(IO_CACHE* file); +#endif + +private: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); +#endif +}; + + +/***************************************************************************** + + Append Block Log Event class + + ****************************************************************************/ + +class Append_block_log_event: public Log_event +{ +public: + char* block; + uint block_len; + uint file_id; + /* + 'db' is filled when the event is created in mysql_load() (the + event needs to have a 'db' member to be well filtered by + binlog-*-db rules). 'db' is not written to the binlog (it's not + used by Append_block_log_event::write()), so it can't be read in + the Append_block_log_event(const char* buf, int event_len) + constructor. In other words, 'db' is used only for filtering by + binlog-*-db rules. Create_file_log_event is different: it's 'db' + (which is inherited from Load_log_event) is written to the binlog + and can be re-read. + */ + const char* db; + +#ifndef MYSQL_CLIENT + Append_block_log_event(THD* thd, const char* db_arg, char* block_arg, + uint block_len_arg, bool using_trans); +#ifdef HAVE_REPLICATION + void pack_info(Protocol* protocol); + virtual int get_create_or_append() const; +#endif /* HAVE_REPLICATION */ +#else + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); +#endif + + Append_block_log_event(const char* buf, uint event_len, + const Format_description_log_event* description_event); + ~Append_block_log_event() {} + Log_event_type get_type_code() { return APPEND_BLOCK_EVENT;} + int get_data_size() { return block_len + APPEND_BLOCK_HEADER_LEN ;} + bool is_valid() const { return block != 0; } +#ifndef MYSQL_CLIENT + bool write(IO_CACHE* file); + const char* get_db() { return db; } +#endif + +private: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); +#endif +}; + + +/***************************************************************************** + + Delete File Log Event class + + ****************************************************************************/ + +class Delete_file_log_event: public Log_event +{ +public: + uint file_id; + const char* db; /* see comment in Append_block_log_event */ + +#ifndef MYSQL_CLIENT + Delete_file_log_event(THD* thd, const char* db_arg, bool using_trans); +#ifdef HAVE_REPLICATION + void pack_info(Protocol* protocol); +#endif /* HAVE_REPLICATION */ +#else + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); + void print(FILE* file, PRINT_EVENT_INFO* print_event_info, bool enable_local); +#endif + + Delete_file_log_event(const char* buf, uint event_len, + const Format_description_log_event* description_event); + ~Delete_file_log_event() {} + Log_event_type get_type_code() { return DELETE_FILE_EVENT;} + int get_data_size() { return DELETE_FILE_HEADER_LEN ;} + bool is_valid() const { return file_id != 0; } +#ifndef MYSQL_CLIENT + bool write(IO_CACHE* file); + const char* get_db() { return db; } +#endif + +private: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); +#endif +}; + + +/***************************************************************************** + + Execute Load Log Event class + + ****************************************************************************/ + +class Execute_load_log_event: public Log_event +{ +public: + uint file_id; + const char* db; /* see comment in Append_block_log_event */ + +#ifndef MYSQL_CLIENT + Execute_load_log_event(THD* thd, const char* db_arg, bool using_trans); +#ifdef HAVE_REPLICATION + void pack_info(Protocol* protocol); +#endif /* HAVE_REPLICATION */ +#else + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); +#endif + + Execute_load_log_event(const char* buf, uint event_len, + const Format_description_log_event* description_event); + ~Execute_load_log_event() {} + Log_event_type get_type_code() { return EXEC_LOAD_EVENT;} + int get_data_size() { return EXEC_LOAD_HEADER_LEN ;} + bool is_valid() const { return file_id != 0; } +#ifndef MYSQL_CLIENT + bool write(IO_CACHE* file); + const char* get_db() { return db; } +#endif + +private: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); +#endif +}; + + +/*************************************************************************** + + Begin load query Log Event class + + Event for the first block of file to be loaded, its only difference from + Append_block event is that this event creates or truncates existing file + before writing data. + +****************************************************************************/ +class Begin_load_query_log_event: public Append_block_log_event +{ +public: +#ifndef MYSQL_CLIENT + Begin_load_query_log_event(THD* thd_arg, const char *db_arg, + char* block_arg, uint block_len_arg, + bool using_trans); +#ifdef HAVE_REPLICATION + Begin_load_query_log_event(THD* thd); + int get_create_or_append() const; +#endif /* HAVE_REPLICATION */ +#endif + Begin_load_query_log_event(const char* buf, uint event_len, + const Format_description_log_event* description_event); + ~Begin_load_query_log_event() {} + Log_event_type get_type_code() { return BEGIN_LOAD_QUERY_EVENT; } +}; + + +/* + Elements of this enum describe how LOAD DATA handles duplicates. +*/ +enum enum_load_dup_handling { LOAD_DUP_ERROR= 0, LOAD_DUP_IGNORE, + LOAD_DUP_REPLACE }; + +/**************************************************************************** + + Execute load query Log Event class + + Event responsible for LOAD DATA execution, it similar to Query_log_event + but before executing the query it substitutes original filename in LOAD DATA + query with name of temporary file. + +****************************************************************************/ +class Execute_load_query_log_event: public Query_log_event +{ +public: + uint file_id; // file_id of temporary file + uint fn_pos_start; // pointer to the part of the query that should + // be substituted + uint fn_pos_end; // pointer to the end of this part of query + /* + We have to store type of duplicate handling explicitly, because + for LOAD DATA it also depends on LOCAL option. And this part + of query will be rewritten during replication so this information + may be lost... + */ + enum_load_dup_handling dup_handling; + +#ifndef MYSQL_CLIENT + Execute_load_query_log_event(THD* thd, const char* query_arg, + ulong query_length, uint fn_pos_start_arg, + uint fn_pos_end_arg, + enum_load_dup_handling dup_handling_arg, + bool using_trans, bool suppress_use); +#ifdef HAVE_REPLICATION + void pack_info(Protocol* protocol); +#endif /* HAVE_REPLICATION */ +#else + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); + /* Prints the query as LOAD DATA LOCAL and with rewritten filename */ + void print(FILE* file, PRINT_EVENT_INFO* print_event_info, + const char *local_fname); +#endif + Execute_load_query_log_event(const char* buf, uint event_len, + const Format_description_log_event *description_event); + ~Execute_load_query_log_event() {} + + Log_event_type get_type_code() { return EXECUTE_LOAD_QUERY_EVENT; } + bool is_valid() const { return Query_log_event::is_valid() && file_id != 0; } + + ulong get_post_header_size_for_derived(); +#ifndef MYSQL_CLIENT + bool write_post_header_for_derived(IO_CACHE* file); +#endif + +private: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); +#endif +}; + + +#ifdef MYSQL_CLIENT +class Unknown_log_event: public Log_event +{ +public: + /* + Even if this is an unknown event, we still pass description_event to + Log_event's ctor, this way we can extract maximum information from the + event's header (the unique ID for example). + */ + Unknown_log_event(const char* buf, const Format_description_log_event* description_event): + Log_event(buf, description_event) + {} + ~Unknown_log_event() {} + void print(FILE* file, PRINT_EVENT_INFO* print_event_info); + Log_event_type get_type_code() { return UNKNOWN_EVENT;} + bool is_valid() const { return 1; } +}; +#endif +char *str_to_hex(char *to, const char *from, uint len); + +/***************************************************************************** + + Table map log event class + + Create a mapping from a (database name, table name) couple to a table + identifier (an integer number). + + ****************************************************************************/ +class Table_map_log_event : public Log_event +{ +public: + /* Constants */ + enum + { + TYPE_CODE = TABLE_MAP_EVENT + }; + + /** + Enumeration of the errors that can be returned. + */ + enum enum_error + { + ERR_OPEN_FAILURE = -1, /**< Failure to open table */ + ERR_OK = 0, /**< No error */ + ERR_TABLE_LIMIT_EXCEEDED = 1, /**< No more room for tables */ + ERR_OUT_OF_MEM = 2, /**< Out of memory */ + ERR_BAD_TABLE_DEF = 3, /**< Table definition does not match */ + ERR_RBR_TO_SBR = 4 /**< daisy-chanining RBR to SBR not allowed */ + }; + + enum enum_flag + { + /* + Nothing here right now, but the flags support is there in + preparation for changes that are coming. Need to add a + constant to make it compile under HP-UX: aCC does not like + empty enumerations. + */ + ENUM_FLAG_COUNT + }; + + typedef uint16 flag_set; + + /* Special constants representing sets of flags */ + enum + { + TM_NO_FLAGS = 0U + }; + + void set_flags(flag_set flag) { m_flags |= flag; } + void clear_flags(flag_set flag) { m_flags &= ~flag; } + flag_set get_flags(flag_set flag) const { return m_flags & flag; } + +#ifndef MYSQL_CLIENT + Table_map_log_event(THD *thd, TABLE *tbl, ulong tid, + bool is_transactional, uint16 flags); +#endif +#ifdef HAVE_REPLICATION + Table_map_log_event(const char *buf, uint event_len, + const Format_description_log_event *description_event); +#endif + + ~Table_map_log_event(); + + virtual Log_event_type get_type_code() { return TABLE_MAP_EVENT; } + virtual bool is_valid() const { return m_memory != NULL; /* we check malloc */ } + + virtual int get_data_size() { return m_data_size; } +#ifndef MYSQL_CLIENT + virtual bool write_data_header(IO_CACHE *file); + virtual bool write_data_body(IO_CACHE *file); + virtual const char *get_db() { return m_dbnam; } +#endif + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual void pack_info(Protocol *protocol); +#endif + +#ifdef MYSQL_CLIENT + virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info); +#endif + + +private: +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); + virtual int do_update_pos(RELAY_LOG_INFO *rli); + virtual enum_skip_reason do_shall_skip(RELAY_LOG_INFO *rli); +#endif + +#ifndef MYSQL_CLIENT + TABLE *m_table; +#endif + char const *m_dbnam; + size_t m_dblen; + char const *m_tblnam; + size_t m_tbllen; + ulong m_colcnt; + uchar *m_coltype; + + uchar *m_memory; + ulong m_table_id; + flag_set m_flags; + + size_t m_data_size; +}; + + +/***************************************************************************** + + Row level log event class. + + Common base class for all row-containing log events. + + RESPONSIBILITIES + + Encode the common parts of all events containing rows, which are: + - Write data header and data body to an IO_CACHE. + - Provide an interface for adding an individual row to the event. + + ****************************************************************************/ + + +class Rows_log_event : public Log_event +{ +public: + /** + Enumeration of the errors that can be returned. + */ + enum enum_error + { + ERR_OPEN_FAILURE = -1, /**< Failure to open table */ + ERR_OK = 0, /**< No error */ + ERR_TABLE_LIMIT_EXCEEDED = 1, /**< No more room for tables */ + ERR_OUT_OF_MEM = 2, /**< Out of memory */ + ERR_BAD_TABLE_DEF = 3, /**< Table definition does not match */ + ERR_RBR_TO_SBR = 4 /**< daisy-chanining RBR to SBR not allowed */ + }; + + /* + These definitions allow you to combine the flags into an + appropriate flag set using the normal bitwise operators. The + implicit conversion from an enum-constant to an integer is + accepted by the compiler, which is then used to set the real set + of flags. + */ + enum enum_flag + { + /* Last event of a statement */ + STMT_END_F = (1U << 0), + + /* Value of the OPTION_NO_FOREIGN_KEY_CHECKS flag in thd->options */ + NO_FOREIGN_KEY_CHECKS_F = (1U << 1), + + /* Value of the OPTION_RELAXED_UNIQUE_CHECKS flag in thd->options */ + RELAXED_UNIQUE_CHECKS_F = (1U << 2) + }; + + typedef uint16 flag_set; + + /* Special constants representing sets of flags */ + enum + { + RLE_NO_FLAGS = 0U + }; + + virtual ~Rows_log_event(); + + void set_flags(flag_set flags_arg) { m_flags |= flags_arg; } + void clear_flags(flag_set flags_arg) { m_flags &= ~flags_arg; } + flag_set get_flags(flag_set flags_arg) const { return m_flags & flags_arg; } + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual void pack_info(Protocol *protocol); +#endif + +#ifdef MYSQL_CLIENT + /* not for direct call, each derived has its own ::print() */ + virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info)= 0; +#endif + +#ifndef MYSQL_CLIENT + int add_row_data(uchar *data, size_t length) + { + return do_add_row_data(data,length); + } +#endif + + /* Member functions to implement superclass interface */ + virtual int get_data_size(); + + MY_BITMAP const *get_cols() const { return &m_cols; } + size_t get_width() const { return m_width; } + ulong get_table_id() const { return m_table_id; } + +#ifndef MYSQL_CLIENT + virtual bool write_data_header(IO_CACHE *file); + virtual bool write_data_body(IO_CACHE *file); + virtual const char *get_db() { return m_table->s->db.str; } +#endif + /* + Check that malloc() succeeded in allocating memory for the rows + buffer and the COLS vector. Checking that an Update_rows_log_event + is valid is done in the Update_rows_log_event::is_valid() + function. + */ + virtual bool is_valid() const + { + return m_rows_buf && m_cols.bitmap; + } + + uint m_row_count; /* The number of rows added to the event */ + +protected: + /* + The constructors are protected since you're supposed to inherit + this class, not create instances of this class. + */ +#ifndef MYSQL_CLIENT + Rows_log_event(THD*, TABLE*, ulong table_id, + MY_BITMAP const *cols, bool is_transactional); +#endif + Rows_log_event(const char *row_data, uint event_len, + Log_event_type event_type, + const Format_description_log_event *description_event); + +#ifdef MYSQL_CLIENT + void print_helper(FILE *, PRINT_EVENT_INFO *, char const *const name); +#endif + +#ifndef MYSQL_CLIENT + virtual int do_add_row_data(uchar *data, size_t length); +#endif + +#ifndef MYSQL_CLIENT + TABLE *m_table; /* The table the rows belong to */ +#endif + ulong m_table_id; /* Table ID */ + MY_BITMAP m_cols; /* Bitmap denoting columns available */ + ulong m_width; /* The width of the columns bitmap */ + /* + Bitmap for columns available in the after image, if present. These + fields are only available for Update_rows events. Observe that the + width of both the before image COLS vector and the after image + COLS vector is the same: the number of columns of the table on the + master. + */ + MY_BITMAP m_cols_ai; + + ulong m_master_reclength; /* Length of record on master side */ + + /* Bit buffers in the same memory as the class */ + uint32 m_bitbuf[128/(sizeof(uint32)*8)]; + uint32 m_bitbuf_ai[128/(sizeof(uint32)*8)]; + + uchar *m_rows_buf; /* The rows in packed format */ + uchar *m_rows_cur; /* One-after the end of the data */ + uchar *m_rows_end; /* One-after the end of the allocated space */ + + flag_set m_flags; /* Flags for row-level events */ + +private: + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); + virtual int do_update_pos(RELAY_LOG_INFO *rli); + virtual enum_skip_reason do_shall_skip(RELAY_LOG_INFO *rli); + + /* + Primitive to prepare for a sequence of row executions. + + DESCRIPTION + + Before doing a sequence of do_prepare_row() and do_exec_row() + calls, this member function should be called to prepare for the + entire sequence. Typically, this member function will allocate + space for any buffers that are needed for the two member + functions mentioned above. + + RETURN VALUE + + The member function will return 0 if all went OK, or a non-zero + error code otherwise. + */ + virtual int do_before_row_operations(TABLE *table) = 0; + + /* + Primitive to clean up after a sequence of row executions. + + DESCRIPTION + + After doing a sequence of do_prepare_row() and do_exec_row(), + this member function should be called to clean up and release + any allocated buffers. + */ + virtual int do_after_row_operations(TABLE *table, int error) = 0; + + /* + Primitive to prepare for handling one row in a row-level event. + + DESCRIPTION + + The member function prepares for execution of operations needed for one + row in a row-level event by reading up data from the buffer containing + the row. No specific interpretation of the data is normally done here, + since SQL thread specific data is not available: that data is made + available for the do_exec function. + + A pointer to the start of the next row, or NULL if the preparation + failed. Currently, preparation cannot fail, but don't rely on this + behavior. + + RETURN VALUE + Error code, if something went wrong, 0 otherwise. + */ + virtual int do_prepare_row(THD*, RELAY_LOG_INFO const*, TABLE*, + uchar const *row_start, + uchar const **row_end) = 0; + + /* + Primitive to do the actual execution necessary for a row. + + DESCRIPTION + The member function will do the actual execution needed to handle a row. + + RETURN VALUE + 0 if execution succeeded, 1 if execution failed. + + */ + virtual int do_exec_row(TABLE *table) = 0; +#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */ +}; + + +/***************************************************************************** + + Write row log event class + + Log row insertions and updates. The event contain several + insert/update rows for a table. Note that each event contains only + rows for one table. + + ****************************************************************************/ +class Write_rows_log_event : public Rows_log_event +{ +public: + enum + { + /* Support interface to THD::binlog_prepare_pending_rows_event */ + TYPE_CODE = WRITE_ROWS_EVENT + }; + +#if !defined(MYSQL_CLIENT) + Write_rows_log_event(THD*, TABLE*, ulong table_id, + MY_BITMAP const *cols, bool is_transactional); +#endif +#ifdef HAVE_REPLICATION + Write_rows_log_event(const char *buf, uint event_len, + const Format_description_log_event *description_event); +#endif +#if !defined(MYSQL_CLIENT) + static bool binlog_row_logging_function(THD *thd, TABLE *table, + bool is_transactional, + MY_BITMAP *cols, + uint fields, + const uchar *before_record + __attribute__((unused)), + const uchar *after_record) + { + return thd->binlog_write_row(table, is_transactional, + cols, fields, after_record); + } +#endif + +private: + virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; } + +#ifdef MYSQL_CLIENT + void print(FILE *file, PRINT_EVENT_INFO *print_event_info); +#endif + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + uchar *m_memory; + uchar *m_after_image; + + virtual int do_before_row_operations(TABLE *table); + virtual int do_after_row_operations(TABLE *table, int error); + virtual int do_prepare_row(THD*, RELAY_LOG_INFO const*, TABLE*, + uchar const *row_start, uchar const **row_end); + virtual int do_exec_row(TABLE *table); +#endif +}; + + +/***************************************************************************** + + Update rows log event class + + Log row updates with a before image. The event contain several + update rows for a table. Note that each event contains only rows for + one table. + + Also note that the row data consists of pairs of row data: one row + for the old data and one row for the new data. + + ****************************************************************************/ +class Update_rows_log_event : public Rows_log_event +{ +public: + enum + { + /* Support interface to THD::binlog_prepare_pending_rows_event */ + TYPE_CODE = UPDATE_ROWS_EVENT + }; + +#ifndef MYSQL_CLIENT + Update_rows_log_event(THD*, TABLE*, ulong table_id, + MY_BITMAP const *cols_bi, + MY_BITMAP const *cols_ai, + bool is_transactional); + + Update_rows_log_event(THD*, TABLE*, ulong table_id, + MY_BITMAP const *cols, + bool is_transactional); + + void init(MY_BITMAP const *cols); +#endif + + virtual ~Update_rows_log_event(); + +#ifdef HAVE_REPLICATION + Update_rows_log_event(const char *buf, uint event_len, + const Format_description_log_event *description_event); +#endif + +#if !defined(MYSQL_CLIENT) + static bool binlog_row_logging_function(THD *thd, TABLE *table, + bool is_transactional, + MY_BITMAP *cols, + uint fields, + const uchar *before_record, + const uchar *after_record) + { + return thd->binlog_update_row(table, is_transactional, + cols, fields, before_record, after_record); + } +#endif + + virtual bool is_valid() const + { + return Rows_log_event::is_valid() && m_cols_ai.bitmap; + } + +protected: + virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; } + +#ifdef MYSQL_CLIENT + void print(FILE *file, PRINT_EVENT_INFO *print_event_info); +#endif + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + uchar *m_memory; + uchar *m_key; + uchar *m_after_image; + + virtual int do_before_row_operations(TABLE *table); + virtual int do_after_row_operations(TABLE *table, int error); + virtual int do_prepare_row(THD*, RELAY_LOG_INFO const*, TABLE*, + uchar const *row_start, uchar const **row_end); + virtual int do_exec_row(TABLE *table); +#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */ +}; + +/***************************************************************************** + + Delete rows log event class. + + Log row deletions. The event contain several delete rows for a + table. Note that each event contains only rows for one table. + + RESPONSIBILITIES + + - Act as a container for rows that has been deleted on the master + and should be deleted on the slave. + + COLLABORATION + + Row_writer + Create the event and add rows to the event. + Row_reader + Extract the rows from the event. + + ****************************************************************************/ +class Delete_rows_log_event : public Rows_log_event +{ +public: + enum + { + /* Support interface to THD::binlog_prepare_pending_rows_event */ + TYPE_CODE = DELETE_ROWS_EVENT + }; + +#ifndef MYSQL_CLIENT + Delete_rows_log_event(THD*, TABLE*, ulong, + MY_BITMAP const *cols, bool is_transactional); +#endif +#ifdef HAVE_REPLICATION + Delete_rows_log_event(const char *buf, uint event_len, + const Format_description_log_event *description_event); +#endif +#if !defined(MYSQL_CLIENT) + static bool binlog_row_logging_function(THD *thd, TABLE *table, + bool is_transactional, + MY_BITMAP *cols, + uint fields, + const uchar *before_record, + const uchar *after_record + __attribute__((unused))) + { + return thd->binlog_delete_row(table, is_transactional, + cols, fields, before_record); + } +#endif + +protected: + virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; } + +#ifdef MYSQL_CLIENT + void print(FILE *file, PRINT_EVENT_INFO *print_event_info); +#endif + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + uchar *m_memory; + uchar *m_key; + uchar *m_after_image; + + virtual int do_before_row_operations(TABLE *table); + virtual int do_after_row_operations(TABLE *table, int error); + virtual int do_prepare_row(THD*, RELAY_LOG_INFO const*, TABLE*, + uchar const *row_start, uchar const **row_end); + virtual int do_exec_row(TABLE *table); +#endif +}; + + +#include "log_event_old.h" + +/** + Class representing an incident, an occurance out of the ordinary, + that happened on the master. + + The event is used to inform the slave that something out of the + ordinary happened on the master that might cause the database to be + in an inconsistent state. + + <table id="IncidentFormat"> + <caption>Incident event format</caption> + <tr> + <th>Symbol</th> + <th>Size<br/>(bytes)</th> + <th>Description</th> + </tr> + <tr> + <td>INCIDENT</td> + <td align="right">2</td> + <td>Incident number as an unsigned integer</td> + </tr> + <tr> + <td>MSGLEN</td> + <td align="right">1</td> + <td>Message length as an unsigned integer</td> + </tr> + <tr> + <td>MESSAGE</td> + <td align="right">MSGLEN</td> + <td>The message, if present. Not null terminated.</td> + </tr> + </table> + */ +class Incident_log_event : public Log_event { +public: +#ifndef MYSQL_CLIENT + Incident_log_event(THD *thd_arg, Incident incident) + : Log_event(thd_arg, 0, FALSE), m_incident(incident) + { + DBUG_ENTER("Incident_log_event::Incident_log_event"); + DBUG_PRINT("enter", ("m_incident: %d", m_incident)); + m_message.str= NULL; /* Just as a precaution */ + m_message.length= 0; + DBUG_VOID_RETURN; + } + + Incident_log_event(THD *thd_arg, Incident incident, LEX_STRING const msg) + : Log_event(thd_arg, 0, FALSE), m_incident(incident) + { + DBUG_ENTER("Incident_log_event::Incident_log_event"); + DBUG_PRINT("enter", ("m_incident: %d", m_incident)); + m_message= msg; + DBUG_VOID_RETURN; + } +#endif + +#ifndef MYSQL_CLIENT + void pack_info(Protocol*); +#endif + + Incident_log_event(const char *buf, uint event_len, + const Format_description_log_event *descr_event); + + virtual ~Incident_log_event(); + +#ifdef MYSQL_CLIENT + virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info); +#endif + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_apply_event(RELAY_LOG_INFO const *rli); +#endif + + virtual bool write_data_header(IO_CACHE *file); + virtual bool write_data_body(IO_CACHE *file); + + virtual Log_event_type get_type_code() { return INCIDENT_EVENT; } + + virtual bool is_valid() const { return 1; } + virtual int get_data_size() { + return INCIDENT_HEADER_LEN + 1 + m_message.length; + } + +private: + const char *description() const; + + Incident m_incident; + LEX_STRING m_message; +}; + +static inline bool copy_event_cache_to_file_and_reinit(IO_CACHE *cache, + FILE *file) +{ + return + my_b_copy_to_file(cache, file) || + reinit_io_cache(cache, WRITE_CACHE, 0, FALSE, TRUE); +} + +#endif /* _log_event_h */ diff -Nrup a/sql/rpl_record.cc b/sql/rpl_record.cc --- a/sql/rpl_record.cc 2007-06-11 22:15:28 +02:00 +++ b/sql/rpl_record.cc 2007-07-03 18:04:06 +02:00 @@ -17,6 +17,7 @@ #include "rpl_rli.h" #include "rpl_record.h" #include "slave.h" // Need to pull in slave_print_msg +//#include "rpl_rli.h" // for MAX_SLAVE_ERRMSG /** Pack a record of data for a table into a format suitable for @@ -133,26 +134,22 @@ pack_row(TABLE *table, MY_BITMAP const* the various member functions of Field and subclasses expect to write. - The row is assumed to only consist of the fields for which the - bitset represented by @c arr and @c bits; the other parts of the + The row is assumed to only consist of the fields for which the corresponding + bit in bitset @c cols is set; the other parts of the record are left alone. At most @c colcnt columns are read: if the table is larger than that, the remaining fields are not filled in. - @param rli Relay log info @param table Table to unpack into @param colcnt Number of columns to read from record - @param row Packed row data - @param cols Pointer to columns data to fill in + @param row_data Packed row data + @param cols Pointer to bitset describing columns to fill in @param row_end Pointer to variable that will hold the value of the one-after-end position for the row @param master_reclength Pointer to variable that will be set to the length of the record on the master side - @param rw_set Pointer to bitmap that holds either the read_set or the - write_set of the table - @retval 0 No error @@ -163,11 +160,9 @@ pack_row(TABLE *table, MY_BITMAP const* */ #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) int -unpack_row(RELAY_LOG_INFO const *rli, - TABLE *table, uint const colcnt, +unpack_row(TABLE *table, uint const colcnt, uchar const *const row_data, MY_BITMAP const *cols, - uchar const **const row_end, ulong *const master_reclength, - MY_BITMAP* const rw_set, Log_event_type const event_type) + uchar const **const row_end, ulong *const master_reclength) { DBUG_ENTER("unpack_row"); DBUG_ASSERT(row_data); @@ -177,10 +172,6 @@ unpack_row(RELAY_LOG_INFO const *rli, uchar const *null_ptr= row_data; uchar const *pack_ptr= row_data + master_null_byte_count; - bitmap_clear_all(rw_set); - - empty_record(table); - Field **const begin_ptr = table->field; Field **field_ptr; Field **const end_ptr= begin_ptr + colcnt; @@ -225,7 +216,6 @@ unpack_row(RELAY_LOG_INFO const *rli, pack_ptr= f->unpack(f->ptr, pack_ptr); } - bitmap_set_bit(rw_set, f->field_index); null_mask <<= 1; } } @@ -244,30 +234,44 @@ unpack_row(RELAY_LOG_INFO const *rli, else *master_reclength = table->s->reclength; } + + DBUG_RETURN(error); +} - /* - Set properties for remaining columns, if there are any. We let the - corresponding bit in the write_set be set, to write the value if - it was not there already. We iterate over all remaining columns, - even if there were an error, to get as many error messages as - possible. We are still able to return a pointer to the next row, - so redo that. +/** + Fills table->record[0] with default values. - This generation of error messages is only relevant when inserting - new rows. - */ - for ( ; *field_ptr ; ++field_ptr) + First @c empty_record() is called and then, additionally, fields are + initialized explicitly with a call to @c set_default(). + + For optimization reasons, the explicit initialization can be skipped for + first @c skip fields. This is useful if later we are going to fill these + fields from other source (e.g. from a Rows replication event). + + If @c check is true, fields are explicitly initialized only if they have + default value or can be NULL. Otherwise error is reported. + */ +int prepare_record(const RELAY_LOG_INFO *const rli, TABLE *const table, + const uint skip, const bool check) +{ + DBUG_ENTER("prepare_record"); + + int error= 0; + empty_record(table); + + /* Explicit initialization of fields */ + + for (Field **field_ptr= table->field+skip ; *field_ptr ; ++field_ptr) { uint32 const mask= NOT_NULL_FLAG | NO_DEFAULT_VALUE_FLAG; Field *const f= *field_ptr; - if (event_type == WRITE_ROWS_EVENT && - ((*field_ptr)->flags & mask) == mask) + if (check && ((f->flags & mask) == mask)) { rli->report(ERROR_LEVEL, ER_NO_DEFAULT_FOR_FIELD, "Field `%s` of table `%s`.`%s` " "has no default value and cannot be NULL", - (*field_ptr)->field_name, table->s->db.str, + f->field_name, table->s->db.str, table->s->table_name.str); error = ER_NO_DEFAULT_FOR_FIELD; } diff -Nrup a/sql/rpl_record.h b/sql/rpl_record.h --- a/sql/rpl_record.h 2007-05-10 11:59:28 +02:00 +++ b/sql/rpl_record.h 2007-07-03 18:04:06 +02:00 @@ -22,12 +22,13 @@ size_t pack_row(TABLE* table, MY_BITMAP #endif #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) -int unpack_row(RELAY_LOG_INFO const *rli, - TABLE *table, uint const colcnt, +int unpack_row(TABLE *table, uint const colcnt, uchar const *const row_data, MY_BITMAP const *cols, - uchar const **const row_end, ulong *const master_reclength, - MY_BITMAP* const rw_set, - Log_event_type const event_type); + uchar const **const row_end, ulong *const master_reclength); + +// Fill table's record[0] with default values. +int prepare_record(const RELAY_LOG_INFO *const, TABLE *const, + const uint =0, const bool =FALSE); #endif #endif
| Thread | ||
|---|---|---|
| • bk commit into 5.1 tree (rafal:1.2530) BUG#21842 | rsomla | 3 Jul |
© 1995-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
Page generated in 1.768 sec. using MySQL 5.1.14-beta-log