From ccfcd5957fe0f73ddb1e31a0b498c5c4c3126d84 Mon Sep 17 00:00:00 2001 From: unknown Date: Tue, 20 Nov 2007 19:49:35 +0100 Subject: BUG#31581: 5.1-telco-6.1 -> 5.1.22. Slave crashes during starting This patch has two purposes: (1) To refactor the code so that {Write|Update|Delete}_rows_log_event_old does not use code from {Write|Update|Delete}_rows_log_event. Before refactoring there was the following problem: whenever we modifed the code for new events, it affected the old events. This is bad, as it makes maintainance difficult. After refactoring, we can safely edit the new code without affecting old events. So, if we for instance modify the binary format of new events, we no longer need to worry about how the new code reads old events. (2) To fix BUG#31581. These two objectives are reached by the following changes: - Merged Rows_log_event into Old_rows_log_event and {Write|Update|Delete}_rows_log_event into {Write|Update|Delete}_rows_log_event_old. - Fixed the bug by replacing {WRITE|UPDATE|DELETE}_ROWS_EVENT by PRE_GA_{WRITE|UPDATE|DELETE}_ROWS_EVENT. - Added comments to log_event_old.h (This patch is identical to the previously committed patch which was a collapse of three changesets, except that it adds assert(0) to constructors for old types of row log events that should never be called.) sql/log_event_old.cc: Merged Rows_log_event into Old_rows_log_event and {Write|Update|Delete}_rows_log_event into {Write|Update|Delete}_rows_log_event_old. Also fixed the bug by replacing {WRITE|UPDATE|DELETE}_ROWS_EVENT by PRE_GA_{WRITE|UPDATE|DELETE}_ROWS_EVENT. sql/log_event_old.h: Merged Rows_log_event into Old_rows_log_event and {Write|Update|Delete}_rows_log_event into {Write|Update|Delete}_rows_log_event_old. Also added comment explaining what the file contains and what the classes do. --- sql/log_event_old.cc | 1781 +++++++++++++++++++++++++++++++++++++++++++++++++- sql/log_event_old.h | 467 +++++++++++-- 2 files changed, 2176 insertions(+), 72 deletions(-) (limited to 'sql') diff --git a/sql/log_event_old.cc b/sql/log_event_old.cc index 949179386ea..e9b7f50ee3b 100644 --- a/sql/log_event_old.cc +++ b/sql/log_event_old.cc @@ -11,9 +11,9 @@ // Old implementation of do_apply_event() int -Old_rows_log_event::do_apply_event(Rows_log_event *ev, const Relay_log_info *rli) +Old_rows_log_event::do_apply_event(Old_rows_log_event *ev, const Relay_log_info *rli) { - DBUG_ENTER("Rows_log_event::do_apply_event(st_relay_log_info*)"); + DBUG_ENTER("Old_rows_log_event::do_apply_event(st_relay_log_info*)"); int error= 0; THD *thd= ev->thd; uchar const *row_start= ev->m_rows_buf; @@ -30,7 +30,7 @@ Old_rows_log_event::do_apply_event(Rows_log_event *ev, const Relay_log_info *rli This one is supposed to be set: just an extra check so that nothing strange has happened. */ - DBUG_ASSERT(ev->get_flags(Rows_log_event::STMT_END_F)); + DBUG_ASSERT(ev->get_flags(Old_rows_log_event::STMT_END_F)); const_cast(rli)->clear_tables_to_lock(); close_thread_tables(thd); @@ -148,7 +148,7 @@ Old_rows_log_event::do_apply_event(Rows_log_event *ev, const Relay_log_info *rli thd->lock= 0; thd->query_error= 1; const_cast(rli)->clear_tables_to_lock(); - DBUG_RETURN(Rows_log_event::ERR_BAD_TABLE_DEF); + DBUG_RETURN(Old_rows_log_event::ERR_BAD_TABLE_DEF); } } } @@ -163,8 +163,8 @@ Old_rows_log_event::do_apply_event(Rows_log_event *ev, const 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 + Old_rows_log_event contain at least one row, so after processing one + Old_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) @@ -200,12 +200,12 @@ Old_rows_log_event::do_apply_event(Rows_log_event *ev, const Relay_log_info *rli Make sure to set/clear them before executing the main body of the event. */ - if (ev->get_flags(Rows_log_event::NO_FOREIGN_KEY_CHECKS_F)) + if (ev->get_flags(Old_rows_log_event::NO_FOREIGN_KEY_CHECKS_F)) thd->options|= OPTION_NO_FOREIGN_KEY_CHECKS; else thd->options&= ~OPTION_NO_FOREIGN_KEY_CHECKS; - if (ev->get_flags(Rows_log_event::RELAXED_UNIQUE_CHECKS_F)) + if (ev->get_flags(Old_rows_log_event::RELAXED_UNIQUE_CHECKS_F)) thd->options|= OPTION_RELAXED_UNIQUE_CHECKS; else thd->options&= ~OPTION_RELAXED_UNIQUE_CHECKS; @@ -275,7 +275,7 @@ Old_rows_log_event::do_apply_event(Rows_log_event *ev, const Relay_log_info *rli We need to delay this clear until the table def is no longer needed. The table def is needed in unpack_row(). */ - if (rli->tables_to_lock && ev->get_flags(Rows_log_event::STMT_END_F)) + if (rli->tables_to_lock && ev->get_flags(Old_rows_log_event::STMT_END_F)) const_cast(rli)->clear_tables_to_lock(); if (error) @@ -311,7 +311,7 @@ Old_rows_log_event::do_apply_event(Rows_log_event *ev, const Relay_log_info *rli */ if (table && (table->s->primary_key == MAX_KEY) && !ev->cache_stmt && - ev->get_flags(Rows_log_event::STMT_END_F) == Rows_log_event::RLE_NO_FLAGS) + ev->get_flags(Old_rows_log_event::STMT_END_F) == Old_rows_log_event::RLE_NO_FLAGS) { /* ------------ Temporary fix until WL#2975 is implemented --------- @@ -323,7 +323,7 @@ Old_rows_log_event::do_apply_event(Rows_log_event *ev, const Relay_log_info *rli present, and idempotency is not guaranteed (no PK) so we risk that repeating leads to double insert. So we desperately try to continue, hope we'll eventually leave this buggy situation (by - executing the final Rows_log_event). If we are in a hopeless + executing the final Old_rows_log_event). If we are in a hopeless wait (reached end of last relay log and nothing gets appended there), we timeout after one minute, and notify DBA about the problem. When WL#2975 is implemented, just remove the member @@ -336,6 +336,7 @@ Old_rows_log_event::do_apply_event(Rows_log_event *ev, const Relay_log_info *rli } #endif + #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) /* @@ -350,6 +351,7 @@ last_uniq_key(TABLE *table, uint keyno) return 1; } + /* Compares table->record[0] and table->record[1] @@ -428,6 +430,7 @@ record_compare_exit: return result; } + /* Copy "extra" columns from record[1] to record[0]. @@ -516,6 +519,7 @@ copy_extra_record_fields(TABLE *table, DBUG_RETURN(0); // All OK } + /* Replace the provided record in the database. @@ -668,6 +672,7 @@ replace_record(THD *thd, TABLE *table, DBUG_RETURN(error); } + /** Find the row given by 'key', if the table has keys, or else use a table scan to find (and fetch) the row. @@ -879,6 +884,7 @@ static int find_and_fetch_row(TABLE *table, uchar *key) DBUG_RETURN(0); } + /********************************************************** Row handling primitives for Write_rows_log_event_old **********************************************************/ @@ -944,6 +950,7 @@ int Write_rows_log_event_old::do_before_row_operations(TABLE *table) return error; } + int Write_rows_log_event_old::do_after_row_operations(TABLE *table, int error) { int local_error= 0; @@ -962,6 +969,7 @@ int Write_rows_log_event_old::do_after_row_operations(TABLE *table, int error) return error? error : local_error; } + int Write_rows_log_event_old::do_prepare_row(THD *thd_arg, Relay_log_info const *rli, @@ -981,6 +989,7 @@ Write_rows_log_event_old::do_prepare_row(THD *thd_arg, return error; } + int Write_rows_log_event_old::do_exec_row(TABLE *table) { DBUG_ASSERT(table != NULL); @@ -988,6 +997,7 @@ int Write_rows_log_event_old::do_exec_row(TABLE *table) return error; } + /********************************************************** Row handling primitives for Delete_rows_log_event_old **********************************************************/ @@ -1029,6 +1039,7 @@ int Delete_rows_log_event_old::do_before_row_operations(TABLE *table) return error; } + int Delete_rows_log_event_old::do_after_row_operations(TABLE *table, int error) { /*error= ToDo:find out what this should really be, this triggers close_scan in nbd, returning error?*/ @@ -1041,6 +1052,7 @@ int Delete_rows_log_event_old::do_after_row_operations(TABLE *table, int error) return error; } + int Delete_rows_log_event_old::do_prepare_row(THD *thd_arg, Relay_log_info const *rli, @@ -1074,6 +1086,7 @@ Delete_rows_log_event_old::do_prepare_row(THD *thd_arg, return error; } + int Delete_rows_log_event_old::do_exec_row(TABLE *table) { int error; @@ -1091,6 +1104,7 @@ int Delete_rows_log_event_old::do_exec_row(TABLE *table) return error; } + /********************************************************** Row handling primitives for Update_rows_log_event_old **********************************************************/ @@ -1124,6 +1138,7 @@ int Update_rows_log_event_old::do_before_row_operations(TABLE *table) return error; } + int Update_rows_log_event_old::do_after_row_operations(TABLE *table, int error) { /*error= ToDo:find out what this should really be, this triggers close_scan in nbd, returning error?*/ @@ -1136,6 +1151,7 @@ int Update_rows_log_event_old::do_after_row_operations(TABLE *table, int error) return error; } + int Update_rows_log_event_old::do_prepare_row(THD *thd_arg, Relay_log_info const *rli, TABLE *table, @@ -1179,6 +1195,7 @@ int Update_rows_log_event_old::do_prepare_row(THD *thd_arg, return error; } + int Update_rows_log_event_old::do_exec_row(TABLE *table) { DBUG_ASSERT(table != NULL); @@ -1217,3 +1234,1745 @@ int Update_rows_log_event_old::do_exec_row(TABLE *table) } #endif + + +/************************************************************************** + Rows_log_event member functions +**************************************************************************/ + +#ifndef MYSQL_CLIENT +Old_rows_log_event::Old_rows_log_event(THD *thd_arg, TABLE *tbl_arg, ulong tid, + MY_BITMAP const *cols, + bool is_transactional) + : Log_event(thd_arg, 0, is_transactional), + m_row_count(0), + m_table(tbl_arg), + 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_flags(0) +#ifdef HAVE_REPLICATION + ,m_key(NULL), m_curr_row(NULL), m_curr_row_end(NULL) +#endif +{ + + // This constructor should not be reached. + assert(0); + + /* + We allow a special form of dummy event when the table, and cols + are null and the table id is ~0UL. This is a temporary + solution, to be able to terminate a started statement in the + binary log: the extraneous events will be removed in the future. + */ + DBUG_ASSERT(tbl_arg && tbl_arg->s && tid != ~0UL || + !tbl_arg && !cols && tid == ~0UL); + + if (thd_arg->options & OPTION_NO_FOREIGN_KEY_CHECKS) + set_flags(NO_FOREIGN_KEY_CHECKS_F); + if (thd_arg->options & OPTION_RELAXED_UNIQUE_CHECKS) + set_flags(RELAXED_UNIQUE_CHECKS_F); + /* if bitmap_init fails, caught in is_valid() */ + if (likely(!bitmap_init(&m_cols, + m_width <= sizeof(m_bitbuf)*8 ? m_bitbuf : NULL, + m_width, + false))) + { + /* Cols can be zero if this is a dummy binrows event */ + if (likely(cols != NULL)) + { + memcpy(m_cols.bitmap, cols->bitmap, no_bytes_in_map(cols)); + create_last_word_mask(&m_cols); + } + } + else + { + // Needed because bitmap_init() does not set it to null on failure + m_cols.bitmap= 0; + } +} +#endif + + +Old_rows_log_event::Old_rows_log_event(const char *buf, uint event_len, + Log_event_type event_type, + const Format_description_log_event + *description_event) + : Log_event(buf, description_event), + m_row_count(0), +#ifndef MYSQL_CLIENT + m_table(NULL), +#endif + m_table_id(0), m_rows_buf(0), m_rows_cur(0), m_rows_end(0) +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + ,m_key(NULL), m_curr_row(NULL), m_curr_row_end(NULL) +#endif +{ + DBUG_ENTER("Old_rows_log_event::Old_Rows_log_event(const char*,...)"); + uint8 const common_header_len= description_event->common_header_len; + uint8 const post_header_len= description_event->post_header_len[event_type-1]; + + DBUG_PRINT("enter",("event_len: %u common_header_len: %d " + "post_header_len: %d", + event_len, common_header_len, + post_header_len)); + + const char *post_start= buf + common_header_len; + post_start+= RW_MAPID_OFFSET; + if (post_header_len == 6) + { + /* Master is of an intermediate source tree before 5.1.4. Id is 4 bytes */ + m_table_id= uint4korr(post_start); + post_start+= 4; + } + else + { + m_table_id= (ulong) uint6korr(post_start); + post_start+= RW_FLAGS_OFFSET; + } + + m_flags= uint2korr(post_start); + + uchar const *const var_start= + (const uchar *)buf + common_header_len + post_header_len; + uchar const *const ptr_width= var_start; + uchar *ptr_after_width= (uchar*) ptr_width; + DBUG_PRINT("debug", ("Reading from %p", ptr_after_width)); + m_width = net_field_length(&ptr_after_width); + DBUG_PRINT("debug", ("m_width=%lu", m_width)); + /* if bitmap_init fails, catched in is_valid() */ + if (likely(!bitmap_init(&m_cols, + m_width <= sizeof(m_bitbuf)*8 ? m_bitbuf : NULL, + m_width, + false))) + { + DBUG_PRINT("debug", ("Reading from %p", ptr_after_width)); + memcpy(m_cols.bitmap, ptr_after_width, (m_width + 7) / 8); + create_last_word_mask(&m_cols); + ptr_after_width+= (m_width + 7) / 8; + DBUG_DUMP("m_cols", (uchar*) m_cols.bitmap, no_bytes_in_map(&m_cols)); + } + else + { + // Needed because bitmap_init() does not set it to null on failure + m_cols.bitmap= NULL; + DBUG_VOID_RETURN; + } + + m_cols_ai.bitmap= m_cols.bitmap; /* See explanation in is_valid() */ + + if (event_type == PRE_GA_UPDATE_ROWS_EVENT) + { + DBUG_PRINT("debug", ("Reading from %p", ptr_after_width)); + + /* if bitmap_init fails, caught in is_valid() */ + if (likely(!bitmap_init(&m_cols_ai, + m_width <= sizeof(m_bitbuf_ai)*8 ? m_bitbuf_ai : NULL, + m_width, + false))) + { + DBUG_PRINT("debug", ("Reading from %p", ptr_after_width)); + memcpy(m_cols_ai.bitmap, ptr_after_width, (m_width + 7) / 8); + create_last_word_mask(&m_cols_ai); + ptr_after_width+= (m_width + 7) / 8; + DBUG_DUMP("m_cols_ai", (uchar*) m_cols_ai.bitmap, + no_bytes_in_map(&m_cols_ai)); + } + else + { + // Needed because bitmap_init() does not set it to null on failure + m_cols_ai.bitmap= 0; + DBUG_VOID_RETURN; + } + } + + const uchar* const ptr_rows_data= (const uchar*) ptr_after_width; + + size_t const data_size= event_len - (ptr_rows_data - (const uchar *) buf); + DBUG_PRINT("info",("m_table_id: %lu m_flags: %d m_width: %lu data_size: %lu", + m_table_id, m_flags, m_width, (ulong) data_size)); + + m_rows_buf= (uchar*) my_malloc(data_size, MYF(MY_WME)); + if (likely((bool)m_rows_buf)) + { +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + m_curr_row= m_rows_buf; +#endif + m_rows_end= m_rows_buf + data_size; + m_rows_cur= m_rows_end; + memcpy(m_rows_buf, ptr_rows_data, data_size); + } + else + m_cols.bitmap= 0; // to not free it + + DBUG_VOID_RETURN; +} + + +Old_rows_log_event::~Old_rows_log_event() +{ + if (m_cols.bitmap == m_bitbuf) // no my_malloc happened + m_cols.bitmap= 0; // so no my_free in bitmap_free + bitmap_free(&m_cols); // To pair with bitmap_init(). + my_free((uchar*)m_rows_buf, MYF(MY_ALLOW_ZERO_PTR)); +} + + +int Old_rows_log_event::get_data_size() +{ + int const type_code= get_type_code(); + + uchar buf[sizeof(m_width)+1]; + uchar *end= net_store_length(buf, (m_width + 7) / 8); + + DBUG_EXECUTE_IF("old_row_based_repl_4_byte_map_id_master", + return 6 + no_bytes_in_map(&m_cols) + (end - buf) + + (type_code == PRE_GA_UPDATE_ROWS_EVENT ? no_bytes_in_map(&m_cols_ai) : 0) + + (m_rows_cur - m_rows_buf);); + int data_size= ROWS_HEADER_LEN; + data_size+= no_bytes_in_map(&m_cols); + data_size+= end - buf; + + if (type_code == PRE_GA_UPDATE_ROWS_EVENT) + data_size+= no_bytes_in_map(&m_cols_ai); + + data_size+= (m_rows_cur - m_rows_buf); + return data_size; +} + + +#ifndef MYSQL_CLIENT +int Old_rows_log_event::do_add_row_data(uchar *row_data, size_t length) +{ + /* + When the table has a primary key, we would probably want, by default, to + log only the primary key value instead of the entire "before image". This + would save binlog space. TODO + */ + DBUG_ENTER("Old_rows_log_event::do_add_row_data"); + DBUG_PRINT("enter", ("row_data: 0x%lx length: %lu", (ulong) row_data, + (ulong) length)); + /* + Don't print debug messages when running valgrind since they can + trigger false warnings. + */ +#ifndef HAVE_purify + DBUG_DUMP("row_data", row_data, min(length, 32)); +#endif + + DBUG_ASSERT(m_rows_buf <= m_rows_cur); + DBUG_ASSERT(!m_rows_buf || m_rows_end && m_rows_buf < m_rows_end); + DBUG_ASSERT(m_rows_cur <= m_rows_end); + + /* The cast will always work since m_rows_cur <= m_rows_end */ + if (static_cast(m_rows_end - m_rows_cur) <= length) + { + size_t const block_size= 1024; + my_ptrdiff_t const cur_size= m_rows_cur - m_rows_buf; + my_ptrdiff_t const new_alloc= + block_size * ((cur_size + length + block_size - 1) / block_size); + + uchar* const new_buf= (uchar*)my_realloc((uchar*)m_rows_buf, (uint) new_alloc, + MYF(MY_ALLOW_ZERO_PTR|MY_WME)); + if (unlikely(!new_buf)) + DBUG_RETURN(HA_ERR_OUT_OF_MEM); + + /* If the memory moved, we need to move the pointers */ + if (new_buf != m_rows_buf) + { + m_rows_buf= new_buf; + m_rows_cur= m_rows_buf + cur_size; + } + + /* + The end pointer should always be changed to point to the end of + the allocated memory. + */ + m_rows_end= m_rows_buf + new_alloc; + } + + DBUG_ASSERT(m_rows_cur + length <= m_rows_end); + memcpy(m_rows_cur, row_data, length); + m_rows_cur+= length; + m_row_count++; + DBUG_RETURN(0); +} +#endif + + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) +int Old_rows_log_event::do_apply_event(Relay_log_info const *rli) +{ + DBUG_ENTER("Old_rows_log_event::do_apply_event(Relay_log_info*)"); + int error= 0; + + /* + If m_table_id == ~0UL, then we have a dummy event that does not + contain any data. In that case, we just remove all tables in the + tables_to_lock list, close the thread tables, and return with + success. + */ + if (m_table_id == ~0UL) + { + /* + This one is supposed to be set: just an extra check so that + nothing strange has happened. + */ + DBUG_ASSERT(get_flags(STMT_END_F)); + + const_cast(rli)->clear_tables_to_lock(); + close_thread_tables(thd); + thd->clear_error(); + DBUG_RETURN(0); + } + + /* + 'thd' has been set by exec_relay_log_event(), just before calling + do_apply_event(). We still check here to prevent future coding + errors. + */ + DBUG_ASSERT(rli->sql_thd == thd); + + /* + If there is no locks taken, this is the first binrow event seen + after the table map events. We should then lock all the tables + used in the transaction and proceed with execution of the actual + 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(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(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(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(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 + Old_rows_log_event contain at least one row, so after processing one + Old_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(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 + } + + TABLE* + table= + m_table= const_cast(rli)->m_table_map.get_table(m_table_id); + + if (table) + { + /* + table == NULL means that this table should not be replicated + (this was set up by Table_map_log_event::do_apply_event() + which tested replicate-* rules). + */ + + /* + It's not needed to set_time() but + 1) it continues the property that "Time" in SHOW PROCESSLIST shows how + much slave is behind + 2) it will be needed when we allow replication from a table with no + TIMESTAMP column to a table with one. + So we call set_time(), like in SBR. Presently it changes nothing. + */ + thd->set_time((time_t)when); + /* + There are a few flags that are replicated with each row event. + Make sure to set/clear them before executing the main body of + the event. + */ + if (get_flags(NO_FOREIGN_KEY_CHECKS_F)) + thd->options|= OPTION_NO_FOREIGN_KEY_CHECKS; + else + thd->options&= ~OPTION_NO_FOREIGN_KEY_CHECKS; + + if (get_flags(RELAXED_UNIQUE_CHECKS_F)) + thd->options|= OPTION_RELAXED_UNIQUE_CHECKS; + else + thd->options&= ~OPTION_RELAXED_UNIQUE_CHECKS; + /* A small test to verify that objects have consistent types */ + DBUG_ASSERT(sizeof(thd->options) == sizeof(OPTION_RELAXED_UNIQUE_CHECKS)); + + /* + Now we are in a statement and will stay in a statement until we + see a STMT_END_F. + + We set this flag here, before actually applying any rows, in + case the SQL thread is stopped and we need to detect that we're + inside a statement and halting abruptly might cause problems + when restarting. + */ + const_cast(rli)->set_flag(Relay_log_info::IN_STMT); + + if ( m_width == table->s->fields && bitmap_is_set_all(&m_cols)) + set_flags(COMPLETE_ROWS_F); + + /* + Set tables write and read sets. + + Read_set contains all slave columns (in case we are going to fetch + a complete record from slave) + + Write_set equals the m_cols bitmap sent from master but it can be + longer if slave has extra columns. + */ + + DBUG_PRINT_BITSET("debug", "Setting table's write_set from: %s", &m_cols); + + bitmap_set_all(table->read_set); + bitmap_set_all(table->write_set); + if (!get_flags(COMPLETE_ROWS_F)) + bitmap_intersect(table->write_set,&m_cols); + + // Do event specific preparations + + error= do_before_row_operations(rli); + + // row processing loop + + while (error == 0 && m_curr_row < 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(rli); + + table->in_use = old_thd; + switch (error) + { + case 0: + break; + + /* Some recoverable errors */ + case HA_ERR_RECORD_CHANGED: + case HA_ERR_KEY_NOT_FOUND: /* Idempotency support: OK if + tuple does not exist */ + error= 0; + break; + + default: + rli->report(ERROR_LEVEL, thd->net.last_errno, + "Error in %s event: row application failed. %s", + get_type_str(), + thd->net.last_error ? thd->net.last_error : ""); + thd->query_error= 1; + break; + } + + /* + If m_curr_row_end was not set during event execution (e.g., because + of errors) we can't proceed to the next row. If the error is transient + (i.e., error==0 at this point) we must call unpack_current_row() to set + m_curr_row_end. + */ + + DBUG_PRINT("info", ("error: %d", error)); + DBUG_PRINT("info", ("curr_row: 0x%lu; curr_row_end: 0x%lu; rows_end: 0x%lu", + (ulong) m_curr_row, (ulong) m_curr_row_end, (ulong) m_rows_end)); + + if (!m_curr_row_end && !error) + unpack_current_row(rli); + + // at this moment m_curr_row_end should be set + DBUG_ASSERT(error || m_curr_row_end != NULL); + DBUG_ASSERT(error || m_curr_row < m_curr_row_end); + DBUG_ASSERT(error || m_curr_row_end <= m_rows_end); + + m_curr_row= m_curr_row_end; + + } // row processing loop + + DBUG_EXECUTE_IF("STOP_SLAVE_after_first_Rows_event", + const_cast(rli)->abort_slave= 1;); + error= do_after_row_operations(rli, error); + if (!cache_stmt) + { + DBUG_PRINT("info", ("Marked that we need to keep log")); + thd->options|= OPTION_KEEP_LOG; + } + } // if (table) + + /* + We need to delay this clear until here bacause unpack_current_row() uses + master-side table definitions stored in rli. + */ + if (rli->tables_to_lock && get_flags(STMT_END_F)) + const_cast(rli)->clear_tables_to_lock(); + + if (error) + { /* error has occured during the transaction */ + rli->report(ERROR_LEVEL, thd->net.last_errno, + "Error in %s event: error during transaction execution " + "on table %s.%s. %s", + get_type_str(), table->s->db.str, + table->s->table_name.str, + thd->net.last_error ? thd->net.last_error : ""); + + /* + If one day we honour --skip-slave-errors in row-based replication, and + the error should be skipped, then we would clear mappings, rollback, + close tables, but the slave SQL thread would not stop and then may + assume the mapping is still available, the tables are still open... + So then we should clear mappings/rollback/close here only if this is a + STMT_END_F. + For now we code, knowing that error is not skippable and so slave SQL + thread is certainly going to stop. + rollback at the caller along with sbr. + */ + thd->reset_current_stmt_binlog_row_based(); + const_cast(rli)->cleanup_context(thd, error); + thd->query_error= 1; + DBUG_RETURN(error); + } + + /* + This code would ideally be placed in do_update_pos() instead, but + since we have no access to table there, we do the setting of + last_event_start_time here instead. + */ + if (table && (table->s->primary_key == MAX_KEY) && + !cache_stmt && get_flags(STMT_END_F) == RLE_NO_FLAGS) + { + /* + ------------ Temporary fix until WL#2975 is implemented --------- + + This event is not the last one (no STMT_END_F). If we stop now + (in case of terminate_slave_thread()), how will we restart? We + have to restart from Table_map_log_event, but as this table is + not transactional, the rows already inserted will still be + present, and idempotency is not guaranteed (no PK) so we risk + that repeating leads to double insert. So we desperately try to + continue, hope we'll eventually leave this buggy situation (by + executing the final Old_rows_log_event). If we are in a hopeless + wait (reached end of last relay log and nothing gets appended + there), we timeout after one minute, and notify DBA about the + problem. When WL#2975 is implemented, just remove the member + Relay_log_info::last_event_start_time and all its occurrences. + */ + const_cast(rli)->last_event_start_time= my_time(0); + } + + DBUG_RETURN(0); +} + + +Log_event::enum_skip_reason +Old_rows_log_event::do_shall_skip(Relay_log_info *rli) +{ + /* + If the slave skip counter is 1 and this event does not end a + statement, then we should not start executing on the next event. + Otherwise, we defer the decision to the normal skipping logic. + */ + if (rli->slave_skip_counter == 1 && !get_flags(STMT_END_F)) + return Log_event::EVENT_SKIP_IGNORE; + else + return Log_event::do_shall_skip(rli); +} + +int +Old_rows_log_event::do_update_pos(Relay_log_info *rli) +{ + DBUG_ENTER("Old_rows_log_event::do_update_pos"); + int error= 0; + + DBUG_PRINT("info", ("flags: %s", + get_flags(STMT_END_F) ? "STMT_END_F " : "")); + + if (get_flags(STMT_END_F)) + { + /* + This is the end of a statement or transaction, so close (and + unlock) the tables we opened when processing the + Table_map_log_event starting the statement. + + OBSERVER. This will clear *all* mappings, not only those that + are open for the table. There is not good handle for on-close + actions for tables. + + NOTE. Even if we have no table ('table' == 0) we still need to be + here, so that we increase the group relay log position. If we didn't, we + could have a group relay log position which lags behind "forever" + (assume the last master's transaction is ignored by the slave because of + replicate-ignore rules). + */ + thd->binlog_flush_pending_rows_event(true); + + /* + If this event is not in a transaction, the call below will, if some + transactional storage engines are involved, commit the statement into + them and flush the pending event to binlog. + If this event is in a transaction, the call will do nothing, but a + Xid_log_event will come next which will, if some transactional engines + are involved, commit the transaction and flush the pending event to the + binlog. + */ + error= ha_autocommit_or_rollback(thd, 0); + + /* + Now what if this is not a transactional engine? we still need to + flush the pending event to the binlog; we did it with + thd->binlog_flush_pending_rows_event(). Note that we imitate + what is done for real queries: a call to + ha_autocommit_or_rollback() (sometimes only if involves a + transactional engine), and a call to be sure to have the pending + event flushed. + */ + + thd->reset_current_stmt_binlog_row_based(); + rli->cleanup_context(thd, 0); + if (error == 0) + { + /* + Indicate that a statement is finished. + Step the group log position if we are not in a transaction, + otherwise increase the event log position. + */ + rli->stmt_done(log_pos, when); + + /* + Clear any errors pushed in thd->net.last_err* if for example "no key + found" (as this is allowed). This is a safety measure; apparently + those errors (e.g. when executing a Delete_rows_log_event_old of a + non-existing row, like in rpl_row_mystery22.test, + thd->net.last_error = "Can't find record in 't1'" and last_errno=1032) + do not become visible. We still prefer to wipe them out. + */ + thd->clear_error(); + } + else + rli->report(ERROR_LEVEL, error, + "Error in %s event: commit of row events failed, " + "table `%s`.`%s`", + get_type_str(), m_table->s->db.str, + m_table->s->table_name.str); + } + else + { + rli->inc_event_relay_log_pos(); + } + + DBUG_RETURN(error); +} + +#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */ + + +#ifndef MYSQL_CLIENT +bool Old_rows_log_event::write_data_header(IO_CACHE *file) +{ + uchar buf[ROWS_HEADER_LEN]; // No need to init the buffer + + // This method should not be reached. + assert(0); + + DBUG_ASSERT(m_table_id != ~0UL); + DBUG_EXECUTE_IF("old_row_based_repl_4_byte_map_id_master", + { + int4store(buf + 0, m_table_id); + int2store(buf + 4, m_flags); + return (my_b_safe_write(file, buf, 6)); + }); + int6store(buf + RW_MAPID_OFFSET, (ulonglong)m_table_id); + int2store(buf + RW_FLAGS_OFFSET, m_flags); + return (my_b_safe_write(file, buf, ROWS_HEADER_LEN)); +} + + +bool Old_rows_log_event::write_data_body(IO_CACHE*file) +{ + /* + Note that this should be the number of *bits*, not the number of + bytes. + */ + uchar sbuf[sizeof(m_width)]; + my_ptrdiff_t const data_size= m_rows_cur - m_rows_buf; + + // This method should not be reached. + assert(0); + + bool res= false; + uchar *const sbuf_end= net_store_length(sbuf, (size_t) m_width); + DBUG_ASSERT(static_cast(sbuf_end - sbuf) <= sizeof(sbuf)); + + DBUG_DUMP("m_width", sbuf, (size_t) (sbuf_end - sbuf)); + res= res || my_b_safe_write(file, sbuf, (size_t) (sbuf_end - sbuf)); + + DBUG_DUMP("m_cols", (uchar*) m_cols.bitmap, no_bytes_in_map(&m_cols)); + res= res || my_b_safe_write(file, (uchar*) m_cols.bitmap, + no_bytes_in_map(&m_cols)); + /* + TODO[refactor write]: Remove the "down cast" here (and elsewhere). + */ + if (get_type_code() == PRE_GA_UPDATE_ROWS_EVENT) + { + DBUG_DUMP("m_cols_ai", (uchar*) m_cols_ai.bitmap, + no_bytes_in_map(&m_cols_ai)); + res= res || my_b_safe_write(file, (uchar*) m_cols_ai.bitmap, + no_bytes_in_map(&m_cols_ai)); + } + DBUG_DUMP("rows", m_rows_buf, data_size); + res= res || my_b_safe_write(file, m_rows_buf, (size_t) data_size); + + return res; + +} +#endif + + +#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) +void Old_rows_log_event::pack_info(Protocol *protocol) +{ + char buf[256]; + char const *const flagstr= + get_flags(STMT_END_F) ? " flags: STMT_END_F" : ""; + size_t bytes= my_snprintf(buf, sizeof(buf), + "table_id: %lu%s", m_table_id, flagstr); + protocol->store(buf, bytes, &my_charset_bin); +} +#endif + + +#ifdef MYSQL_CLIENT +void Old_rows_log_event::print_helper(FILE *file, + PRINT_EVENT_INFO *print_event_info, + char const *const name) +{ + IO_CACHE *const head= &print_event_info->head_cache; + IO_CACHE *const body= &print_event_info->body_cache; + if (!print_event_info->short_form) + { + bool const last_stmt_event= get_flags(STMT_END_F); + print_header(head, print_event_info, !last_stmt_event); + my_b_printf(head, "\t%s: table id %lu%s\n", + name, m_table_id, + last_stmt_event ? " flags: STMT_END_F" : ""); + print_base64(body, print_event_info, !last_stmt_event); + } + + if (get_flags(STMT_END_F)) + { + copy_event_cache_to_file_and_reinit(head, file); + copy_event_cache_to_file_and_reinit(body, file); + } +} +#endif + + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) +/** + Write the current row into event's table. + + The row is located in the row buffer, pointed by @c m_curr_row member. + Number of columns of the row is stored in @c m_width member (it can be + different from the number of columns in the table to which we insert). + Bitmap @c m_cols indicates which columns are present in the row. It is assumed + that event's table is already open and pointed by @c m_table. + + If the same record already exists in the table it can be either overwritten + or an error is reported depending on the value of @c overwrite flag + (error reporting not yet implemented). Note that the matching record can be + different from the row we insert if we use primary keys to identify records in + the table. + + The row to be inserted can contain values only for selected columns. The + missing columns are filled with default values using @c prepare_record() + function. If a matching record is found in the table and @c overwritte is + true, the missing columns are taken from it. + + @param rli Relay log info (needed for row unpacking). + @param overwrite + Shall we overwrite if the row already exists or signal + error (currently ignored). + + @returns Error code on failure, 0 on success. + + This method, if successful, sets @c m_curr_row_end pointer to point at the + next row in the rows buffer. This is done when unpacking the row to be + inserted. + + @note If a matching record is found, it is either updated using + @c ha_update_row() or first deleted and then new record written. +*/ + +int +Old_rows_log_event::write_row(const Relay_log_info *const rli, + const bool overwrite) +{ + DBUG_ENTER("write_row"); + DBUG_ASSERT(m_table != NULL && thd != NULL); + + TABLE *table= m_table; // pointer to event's table + int error; + int keynum; + auto_afree_ptr key(NULL); + + /* fill table->record[0] with default values */ + + if ((error= prepare_record(rli, table, m_width, + TRUE /* check if columns have def. values */))) + DBUG_RETURN(error); + + /* unpack row into table->record[0] */ + error= unpack_current_row(rli); // TODO: how to handle errors? + +#ifndef DBUG_OFF + DBUG_DUMP("record[0]", table->record[0], table->s->reclength); + DBUG_PRINT_BITSET("debug", "write_set = %s", table->write_set); + DBUG_PRINT_BITSET("debug", "read_set = %s", table->read_set); +#endif + + /* + Try to write record. If a corresponding record already exists in the table, + we try to change it using ha_update_row() if possible. Otherwise we delete + it and repeat the whole process again. + + TODO: Add safety measures against infinite looping. + */ + + while ((error= table->file->ha_write_row(table->record[0]))) + { + if (error == HA_ERR_LOCK_DEADLOCK || error == HA_ERR_LOCK_WAIT_TIMEOUT) + { + table->file->print_error(error, MYF(0)); /* to check at exec_relay_log_event */ + DBUG_RETURN(error); + } + if ((keynum= table->file->get_dup_key(error)) < 0) + { + DBUG_PRINT("info",("Can't locate duplicate key (get_dup_key returns %d)",keynum)); + table->file->print_error(error, MYF(0)); + /* + We failed to retrieve the duplicate key + - either because the error was not "duplicate key" error + - or because the information which key is not available + */ + DBUG_RETURN(error); + } + + /* + We need to retrieve the old row into record[1] to be able to + either update or delete the offending record. We either: + + - use rnd_pos() with a row-id (available as dupp_row) to the + offending row, if that is possible (MyISAM and Blackhole), or else + + - use index_read_idx() with the key that is duplicated, to + retrieve the offending row. + */ + if (table->file->ha_table_flags() & HA_DUPLICATE_POS) + { + DBUG_PRINT("info",("Locating offending record using rnd_pos()")); + error= table->file->rnd_pos(table->record[1], table->file->dup_ref); + if (error) + { + DBUG_PRINT("info",("rnd_pos() returns error %d",error)); + table->file->print_error(error, MYF(0)); + DBUG_RETURN(error); + } + } + else + { + DBUG_PRINT("info",("Locating offending record using index_read_idx()")); + + if (table->file->extra(HA_EXTRA_FLUSH_CACHE)) + { + DBUG_PRINT("info",("Error when setting HA_EXTRA_FLUSH_CACHE")); + DBUG_RETURN(my_errno); + } + + if (key.get() == NULL) + { + key.assign(static_cast(my_alloca(table->s->max_unique_length))); + if (key.get() == NULL) + { + DBUG_PRINT("info",("Can't allocate key buffer")); + DBUG_RETURN(ENOMEM); + } + } + + key_copy((uchar*)key.get(), table->record[0], table->key_info + keynum, + 0); + error= table->file->index_read_idx_map(table->record[1], keynum, + (const uchar*)key.get(), + HA_WHOLE_KEY, + HA_READ_KEY_EXACT); + if (error) + { + DBUG_PRINT("info",("index_read_idx() returns error %d",error)); + table->file->print_error(error, MYF(0)); + DBUG_RETURN(error); + } + } + + /* + Now, record[1] should contain the offending row. That + will enable us to update it or, alternatively, delete it (so + that we can insert the new row afterwards). + */ + + /* + If row is incomplete we will use the record found to fill + missing columns. + */ + if (!get_flags(COMPLETE_ROWS_F)) + { + restore_record(table,record[1]); + error= unpack_current_row(rli); + } + +#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 + work on InnoDB if FOREIGN KEY checks are necessary. + + I (Matz) am not sure of the reason for the last_uniq_key() + check as, but I'm guessing that it's something along the + following lines. + + Suppose that we got the duplicate key to be a key that is not + the last unique key for the table and we perform an update: + then there might be another key for which the unique check will + fail, so we're better off just deleting the row and inserting + the correct row. + */ + if (last_uniq_key(table, keynum) && + !table->file->referenced_by_foreign_key()) + { + DBUG_PRINT("info",("Updating row using ha_update_row()")); + error=table->file->ha_update_row(table->record[1], + table->record[0]); + switch (error) { + + case HA_ERR_RECORD_IS_THE_SAME: + DBUG_PRINT("info",("ignoring HA_ERR_RECORD_IS_THE_SAME error from" + " ha_update_row()")); + error= 0; + + case 0: + break; + + default: + DBUG_PRINT("info",("ha_update_row() returns error %d",error)); + table->file->print_error(error, MYF(0)); + } + + DBUG_RETURN(error); + } + else + { + DBUG_PRINT("info",("Deleting offending row and trying to write new one again")); + if ((error= table->file->ha_delete_row(table->record[1]))) + { + DBUG_PRINT("info",("ha_delete_row() returns error %d",error)); + table->file->print_error(error, MYF(0)); + DBUG_RETURN(error); + } + /* Will retry ha_write_row() with the offending row removed. */ + } + } + + DBUG_RETURN(error); +} + + +/** + Locate the current row in event's table. + + The current row is pointed by @c m_curr_row. Member @c m_width tells how many + columns are there in the row (this can be differnet from the number of columns + in the table). It is assumed that event's table is already open and pointed + by @c m_table. + + If a corresponding record is found in the table it is stored in + @c m_table->record[0]. Note that when record is located based on a primary + key, it is possible that the record found differs from the row being located. + + If no key is specified or table does not have keys, a table scan is used to + find the row. In that case the row should be complete and contain values for + all columns. However, it can still be shorter than the table, i.e. the table + can contain extra columns not present in the row. It is also possible that + the table has fewer columns than the row being located. + + @returns Error code on failure, 0 on success. + + @post In case of success @c m_table->record[0] contains the record found. + Also, the internal "cursor" of the table is positioned at the record found. + + @note If the engine allows random access of the records, a combination of + @c position() and @c rnd_pos() will be used. + */ + +int Old_rows_log_event::find_row(const Relay_log_info *rli) +{ + DBUG_ENTER("find_row"); + + DBUG_ASSERT(m_table && m_table->in_use != NULL); + + TABLE *table= m_table; + int error; + + /* unpack row - missing fields get default values */ + + // TODO: shall we check and report errors here? + prepare_record(NULL,table,m_width,FALSE /* don't check errors */); + error= unpack_current_row(rli); + +#ifndef DBUG_OFF + DBUG_PRINT("info",("looking for the following record")); + DBUG_DUMP("record[0]", table->record[0], table->s->reclength); +#endif + + if ((table->file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_POSITION) && + table->s->primary_key < MAX_KEY) + { + /* + Use a more efficient method to fetch the record given by + table->record[0] if the engine allows it. We first compute a + row reference using the position() member function (it will be + stored in table->file->ref) and the use rnd_pos() to position + the "cursor" (i.e., record[0] in this case) at the correct row. + + TODO: Add a check that the correct record has been fetched by + comparing with the original record. Take into account that the + record on the master and slave can be of different + length. Something along these lines should work: + + ADD>>> store_record(table,record[1]); + int error= table->file->rnd_pos(table->record[0], table->file->ref); + ADD>>> DBUG_ASSERT(memcmp(table->record[1], table->record[0], + table->s->reclength) == 0); + + */ + DBUG_PRINT("info",("locating record using primary key (position)")); + int error= table->file->rnd_pos_by_record(table->record[0]); + if (error) + { + DBUG_PRINT("info",("rnd_pos returns error %d",error)); + table->file->print_error(error, MYF(0)); + } + DBUG_RETURN(error); + } + + // We can't use position() - try other methods. + + /* + We need to retrieve all fields + TODO: Move this out from this function to main loop + */ + table->use_all_columns(); + + /* + Save copy of the record in table->record[1]. It might be needed + later if linear search is used to find exact match. + */ + store_record(table,record[1]); + + if (table->s->keys > 0) + { + DBUG_PRINT("info",("locating record using primary key (index_read)")); + + /* We have a key: search the table using the index */ + if (!table->file->inited && (error= table->file->ha_index_init(0, FALSE))) + { + DBUG_PRINT("info",("ha_index_init returns error %d",error)); + table->file->print_error(error, MYF(0)); + DBUG_RETURN(error); + } + + /* Fill key data for the row */ + + DBUG_ASSERT(m_key); + key_copy(m_key, table->record[0], table->key_info, 0); + + /* + Don't print debug messages when running valgrind since they can + trigger false warnings. + */ +#ifndef HAVE_purify + DBUG_DUMP("key data", m_key, table->key_info->key_length); +#endif + + /* + We need to set the null bytes to ensure that the filler bit are + all set when returning. There are storage engines that just set + the necessary bits on the bytes and don't set the filler bits + correctly. + */ + my_ptrdiff_t const pos= + table->s->null_bytes > 0 ? table->s->null_bytes - 1 : 0; + table->record[0][pos]= 0xFF; + + if ((error= table->file->index_read_map(table->record[0], m_key, + HA_WHOLE_KEY, + HA_READ_KEY_EXACT))) + { + DBUG_PRINT("info",("no record matching the key found in the table")); + table->file->print_error(error, MYF(0)); + table->file->ha_index_end(); + DBUG_RETURN(error); + } + + /* + Don't print debug messages when running valgrind since they can + trigger false warnings. + */ +#ifndef HAVE_purify + DBUG_PRINT("info",("found first matching record")); + DBUG_DUMP("record[0]", table->record[0], table->s->reclength); +#endif + /* + Below is a minor "optimization". If the key (i.e., key number + 0) has the HA_NOSAME flag set, we know that we have found the + correct record (since there can be no duplicates); otherwise, we + have to compare the record with the one found to see if it is + the correct one. + + CAVEAT! This behaviour is essential for the replication of, + e.g., the mysql.proc table since the correct record *shall* be + found using the primary key *only*. There shall be no + comparison of non-PK columns to decide if the correct record is + found. I can see no scenario where it would be incorrect to + chose the row to change only using a PK or an UNNI. + */ + if (table->key_info->flags & HA_NOSAME) + { + table->file->ha_index_end(); + DBUG_RETURN(0); + } + + /* + In case key is not unique, we still have to iterate over records found + and find the one which is identical to the row given. A copy of the + record we are looking for is stored in record[1]. + */ + DBUG_PRINT("info",("non-unique index, scanning it to find matching record")); + + while (record_compare(table)) + { + /* + We need to set the null bytes to ensure that the filler bit + are all set when returning. There are storage engines that + just set the necessary bits on the bytes and don't set the + filler bits correctly. + + TODO[record format ndb]: Remove this code once NDB returns the + correct record format. + */ + if (table->s->null_bytes > 0) + { + table->record[0][table->s->null_bytes - 1]|= + 256U - (1U << table->s->last_null_bit_pos); + } + + if ((error= table->file->index_next(table->record[0]))) + { + DBUG_PRINT("info",("no record matching the given row found")); + table->file->print_error(error, MYF(0)); + table->file->ha_index_end(); + DBUG_RETURN(error); + } + } + + /* + Have to restart the scan to be able to fetch the next row. + */ + table->file->ha_index_end(); + } + else + { + DBUG_PRINT("info",("locating record using table scan (rnd_next)")); + + int restart_count= 0; // Number of times scanning has restarted from top + + /* We don't have a key: search the table using rnd_next() */ + if ((error= table->file->ha_rnd_init(1))) + { + DBUG_PRINT("info",("error initializing table scan" + " (ha_rnd_init returns %d)",error)); + table->file->print_error(error, MYF(0)); + DBUG_RETURN(error); + } + + /* Continue until we find the right record or have made a full loop */ + do + { + error= table->file->rnd_next(table->record[0]); + + switch (error) { + + case 0: + case HA_ERR_RECORD_DELETED: + break; + + case HA_ERR_END_OF_FILE: + if (++restart_count < 2) + table->file->ha_rnd_init(1); + break; + + default: + DBUG_PRINT("info", ("Failed to get next record" + " (rnd_next returns %d)",error)); + table->file->print_error(error, MYF(0)); + table->file->ha_rnd_end(); + DBUG_RETURN(error); + } + } + while (restart_count < 2 && record_compare(table)); + + /* + Note: above record_compare will take into accout all record fields + which might be incorrect in case a partial row was given in the event + */ + + /* + Have to restart the scan to be able to fetch the next row. + */ + if (restart_count == 2) + DBUG_PRINT("info", ("Record not found")); + else + DBUG_DUMP("record found", table->record[0], table->s->reclength); + table->file->ha_rnd_end(); + + DBUG_ASSERT(error == HA_ERR_END_OF_FILE || error == 0); + DBUG_RETURN(error); + } + + DBUG_RETURN(0); +} + +#endif + + +/************************************************************************** + Write_rows_log_event member functions +**************************************************************************/ + +/* + Constructor used to build an event for writing to the binary log. + */ +#if !defined(MYSQL_CLIENT) +Write_rows_log_event_old::Write_rows_log_event_old(THD *thd_arg, + TABLE *tbl_arg, + ulong tid_arg, + MY_BITMAP const *cols, + bool is_transactional) + : Old_rows_log_event(thd_arg, tbl_arg, tid_arg, cols, is_transactional) +{ + + // This constructor should not be reached. + assert(0); + +} +#endif + + +/* + Constructor used by slave to read the event from the binary log. + */ +#ifdef HAVE_REPLICATION +Write_rows_log_event_old::Write_rows_log_event_old(const char *buf, + uint event_len, + const Format_description_log_event + *description_event) +: Old_rows_log_event(buf, event_len, PRE_GA_WRITE_ROWS_EVENT, + description_event) +{ +} +#endif + + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) +int +Write_rows_log_event_old::do_before_row_operations(const Slave_reporting_capability *const) +{ + int error= 0; + + /* + We are using REPLACE semantics and not INSERT IGNORE semantics + when writing rows, that is: new rows replace old rows. We need to + inform the storage engine that it should use this behaviour. + */ + + /* Tell the storage engine that we are using REPLACE semantics. */ + thd->lex->duplicates= DUP_REPLACE; + + /* + Pretend we're executing a REPLACE command: this is needed for + InnoDB and NDB Cluster since they are not (properly) checking the + lex->duplicates flag. + */ + thd->lex->sql_command= SQLCOM_REPLACE; + /* + Do not raise the error flag in case of hitting to an unique attribute + */ + 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 + */ + 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. + */ + 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. + */ + 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 + the event's current time. + As we replicate from TIMESTAMP to TIMESTAMP and slave has no extra + columns, we know that all TIMESTAMP columns on slave will receive explicit + data from the row, so TIMESTAMP_NO_AUTO_SET is ok. + When we allow a table without TIMESTAMP to be replicated to a table having + more columns including a TIMESTAMP column, or when we allow a TIMESTAMP + column to be replicated into a BIGINT column and the slave's table has a + TIMESTAMP column, then the slave's TIMESTAMP column will take its value + from set_time() which we called earlier (consistent with SBR). And then in + 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). + */ + m_table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET; + return error; +} + + +int +Write_rows_log_event_old::do_after_row_operations(const Slave_reporting_capability *const, + int error) +{ + int local_error= 0; + 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); + fires bug#27077 + todo: explain or fix + */ + if ((local_error= m_table->file->ha_end_bulk_insert())) + { + m_table->file->print_error(local_error, MYF(0)); + } + return error? error : local_error; +} + + +int +Write_rows_log_event_old::do_exec_row(const Relay_log_info *const rli) +{ + DBUG_ASSERT(m_table != NULL); + int error= write_row(rli, TRUE /* overwrite */); + + if (error && !thd->net.last_errno) + thd->net.last_errno= error; + + return error; +} + +#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */ + + +#ifdef MYSQL_CLIENT +void Write_rows_log_event_old::print(FILE *file, + PRINT_EVENT_INFO* print_event_info) +{ + Old_rows_log_event::print_helper(file, print_event_info, "Write_rows_old"); +} +#endif + + +/************************************************************************** + Delete_rows_log_event member functions +**************************************************************************/ + +/* + Constructor used to build an event for writing to the binary log. + */ + +#ifndef MYSQL_CLIENT +Delete_rows_log_event_old::Delete_rows_log_event_old(THD *thd_arg, + TABLE *tbl_arg, + ulong tid, + MY_BITMAP const *cols, + bool is_transactional) + : Old_rows_log_event(thd_arg, tbl_arg, tid, cols, is_transactional), + m_after_image(NULL), m_memory(NULL) +{ + + // This constructor should not be reached. + assert(0); + +} +#endif /* #if !defined(MYSQL_CLIENT) */ + + +/* + Constructor used by slave to read the event from the binary log. + */ +#ifdef HAVE_REPLICATION +Delete_rows_log_event_old::Delete_rows_log_event_old(const char *buf, + uint event_len, + const Format_description_log_event + *description_event) + : Old_rows_log_event(buf, event_len, PRE_GA_DELETE_ROWS_EVENT, + description_event), + m_after_image(NULL), m_memory(NULL) +{ +} +#endif + + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + +int +Delete_rows_log_event_old::do_before_row_operations(const Slave_reporting_capability *const) +{ + 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_key since it is not used. + */ + return 0; + } + + if (m_table->s->keys > 0) + { + // Allocate buffer for key searches + m_key= (uchar*)my_malloc(m_table->key_info->key_length, MYF(MY_WME)); + if (!m_key) + return HA_ERR_OUT_OF_MEM; + } + return 0; +} + + +int +Delete_rows_log_event_old::do_after_row_operations(const Slave_reporting_capability *const, + int error) +{ + /*error= ToDo:find out what this should really be, this triggers close_scan in nbd, returning error?*/ + m_table->file->ha_index_or_rnd_end(); + my_free(m_key, MYF(MY_ALLOW_ZERO_PTR)); + m_key= NULL; + + return error; +} + + +int Delete_rows_log_event_old::do_exec_row(const Relay_log_info *const rli) +{ + int error; + DBUG_ASSERT(m_table != NULL); + + if (!(error= find_row(rli))) + { + /* + Delete the record found, located in record[0] + */ + error= m_table->file->ha_delete_row(m_table->record[0]); + } + return error; +} + +#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */ + + +#ifdef MYSQL_CLIENT +void Delete_rows_log_event_old::print(FILE *file, + PRINT_EVENT_INFO* print_event_info) +{ + Old_rows_log_event::print_helper(file, print_event_info, "Delete_rows_old"); +} +#endif + + +/************************************************************************** + Update_rows_log_event member functions +**************************************************************************/ + +/* + Constructor used to build an event for writing to the binary log. + */ +#if !defined(MYSQL_CLIENT) +Update_rows_log_event_old::Update_rows_log_event_old(THD *thd_arg, + TABLE *tbl_arg, + ulong tid, + MY_BITMAP const *cols, + bool is_transactional) + : Old_rows_log_event(thd_arg, tbl_arg, tid, cols, is_transactional), + m_after_image(NULL), m_memory(NULL) +{ + + // This constructor should not be reached. + assert(0); + + init(cols); +} + + +void Update_rows_log_event_old::init(MY_BITMAP const *cols) +{ + /* if bitmap_init fails, caught in is_valid() */ + if (likely(!bitmap_init(&m_cols_ai, + m_width <= sizeof(m_bitbuf_ai)*8 ? m_bitbuf_ai : NULL, + m_width, + false))) + { + /* Cols can be zero if this is a dummy binrows event */ + if (likely(cols != NULL)) + { + memcpy(m_cols_ai.bitmap, cols->bitmap, no_bytes_in_map(cols)); + create_last_word_mask(&m_cols_ai); + } + } +} +#endif /* !defined(MYSQL_CLIENT) */ + + +Update_rows_log_event_old::~Update_rows_log_event_old() +{ + if (m_cols_ai.bitmap == m_bitbuf_ai) // no my_malloc happened + m_cols_ai.bitmap= 0; // so no my_free in bitmap_free + bitmap_free(&m_cols_ai); // To pair with bitmap_init(). +} + + +/* + Constructor used by slave to read the event from the binary log. + */ +#ifdef HAVE_REPLICATION +Update_rows_log_event_old::Update_rows_log_event_old(const char *buf, + uint event_len, + const + Format_description_log_event + *description_event) + : Old_rows_log_event(buf, event_len, PRE_GA_UPDATE_ROWS_EVENT, + description_event), + m_after_image(NULL), m_memory(NULL) +{ +} +#endif + + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + +int +Update_rows_log_event_old::do_before_row_operations(const Slave_reporting_capability *const) +{ + if (m_table->s->keys > 0) + { + // Allocate buffer for key searches + m_key= (uchar*)my_malloc(m_table->key_info->key_length, MYF(MY_WME)); + if (!m_key) + return HA_ERR_OUT_OF_MEM; + } + + m_table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET; + + return 0; +} + + +int +Update_rows_log_event_old::do_after_row_operations(const Slave_reporting_capability *const, + int error) +{ + /*error= ToDo:find out what this should really be, this triggers close_scan in nbd, returning error?*/ + m_table->file->ha_index_or_rnd_end(); + my_free(m_key, MYF(MY_ALLOW_ZERO_PTR)); // Free for multi_malloc + m_key= NULL; + + return error; +} + + +int +Update_rows_log_event_old::do_exec_row(const Relay_log_info *const rli) +{ + DBUG_ASSERT(m_table != NULL); + + int error= find_row(rli); + if (error) + { + /* + We need to read the second image in the event of error to be + able to skip to the next pair of updates + */ + m_curr_row= m_curr_row_end; + unpack_current_row(rli); + return error; + } + + /* + This is the situation after locating BI: + + ===|=== before image ====|=== after image ===|=== + ^ ^ + m_curr_row m_curr_row_end + + BI found in the table is stored in record[0]. We copy it to record[1] + and unpack AI to record[0]. + */ + + store_record(m_table,record[1]); + + m_curr_row= m_curr_row_end; + error= unpack_current_row(rli); // this also updates m_curr_row_end + + /* + Now we have the right row to update. The old row (the one we're + looking for) is in record[1] and the new row is in record[0]. + */ +#ifndef HAVE_purify + /* + Don't print debug messages when running valgrind since they can + trigger false warnings. + */ + DBUG_PRINT("info",("Updating row in table")); + DBUG_DUMP("old record", m_table->record[1], m_table->s->reclength); + DBUG_DUMP("new values", m_table->record[0], m_table->s->reclength); +#endif + + 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; + + return error; +} + +#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */ + + +#ifdef MYSQL_CLIENT +void Update_rows_log_event_old::print(FILE *file, + PRINT_EVENT_INFO* print_event_info) +{ + Old_rows_log_event::print_helper(file, print_event_info, "Update_rows_old"); +} +#endif diff --git a/sql/log_event_old.h b/sql/log_event_old.h index 81e55097905..efb2be29ee4 100644 --- a/sql/log_event_old.h +++ b/sql/log_event_old.h @@ -20,18 +20,269 @@ Need to include this file at the proper position of log_event.h */ + +/** + @file + + @brief This file contains classes handling old formats of row-based + binlog events. +*/ +/* + Around 2007-10-31, I made these classes completely separated from + the new classes (before, there was a complex class hierarchy + involving multiple inheritance; see BUG#31581), by simply copying + and pasting the entire contents of Rows_log_event into + Old_rows_log_event and the entire contents of + {Write|Update|Delete}_rows_log_event into + {Write|Update|Delete}_rows_log_event_old. For clarity, I will keep + the comments marking which code was cut-and-pasted for some time. + With the classes collapsed into one, there is probably some + redundancy (maybe some methods can be simplified and/or removed), + but we keep them this way for now. /Sven +*/ + + +/** + @class Old_rows_log_event -class Old_rows_log_event + Base class for the three types of row-based events + {Write|Update|Delete}_row_log_event_old, with event type codes + PRE_GA_{WRITE|UPDATE|DELETE}_ROWS_EVENT. These events are never + created any more, except when reading a relay log created by an old + server. +*/ +class Old_rows_log_event : public Log_event { - public: - - virtual ~Old_rows_log_event() {} + /********** BEGIN CUT & PASTE FROM Rows_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), + + /** + Indicates that rows in this event are complete, that is contain + values for all columns of the table. + */ + COMPLETE_ROWS_F = (1U << 3) + }; + + typedef uint16 flag_set; + + /* Special constants representing sets of flags */ + enum + { + RLE_NO_FLAGS = 0U + }; + + virtual ~Old_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_old + is valid is done in the Update_rows_log_event_old::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 + Old_rows_log_event(THD*, TABLE*, ulong table_id, + MY_BITMAP const *cols, bool is_transactional); +#endif + Old_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 */ + + /* helper functions */ + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + 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 */ + uchar *m_key; /* Buffer to keep key value during searches */ + + int find_row(const Relay_log_info *const); + int write_row(const Relay_log_info *const, const bool); + + // Unpack the current row into m_table->record[0] + int unpack_current_row(const Relay_log_info *const rli) + { + DBUG_ASSERT(m_table); + ASSERT_OR_RETURN_ERROR(m_curr_row < m_rows_end, HA_ERR_CORRUPT_EVENT); + int const result= ::unpack_row(rli, m_table, m_width, m_curr_row, &m_cols, + &m_curr_row_end, &m_master_reclength); + ASSERT_OR_RETURN_ERROR(m_curr_row_end <= m_rows_end, HA_ERR_CORRUPT_EVENT); + return result; + } +#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); + + /* + 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(const Slave_reporting_capability *const log) = 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. + + The error argument, if non-zero, indicates an error which happened during + row processing before this function was called. In this case, even if + function is successful, it should return the error code given in the argument. + */ + virtual + int do_after_row_operations(const Slave_reporting_capability *const log, + int error) = 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(const Relay_log_info *const rli) = 0; +#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */ + + /********** END OF CUT & PASTE FROM Rows_log_event **********/ protected: #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) - int do_apply_event(Rows_log_event*,const Relay_log_info*); + int do_apply_event(Old_rows_log_event*,const Relay_log_info*); /* Primitive to prepare for a sequence of row executions. @@ -100,32 +351,60 @@ class Old_rows_log_event }; -class Write_rows_log_event_old - : public Write_rows_log_event, public Old_rows_log_event -{ +/** + @class Write_rows_log_event_old + Old class for binlog events that write new rows to a table (event + type code PRE_GA_WRITE_ROWS_EVENT). Such events are never produced + by this version of the server, but they may be read from a relay log + created by an old server. New servers create events of class + Write_rows_log_event (event type code WRITE_ROWS_EVENT) instead. +*/ +class Write_rows_log_event_old : public Old_rows_log_event +{ + /********** BEGIN CUT & PASTE FROM Write_rows_log_event **********/ public: - enum - { - /* Support interface to THD::binlog_prepare_pending_rows_event */ - TYPE_CODE = PRE_GA_WRITE_ROWS_EVENT - }; - #if !defined(MYSQL_CLIENT) - Write_rows_log_event_old(THD *thd, TABLE *table, ulong table_id, - MY_BITMAP const *cols, bool is_transactional) - : Write_rows_log_event(thd, table, table_id, cols, is_transactional) - { - } + Write_rows_log_event_old(THD*, TABLE*, ulong table_id, + MY_BITMAP const *cols, bool is_transactional); #endif -#if defined(HAVE_REPLICATION) +#ifdef HAVE_REPLICATION Write_rows_log_event_old(const char *buf, uint event_len, - const Format_description_log_event *descr) - : Write_rows_log_event(buf, event_len, descr) + 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: +#ifdef MYSQL_CLIENT + void print(FILE *file, PRINT_EVENT_INFO *print_event_info); +#endif + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_before_row_operations(const Slave_reporting_capability *const); + virtual int do_after_row_operations(const Slave_reporting_capability *const,int); + virtual int do_exec_row(const Relay_log_info *const); +#endif + /********** END OF CUT & PASTE FROM Write_rows_log_event **********/ + +public: + enum + { + /* Support interface to THD::binlog_prepare_pending_rows_event */ + TYPE_CODE = PRE_GA_WRITE_ROWS_EVENT + }; + private: virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; } @@ -145,35 +424,74 @@ private: }; -class Update_rows_log_event_old - : public Update_rows_log_event, public Old_rows_log_event +/** + @class Update_rows_log_event_old + + Old class for binlog events that modify existing rows to a table + (event type code PRE_GA_UPDATE_ROWS_EVENT). Such events are never + produced by this version of the server, but they may be read from a + relay log created by an old server. New servers create events of + class Update_rows_log_event (event type code UPDATE_ROWS_EVENT) + instead. +*/ +class Update_rows_log_event_old : public Old_rows_log_event { - uchar *m_after_image, *m_memory; - + /********** BEGIN CUT & PASTE FROM Update_rows_log_event **********/ public: - enum - { - /* Support interface to THD::binlog_prepare_pending_rows_event */ - TYPE_CODE = PRE_GA_UPDATE_ROWS_EVENT - }; +#ifndef MYSQL_CLIENT + Update_rows_log_event_old(THD*, TABLE*, ulong table_id, + MY_BITMAP const *cols, + bool is_transactional); -#if !defined(MYSQL_CLIENT) - Update_rows_log_event_old(THD *thd, TABLE *table, ulong table_id, - MY_BITMAP const *cols, bool is_transactional) - : Update_rows_log_event(thd, table, table_id, cols, is_transactional), - m_after_image(NULL), m_memory(NULL) + void init(MY_BITMAP const *cols); +#endif + + virtual ~Update_rows_log_event_old(); + +#ifdef HAVE_REPLICATION + Update_rows_log_event_old(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 -#if defined(HAVE_REPLICATION) - Update_rows_log_event_old(const char *buf, uint event_len, - const Format_description_log_event *descr) - : Update_rows_log_event(buf, event_len, descr), - m_after_image(NULL), m_memory(NULL) + + virtual bool is_valid() const { + return Old_rows_log_event::is_valid() && m_cols_ai.bitmap; } + +protected: +#ifdef MYSQL_CLIENT + void print(FILE *file, PRINT_EVENT_INFO *print_event_info); #endif +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_before_row_operations(const Slave_reporting_capability *const); + virtual int do_after_row_operations(const Slave_reporting_capability *const,int); + virtual int do_exec_row(const Relay_log_info *const); +#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */ + /********** END OF CUT & PASTE FROM Update_rows_log_event **********/ + + uchar *m_after_image, *m_memory; + +public: + enum + { + /* Support interface to THD::binlog_prepare_pending_rows_event */ + TYPE_CODE = PRE_GA_UPDATE_ROWS_EVENT + }; + private: virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; } @@ -192,9 +510,54 @@ private: }; -class Delete_rows_log_event_old - : public Delete_rows_log_event, public Old_rows_log_event +/** + @class Delete_rows_log_event_old + + Old class for binlog events that delete existing rows from a table + (event type code PRE_GA_DELETE_ROWS_EVENT). Such events are never + produced by this version of the server, but they may be read from a + relay log created by an old server. New servers create events of + class Delete_rows_log_event (event type code DELETE_ROWS_EVENT) + instead. +*/ +class Delete_rows_log_event_old : public Old_rows_log_event { + /********** BEGIN CUT & PASTE FROM Update_rows_log_event **********/ +public: +#ifndef MYSQL_CLIENT + Delete_rows_log_event_old(THD*, TABLE*, ulong, + MY_BITMAP const *cols, bool is_transactional); +#endif +#ifdef HAVE_REPLICATION + Delete_rows_log_event_old(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: +#ifdef MYSQL_CLIENT + void print(FILE *file, PRINT_EVENT_INFO *print_event_info); +#endif + +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) + virtual int do_before_row_operations(const Slave_reporting_capability *const); + virtual int do_after_row_operations(const Slave_reporting_capability *const,int); + virtual int do_exec_row(const Relay_log_info *const); +#endif + /********** END CUT & PASTE FROM Delete_rows_log_event **********/ + uchar *m_after_image, *m_memory; public: @@ -204,23 +567,6 @@ public: TYPE_CODE = PRE_GA_DELETE_ROWS_EVENT }; -#if !defined(MYSQL_CLIENT) - Delete_rows_log_event_old(THD *thd, TABLE *table, ulong table_id, - MY_BITMAP const *cols, bool is_transactional) - : Delete_rows_log_event(thd, table, table_id, cols, is_transactional), - m_after_image(NULL), m_memory(NULL) - { - } -#endif -#if defined(HAVE_REPLICATION) - Delete_rows_log_event_old(const char *buf, uint event_len, - const Format_description_log_event *descr) - : Delete_rows_log_event(buf, event_len, descr), - m_after_image(NULL), m_memory(NULL) - { - } -#endif - private: virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; } @@ -240,4 +586,3 @@ private: #endif - -- cgit v1.2.1 From 64f6ce046fc9e710152a12d4b6384355a107d25d Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 21 Nov 2007 16:53:46 +0100 Subject: BUG#31581: 5.1-telco-6.1 -> 5.1.22. Slave crashes during starting The patch I previously pushed for this bug did not compile because a field in class THD had been renamed. This patch renames thd->query_error to thd->is_slave_error in log_event_old.cc by applying the same patch to log_event_old.cc as was previously applied to log_event.cc. sql/log_event_old.cc: Renames thd->query_error to thd->is_slave_error in log_event_old.cc by applying the same patch to log_event_old.cc as was previously applied to log_event.cc. --- sql/log_event_old.cc | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'sql') diff --git a/sql/log_event_old.cc b/sql/log_event_old.cc index e9625a992d3..b16af43f24e 100644 --- a/sql/log_event_old.cc +++ b/sql/log_event_old.cc @@ -1251,7 +1251,7 @@ Old_rows_log_event::Old_rows_log_event(THD *thd_arg, TABLE *tbl_arg, ulong tid, m_width(tbl_arg ? tbl_arg->s->fields : 1), m_rows_buf(0), m_rows_cur(0), m_rows_end(0), m_flags(0) #ifdef HAVE_REPLICATION - ,m_key(NULL), m_curr_row(NULL), m_curr_row_end(NULL) + , m_curr_row(NULL), m_curr_row_end(NULL), m_key(NULL) #endif { @@ -1304,7 +1304,7 @@ Old_rows_log_event::Old_rows_log_event(const char *buf, uint event_len, #endif m_table_id(0), m_rows_buf(0), m_rows_cur(0), m_rows_end(0) #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) - ,m_key(NULL), m_curr_row(NULL), m_curr_row_end(NULL) + , m_curr_row(NULL), m_curr_row_end(NULL), m_key(NULL) #endif { DBUG_ENTER("Old_rows_log_event::Old_Rows_log_event(const char*,...)"); @@ -1555,7 +1555,7 @@ int Old_rows_log_event::do_apply_event(Relay_log_info const *rli) { if (!need_reopen) { - if (thd->query_error || thd->is_fatal_error) + if (thd->is_slave_error || thd->is_fatal_error) { /* Error reporting borrowed from Query_log_event with many excessive @@ -1599,7 +1599,7 @@ int Old_rows_log_event::do_apply_event(Relay_log_info const *rli) 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) + if (thd->is_slave_error || thd->is_fatal_error) { /* Error reporting borrowed from Query_log_event with many excessive @@ -1610,7 +1610,7 @@ int Old_rows_log_event::do_apply_event(Relay_log_info const *rli) "Error '%s' on reopening tables", (actual_error ? thd->net.last_error : "unexpected success or fatal error")); - thd->query_error= 1; + thd->is_slave_error= 1; } const_cast(rli)->clear_tables_to_lock(); DBUG_RETURN(error); @@ -1633,7 +1633,7 @@ int Old_rows_log_event::do_apply_event(Relay_log_info const *rli) { mysql_unlock_tables(thd, thd->lock); thd->lock= 0; - thd->query_error= 1; + thd->is_slave_error= 1; const_cast(rli)->clear_tables_to_lock(); DBUG_RETURN(ERR_BAD_TABLE_DEF); } @@ -1765,7 +1765,7 @@ int Old_rows_log_event::do_apply_event(Relay_log_info const *rli) "Error in %s event: row application failed. %s", get_type_str(), thd->net.last_error ? thd->net.last_error : ""); - thd->query_error= 1; + thd->is_slave_error= 1; break; } @@ -1831,7 +1831,7 @@ int Old_rows_log_event::do_apply_event(Relay_log_info const *rli) */ thd->reset_current_stmt_binlog_row_based(); const_cast(rli)->cleanup_context(thd, error); - thd->query_error= 1; + thd->is_slave_error= 1; DBUG_RETURN(error); } -- cgit v1.2.1 From dc8d5bc7ba7e73cd0f651c3fabc921fe3b00a2f8 Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 23 Nov 2007 14:41:41 +0100 Subject: BUG#32580 (mysqlbinlog cannot read binlog event generated by user variable usage): The client program 'mysqlbinlog' crashed when trying to print a User_var_log_event holding a floating-point value since the format specifier for my_b_printf() does not support floating-point format specifiers. This patch prints the floating-point number to an internal buffer, and then writes that buffer to the output instead. mysql-test/r/mysqlbinlog.result: Result file change. mysql-test/t/mysqlbinlog.test: Adding test that mysqlbinlog can write and read back User_var_log_event for real, decimal, integer, and string. These are the only types supported for user variables. sql/log_event.cc: Using my_sprintf() to print floating-point value of User_var_log_event value to a character buffer and then to the real output, since my_b_printf() does not support floating-point format. Also adding macro to give buffer size needed for printing floating-point numbers in %g format. --- sql/log_event.cc | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) (limited to 'sql') diff --git a/sql/log_event.cc b/sql/log_event.cc index 9ad85be8a91..d1ad9211d63 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -36,6 +36,16 @@ #define FLAGSTR(V,F) ((V)&(F)?#F" ":"") + +/* + Size of buffer for printing a double in format %.g + + optional '-' + optional zero + '.' + PREC digits + 'e' + sign + + exponent digits + '\0' +*/ +#define FMT_G_BUFSIZE(PREC) (3 + (PREC) + 5 + 1) + + #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) && !defined(DBUG_OFF) && !defined(_lint) static const char *HA_ERR(int i) { @@ -4404,8 +4414,10 @@ void User_var_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info) switch (type) { case REAL_RESULT: double real_val; + char real_buf[FMT_G_BUFSIZE(14)]; float8get(real_val, val); - my_b_printf(&cache, ":=%.14g%s\n", real_val, print_event_info->delimiter); + my_sprintf(real_buf, (real_buf, "%.14g", real_val)); + my_b_printf(&cache, ":=%s%s\n", real_buf, print_event_info->delimiter); break; case INT_RESULT: char int_buf[22]; -- cgit v1.2.1 From 7ed596398becf839238e02fc6e0b30a1b8dd2b54 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 28 Nov 2007 15:35:25 +0400 Subject: bug#29562 default collation of ucs2_unicode_ci crashes slave Problem: some pieces of code relied on the default character set settings, which didn't work in case of default character set ucs2. Fix: Specifying character set explicitly, not to depend on the default settings. mysql-test/suite/rpl_ndb/r/rpl_ndb_ctype_ucs2_def.result: Recording correct test result mysql-test/suite/rpl_ndb/t/disabled.def: Enabling test sql/ha_ndbcluster_binlog.cc: Character set of the NDB helper tables should not rely of the default settings, to avoid creating tables in different character sets on master and slave. Adding explicit character set. UTF8 should be fine. character_set_client should not rely on the default character set settings, which can be ucs2. Helper SQL queries sent by NDB are all in pure ASCII. Setting client_character_set to latin1. sql/log_event.cc: Adding assert to make sure that binary log does not have queries in character set which parser does not understand (e.g. ucs2). --- sql/ha_ndbcluster_binlog.cc | 5 +++-- sql/log_event.cc | 1 + 2 files changed, 4 insertions(+), 2 deletions(-) (limited to 'sql') diff --git a/sql/ha_ndbcluster_binlog.cc b/sql/ha_ndbcluster_binlog.cc index fc35a7a930e..cf13110e359 100644 --- a/sql/ha_ndbcluster_binlog.cc +++ b/sql/ha_ndbcluster_binlog.cc @@ -775,7 +775,7 @@ static int ndbcluster_create_ndb_apply_status_table(THD *thd) " log_name VARCHAR(255) BINARY NOT NULL, " " start_pos BIGINT UNSIGNED NOT NULL, " " end_pos BIGINT UNSIGNED NOT NULL, " - " PRIMARY KEY USING HASH (server_id) ) ENGINE=NDB"); + " PRIMARY KEY USING HASH (server_id) ) ENGINE=NDB CHARACTER SET utf8"); const int no_print_error[4]= {ER_TABLE_EXISTS_ERROR, 701, @@ -835,7 +835,7 @@ static int ndbcluster_create_schema_table(THD *thd) " id INT UNSIGNED NOT NULL," " version INT UNSIGNED NOT NULL," " type INT UNSIGNED NOT NULL," - " PRIMARY KEY USING HASH (db,name) ) ENGINE=NDB"); + " PRIMARY KEY USING HASH (db,name) ) ENGINE=NDB CHARACTER SET utf8"); const int no_print_error[4]= {ER_TABLE_EXISTS_ERROR, 701, @@ -3959,6 +3959,7 @@ restart: i_ndb->setReportThreshEventFreeMem(ndb_report_thresh_binlog_mem_usage); bzero((char*) &row, sizeof(row)); + thd->variables.character_set_client= &my_charset_latin1; injector::transaction trans; // pass table map before epoch { diff --git a/sql/log_event.cc b/sql/log_event.cc index d1ad9211d63..fbb44fd8f38 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -1648,6 +1648,7 @@ Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg, DBUG_ASSERT(thd_arg->variables.character_set_client->number < 256*256); DBUG_ASSERT(thd_arg->variables.collation_connection->number < 256*256); DBUG_ASSERT(thd_arg->variables.collation_server->number < 256*256); + DBUG_ASSERT(thd_arg->variables.character_set_client->mbminlen == 1); int2store(charset, thd_arg->variables.character_set_client->number); int2store(charset+2, thd_arg->variables.collation_connection->number); int2store(charset+4, thd_arg->variables.collation_server->number); -- cgit v1.2.1 From df35f2c353c4453f3b5dbe56bb6ef4935312ffb7 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 3 Dec 2007 13:11:40 +0800 Subject: Bug#30998 Drop View breaks replication if view does not exist When executing drop view statement on the master, the statement is written into bin-log without checking for possible errors, so the statement would always be bin-logged with error code cleared even if some error might occur, for example, some of the views being dropped does not exist. This would cause failure on the slave. Writing bin-log after check for errors, if at least one view has been dropped the query is bin-logged possible with an error. sql/sql_view.cc: Writing bin-log after check for errors, if at least one view has been dropped the query is bin-logged possible with an error. mysql-test/r/rpl_drop_view.result: Add test result for bug#30998 mysql-test/t/rpl_drop_view.test: Add test for bug#30998 --- sql/sql_view.cc | 32 +++++++++++++++++++------------- 1 file changed, 19 insertions(+), 13 deletions(-) (limited to 'sql') diff --git a/sql/sql_view.cc b/sql/sql_view.cc index 297edd0d90d..dd0b92a06f8 100644 --- a/sql/sql_view.cc +++ b/sql/sql_view.cc @@ -1424,6 +1424,8 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode) String non_existant_views; char *wrong_object_db= NULL, *wrong_object_name= NULL; bool error= FALSE; + bool some_views_deleted= FALSE; + bool something_wrong= FALSE; VOID(pthread_mutex_lock(&LOCK_open)); for (view= views; view; view= view->next_local) @@ -1462,33 +1464,37 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode) } if (my_delete(path, MYF(MY_WME))) error= TRUE; + some_views_deleted= TRUE; query_cache_invalidate3(thd, view, 0); sp_cache_invalidate(); } - if (mysql_bin_log.is_open()) - { - thd->clear_error(); - Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE); - mysql_bin_log.write(&qinfo); - } - - VOID(pthread_mutex_unlock(&LOCK_open)); - if (error) - { - DBUG_RETURN(TRUE); - } if (wrong_object_name) { my_error(ER_WRONG_OBJECT, MYF(0), wrong_object_db, wrong_object_name, "VIEW"); - DBUG_RETURN(TRUE); } if (non_existant_views.length()) { my_error(ER_BAD_TABLE_ERROR, MYF(0), non_existant_views.c_ptr()); + } + + something_wrong= error || wrong_object_name || non_existant_views.length(); + if (some_views_deleted || !something_wrong) + { + if (!something_wrong) + thd->clear_error(); + Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE); + mysql_bin_log.write(&qinfo); + } + + VOID(pthread_mutex_unlock(&LOCK_open)); + + if (something_wrong) + { DBUG_RETURN(TRUE); } + send_ok(thd); DBUG_RETURN(FALSE); } -- cgit v1.2.1 From 26946f3176b669a9c7e246b2898511701ff871b3 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 3 Dec 2007 16:54:44 +0800 Subject: Bug#30998 Drop View breaks replication if view does not exist When executing drop view statement on the master, the statement is not written into bin-log if any error occurs, this could cause master slave inconsistence if any view has been dropped. If some error occured and no view has been dropped, don't bin-log the statement, if at least one view has been dropped the query is bin-logged possible with an error. sql/sql_view.cc: If at least one view has been dropped the query is bin-logged possible with an error. mysql-test/suite/rpl/r/rpl_drop_view.result: Add test result for bug#30998 mysql-test/suite/rpl/t/rpl_drop_view.test: Add test case for bug#30998 --- sql/sql_view.cc | 29 ++++++++++++++++++----------- 1 file changed, 18 insertions(+), 11 deletions(-) (limited to 'sql') diff --git a/sql/sql_view.cc b/sql/sql_view.cc index f7223cafb5e..362bab2d700 100644 --- a/sql/sql_view.cc +++ b/sql/sql_view.cc @@ -1465,6 +1465,8 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode) char *wrong_object_db= NULL, *wrong_object_name= NULL; bool error= FALSE; enum legacy_db_type not_used; + bool some_views_deleted= FALSE; + bool something_wrong= FALSE; DBUG_ENTER("mysql_drop_view"); VOID(pthread_mutex_lock(&LOCK_open)); @@ -1506,6 +1508,8 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode) if (my_delete(path, MYF(MY_WME))) error= TRUE; + some_views_deleted= TRUE; + /* For a view, there is only one table_share object which should never be used outside of LOCK_open @@ -1523,29 +1527,32 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode) sp_cache_invalidate(); } - if (error) - { - VOID(pthread_mutex_unlock(&LOCK_open)); - DBUG_RETURN(TRUE); - } if (wrong_object_name) { - VOID(pthread_mutex_unlock(&LOCK_open)); my_error(ER_WRONG_OBJECT, MYF(0), wrong_object_db, wrong_object_name, "VIEW"); - DBUG_RETURN(TRUE); } if (non_existant_views.length()) { - VOID(pthread_mutex_unlock(&LOCK_open)); my_error(ER_BAD_TABLE_ERROR, MYF(0), non_existant_views.c_ptr()); - DBUG_RETURN(TRUE); } - write_bin_log(thd, TRUE, thd->query, thd->query_length); + something_wrong= error || wrong_object_name || non_existant_views.length(); + if (some_views_deleted || !something_wrong) + { + /* if something goes wrong, bin-log with possible error code, + otherwise bin-log with error code cleared. + */ + write_bin_log(thd, !something_wrong, thd->query, thd->query_length); + } - send_ok(thd); VOID(pthread_mutex_unlock(&LOCK_open)); + + if (something_wrong) + { + DBUG_RETURN(TRUE); + } + send_ok(thd); DBUG_RETURN(FALSE); } -- cgit v1.2.1 From c4faf61acd405231954943548de200c9dce78101 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 5 Dec 2007 12:26:21 +0400 Subject: sql_string.cc: Fixing a wrong comment. sql/sql_string.cc: Fixing a wrong comment. --- sql/sql_string.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'sql') diff --git a/sql/sql_string.cc b/sql/sql_string.cc index 9d7df73cd7a..278130db7bb 100644 --- a/sql/sql_string.cc +++ b/sql/sql_string.cc @@ -307,8 +307,8 @@ bool String::copy_aligned(const char *str,uint32 arg_length, uint32 offset, return TRUE; /* - Note, this is only safe for little-endian UCS-2. - If we add big-endian UCS-2 sometimes, this code + Note, this is only safe for big-endian UCS-2. + If we add little-endian UCS-2 sometimes, this code will be more complicated. But it's OK for now. */ bzero((char*) Ptr, offset); -- cgit v1.2.1 From 7a5f3f12bc45f7f1db9ba97be0337dfd256b96d3 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 5 Dec 2007 20:00:14 +0100 Subject: BUG#31583 (5.1-telco-6.1 -> 5.1.22. Slave returns Error in unknown event): In the patch for BUG#21842, the code for handling old rows events were refactored. There were a bug in the refactored code (possibly introduced after the patch for BUG#21842) that caused caused the refactored old events to read a columns bitmap after image even though there is no such bitmap for old events. As a result, the reading got out of sync, and started reading invalid data. This patch removes all trace of the after image column bitmap from the refactored old events and removes functions that are no longer needed because they are empty. sql/log_event.cc: Adding debug printouts and adding old rows events names to output so that they are not printed as unknown events. sql/log_event_old.cc: Adding debug printouts to see how the old events are partitioned when being decoded. Removing all traces of the column bitmap for the after image in the old events since there is none. Removing the following functions since they are no longer needed: - Update_rows_log_event_old::init() - Update_rows_log_event_old::~Update_rows_log_event_old() Removing unused local variable. sql/log_event_old.h: Removing all traces of the column bitmap for the after image in the old events since there is none. Removing the following functions since they are no longer needed: - Update_rows_log_event_old::init() - Update_rows_log_event_old::is_valid() - Update_rows_log_event_old::~Update_rows_log_event_old() Removing unused local variable. mysql-test/suite/bugs/r/rpl_bug31583.result: New BitKeeper file ``mysql-test/suite/bugs/r/rpl_bug31583.result'' mysql-test/suite/bugs/t/rpl_bug31583.test: New BitKeeper file ``mysql-test/suite/bugs/t/rpl_bug31583.test'' --- sql/log_event.cc | 5 ++++ sql/log_event_old.cc | 76 +++------------------------------------------------- sql/log_event_old.h | 17 ------------ 3 files changed, 8 insertions(+), 90 deletions(-) (limited to 'sql') diff --git a/sql/log_event.cc b/sql/log_event.cc index d3b0f7ed3b4..c7963fe803a 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -490,6 +490,9 @@ const char* Log_event::get_type_str() case USER_VAR_EVENT: return "User var"; case FORMAT_DESCRIPTION_EVENT: return "Format_desc"; case TABLE_MAP_EVENT: return "Table_map"; + case PRE_GA_WRITE_ROWS_EVENT: return "Write_rows_event_old"; + case PRE_GA_UPDATE_ROWS_EVENT: return "Update_rows_event_old"; + case PRE_GA_DELETE_ROWS_EVENT: return "Delete_rows_event_old"; case WRITE_ROWS_EVENT: return "Write_rows"; case UPDATE_ROWS_EVENT: return "Update_rows"; case DELETE_ROWS_EVENT: return "Delete_rows"; @@ -1015,6 +1018,8 @@ Log_event* Log_event::read_log_event(const char* buf, uint event_len, DBUG_ENTER("Log_event::read_log_event(char*,...)"); DBUG_ASSERT(description_event != 0); DBUG_PRINT("info", ("binlog_version: %d", description_event->binlog_version)); + DBUG_DUMP("data", (unsigned char*) buf, event_len); + /* Check the integrity */ if (event_len < EVENT_LEN_OFFSET || buf[EVENT_TYPE_OFFSET] >= ENUM_END_EVENT || diff --git a/sql/log_event_old.cc b/sql/log_event_old.cc index b16af43f24e..12c3b2a6dc3 100644 --- a/sql/log_event_old.cc +++ b/sql/log_event_old.cc @@ -1317,6 +1317,7 @@ Old_rows_log_event::Old_rows_log_event(const char *buf, uint event_len, post_header_len)); const char *post_start= buf + common_header_len; + DBUG_DUMP("post_header", (uchar*) post_start, post_header_len); post_start+= RW_MAPID_OFFSET; if (post_header_len == 6) { @@ -1358,38 +1359,11 @@ Old_rows_log_event::Old_rows_log_event(const char *buf, uint event_len, DBUG_VOID_RETURN; } - m_cols_ai.bitmap= m_cols.bitmap; /* See explanation in is_valid() */ - - if (event_type == PRE_GA_UPDATE_ROWS_EVENT) - { - DBUG_PRINT("debug", ("Reading from %p", ptr_after_width)); - - /* if bitmap_init fails, caught in is_valid() */ - if (likely(!bitmap_init(&m_cols_ai, - m_width <= sizeof(m_bitbuf_ai)*8 ? m_bitbuf_ai : NULL, - m_width, - false))) - { - DBUG_PRINT("debug", ("Reading from %p", ptr_after_width)); - memcpy(m_cols_ai.bitmap, ptr_after_width, (m_width + 7) / 8); - create_last_word_mask(&m_cols_ai); - ptr_after_width+= (m_width + 7) / 8; - DBUG_DUMP("m_cols_ai", (uchar*) m_cols_ai.bitmap, - no_bytes_in_map(&m_cols_ai)); - } - else - { - // Needed because bitmap_init() does not set it to null on failure - m_cols_ai.bitmap= 0; - DBUG_VOID_RETURN; - } - } - const uchar* const ptr_rows_data= (const uchar*) ptr_after_width; - size_t const data_size= event_len - (ptr_rows_data - (const uchar *) buf); DBUG_PRINT("info",("m_table_id: %lu m_flags: %d m_width: %lu data_size: %lu", m_table_id, m_flags, m_width, (ulong) data_size)); + DBUG_DUMP("rows_data", (uchar*) ptr_rows_data, data_size); m_rows_buf= (uchar*) my_malloc(data_size, MYF(MY_WME)); if (likely((bool)m_rows_buf)) @@ -1419,24 +1393,18 @@ Old_rows_log_event::~Old_rows_log_event() int Old_rows_log_event::get_data_size() { - int const type_code= get_type_code(); - uchar buf[sizeof(m_width)+1]; uchar *end= net_store_length(buf, (m_width + 7) / 8); DBUG_EXECUTE_IF("old_row_based_repl_4_byte_map_id_master", return 6 + no_bytes_in_map(&m_cols) + (end - buf) + - (type_code == PRE_GA_UPDATE_ROWS_EVENT ? no_bytes_in_map(&m_cols_ai) : 0) + (m_rows_cur - m_rows_buf);); int data_size= ROWS_HEADER_LEN; data_size+= no_bytes_in_map(&m_cols); data_size+= end - buf; - if (type_code == PRE_GA_UPDATE_ROWS_EVENT) - data_size+= no_bytes_in_map(&m_cols_ai); - data_size+= (m_rows_cur - m_rows_buf); - return data_size; + return data_size; } @@ -2011,16 +1979,6 @@ bool Old_rows_log_event::write_data_body(IO_CACHE*file) DBUG_DUMP("m_cols", (uchar*) m_cols.bitmap, no_bytes_in_map(&m_cols)); res= res || my_b_safe_write(file, (uchar*) m_cols.bitmap, no_bytes_in_map(&m_cols)); - /* - TODO[refactor write]: Remove the "down cast" here (and elsewhere). - */ - if (get_type_code() == PRE_GA_UPDATE_ROWS_EVENT) - { - DBUG_DUMP("m_cols_ai", (uchar*) m_cols_ai.bitmap, - no_bytes_in_map(&m_cols_ai)); - res= res || my_b_safe_write(file, (uchar*) m_cols_ai.bitmap, - no_bytes_in_map(&m_cols_ai)); - } DBUG_DUMP("rows", m_rows_buf, data_size); res= res || my_b_safe_write(file, m_rows_buf, (size_t) data_size); @@ -2831,38 +2789,10 @@ Update_rows_log_event_old::Update_rows_log_event_old(THD *thd_arg, // This constructor should not be reached. assert(0); - - init(cols); -} - - -void Update_rows_log_event_old::init(MY_BITMAP const *cols) -{ - /* if bitmap_init fails, caught in is_valid() */ - if (likely(!bitmap_init(&m_cols_ai, - m_width <= sizeof(m_bitbuf_ai)*8 ? m_bitbuf_ai : NULL, - m_width, - false))) - { - /* Cols can be zero if this is a dummy binrows event */ - if (likely(cols != NULL)) - { - memcpy(m_cols_ai.bitmap, cols->bitmap, no_bytes_in_map(cols)); - create_last_word_mask(&m_cols_ai); - } - } } #endif /* !defined(MYSQL_CLIENT) */ -Update_rows_log_event_old::~Update_rows_log_event_old() -{ - if (m_cols_ai.bitmap == m_bitbuf_ai) // no my_malloc happened - m_cols_ai.bitmap= 0; // so no my_free in bitmap_free - bitmap_free(&m_cols_ai); // To pair with bitmap_init(). -} - - /* Constructor used by slave to read the event from the binary log. */ diff --git a/sql/log_event_old.h b/sql/log_event_old.h index efb2be29ee4..719802a80fb 100644 --- a/sql/log_event_old.h +++ b/sql/log_event_old.h @@ -175,14 +175,6 @@ protected: 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 */ @@ -442,12 +434,8 @@ public: Update_rows_log_event_old(THD*, TABLE*, ulong table_id, MY_BITMAP const *cols, bool is_transactional); - - void init(MY_BITMAP const *cols); #endif - virtual ~Update_rows_log_event_old(); - #ifdef HAVE_REPLICATION Update_rows_log_event_old(const char *buf, uint event_len, const Format_description_log_event *description_event); @@ -466,11 +454,6 @@ public: } #endif - virtual bool is_valid() const - { - return Old_rows_log_event::is_valid() && m_cols_ai.bitmap; - } - protected: #ifdef MYSQL_CLIENT void print(FILE *file, PRINT_EVENT_INFO *print_event_info); -- cgit v1.2.1 From 96a51b7f39be9bd664a8d242670ad1d6522c2b83 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 12 Dec 2007 12:14:59 +0200 Subject: Bug#31552 Replication breaks when deleting rows from out-of-sync table without PK Bug#31609 Not all RBR slave errors reported as errors bug#32468 delete rows event on a table with foreign key constraint fails The first two bugs comprise idempotency issues. First, there was no error code reported under conditions of the bug description although the slave sql thread halted. Second, executions were different with and without presence of prim key in the table. Third, there was no way to instruct the slave whether to ignore an error and skip to the following event or to halt. Fourth, there are handler errors which might happen due to idempotent applying of binlog but those were not listed among the "idempotent" error list. All the named issues are addressed. Wrt to the 3rd, there is the new global system variable, changeble at run time, which controls the slave sql thread behaviour. The new variable allows further extensions to mimic the sql_mode session/global variable. To address the 4th, the new bug#32468 had to be fixed as it was staying in the way. include/my_bitmap.h: basic operations with bits of an integer type are added. mysql-test/extra/rpl_tests/rpl_foreign_key.test: regression test for bug#32468 mysql-test/extra/rpl_tests/rpl_row_basic.test: changes due to bug#31552/31609 idempotency is not default any longer mysql-test/extra/rpl_tests/rpl_row_tabledefs.test: changes due to bug#31552/31609 idempotency is not default any longer mysql-test/suite/rpl/r/rpl_foreign_key_innodb.result: results changed mysql-test/suite/rpl/r/rpl_idempotency.result: results changed mysql-test/suite/rpl/r/rpl_row_basic_11bugs.result: results changed mysql-test/suite/rpl/r/rpl_row_basic_2myisam.result: results changed mysql-test/suite/rpl/r/rpl_row_basic_3innodb.result: results changed mysql-test/suite/rpl/r/rpl_row_mystery22.result: results changed mysql-test/suite/rpl/r/rpl_row_tabledefs_2myisam.result: results changed mysql-test/suite/rpl/r/rpl_row_tabledefs_3innodb.result: results changed mysql-test/suite/rpl/r/rpl_temporary_errors.result: results changed mysql-test/suite/rpl/t/rpl_idempotency.test: extenstions to the test providing testing of complements to the idempotent error set and checking how slave halts when it faces an error from the list when the mode is STRICT. mysql-test/suite/rpl/t/rpl_row_basic_11bugs.test: changes due to bug#31552/31609 idempotency is not default any longer. mysql-test/suite/rpl/t/rpl_row_mystery22.test: changes due to bug#31552/31609 idempotency is not default any longer mysql-test/suite/rpl/t/rpl_temporary_errors.test: changes due to bug#31552/31609 idempotency is not default any longer mysql-test/suite/rpl_ndb/r/rpl_ndb_dd_advance.result: results changed mysql-test/suite/rpl_ndb/r/rpl_row_basic_7ndb.result: results changed sql/log_event.cc: the fix for bug#32468 delete rows event on a table with foreign key constraint fails ensures the flags are set at proper time so that their values will be caught by innodb. reseting the flags is done along the common error and errorless execution path. The list of idempotent error is extended with foreign keys related items. NDB engine write events are designed with the replace sematics in mind. Therefore the corrsponding ndb handler's flag are (re)set regardless of the slave's execution mode. Rows_log_event::write_row() starts using the bool replace argument as its caller sets it depending on the event's execution mode. sql/log_event.h: adding a new member to hold the slave's mode during execution of the event. sql/mysql_priv.h: changes to link the command line option with the new global sys var. sql/mysqld.cc: introduction of the new command line option. providing its initialization to a default. changes to link the command line option with the new global sys var. sql/rpl_rli.cc: rli post-event-execution cleanup restores the default bits. sql/set_var.cc: The new "standard" sys_var_set class' and the new global system var related declarations and definitions. fix_slave_exec_mode() is used as with the update method of a new class so as at time of the command line arguments parsing. sql/set_var.h: new declarations. The class for the new global sys var is based on yet another new "standard" one. sql/share/errmsg.txt: slave_exec_mode setting error; slave inconsistency error which may be not an error when the intention is "idempotent". I.e consisting of row-based events binlog is being applied for the 2nd (more) time. sql/sql_class.h: The names for the bits of the new sever slave_exec_mode_options. mysql-test/suite/rpl/t/rpl_idempotency-master.opt: innodb is necessary mysql-test/suite/rpl/t/rpl_idempotency-slave.opt: innodb is necessary, as well as the tests start with non-default IDEMPOTENT slave execution mode. --- sql/log_event.cc | 239 +++++++++++++++++++++++++++++++-------------------- sql/log_event.h | 6 ++ sql/mysql_priv.h | 1 + sql/mysqld.cc | 19 +++- sql/rpl_rli.cc | 5 ++ sql/set_var.cc | 99 +++++++++++++++++++++ sql/set_var.h | 40 ++++++++- sql/share/errmsg.txt | 2 + sql/sql_class.h | 3 + 9 files changed, 319 insertions(+), 95 deletions(-) (limited to 'sql') diff --git a/sql/log_event.cc b/sql/log_event.cc index 77cf719fde5..fc8b1904496 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -90,6 +90,28 @@ static const char *HA_ERR(int i) case HA_ERR_LOGGING_IMPOSSIBLE: return "HA_ERR_LOGGING_IMPOSSIBLE"; case HA_ERR_CORRUPT_EVENT: return "HA_ERR_CORRUPT_EVENT"; } + return 0; +} + +/** + macro to call from different branches of Rows_log_event::do_apply_event +*/ +static void inline slave_rows_error_report(enum loglevel level, int ha_error, + Relay_log_info const *rli, THD *thd, + TABLE *table, const char * type, + const char *log_name, ulong pos) +{ + const char *handler_error= HA_ERR(ha_error); + rli->report(level, thd->net.last_errno, + "Could not execute %s event on table %s.%s;" + "%s%s handler error %s; " + "the event's master log %s, end_log_pos %lu", + type, table->s->db.str, + table->s->table_name.str, + thd->net.last_error[0] != 0 ? thd->net.last_error : "", + thd->net.last_error[0] != 0 ? ";" : "", + handler_error == NULL? "" : handler_error, + log_name, pos); } #endif @@ -6060,7 +6082,6 @@ int Rows_log_event::do_apply_event(Relay_log_info const *rli) { DBUG_ENTER("Rows_log_event::do_apply_event(Relay_log_info*)"); int error= 0; - /* If m_table_id == ~0UL, then we have a dummy event that does not contain any data. In that case, we just remove all tables in the @@ -6106,6 +6127,24 @@ int Rows_log_event::do_apply_event(Relay_log_info const *rli) */ lex_start(thd); + /* + There are a few flags that are replicated with each row event. + Make sure to set/clear them before executing the main body of + the event. + */ + if (get_flags(NO_FOREIGN_KEY_CHECKS_F)) + thd->options|= OPTION_NO_FOREIGN_KEY_CHECKS; + else + thd->options&= ~OPTION_NO_FOREIGN_KEY_CHECKS; + + if (get_flags(RELAXED_UNIQUE_CHECKS_F)) + thd->options|= OPTION_RELAXED_UNIQUE_CHECKS; + else + thd->options&= ~OPTION_RELAXED_UNIQUE_CHECKS; + /* A small test to verify that objects have consistent types */ + DBUG_ASSERT(sizeof(thd->options) == sizeof(OPTION_RELAXED_UNIQUE_CHECKS)); + + while ((error= lock_tables(thd, rli->tables_to_lock, rli->tables_to_lock_count, &need_reopen))) { @@ -6240,22 +6279,6 @@ int Rows_log_event::do_apply_event(Relay_log_info const *rli) So we call set_time(), like in SBR. Presently it changes nothing. */ thd->set_time((time_t)when); - /* - There are a few flags that are replicated with each row event. - Make sure to set/clear them before executing the main body of - the event. - */ - if (get_flags(NO_FOREIGN_KEY_CHECKS_F)) - thd->options|= OPTION_NO_FOREIGN_KEY_CHECKS; - else - thd->options&= ~OPTION_NO_FOREIGN_KEY_CHECKS; - - if (get_flags(RELAXED_UNIQUE_CHECKS_F)) - thd->options|= OPTION_RELAXED_UNIQUE_CHECKS; - else - thd->options&= ~OPTION_RELAXED_UNIQUE_CHECKS; - /* A small test to verify that objects have consistent types */ - DBUG_ASSERT(sizeof(thd->options) == sizeof(OPTION_RELAXED_UNIQUE_CHECKS)); /* Now we are in a statement and will stay in a statement until we @@ -6288,8 +6311,9 @@ int Rows_log_event::do_apply_event(Relay_log_info const *rli) if (!get_flags(COMPLETE_ROWS_F)) bitmap_intersect(table->write_set,&m_cols); + this->slave_exec_mode= slave_exec_mode_options; // fix the mode + // Do event specific preparations - error= do_before_row_operations(rli); // row processing loop @@ -6308,22 +6332,41 @@ int Rows_log_event::do_apply_event(Relay_log_info const *rli) { case 0: break; - - /* Some recoverable errors */ + /* + The following list of "idempotent" errors + means that an error from the list might happen + because of idempotent (more than once) + applying of a binlog file. + Notice, that binlog has a ddl operation its + second applying may cause + + case HA_ERR_TABLE_DEF_CHANGED: + case HA_ERR_CANNOT_ADD_FOREIGN: + + which are not included into to the list. + */ case HA_ERR_RECORD_CHANGED: case HA_ERR_RECORD_DELETED: case HA_ERR_KEY_NOT_FOUND: case HA_ERR_END_OF_FILE: - /* Idempotency support: OK if tuple does not exist */ + case HA_ERR_FOUND_DUPP_KEY: + case HA_ERR_FOUND_DUPP_UNIQUE: + case HA_ERR_FOREIGN_DUPLICATE_KEY: + case HA_ERR_NO_REFERENCED_ROW: + case HA_ERR_ROW_IS_REFERENCED: + DBUG_PRINT("info", ("error: %s", HA_ERR(error))); - error= 0; + if (bit_is_set(slave_exec_mode, SLAVE_EXEC_MODE_IDEMPOTENT) == 1) + { + if (global_system_variables.log_warnings) + slave_rows_error_report(WARNING_LEVEL, error, rli, thd, table, + get_type_str(), + RPL_LOG_NAME, (ulong) log_pos); + error= 0; + } break; - + default: - rli->report(ERROR_LEVEL, thd->net.last_errno, - "Error in %s event: row application failed. %s", - get_type_str(), - thd->net.last_error ? thd->net.last_error : ""); thd->query_error= 1; break; } @@ -6367,16 +6410,14 @@ int Rows_log_event::do_apply_event(Relay_log_info const *rli) */ if (rli->tables_to_lock && get_flags(STMT_END_F)) const_cast(rli)->clear_tables_to_lock(); - + if (error) { /* error has occured during the transaction */ - rli->report(ERROR_LEVEL, thd->net.last_errno, - "Error in %s event: error during transaction execution " - "on table %s.%s. %s", - get_type_str(), table->s->db.str, - table->s->table_name.str, - thd->net.last_error ? thd->net.last_error : ""); - + slave_rows_error_report(ERROR_LEVEL, error, rli, thd, table, + get_type_str(), RPL_LOG_NAME, (ulong) log_pos); + } + if (error) + { /* If one day we honour --skip-slave-errors in row-based replication, and the error should be skipped, then we would clear mappings, rollback, @@ -6488,6 +6529,7 @@ Rows_log_event::do_update_pos(Relay_log_info *rli) */ thd->reset_current_stmt_binlog_row_based(); + rli->cleanup_context(thd, 0); if (error == 0) { @@ -7170,43 +7212,50 @@ Write_rows_log_event::do_before_row_operations(const Slave_reporting_capability { int error= 0; - /* - We are using REPLACE semantics and not INSERT IGNORE semantics - when writing rows, that is: new rows replace old rows. We need to - inform the storage engine that it should use this behaviour. + /** + todo: to introduce a property for the event (handler?) which forces + applying the event in the replace (idempotent) fashion. */ + if (bit_is_set(slave_exec_mode, SLAVE_EXEC_MODE_IDEMPOTENT) == 1 || + m_table->s->db_type()->db_type == DB_TYPE_NDBCLUSTER) + { + /* + We are using REPLACE semantics and not INSERT IGNORE semantics + when writing rows, that is: new rows replace old rows. We need to + inform the storage engine that it should use this behaviour. + */ + + /* Tell the storage engine that we are using REPLACE semantics. */ + thd->lex->duplicates= DUP_REPLACE; + + /* + Pretend we're executing a REPLACE command: this is needed for + InnoDB and NDB Cluster since they are not (properly) checking the + lex->duplicates flag. + */ + thd->lex->sql_command= SQLCOM_REPLACE; + /* + Do not raise the error flag in case of hitting to an unique attribute + */ + 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 + */ + 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. + */ + 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. + */ + } - /* Tell the storage engine that we are using REPLACE semantics. */ - thd->lex->duplicates= DUP_REPLACE; - - /* - Pretend we're executing a REPLACE command: this is needed for - InnoDB and NDB Cluster since they are not (properly) checking the - lex->duplicates flag. - */ - thd->lex->sql_command= SQLCOM_REPLACE; - /* - Do not raise the error flag in case of hitting to an unique attribute - */ - 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 - */ - 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. - */ - 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. - */ m_table->file->ha_start_bulk_insert(0); /* We need TIMESTAMP_NO_AUTO_SET otherwise ha_write_row() will not use fill @@ -7228,18 +7277,23 @@ Write_rows_log_event::do_before_row_operations(const Slave_reporting_capability } int -Write_rows_log_event::do_after_row_operations(const Slave_reporting_capability *const, +Write_rows_log_event::do_after_row_operations(const Slave_reporting_capability *const, int error) { int local_error= 0; - 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); - fires bug#27077 - todo: explain or fix - */ + if (bit_is_set(slave_exec_mode, SLAVE_EXEC_MODE_IDEMPOTENT) == 1 || + m_table->s->db_type()->db_type == DB_TYPE_NDBCLUSTER) + { + m_table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY); + m_table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE); + /* + resetting the extra with + table->file->extra(HA_EXTRA_NO_IGNORE_NO_KEY); + fires bug#27077 + explanation: file->reset() performs this duty + ultimately. Still todo: fix + */ + } if ((local_error= m_table->file->ha_end_bulk_insert())) { m_table->file->print_error(local_error, MYF(0)); @@ -7358,23 +7412,22 @@ Rows_log_event::write_row(const Relay_log_info *const rli, while ((error= table->file->ha_write_row(table->record[0]))) { - if (error == HA_ERR_LOCK_DEADLOCK || error == HA_ERR_LOCK_WAIT_TIMEOUT) + if (error == HA_ERR_LOCK_DEADLOCK || + error == HA_ERR_LOCK_WAIT_TIMEOUT || + (keynum= table->file->get_dup_key(error)) < 0 || + !overwrite) { - table->file->print_error(error, MYF(0)); /* to check at exec_relay_log_event */ - DBUG_RETURN(error); - } - if ((keynum= table->file->get_dup_key(error)) < 0) - { - DBUG_PRINT("info",("Can't locate duplicate key (get_dup_key returns %d)",keynum)); - table->file->print_error(error, MYF(0)); + DBUG_PRINT("info",("get_dup_key returns %d)", keynum)); /* - We failed to retrieve the duplicate key + Deadlock, waiting for lock or just an error from the handler + such as HA_ERR_FOUND_DUPP_KEY when overwrite is false. + Retrieval of the duplicate key number may fail - either because the error was not "duplicate key" error - or because the information which key is not available */ + table->file->print_error(error, MYF(0)); DBUG_RETURN(error); } - /* We need to retrieve the old row into record[1] to be able to either update or delete the offending record. We either: @@ -7512,11 +7565,13 @@ int Write_rows_log_event::do_exec_row(const Relay_log_info *const rli) { DBUG_ASSERT(m_table != NULL); - int error= write_row(rli, TRUE /* overwrite */); - + int error= + write_row(rli, /* if 1 then overwrite */ + bit_is_set(slave_exec_mode, SLAVE_EXEC_MODE_IDEMPOTENT) == 1); + if (error && !thd->net.last_errno) thd->net.last_errno= error; - + return error; } diff --git a/sql/log_event.h b/sql/log_event.h index 4bd496af2a4..0275b02dd49 100644 --- a/sql/log_event.h +++ b/sql/log_event.h @@ -809,6 +809,12 @@ public: bool cache_stmt; + /** + A storage to cache the global system variable's value. + Handling of a separate event will be governed its member. + */ + ulong slave_exec_mode; + #ifndef MYSQL_CLIENT THD* thd; diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h index 3b88fe0fca8..712352a8c0b 100644 --- a/sql/mysql_priv.h +++ b/sql/mysql_priv.h @@ -1813,6 +1813,7 @@ extern uint volatile thread_count, thread_running, global_read_lock; extern my_bool opt_sql_bin_update, opt_safe_user_create, opt_no_mix_types; extern my_bool opt_safe_show_db, opt_local_infile, opt_myisam_use_mmap; extern my_bool opt_slave_compressed_protocol, use_temp_pool; +extern ulong slave_exec_mode_options; extern my_bool opt_readonly, lower_case_file_system; extern my_bool opt_enable_named_pipe, opt_sync_frm, opt_allow_suspicious_udfs; extern my_bool opt_secure_auth; diff --git a/sql/mysqld.cc b/sql/mysqld.cc index 9d74280b11b..eb7ce1de7b6 100644 --- a/sql/mysqld.cc +++ b/sql/mysqld.cc @@ -445,6 +445,8 @@ ulong thread_stack, what_to_log; ulong query_buff_size, slow_launch_time, slave_open_temp_tables; ulong open_files_limit, max_binlog_size, max_relay_log_size; ulong slave_net_timeout, slave_trans_retries; +ulong slave_exec_mode_options; +const char *slave_exec_mode_str= "STRICT"; ulong thread_cache_size=0, thread_pool_size= 0; ulong binlog_cache_size=0, max_binlog_cache_size=0; ulong query_cache_size=0; @@ -5101,7 +5103,8 @@ enum options_mysqld OPT_SECURE_FILE_PRIV, OPT_MIN_EXAMINED_ROW_LIMIT, OPT_LOG_SLOW_SLAVE_STATEMENTS, - OPT_OLD_MODE + OPT_OLD_MODE, + OPT_SLAVE_EXEC_MODE }; @@ -5799,8 +5802,11 @@ replicating a LOAD DATA INFILE command.", (uchar**) &slave_load_tmpdir, (uchar**) &slave_load_tmpdir, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0}, {"slave-skip-errors", OPT_SLAVE_SKIP_ERRORS, - "Tells the slave thread to continue replication when a query returns an error from the provided list.", + "Tells the slave thread to continue replication when a query event returns an error from the provided list.", 0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0}, + {"slave-exec-mode", OPT_SLAVE_EXEC_MODE, + "Modes for how replication events should be executed. Legal values are STRICT (default) and IDEMPOTENT. In IDEMPOTENT mode, replication will not stop for operations that are idempotent. In STRICT mode, replication will stop on any unexpected difference between the master and the slave.", + (uchar**) &slave_exec_mode_str, (uchar**) &slave_exec_mode_str, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0}, #endif {"slow-query-log", OPT_SLOW_LOG, "Enable|disable slow query log", (uchar**) &opt_slow_log, @@ -7109,6 +7115,9 @@ static void mysql_init_variables(void) /* Things with default values that are not zero */ delay_key_write_options= (uint) DELAY_KEY_WRITE_ON; + slave_exec_mode_options= 0; + slave_exec_mode_options= (uint) + find_bit_type_or_exit(slave_exec_mode_str, &slave_exec_mode_typelib, NULL); opt_specialflag= SPECIAL_ENGLISH; unix_sock= ip_sock= INVALID_SOCKET; mysql_home_ptr= mysql_home; @@ -7318,6 +7327,10 @@ mysqld_get_one_option(int optid, case OPT_SLAVE_SKIP_ERRORS: init_slave_skip_errors(argument); break; + case OPT_SLAVE_EXEC_MODE: + slave_exec_mode_options= (uint) + find_bit_type_or_exit(argument, &slave_exec_mode_typelib, ""); + break; #endif case OPT_SAFEMALLOC_MEM_LIMIT: #if !defined(DBUG_OFF) && defined(SAFEMALLOC) @@ -7863,6 +7876,8 @@ static void get_options(int *argc,char **argv) } /* Set global MyISAM variables from delay_key_write_options */ fix_delay_key_write((THD*) 0, OPT_GLOBAL); + /* Set global slave_exec_mode from its option */ + fix_slave_exec_mode(OPT_GLOBAL); #ifndef EMBEDDED_LIBRARY if (mysqld_chroot) diff --git a/sql/rpl_rli.cc b/sql/rpl_rli.cc index 15d7d97affd..c28d1ba97f7 100644 --- a/sql/rpl_rli.cc +++ b/sql/rpl_rli.cc @@ -1160,6 +1160,11 @@ void Relay_log_info::cleanup_context(THD *thd, bool error) close_thread_tables(thd); clear_tables_to_lock(); clear_flag(IN_STMT); + /* + Cleanup for the flags that have been set at do_apply_event. + */ + thd->options&= ~OPTION_NO_FOREIGN_KEY_CHECKS; + thd->options&= ~OPTION_RELAXED_UNIQUE_CHECKS; last_event_start_time= 0; DBUG_VOID_RETURN; } diff --git a/sql/set_var.cc b/sql/set_var.cc index 138c71fa559..460f877c0ab 100644 --- a/sql/set_var.cc +++ b/sql/set_var.cc @@ -88,6 +88,16 @@ TYPELIB delay_key_write_typelib= delay_key_write_type_names, NULL }; +const char *slave_exec_mode_names[]= +{ "STRICT", "IDEMPOTENT", NullS }; +static const unsigned int slave_exec_mode_names_len[]= +{ sizeof("STRICT") - 1, sizeof("IDEMPOTENT") - 1, 0 }; +TYPELIB slave_exec_mode_typelib= +{ + array_elements(slave_exec_mode_names)-1, "", + slave_exec_mode_names, (unsigned int *) slave_exec_mode_names_len +}; + static int sys_check_ftb_syntax(THD *thd, set_var *var); static bool sys_update_ftb_syntax(THD *thd, set_var * var); static void sys_default_ftb_syntax(THD *thd, enum_var_type type); @@ -408,6 +418,11 @@ static sys_var_const_str_ptr sys_secure_file_priv(&vars, "secure_file_priv", static sys_var_long_ptr sys_server_id(&vars, "server_id", &server_id, fix_server_id); static sys_var_bool_ptr sys_slave_compressed_protocol(&vars, "slave_compressed_protocol", &opt_slave_compressed_protocol); +static sys_var_set_slave_mode slave_exec_mode(&vars, + "slave_exec_mode", + &slave_exec_mode_options, + &slave_exec_mode_typelib, + 0); static sys_var_long_ptr sys_slow_launch_time(&vars, "slow_launch_time", &slow_launch_time); static sys_var_thd_ulong sys_sort_buffer(&vars, "sort_buffer_size", @@ -981,6 +996,79 @@ extern void fix_delay_key_write(THD *thd, enum_var_type type) } } +bool sys_var_set::update(THD *thd, set_var *var) +{ + *value= var->save_result.ulong_value; + return 0; +}; + +uchar *sys_var_set::value_ptr(THD *thd, enum_var_type type, + LEX_STRING *base) +{ + char buff[256]; + String tmp(buff, sizeof(buff), &my_charset_latin1); + ulong length; + ulong val= *value; + + tmp.length(0); + for (uint i= 0; val; val>>= 1, i++) + { + if (val & 1) + { + tmp.append(enum_names->type_names[i], + enum_names->type_lengths[i]); + tmp.append(','); + } + } + + if ((length= tmp.length())) + length--; + return (uchar*) thd->strmake(tmp.ptr(), length); +} + +void sys_var_set_slave_mode::set_default(THD *thd, enum_var_type type) +{ + slave_exec_mode_options= 0; + bit_do_set(slave_exec_mode_options, SLAVE_EXEC_MODE_STRICT); +} + +bool sys_var_set_slave_mode::check(THD *thd, set_var *var) +{ + bool rc= sys_var_set::check(thd, var); + if (!rc && + bit_is_set(var->save_result.ulong_value, SLAVE_EXEC_MODE_STRICT) == 1 && + bit_is_set(var->save_result.ulong_value, SLAVE_EXEC_MODE_IDEMPOTENT) == 1) + { + rc= true; + my_error(ER_SLAVE_AMBIGOUS_EXEC_MODE, MYF(0), ""); + } + return rc; +} + +bool sys_var_set_slave_mode::update(THD *thd, set_var *var) +{ + bool rc; + pthread_mutex_lock(&LOCK_global_system_variables); + rc= sys_var_set::update(thd, var); + pthread_mutex_unlock(&LOCK_global_system_variables); + return rc; +} + +void fix_slave_exec_mode(enum_var_type type) +{ + DBUG_ENTER("fix_slave_exec_mode"); + compile_time_assert(sizeof(slave_exec_mode_options) * CHAR_BIT + > SLAVE_EXEC_MODE_LAST_BIT - 1); + if (bit_is_set(slave_exec_mode_options, SLAVE_EXEC_MODE_STRICT) == 1 && + bit_is_set(slave_exec_mode_options, SLAVE_EXEC_MODE_IDEMPOTENT) == 1) + { + sql_print_error("Ambiguous slave modes combination." + " STRICT will be used"); + bit_do_clear(slave_exec_mode_options, SLAVE_EXEC_MODE_IDEMPOTENT); + } + if (bit_is_set(slave_exec_mode_options, SLAVE_EXEC_MODE_IDEMPOTENT) == 0) + bit_do_set(slave_exec_mode_options, SLAVE_EXEC_MODE_STRICT); +} bool sys_var_thd_binlog_format::is_readonly() const { @@ -3165,7 +3253,18 @@ int set_var::light_check(THD *thd) return 0; } +/** + Update variable + @param thd thread handler + @returns 0|1 ok or ERROR + + @note ERROR can be only due to abnormal operations involving + the server's execution evironment such as + out of memory, hard disk failure or the computer blows up. + Consider set_var::check() method if there is a need to return + an error due to logics. +*/ int set_var::update(THD *thd) { if (!value) diff --git a/sql/set_var.h b/sql/set_var.h index eb2c893c89e..6f44f7889d2 100644 --- a/sql/set_var.h +++ b/sql/set_var.h @@ -30,7 +30,8 @@ class sys_var_pluginvar; /* opaque */ typedef struct system_variables SV; typedef struct my_locale_st MY_LOCALE; -extern TYPELIB bool_typelib, delay_key_write_typelib, sql_mode_typelib; +extern TYPELIB bool_typelib, delay_key_write_typelib, sql_mode_typelib, + slave_exec_mode_typelib; typedef int (*sys_check_func)(THD *, set_var *); typedef bool (*sys_update_func)(THD *, set_var *); @@ -771,6 +772,42 @@ public: }; +class sys_var_set :public sys_var +{ +protected: + ulong *value; + TYPELIB *enum_names; +public: + sys_var_set(sys_var_chain *chain, const char *name_arg, ulong *value_arg, + TYPELIB *typelib, sys_after_update_func func) + :sys_var(name_arg, func), value(value_arg), enum_names(typelib) + { chain_sys_var(chain); } + virtual bool check(THD *thd, set_var *var) + { + return check_set(thd, var, enum_names); + } + virtual void set_default(THD *thd, enum_var_type type) + { + *value= 0; + } + bool update(THD *thd, set_var *var); + uchar *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base); + bool check_update_type(Item_result type) { return 0; } + SHOW_TYPE show_type() { return SHOW_CHAR; } +}; + +class sys_var_set_slave_mode :public sys_var_set +{ +public: + sys_var_set_slave_mode(sys_var_chain *chain, const char *name_arg, + ulong *value_arg, + TYPELIB *typelib, sys_after_update_func func) : + sys_var_set(chain, name_arg, value_arg, typelib, func) {} + void set_default(THD *thd, enum_var_type type); + bool check(THD *thd, set_var *var); + bool update(THD *thd, set_var *var); +}; + class sys_var_log_output :public sys_var { ulong *value; @@ -1189,6 +1226,7 @@ sys_var *find_sys_var(THD *thd, const char *str, uint length=0); int sql_set_variables(THD *thd, List *var_list); bool not_all_support_one_shot(List *var_list); void fix_delay_key_write(THD *thd, enum_var_type type); +void fix_slave_exec_mode(enum_var_type type); ulong fix_sql_mode(ulong sql_mode); extern sys_var_const_str sys_charset_system; extern sys_var_str sys_init_connect; diff --git a/sql/share/errmsg.txt b/sql/share/errmsg.txt index 8fad09eb221..ee68096a21d 100644 --- a/sql/share/errmsg.txt +++ b/sql/share/errmsg.txt @@ -6112,3 +6112,5 @@ ER_TRG_CANT_OPEN_TABLE ER_CANT_CREATE_SROUTINE eng "Cannot create stored routine `%-.64s`. Check warnings" +ER_SLAVE_AMBIGOUS_EXEC_MODE + eng "Ambiguous slave modes combination. %s" diff --git a/sql/sql_class.h b/sql/sql_class.h index 0dcab6eff92..a3fe30d85cd 100644 --- a/sql/sql_class.h +++ b/sql/sql_class.h @@ -38,6 +38,9 @@ enum enum_ha_read_modes { RFIRST, RNEXT, RPREV, RLAST, RKEY, RNEXT_SAME }; enum enum_duplicates { DUP_ERROR, DUP_REPLACE, DUP_UPDATE }; enum enum_delay_key_write { DELAY_KEY_WRITE_NONE, DELAY_KEY_WRITE_ON, DELAY_KEY_WRITE_ALL }; +enum enum_slave_exec_mode { SLAVE_EXEC_MODE_STRICT, + SLAVE_EXEC_MODE_IDEMPOTENT, + SLAVE_EXEC_MODE_LAST_BIT}; enum enum_mark_columns { MARK_COLUMNS_NONE, MARK_COLUMNS_READ, MARK_COLUMNS_WRITE}; -- cgit v1.2.1 From 32c5d070dd49943f6f2510846ba2c8a6a6f5510d Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 12 Dec 2007 20:12:29 +0100 Subject: bug#31552 manual merge and post-make-test-run changes. mysql-test/extra/rpl_tests/rpl_row_basic.test: changes due to the strict mode gets default. This hunk is being added after merging with changes from another bug fixes. mysql-test/suite/rpl/r/rpl_ignore_table.result: results changed mysql-test/suite/rpl/r/rpl_row_basic_2myisam.result: results changed mysql-test/suite/rpl/r/rpl_row_basic_3innodb.result: results changed mysql-test/suite/rpl/t/rpl_ignore_table.test: two queries on mysql db tables are replicated according to binlog_format, ie in row-based when that is requested. Due to cancelling the idempotent default row based events that previously exectuted successfully now stop the slave sql thread. We have to explicitly request the idempotent slave execution mode. mysql-test/suite/rpl_ndb/r/rpl_ndb_dd_advance.result: results changed. They are being committed only now since there was another bug which fixes my working clone did not have. mysql-test/suite/rpl_ndb/r/rpl_row_basic_7ndb.result: results changed sql/log_event.cc: typo in manual merge earlier --- sql/log_event.cc | 1 - 1 file changed, 1 deletion(-) (limited to 'sql') diff --git a/sql/log_event.cc b/sql/log_event.cc index 28f9afec9a0..2490e54282f 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -122,7 +122,6 @@ static void inline slave_rows_error_report(enum loglevel level, int ha_error, thd->net.last_error[0] != 0 ? ";" : "", handler_error == NULL? "" : handler_error, log_name, pos); ->>>>>>> } #endif -- cgit v1.2.1 From d0b9496f8cea2e57c2c7cc4257d0147a36296a7c Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 13 Dec 2007 10:40:39 +0800 Subject: fix manual merge --- sql/sql_view.cc | 2 -- 1 file changed, 2 deletions(-) (limited to 'sql') diff --git a/sql/sql_view.cc b/sql/sql_view.cc index 41c0aff0cd1..362bab2d700 100644 --- a/sql/sql_view.cc +++ b/sql/sql_view.cc @@ -1540,8 +1540,6 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode) something_wrong= error || wrong_object_name || non_existant_views.length(); if (some_views_deleted || !something_wrong) { - DBUG_RETURN(TRUE); - } /* if something goes wrong, bin-log with possible error code, otherwise bin-log with error code cleared. */ -- cgit v1.2.1 From 3473d97857d4b48be9c1d1478040ef67f09ee3be Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 13 Dec 2007 09:32:23 +0100 Subject: bug#31552 fixing a compilation issue in the debugless build. sql/log_event.cc: relaxing compilation condition as HA_ERR is started to be used for error reporting. --- sql/log_event.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sql') diff --git a/sql/log_event.cc b/sql/log_event.cc index 2490e54282f..db0a5c2b53a 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -46,7 +46,7 @@ #define FMT_G_BUFSIZE(PREC) (3 + (PREC) + 5 + 1) -#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) && !defined(DBUG_OFF) && !defined(_lint) +#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) static const char *HA_ERR(int i) { switch (i) { -- cgit v1.2.1 From 44efa9c18b949fa7078e44aef8aba75a4e8bb4db Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 14 Dec 2007 14:40:45 +0100 Subject: BUG#26395: if crash during autocommit update to transactional table on master, slave fails Now, every transaction (including autocommit transactions) starts with a BEGIN and ends with a COMMIT/ROLLBACK in the binlog. Added a test case, and updated lots of test case result files. mysql-test/r/multi_update.result: Updated result file mysql-test/r/sp_trans_log.result: Updated result file mysql-test/suite/binlog/r/binlog_innodb.result: Updated result file mysql-test/suite/binlog/r/binlog_multi_engine.result: Updated result file mysql-test/suite/binlog/r/binlog_stm_blackhole.result: Updated result file mysql-test/suite/binlog/r/binlog_stm_mix_innodb_myisam.result: Updated result file mysql-test/suite/ndb/r/ndb_binlog_format.result: Updated result file mysql-test/suite/rpl/r/rpl_innodb_mixed_dml.result: Updated result file mysql-test/suite/rpl/r/rpl_row_charset_innodb.result: Updated result file mysql-test/suite/rpl/r/rpl_row_create_table.result: Updated result file mysql-test/suite/rpl/r/rpl_row_log_innodb.result: Updated result file mysql-test/suite/rpl/r/rpl_switch_stm_row_mixed.result: Updated result file mysql-test/suite/rpl/r/rpl_truncate_3innodb.result: Updated result file mysql-test/suite/rpl/t/rpl_row_create_table.test: Updated result file mysql-test/suite/rpl_ndb/r/rpl_ndb_stm_innodb.result: Updated result file sql/log.cc: - Always write BEGIN and COMMIT around statements, even in autocommit mode. - Added comments for binlog_commit and binlog_rollback. sql/log_event.cc: Added debug trigger to avoid writing xid events to the binlog. mysql-test/suite/rpl_ndb/r/rpl_ndb_transaction.result: Results for new test case mysql-test/suite/rpl_ndb/t/rpl_ndb_transaction-master.opt: Options for new test case mysql-test/suite/rpl_ndb/t/rpl_ndb_transaction-slave.opt: Options for new test case mysql-test/suite/rpl_ndb/t/rpl_ndb_transaction.test: Added new test case. --- sql/log.cc | 110 ++++++++++++++++++++++++++++++++++++++++--------------- sql/log_event.cc | 1 + 2 files changed, 82 insertions(+), 29 deletions(-) (limited to 'sql') diff --git a/sql/log.cc b/sql/log.cc index 9fdede9ef2c..b6916c855ab 100644 --- a/sql/log.cc +++ b/sql/log.cc @@ -1402,6 +1402,21 @@ static int binlog_prepare(handlerton *hton, THD *thd, bool all) return 0; } +/** + This function is called once after each statement. + + It has the responsibility to flush the transaction cache to the + binlog file on commits. + + @param hton The binlog handlerton. + @param thd The client thread that executes the transaction. + @param all true if this is the last statement before a COMMIT + statement; false if either this is a statement in a + transaction but not the last, or if this is a statement + not inside a BEGIN block and autocommit is on. + + @see handlerton::commit +*/ static int binlog_commit(handlerton *hton, THD *thd, bool all) { DBUG_ENTER("binlog_commit"); @@ -1414,7 +1429,15 @@ static int binlog_commit(handlerton *hton, THD *thd, bool all) trx_data->reset(); DBUG_RETURN(0); } - if (all) + /* + Write commit event if at least one of the following holds: + - the user sends an explicit COMMIT; or + - the autocommit flag is on, and we are not inside a BEGIN. + However, if the user has not sent an explicit COMMIT, and we are + either inside a BEGIN or run with autocommit off, then this is not + the end of a transaction and we should not write a commit event. + */ + if (all || !(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) { Query_log_event qev(thd, STRING_WITH_LEN("COMMIT"), TRUE, FALSE); qev.error_code= 0; // see comment in MYSQL_LOG::write(THD, IO_CACHE) @@ -1428,6 +1451,23 @@ static int binlog_commit(handlerton *hton, THD *thd, bool all) } } +/** + This function is called when a transaction involving a transactional + table is rolled back. + + It has the responsibility to flush the transaction cache to the + binlog file. However, if the transaction does not involve + non-transactional tables, nothing needs to be logged. + + @param hton The binlog handlerton. + @param thd The client thread that executes the transaction. + @param all true if this is the last statement before a COMMIT + statement; false if either this is a statement in a + transaction but not the last, or if this is a statement + not inside a BEGIN block and autocommit is on. + + @see handlerton::rollback +*/ static int binlog_rollback(handlerton *hton, THD *thd, bool all) { DBUG_ENTER("binlog_rollback"); @@ -3967,9 +4007,11 @@ int MYSQL_BIN_LOG::write_cache(IO_CACHE *cache, bool lock_log, bool sync_log) IMPLEMENTATION - To support transaction over replication, we wrap the transaction with BEGIN/COMMIT or BEGIN/ROLLBACK in the binary log. - We want to write a BEGIN/ROLLBACK block when a non-transactional table - was updated in a transaction which was rolled back. This is to ensure - that the same updates are run on the slave. + If a transaction that only involves transactional tables is + rolled back, we do not binlog it. However, we write a + BEGIN/ROLLBACK block when a non-transactional table was updated + in a transaction which was rolled back. This is to ensure that + the same updates are run on the slave. */ bool MYSQL_BIN_LOG::write(THD *thd, IO_CACHE *cache, Log_event *commit_event) @@ -3990,32 +4032,42 @@ bool MYSQL_BIN_LOG::write(THD *thd, IO_CACHE *cache, Log_event *commit_event) if (my_b_tell(cache) > 0) { /* - Log "BEGIN" at the beginning of the transaction. - which may contain more than 1 SQL statement. + Log "BEGIN" at the beginning of every transaction. Here, a + transaction is either a BEGIN..COMMIT block or a single + statement in autocommit mode. */ - if (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) - { - Query_log_event qinfo(thd, STRING_WITH_LEN("BEGIN"), TRUE, FALSE); - /* - Imagine this is rollback due to net timeout, after all statements of - the transaction succeeded. Then we want a zero-error code in BEGIN. - In other words, if there was a really serious error code it's already - in the statement's events, there is no need to put it also in this - internally generated event, and as this event is generated late it - would lead to false alarms. - This is safer than thd->clear_error() against kills at shutdown. - */ - qinfo.error_code= 0; - /* - Now this Query_log_event has artificial log_pos 0. It must be adjusted - to reflect the real position in the log. Not doing it would confuse the - slave: it would prevent this one from knowing where he is in the - master's binlog, which would result in wrong positions being shown to - the user, MASTER_POS_WAIT undue waiting etc. - */ - if (qinfo.write(&log_file)) - goto err; - } + Query_log_event qinfo(thd, STRING_WITH_LEN("BEGIN"), TRUE, FALSE); + /* + Imagine this is rollback due to net timeout, after all + statements of the transaction succeeded. Then we want a + zero-error code in BEGIN. In other words, if there was a + really serious error code it's already in the statement's + events, there is no need to put it also in this internally + generated event, and as this event is generated late it would + lead to false alarms. + + This is safer than thd->clear_error() against kills at shutdown. + */ + qinfo.error_code= 0; + /* + Now this Query_log_event has artificial log_pos 0. It must be + adjusted to reflect the real position in the log. Not doing it + would confuse the slave: it would prevent this one from + knowing where he is in the master's binlog, which would result + in wrong positions being shown to the user, MASTER_POS_WAIT + undue waiting etc. + */ + if (qinfo.write(&log_file)) + goto err; + + DBUG_EXECUTE_IF("crash_before_writing_xid", + { + if ((write_error= write_cache(cache, false, true))) + DBUG_PRINT("info", ("error writing binlog cache: %d", + write_error)); + DBUG_PRINT("info", ("crashing before writing xid")); + abort(); + }); if ((write_error= write_cache(cache, false, false))) goto err; diff --git a/sql/log_event.cc b/sql/log_event.cc index f328f266c05..cdfd58535fb 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -4292,6 +4292,7 @@ Xid_log_event(const char* buf, #ifndef MYSQL_CLIENT bool Xid_log_event::write(IO_CACHE* file) { + DBUG_EXECUTE_IF("do_not_write_xid", return 0;); return write_header(file, sizeof(xid)) || my_b_safe_write(file, (uchar*) &xid, sizeof(xid)); } -- cgit v1.2.1 From 65155892f0e1fb8bb6f2e4f95ff353b9a8b94b46 Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 14 Dec 2007 20:11:49 +0400 Subject: NDB didn't like utf-8 in the last change for some reasons Changing charset to latin1. --- sql/ha_ndbcluster_binlog.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'sql') diff --git a/sql/ha_ndbcluster_binlog.cc b/sql/ha_ndbcluster_binlog.cc index 7606c4911d1..33d3e5b2c70 100644 --- a/sql/ha_ndbcluster_binlog.cc +++ b/sql/ha_ndbcluster_binlog.cc @@ -775,7 +775,7 @@ static int ndbcluster_create_ndb_apply_status_table(THD *thd) " log_name VARCHAR(255) BINARY NOT NULL, " " start_pos BIGINT UNSIGNED NOT NULL, " " end_pos BIGINT UNSIGNED NOT NULL, " - " PRIMARY KEY USING HASH (server_id) ) ENGINE=NDB CHARACTER SET utf8"); + " PRIMARY KEY USING HASH (server_id) ) ENGINE=NDB CHARACTER SET latin1"); const int no_print_error[4]= {ER_TABLE_EXISTS_ERROR, 701, @@ -835,7 +835,7 @@ static int ndbcluster_create_schema_table(THD *thd) " id INT UNSIGNED NOT NULL," " version INT UNSIGNED NOT NULL," " type INT UNSIGNED NOT NULL," - " PRIMARY KEY USING HASH (db,name) ) ENGINE=NDB CHARACTER SET utf8"); + " PRIMARY KEY USING HASH (db,name) ) ENGINE=NDB CHARACTER SET latin1"); const int no_print_error[4]= {ER_TABLE_EXISTS_ERROR, 701, -- cgit v1.2.1 From 8d37a30eac38b4fffea3ab9fbea4824c3bb4f522 Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 14 Dec 2007 19:02:02 +0100 Subject: BUG#32407: Impossible to do point-in-time recovery from older binlog Problem: it is unsafe to read base64-printed events without first reading the Format_description_log_event (FD). Currently, mysqlbinlog cannot print the FD. As a side effect, another bug has also been fixed: When mysqlbinlog --start-position=X was specified, no ROLLBACK was printed. I changed this, so that ROLLBACK is always printed. This patch does several things: - Format_description_log_event (FD) now print themselves in base64 format. - mysqlbinlog is now able to print FD events. It has three modes: --base64-output=auto Print row events in base64 output, and print FD event. The FD event is printed even if it is outside the range specified with --start-position, because it would not be safe to read row events otherwise. This is the default. --base64-output=always Like --base64-output=auto, but also print base64 output for query events. This is like the old --base64-output flag, which is also a shorthand for --base64-output=always --base64-output=never Never print base64 output, generate error if row events occur in binlog. This is useful to suppress the FD event in binlogs known not to contain row events (e.g., because BINLOG statement is unsafe, requires root privileges, is not SQL, etc) - the BINLOG statement now handles FD events correctly, by setting the thread's rli's relay log's description_event_for_exec to the loaded event. In fact, executing a BINLOG statement is almost the same as reading an event from a relay log. Before my patch, the code for this was separated (exec_relay_log_event in slave.cc executes events from the relay log, mysql_client_binlog_statement in sql_binlog.cc executes BINLOG statements). I needed to augment mysql_client_binlog_statement to do parts of what exec_relay_log_event does. Hence, I did a small refactoring and moved parts of exec_relay_log_event to a new function, which I named apply_event_and_update_pos. apply_event_and_update_pos is called both from exec_relay_log_event and from mysql_client_binlog_statement. - When a non-FD event is executed in a BINLOG statement, without previously executing a FD event in a BINLOG statement, it generates an error, because that's unsafe. I took a new error code for that: ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENTS. In order to get a decent error message containing the name of the event, I added the class method char* Log_event::get_type_str(Log_event_type type), which returns a string name for the given Log_event_type. This is just like the existing char* Log_event::get_type_str(), except it is a class method that takes the log event type as parameter. I also added PRE_GA_*_ROWS_LOG_EVENT to Log_event::get_type_str(), so that names of old rows event are properly printed. - When reading an event, I added a check that the event type is known by the current Format_description_log_event. Without this, it may crash on bad input (and I was struck by this several times). - I patched the following test cases, which all contain BINLOG statements for row events which must be preceded by BINLOG statements for FD events: - rpl_bug31076 While I was here, I fixed some small things in log_event.cc: - replaced hard-coded 4 by EVENT_TYPE_OFFSET in 3 places - replaced return by DBUG_VOID_RETURN in one place - The name of the logfile can be '-' to indicate stdin. Before my patch, the code just checked if the first character is '-'; now it does a full strcmp(). Probably, all arguments that begin with a - are already handled somewhere else as flags, but I still think it is better that the code reflects what it is supposed to do, with as little dependencies as possible on other parts of the code. If we one day implement that all command line arguments after -- are files (as most unix tools do), then we need this. I also fixed the following in slave.cc: - next_event() was declared twice, and queue_event was not static but should be static (not used outside the file). client/client_priv.h: Declared the new option for base64 output. client/mysqlbinlog.cc: - Change from using the two-state command line option "default/--base64-output" to the three-state "--base64-output=[never|auto|always]" - Print the FD event even if it is outside the --start-position range. - Stop if a row event is about to be printed without a preceding FD event. - Minor fixes: * changed 4 to EVENT_TYPE_OFFSET in some places * Added comments * before, "mysqlbinlog -xyz" read from stdin; now it does not (only "mysqlbinlog -" reads stdin). mysql-test/r/mysqlbinlog2.result: Updated result file: mysqlbinlog now prints ROLLBACK always. mysql-test/suite/binlog/t/disabled.def: The test must be disabled since it reveals another bug: see BUG#33247. mysql-test/suite/rpl/r/rpl_bug31076.result: Updated result file mysql-test/suite/rpl/r/rpl_row_mysqlbinlog.result: Updated result file mysql-test/suite/rpl/t/rpl_bug31076.test: Had to add explicit Format_description_log_event before other BINLOG statements mysql-test/t/mysqlbinlog2.test: we must suppress base64 output in result file because it contains a timestamp sql/log_event.cc: - Made FD events able to print themselves - Added check that the current FD event knows about the event type, when an event is about to be read. (Hint to reviewers: I had to re-indent a big block because of this; use diff -b) * To get a decent error message, I also added a class method const char* Log_event::get_type_str(Log_event_type) which converts number to event type string without having a Log_event object. * Made Log_event::get_type_str aware of PRE_GA_*_ROWS_LOG_EVENT. - Minor fixes: * Changed return to DBUG_VOID_RETURN sql/log_event.h: - Declared enum to describe the three base64_output modes - Use the enum instead of a flag - Declare the new class method get_type_str (see log_event.cc) sql/share/errmsg.txt: Added error msg. sql/slave.cc: - Factored out part of exec_relay_log_event to the new function apply_event_and_update_pos, because that code is needed when executing BINLOG statements. (this is be functionally equivalent to the previous code, except: (1) skipping events is now optional, controlled by a parameter to the new function (2) the return value of exec_relay_log_event has changed; see next item). - Changed returned error value to always be 1. Before, it would return the error value from apply_log_event, which was unnecessary. This change is safe because the exact return value of exec_relay_log_event is never examined; it is only tested to be ==0 or !=0. - Added comments describing exec_relay_log_event and apply_event_and_update_pos. - Minor fixes: * Removed duplicate declaration of next_event, made queue_event static. * Added doxygen code to include this file. sql/slave.h: Declared the new apply_event_and_update_pos sql/sql_binlog.cc: - Made mysql_binlog_statement set the current FD event when the given event is an FD event. This entails using the new function apply_event_and_update_pos from slave.cc instead of just calling the ev->apply method. - Made mysql_binlog_statement fail if the first BINLOG statement is not an FD event. mysql-test/suite/binlog/r/binlog_base64_flag.result: New test file needs new result file mysql-test/suite/binlog/t/binlog_base64_flag.test: Added test case to verify that: - my patch fixes the bug - the new --base64-output flag works as expected - base64 events not preceded by an FD event give an error - an event of a type not known by the current FD event fails cleanly. mysql-test/suite/binlog/std_data/binlog-bug32407.000001: BitKeeper file /home/sven/bk/b32407-5.1-new-rpl-mysqlbinlog_base64/mysql-test/suite/binlog/std_data/binlog-bug32407.000001 --- sql/log_event.cc | 204 +++++++++++++++++++--------------- sql/log_event.h | 29 ++++- sql/share/errmsg.txt | 3 + sql/slave.cc | 306 +++++++++++++++++++++++++++++++++------------------ sql/slave.h | 2 + sql/sql_binlog.cc | 74 ++++++++++--- 6 files changed, 403 insertions(+), 215 deletions(-) (limited to 'sql') diff --git a/sql/log_event.cc b/sql/log_event.cc index cdfd58535fb..8a4fabde3e3 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -491,9 +491,9 @@ static void print_set_option(IO_CACHE* file, uint32 bits_changed, Log_event::get_type_str() */ -const char* Log_event::get_type_str() +const char* Log_event::get_type_str(Log_event_type type) { - switch(get_type_code()) { + switch(type) { case START_EVENT_V3: return "Start_v3"; case STOP_EVENT: return "Stop"; case QUERY_EVENT: return "Query"; @@ -524,6 +524,11 @@ const char* Log_event::get_type_str() } } +const char* Log_event::get_type_str() +{ + return get_type_str(get_type_code()); +} + /* Log_event::Log_event() @@ -1050,94 +1055,111 @@ Log_event* Log_event::read_log_event(const char* buf, uint event_len, DBUG_RETURN(NULL); // general sanity check - will fail on a partial read } - switch(buf[EVENT_TYPE_OFFSET]) { - case QUERY_EVENT: - ev = new Query_log_event(buf, event_len, description_event, QUERY_EVENT); - break; - case LOAD_EVENT: - ev = new Load_log_event(buf, event_len, description_event); - break; - case NEW_LOAD_EVENT: - ev = new Load_log_event(buf, event_len, description_event); - break; - case ROTATE_EVENT: - ev = new Rotate_log_event(buf, event_len, description_event); - break; + uint event_type= buf[EVENT_TYPE_OFFSET]; + if (event_type > description_event->number_of_event_types && + event_type != FORMAT_DESCRIPTION_EVENT) + { + /* + It is unsafe to use the description_event if its post_header_len + array does not include the event type. + */ + DBUG_PRINT("error", ("event type %d found, but the current " + "Format_description_log_event supports only %d event " + "types", event_type, + description_event->number_of_event_types)); + ev= NULL; + } + else + { + switch(event_type) { + case QUERY_EVENT: + ev = new Query_log_event(buf, event_len, description_event, QUERY_EVENT); + break; + case LOAD_EVENT: + ev = new Load_log_event(buf, event_len, description_event); + break; + case NEW_LOAD_EVENT: + ev = new Load_log_event(buf, event_len, description_event); + break; + case ROTATE_EVENT: + ev = new Rotate_log_event(buf, event_len, description_event); + break; #ifdef HAVE_REPLICATION - case SLAVE_EVENT: /* can never happen (unused event) */ - ev = new Slave_log_event(buf, event_len); - break; + case SLAVE_EVENT: /* can never happen (unused event) */ + ev = new Slave_log_event(buf, event_len); + break; #endif /* HAVE_REPLICATION */ - case CREATE_FILE_EVENT: - ev = new Create_file_log_event(buf, event_len, description_event); - break; - case APPEND_BLOCK_EVENT: - ev = new Append_block_log_event(buf, event_len, description_event); - break; - case DELETE_FILE_EVENT: - ev = new Delete_file_log_event(buf, event_len, description_event); - break; - case EXEC_LOAD_EVENT: - ev = new Execute_load_log_event(buf, event_len, description_event); - break; - case START_EVENT_V3: /* this is sent only by MySQL <=4.x */ - ev = new Start_log_event_v3(buf, description_event); - break; - case STOP_EVENT: - ev = new Stop_log_event(buf, description_event); - break; - case INTVAR_EVENT: - ev = new Intvar_log_event(buf, description_event); - break; - case XID_EVENT: - ev = new Xid_log_event(buf, description_event); - break; - case RAND_EVENT: - ev = new Rand_log_event(buf, description_event); - break; - case USER_VAR_EVENT: - ev = new User_var_log_event(buf, description_event); - break; - case FORMAT_DESCRIPTION_EVENT: - ev = new Format_description_log_event(buf, event_len, description_event); - break; + case CREATE_FILE_EVENT: + ev = new Create_file_log_event(buf, event_len, description_event); + break; + case APPEND_BLOCK_EVENT: + ev = new Append_block_log_event(buf, event_len, description_event); + break; + case DELETE_FILE_EVENT: + ev = new Delete_file_log_event(buf, event_len, description_event); + break; + case EXEC_LOAD_EVENT: + ev = new Execute_load_log_event(buf, event_len, description_event); + break; + case START_EVENT_V3: /* this is sent only by MySQL <=4.x */ + ev = new Start_log_event_v3(buf, description_event); + break; + case STOP_EVENT: + ev = new Stop_log_event(buf, description_event); + break; + case INTVAR_EVENT: + ev = new Intvar_log_event(buf, description_event); + break; + case XID_EVENT: + ev = new Xid_log_event(buf, description_event); + break; + case RAND_EVENT: + ev = new Rand_log_event(buf, description_event); + break; + case USER_VAR_EVENT: + ev = new User_var_log_event(buf, description_event); + break; + case FORMAT_DESCRIPTION_EVENT: + ev = new Format_description_log_event(buf, event_len, description_event); + break; #if defined(HAVE_REPLICATION) - case PRE_GA_WRITE_ROWS_EVENT: - ev = new Write_rows_log_event_old(buf, event_len, description_event); - break; - case PRE_GA_UPDATE_ROWS_EVENT: - ev = new Update_rows_log_event_old(buf, event_len, description_event); - break; - case PRE_GA_DELETE_ROWS_EVENT: - ev = new Delete_rows_log_event_old(buf, event_len, description_event); - break; - case WRITE_ROWS_EVENT: - ev = new Write_rows_log_event(buf, event_len, description_event); - break; - case UPDATE_ROWS_EVENT: - ev = new Update_rows_log_event(buf, event_len, description_event); - break; - case DELETE_ROWS_EVENT: - ev = new Delete_rows_log_event(buf, event_len, description_event); - break; - case TABLE_MAP_EVENT: - ev = new Table_map_log_event(buf, event_len, description_event); - break; + case PRE_GA_WRITE_ROWS_EVENT: + ev = new Write_rows_log_event_old(buf, event_len, description_event); + break; + case PRE_GA_UPDATE_ROWS_EVENT: + ev = new Update_rows_log_event_old(buf, event_len, description_event); + break; + case PRE_GA_DELETE_ROWS_EVENT: + ev = new Delete_rows_log_event_old(buf, event_len, description_event); + break; + case WRITE_ROWS_EVENT: + ev = new Write_rows_log_event(buf, event_len, description_event); + break; + case UPDATE_ROWS_EVENT: + ev = new Update_rows_log_event(buf, event_len, description_event); + break; + case DELETE_ROWS_EVENT: + ev = new Delete_rows_log_event(buf, event_len, description_event); + break; + case TABLE_MAP_EVENT: + ev = new Table_map_log_event(buf, event_len, description_event); + break; #endif - case BEGIN_LOAD_QUERY_EVENT: - ev = new Begin_load_query_log_event(buf, event_len, description_event); - break; - case EXECUTE_LOAD_QUERY_EVENT: - ev= new Execute_load_query_log_event(buf, event_len, description_event); - break; - case INCIDENT_EVENT: - ev = new Incident_log_event(buf, event_len, description_event); - break; - default: - DBUG_PRINT("error",("Unknown event code: %d", - (int) buf[EVENT_TYPE_OFFSET])); - ev= NULL; - break; + case BEGIN_LOAD_QUERY_EVENT: + ev = new Begin_load_query_log_event(buf, event_len, description_event); + break; + case EXECUTE_LOAD_QUERY_EVENT: + ev= new Execute_load_query_log_event(buf, event_len, description_event); + break; + case INCIDENT_EVENT: + ev = new Incident_log_event(buf, event_len, description_event); + break; + default: + DBUG_PRINT("error",("Unknown event code: %d", + (int) buf[EVENT_TYPE_OFFSET])); + ev= NULL; + break; + } } DBUG_PRINT("read_event", ("%s(type_code: %d; event_len: %d)", @@ -2604,6 +2626,14 @@ void Start_log_event_v3::print(FILE* file, PRINT_EVENT_INFO* print_event_info) my_b_printf(&cache,"ROLLBACK%s\n", print_event_info->delimiter); #endif } + if (temp_buf && + print_event_info->base64_output_mode != BASE64_OUTPUT_NEVER && + !print_event_info->short_form) + { + my_b_printf(&cache, "BINLOG '\n"); + print_base64(&cache, print_event_info, FALSE); + print_event_info->printed_fd_event= TRUE; + } DBUG_VOID_RETURN; } #endif /* MYSQL_CLIENT */ @@ -5050,7 +5080,7 @@ Create_file_log_event::Create_file_log_event(const char* buf, uint len, Load_log_event::get_data_size() + create_file_header_len + 1); if (len < block_offset) - return; + DBUG_VOID_RETURN; block = (char*)buf + block_offset; block_len = len - block_offset; } diff --git a/sql/log_event.h b/sql/log_event.h index 0275b02dd49..4a75f330203 100644 --- a/sql/log_event.h +++ b/sql/log_event.h @@ -567,6 +567,15 @@ class Format_description_log_event; class Relay_log_info; #ifdef MYSQL_CLIENT +enum enum_base64_output_mode { + BASE64_OUTPUT_NEVER= 0, + BASE64_OUTPUT_AUTO= 1, + BASE64_OUTPUT_ALWAYS= 2, + BASE64_OUTPUT_UNSPEC= 3, + /* insert new output modes here */ + BASE64_OUTPUT_MODE_COUNT +}; + /* A structure for mysqlbinlog to know how to print events @@ -600,7 +609,8 @@ typedef struct st_print_event_info 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) + lc_time_names_number(0), charset_database_number(0), + base64_output_mode(BASE64_OUTPUT_UNSPEC), printed_fd_event(FALSE) { /* Currently we only use static PRINT_EVENT_INFO objects, so zeroed at @@ -627,7 +637,14 @@ typedef struct st_print_event_info /* Settings on how to print the events */ bool short_form; - bool base64_output; + enum_base64_output_mode base64_output_mode; + /* + This is set whenever a Format_description_event is printed. + Later, when an event is printed in base64, this flag is tested: if + no Format_description_event has been seen, it is unsafe to print + the base64 event, so an error message is generated. + */ + bool printed_fd_event; my_off_t hexdump_from; uint8 common_header_len; char delimiter[16]; @@ -936,7 +953,13 @@ public: const char **error, const Format_description_log_event *description_event); - /* returns the human readable name of the event's type */ + /** + Returns the human readable name of the given event type. + */ + static const char* get_type_str(Log_event_type type); + /** + Returns the human readable name of this event's type. + */ const char* get_type_str(); /* Return start of query time or current time */ diff --git a/sql/share/errmsg.txt b/sql/share/errmsg.txt index dce1dd785bf..026a0023660 100644 --- a/sql/share/errmsg.txt +++ b/sql/share/errmsg.txt @@ -6116,3 +6116,6 @@ ER_CANT_CREATE_SROUTINE eng "Cannot create stored routine `%-.64s`. Check warnings" ER_SLAVE_AMBIGOUS_EXEC_MODE eng "Ambiguous slave modes combination. %s" + +ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT + eng "The BINLOG statement of type `%s` was not preceded by a format description BINLOG statement." diff --git a/sql/slave.cc b/sql/slave.cc index b6611d44723..14fa1c45c36 100644 --- a/sql/slave.cc +++ b/sql/slave.cc @@ -13,6 +13,17 @@ along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/** + @addtogroup Replication + @{ + + @file + + @brief Code to run the io thread and the sql thread on the + replication slave. +*/ + #include "mysql_priv.h" #include @@ -33,10 +44,6 @@ #include "rpl_tblmap.h" -int queue_event(Master_info* mi,const char* buf,ulong event_len); -static Log_event* next_event(Relay_log_info* rli); - - #define FLAGSTR(V,F) ((V)&(F)?#F" ":"") #define MAX_SLAVE_RETRY_PAUSE 5 @@ -132,6 +139,7 @@ static int create_table_from_dump(THD* thd, MYSQL *mysql, const char* db, const char* table_name, bool overwrite); static int get_master_version_and_clock(MYSQL* mysql, Master_info* mi); static Log_event* next_event(Relay_log_info* rli); +static int queue_event(Master_info* mi,const char* buf,ulong event_len); static int terminate_slave_thread(THD *thd, pthread_mutex_t* term_lock, pthread_cond_t* term_cond, @@ -1757,6 +1765,175 @@ static int has_temporary_error(THD *thd) DBUG_RETURN(0); } + +/** + Applies the given event and advances the relay log position. + + In essence, this function does: + + @code + ev->apply_event(rli); + ev->update_pos(rli); + @endcode + + But it also does some maintainance, such as skipping events if + needed and reporting errors. + + If the @c skip flag is set, then it is tested whether the event + should be skipped, by looking at the slave_skip_counter and the + server id. The skip flag should be set when calling this from a + replication thread but not set when executing an explicit BINLOG + statement. + + @retval 0 OK. + + @retval 1 Error calling ev->apply_event(). + + @retval 2 No error calling ev->apply_event(), but error calling + ev->update_pos(). +*/ +int apply_event_and_update_pos(Log_event* ev, THD* thd, Relay_log_info* rli, + bool skip) +{ + int exec_res= 0; + + DBUG_ENTER("apply_event_and_update_pos"); + + DBUG_PRINT("exec_event",("%s(type_code: %d; server_id: %d)", + ev->get_type_str(), ev->get_type_code(), + ev->server_id)); + DBUG_PRINT("info", ("thd->options: %s%s; rli->last_event_start_time: %lu", + FLAGSTR(thd->options, OPTION_NOT_AUTOCOMMIT), + FLAGSTR(thd->options, OPTION_BEGIN), + rli->last_event_start_time)); + + /* + Execute the event to change the database and update the binary + log coordinates, but first we set some data that is needed for + the thread. + + The event will be executed unless it is supposed to be skipped. + + Queries originating from this server must be skipped. Low-level + events (Format_description_log_event, Rotate_log_event, + Stop_log_event) from this server must also be skipped. But for + those we don't want to modify 'group_master_log_pos', because + these events did not exist on the master. + Format_description_log_event is not completely skipped. + + Skip queries specified by the user in 'slave_skip_counter'. We + can't however skip events that has something to do with the log + files themselves. + + Filtering on own server id is extremely important, to ignore + execution of events created by the creation/rotation of the relay + log (remember that now the relay log starts with its Format_desc, + has a Rotate etc). + */ + + thd->server_id = ev->server_id; // use the original server id for logging + thd->set_time(); // time the query + thd->lex->current_select= 0; + if (!ev->when) + ev->when= my_time(0); + ev->thd = thd; // because up to this point, ev->thd == 0 + + if (skip) + { + int reason= ev->shall_skip(rli); + if (reason == Log_event::EVENT_SKIP_COUNT) + --rli->slave_skip_counter; + pthread_mutex_unlock(&rli->data_lock); + if (reason == Log_event::EVENT_SKIP_NOT) + exec_res= ev->apply_event(rli); +#ifndef DBUG_OFF + /* + This only prints information to the debug trace. + + TODO: Print an informational message to the error log? + */ + static const char *const explain[] = { + // EVENT_SKIP_NOT, + "not skipped", + // EVENT_SKIP_IGNORE, + "skipped because event should be ignored", + // EVENT_SKIP_COUNT + "skipped because event skip counter was non-zero" + }; + DBUG_PRINT("info", ("OPTION_BEGIN: %d; IN_STMT: %d", + thd->options & OPTION_BEGIN ? 1 : 0, + rli->get_flag(Relay_log_info::IN_STMT))); + DBUG_PRINT("skip_event", ("%s event was %s", + ev->get_type_str(), explain[reason])); +#endif + } + else + exec_res= ev->apply_event(rli); + + DBUG_PRINT("info", ("apply_event error = %d", exec_res)); + if (exec_res == 0) + { + int error= ev->update_pos(rli); + char buf[22]; + DBUG_PRINT("info", ("update_pos error = %d", error)); + DBUG_PRINT("info", ("group %s %s", + llstr(rli->group_relay_log_pos, buf), + rli->group_relay_log_name)); + DBUG_PRINT("info", ("event %s %s", + llstr(rli->event_relay_log_pos, buf), + rli->event_relay_log_name)); + /* + The update should not fail, so print an error message and + return an error code. + + TODO: Replace this with a decent error message when merged + with BUG#24954 (which adds several new error message). + */ + if (error) + { + rli->report(ERROR_LEVEL, ER_UNKNOWN_ERROR, + "It was not possible to update the positions" + " of the relay log information: the slave may" + " be in an inconsistent state." + " Stopped in %s position %s", + rli->group_relay_log_name, + llstr(rli->group_relay_log_pos, buf)); + DBUG_RETURN(2); + } + } + + DBUG_RETURN(exec_res ? 1 : 0); +} + + +/** + Top-level function for executing the next event from the relay log. + + This function reads the event from the relay log, executes it, and + advances the relay log position. It also handles errors, etc. + + This function may fail to apply the event for the following reasons: + + - The position specfied by the UNTIL condition of the START SLAVE + command is reached. + + - It was not possible to read the event from the log. + + - The slave is killed. + + - An error occurred when applying the event, and the event has been + tried slave_trans_retries times. If the event has been retried + fewer times, 0 is returned. + + - init_master_info or init_relay_log_pos failed. (These are called + if a failure occurs when applying the event.) + + - An error occurred when updating the binlog position. + + @retval 0 The event was applied. + + @retval 1 The event was not applied. +*/ static int exec_relay_log_event(THD* thd, Relay_log_info* rli) { DBUG_ENTER("exec_relay_log_event"); @@ -1802,117 +1979,26 @@ static int exec_relay_log_event(THD* thd, Relay_log_info* rli) } if (ev) { - int const type_code= ev->get_type_code(); - int exec_res= 0; - - DBUG_PRINT("exec_event",("%s(type_code: %d; server_id: %d)", - ev->get_type_str(), type_code, ev->server_id)); - DBUG_PRINT("info", ("thd->options: %s%s; rli->last_event_start_time: %lu", - FLAGSTR(thd->options, OPTION_NOT_AUTOCOMMIT), - FLAGSTR(thd->options, OPTION_BEGIN), - rli->last_event_start_time)); - + int exec_res= apply_event_and_update_pos(ev, thd, rli, TRUE); /* - Execute the event to change the database and update the binary - log coordinates, but first we set some data that is needed for - the thread. - - The event will be executed unless it is supposed to be skipped. - - Queries originating from this server must be skipped. Low-level - events (Format_description_log_event, Rotate_log_event, - Stop_log_event) from this server must also be skipped. But for - those we don't want to modify 'group_master_log_pos', because - these events did not exist on the master. - Format_description_log_event is not completely skipped. - - Skip queries specified by the user in 'slave_skip_counter'. We - can't however skip events that has something to do with the log - files themselves. - - Filtering on own server id is extremely important, to ignore - execution of events created by the creation/rotation of the relay - log (remember that now the relay log starts with its Format_desc, - has a Rotate etc). + Format_description_log_event should not be deleted because it will be + used to read info about the relay log's format; it will be deleted when + the SQL thread does not need it, i.e. when this thread terminates. */ - - thd->server_id = ev->server_id; // use the original server id for logging - thd->set_time(); // time the query - thd->lex->current_select= 0; - if (!ev->when) - ev->when= my_time(0); - ev->thd = thd; // because up to this point, ev->thd == 0 - - int reason= ev->shall_skip(rli); - if (reason == Log_event::EVENT_SKIP_COUNT) - --rli->slave_skip_counter; - pthread_mutex_unlock(&rli->data_lock); - if (reason == Log_event::EVENT_SKIP_NOT) - exec_res= ev->apply_event(rli); -#ifndef DBUG_OFF - /* - This only prints information to the debug trace. - - TODO: Print an informational message to the error log? - */ - static const char *const explain[] = { - // EVENT_SKIP_NOT, - "not skipped", - // EVENT_SKIP_IGNORE, - "skipped because event should be ignored", - // EVENT_SKIP_COUNT - "skipped because event skip counter was non-zero" - }; - DBUG_PRINT("info", ("OPTION_BEGIN: %d; IN_STMT: %d", - thd->options & OPTION_BEGIN ? 1 : 0, - rli->get_flag(Relay_log_info::IN_STMT))); - DBUG_PRINT("skip_event", ("%s event was %s", - ev->get_type_str(), explain[reason])); -#endif - - DBUG_PRINT("info", ("apply_event error = %d", exec_res)); - if (exec_res == 0) + if (ev->get_type_code() != FORMAT_DESCRIPTION_EVENT) { - int error= ev->update_pos(rli); - char buf[22]; - DBUG_PRINT("info", ("update_pos error = %d", error)); - DBUG_PRINT("info", ("group %s %s", - llstr(rli->group_relay_log_pos, buf), - rli->group_relay_log_name)); - DBUG_PRINT("info", ("event %s %s", - llstr(rli->event_relay_log_pos, buf), - rli->event_relay_log_name)); - /* - The update should not fail, so print an error message and - return an error code. - - TODO: Replace this with a decent error message when merged - with BUG#24954 (which adds several new error message). - */ - if (error) - { - rli->report(ERROR_LEVEL, ER_UNKNOWN_ERROR, - "It was not possible to update the positions" - " of the relay log information: the slave may" - " be in an inconsistent state." - " Stopped in %s position %s", - rli->group_relay_log_name, - llstr(rli->group_relay_log_pos, buf)); - DBUG_RETURN(1); - } + DBUG_PRINT("info", ("Deleting the event after it has been executed")); + delete ev; } /* - Format_description_log_event should not be deleted because it will be - used to read info about the relay log's format; it will be deleted when - the SQL thread does not need it, i.e. when this thread terminates. + update_log_pos failed: this should not happen, so we don't + retry. */ - if (type_code != FORMAT_DESCRIPTION_EVENT) - { - DBUG_PRINT("info", ("Deleting the event after it has been executed")); - delete ev; - } + if (exec_res == 2) + DBUG_RETURN(1); + if (slave_trans_retries) { int temp_err; @@ -3051,7 +3137,7 @@ static int queue_old_event(Master_info *mi, const char *buf, any >=5.0.0 format. */ -int queue_event(Master_info* mi,const char* buf, ulong event_len) +static int queue_event(Master_info* mi,const char* buf, ulong event_len) { int error= 0; ulong inc_pos; @@ -3937,4 +4023,8 @@ template class I_List_iterator; template class I_List_iterator; #endif +/** + @} (end of group Replication) +*/ + #endif /* HAVE_REPLICATION */ diff --git a/sql/slave.h b/sql/slave.h index 2cd9ea352ba..f1772bbc1fc 100644 --- a/sql/slave.h +++ b/sql/slave.h @@ -187,6 +187,8 @@ int purge_relay_logs(Relay_log_info* rli, THD *thd, bool just_reset, void set_slave_thread_options(THD* thd); void set_slave_thread_default_charset(THD *thd, Relay_log_info const *rli); void rotate_relay_log(Master_info* mi); +int apply_event_and_update_pos(Log_event* ev, THD* thd, Relay_log_info* rli, + bool skip); pthread_handler_t handle_slave_io(void *arg); pthread_handler_t handle_slave_sql(void *arg); diff --git a/sql/sql_binlog.cc b/sql/sql_binlog.cc index fa6aa8f5881..543b1af9fc0 100644 --- a/sql/sql_binlog.cc +++ b/sql/sql_binlog.cc @@ -17,15 +17,14 @@ #include "rpl_rli.h" #include "base64.h" -/* +/** Execute a BINLOG statement - TODO: This currently assumes a MySQL 5.x binlog. - When we'll have binlog with a different format, to execute the - BINLOG command properly the server will need to know which format - the BINLOG command's event is in. mysqlbinlog should then send - the Format_description_log_event of the binlog it reads and the - server thread should cache this format into + To execute the BINLOG command properly the server needs to know + which format the BINLOG command's event is in. Therefore, the first + BINLOG statement seen must be a base64 encoding of the + Format_description_log_event, as outputted by mysqlbinlog. This + Format_description_log_event is cached in rli->description_event_for_exec. */ @@ -54,11 +53,24 @@ void mysql_client_binlog_statement(THD* thd) /* Allocation */ + + /* + If we do not have a Format_description_event, we create a dummy + one here. In this case, the first event we read must be a + Format_description_event. + */ + my_bool have_fd_event= TRUE; if (!thd->rli_fake) + { thd->rli_fake= new Relay_log_info; - - const Format_description_log_event *desc= - new Format_description_log_event(4); + have_fd_event= FALSE; + } + if (thd->rli_fake && !thd->rli_fake->relay_log.description_event_for_exec) + { + thd->rli_fake->relay_log.description_event_for_exec= + new Format_description_log_event(4); + have_fd_event= FALSE; + } const char *error= 0; char *buf= (char *) my_malloc(decoded_len, MYF(MY_WME)); @@ -67,7 +79,9 @@ void mysql_client_binlog_statement(THD* thd) /* Out of memory check */ - if (!(thd->rli_fake && desc && buf)) + if (!(thd->rli_fake && + thd->rli_fake->relay_log.description_event_for_exec && + buf)) { my_error(ER_OUTOFMEMORY, MYF(0), 1); /* needed 1 bytes */ goto end; @@ -138,7 +152,28 @@ void mysql_client_binlog_statement(THD* thd) goto end; } - ev= Log_event::read_log_event(bufptr, event_len, &error, desc); + /* + If we have not seen any Format_description_event, then we must + see one; it is the only statement that can be read in base64 + without a prior Format_description_event. + */ + if (!have_fd_event) + { + if (bufptr[EVENT_TYPE_OFFSET] == FORMAT_DESCRIPTION_EVENT) + have_fd_event= TRUE; + else + { + my_error(ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT, + MYF(0), + Log_event::get_type_str( + (Log_event_type)bufptr[EVENT_TYPE_OFFSET])); + goto end; + } + } + + ev= Log_event::read_log_event(bufptr, event_len, &error, + thd->rli_fake->relay_log. + description_event_for_exec); DBUG_PRINT("info",("binlog base64 err=%s", error)); if (!ev) @@ -174,11 +209,10 @@ void mysql_client_binlog_statement(THD* thd) Neither do we have to update the log positions, since that is not used at all: the rli_fake instance is used only for error reporting. - */ + */ #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) - if (IF_DBUG(int err= ) ev->apply_event(thd->rli_fake)) + if (apply_event_and_update_pos(ev, thd, thd->rli_fake, FALSE)) { - DBUG_PRINT("info", ("apply_event() returned: %d", err)); /* TODO: Maybe a better error message since the BINLOG statement now contains several events. @@ -188,7 +222,14 @@ void mysql_client_binlog_statement(THD* thd) } #endif - delete ev; + /* + Format_description_log_event should not be deleted because it + will be used to read info about the relay log's format; it + will be deleted when the SQL thread does not need it, + i.e. when this thread terminates. + */ + if (ev->get_type_code() != FORMAT_DESCRIPTION_EVENT) + delete ev; ev= 0; } } @@ -207,7 +248,6 @@ end: */ thd->net.no_send_ok= nsok; - delete desc; my_free(buf, MYF(MY_ALLOW_ZERO_PTR)); DBUG_VOID_RETURN; } -- cgit v1.2.1 From 590350633c23d3d986e9d3c8745aa8f0bbb78105 Mon Sep 17 00:00:00 2001 From: unknown Date: Sat, 15 Dec 2007 19:50:23 +0800 Subject: BUG#32205 Replaying statements from mysqlbinlog fails with a syntax error, replicates fine The reason of this bug is that when mysqlbinlog dumps a query, the query is written to output with a delimeter appended right after it, if the query string ends with a '--' comment, then the delimeter would be considered as part of the comment, if there are any statements after this query, then it will cause a syntax error. Start a newline before appending delimiter after a query string mysql-test/r/ctype_ucs_binlog.result: Update test result for BUG#32205 mysql-test/r/mix_innodb_myisam_binlog.result: Update test result for BUG#32205 mysql-test/r/mysqlbinlog.result: Update test result for BUG#32205 mysql-test/r/rpl_charset.result: Update test result for BUG#32205 mysql-test/r/rpl_timezone.result: Update test result for BUG#32205 mysql-test/r/user_var-binlog.result: Update test result for BUG#32205 mysql-test/t/mix_innodb_myisam_binlog.test: Fixed for BUG#32205 sql/log_event.cc: Start a newline before appending delimiter after a query string mysql-test/r/binlog_start_comment.result: Add test for BUG#32205 mysql-test/t/binlog_start_comment.test: Add test for BUG#32205 --- sql/log_event.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'sql') diff --git a/sql/log_event.cc b/sql/log_event.cc index d22973d12a3..965dfb5f5cf 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -1862,7 +1862,7 @@ void Query_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info) { print_query_header(file, print_event_info); my_fwrite(file, (byte*) query, q_len, MYF(MY_NABP | MY_WME)); - fprintf(file, "%s\n", print_event_info->delimiter); + fprintf(file, "\n%s\n", print_event_info->delimiter); } #endif /* MYSQL_CLIENT */ @@ -5180,12 +5180,12 @@ void Execute_load_query_log_event::print(FILE* file, fprintf(file, " INTO"); my_fwrite(file, (byte*) query + fn_pos_end, q_len-fn_pos_end, MYF(MY_NABP | MY_WME)); - fprintf(file, "%s\n", print_event_info->delimiter); + fprintf(file, "\n%s\n", print_event_info->delimiter); } else { my_fwrite(file, (byte*) query, q_len, MYF(MY_NABP | MY_WME)); - fprintf(file, "%s\n", print_event_info->delimiter); + fprintf(file, "\n%s\n", print_event_info->delimiter); } if (!print_event_info->short_form) -- cgit v1.2.1 From 0968c713aa121af45671b36da4fb546b4df56891 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 17 Dec 2007 21:13:25 +0800 Subject: BUG#32205 Replaying statements from mysqlbinlog fails with a syntax error, replicates fine The reason of this bug is that when mysqlbinlog dumps a query, the query is written to output with a delimeter appended right after it, if the query string ends with a '--' comment, then the delimeter would be considered as part of the comment, if there are any statements after this query, then it will cause a syntax error. Start a newline before appending delimiter after a query string mysql-test/r/mysqlbinlog.result: Update result for BUG#32205 mysql-test/r/mysqlbinlog2.result: Update result for BUG#32205 mysql-test/r/user_var-binlog.result: Update result for BUG#32205 mysql-test/suite/binlog/r/binlog_stm_ctype_ucs.result: Update result for BUG#32205 mysql-test/suite/binlog/r/binlog_stm_mix_innodb_myisam.result: Update result for BUG#32205 mysql-test/suite/binlog/t/binlog_stm_mix_innodb_myisam.test: fix test for BUG#32205 mysql-test/suite/rpl/r/rpl_row_mysqlbinlog.result: Update result for BUG#32205 mysql-test/suite/rpl/r/rpl_stm_charset.result: Update result for BUG#32205 sql/log_event.cc: Start a newline before appending delimiter after a query string mysql-test/suite/binlog/r/binlog_start_comment.result: Add test for BUG#32205 mysql-test/suite/binlog/t/binlog_start_comment.test: Add test for BUG#32205 --- sql/log_event.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'sql') diff --git a/sql/log_event.cc b/sql/log_event.cc index f328f266c05..1914fa3ef32 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -2177,7 +2177,7 @@ void Query_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info) print_query_header(&cache, print_event_info); my_b_write(&cache, (uchar*) query, q_len); - my_b_printf(&cache, "%s\n", print_event_info->delimiter); + my_b_printf(&cache, "\n%s\n", print_event_info->delimiter); } #endif /* MYSQL_CLIENT */ @@ -5756,12 +5756,12 @@ void Execute_load_query_log_event::print(FILE* file, my_b_printf(&cache, " REPLACE"); my_b_printf(&cache, " INTO"); my_b_write(&cache, (uchar*) query + fn_pos_end, q_len-fn_pos_end); - my_b_printf(&cache, "%s\n", print_event_info->delimiter); + my_b_printf(&cache, "\n%s\n", print_event_info->delimiter); } else { my_b_write(&cache, (uchar*) query, q_len); - my_b_printf(&cache, "%s\n", print_event_info->delimiter); + my_b_printf(&cache, "\n%s\n", print_event_info->delimiter); } if (!print_event_info->short_form) -- cgit v1.2.1 From 150590a0bce917f7747765e1589fa37efa09fb53 Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 20 Dec 2007 16:07:54 +0100 Subject: BUG#12691 (Exec_master_log_pos corrupted with SQL_SLAVE_SKIP_COUNTER): Complementary patch since LOAD DATA INFILE was not covered in the previous patch. This patch adds a check so that the slave skip counter is not decreased to zero if seeing a BEGIN_LOAD_QUERY_EVENT, APPEND_BLOCK_EVENT, or CREATE_FILE_EVENT since these cannot end a group. The group is terminated by an EXECUTE_LOAD_QUERY_ EVENT or DELETE_FILE_EVENT. mysql-test/r/rpl_slave_skip.result: Result change. mysql-test/t/rpl_slave_skip.test: Adding tests to test that the first event of a LOAD DATA INFILE can be skipped safely for both transactional and non-transactional tables. Also include a case that will generate a DELETE_FILE event last in the group, and this should be properly skipped as well. sql/slave.cc: Not decrementing slave skip counter to zero when seeing a BEGIN_LOAD_QUERY_EVENT, APPEND_BLOCK_EVENT, or CREATE_FILE_EVENT since these cannot end a group. --- sql/slave.cc | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'sql') diff --git a/sql/slave.cc b/sql/slave.cc index 1509916fe91..4a65e9aaa85 100644 --- a/sql/slave.cc +++ b/sql/slave.cc @@ -3348,7 +3348,10 @@ static int exec_relay_log_event(THD* thd, RELAY_LOG_INFO* rli) if (rli->slave_skip_counter && !((type_code == INTVAR_EVENT || type_code == RAND_EVENT || - type_code == USER_VAR_EVENT) && + type_code == USER_VAR_EVENT || + type_code == BEGIN_LOAD_QUERY_EVENT || + type_code == APPEND_BLOCK_EVENT || + type_code == CREATE_FILE_EVENT) && rli->slave_skip_counter == 1) && #if MYSQL_VERSION_ID < 50100 /* -- cgit v1.2.1 From e2937d7f430414607bbf8a56e5617b26e1fabdb3 Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 21 Dec 2007 11:02:48 +0800 Subject: BUG#28908 Replication: set global server_id is not setting the session server_id When set the server-id dynamically, the server_id member of current thread is not updated. Update the server_id member of current thread after updated the global variable value. sql/set_var.cc: Update server_id of current thread mysql-test/r/rpl_server_id.result: Add test for BUG#28908 mysql-test/t/rpl_server_id.test: Add test for BUG#28908 --- sql/set_var.cc | 1 + 1 file changed, 1 insertion(+) (limited to 'sql') diff --git a/sql/set_var.cc b/sql/set_var.cc index a128529fcc7..fac5a431176 100644 --- a/sql/set_var.cc +++ b/sql/set_var.cc @@ -1441,6 +1441,7 @@ static void fix_trans_mem_root(THD *thd, enum_var_type type) static void fix_server_id(THD *thd, enum_var_type type) { server_id_supplied = 1; + thd->server_id= server_id; } -- cgit v1.2.1 From 544781ad888c388cff6e4d7917585f1173df19f8 Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 21 Dec 2007 10:13:54 +0200 Subject: Bug #31359 change_master sets group_master_log_pos twice, ignores future_group_master_log_p There was a redundant assignement. However, that's the only artifact. Wrt to future_group_master_log_position, there is no issue. The counter is supposed to be set at Log_event::exec_event(). It's used only by Innodb for recovery purposes. sql/sql_repl.cc: removing a redundant line which arrived with the revision 1.102.1.7. --- sql/sql_repl.cc | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) (limited to 'sql') diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc index 903d254db8f..90eea8d322f 100644 --- a/sql/sql_repl.cc +++ b/sql/sql_repl.cc @@ -1229,9 +1229,6 @@ bool change_master(THD* thd, MASTER_INFO* mi) DBUG_RETURN(TRUE); } } - mi->rli.group_master_log_pos = mi->master_log_pos; - DBUG_PRINT("info", ("master_log_pos: %lu", (ulong) mi->master_log_pos)); - /* Coordinates in rli were spoilt by the 'if (need_relay_log_purge)' block, so restore them to good values. If we left them to ''/0, that would work; @@ -1243,6 +1240,7 @@ bool change_master(THD* thd, MASTER_INFO* mi) That's why we always save good coords in rli. */ mi->rli.group_master_log_pos= mi->master_log_pos; + DBUG_PRINT("info", ("master_log_pos: %lu", (ulong) mi->master_log_pos)); strmake(mi->rli.group_master_log_name,mi->master_log_name, sizeof(mi->rli.group_master_log_name)-1); -- cgit v1.2.1 From b5d95f021f1f984384897890d9335f5bd23c4ba6 Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 21 Dec 2007 20:30:23 +0100 Subject: BUG#26395: if crash during autocommit update to transactional table on master, slave fails Now, every transaction (including autocommit transactions) start with a BEGIN and end with a COMMIT/ROLLBACK in the binlog. Added a test case, and updated lots of test case result files. mysql-test/t/rpl_transaction-master.opt: BitKeeper file /home/sven/bk/b26395-autocommit-xa/5.0-rpl/mysql-test/t/rpl_transaction-master.opt mysql-test/t/rpl_transaction-slave.opt: BitKeeper file /home/sven/bk/b26395-autocommit-xa/5.0-rpl/mysql-test/t/rpl_transaction-slave.opt mysql-test/r/mix_innodb_myisam_binlog.result: Updated result file mysql-test/r/multi_update.result: Updated result file mysql-test/r/rpl_transaction.result: New result file for new test case. mysql-test/r/sp_trans_log.result: Updated result file mysql-test/r/variables-big.result: Updated result file mysql-test/t/rpl_transaction.test: New test case. sql/log.cc: - Always write BEGIN and COMMIT around statements, even in autocommit mode. - Added comments for binlog_commit and binlog_rollback. sql/log_event.cc: Added debug trigger to avoid writing xid events to the binlog. --- sql/log.cc | 100 +++++++++++++++++++++++++++++++++++++++---------------- sql/log_event.cc | 1 + 2 files changed, 72 insertions(+), 29 deletions(-) (limited to 'sql') diff --git a/sql/log.cc b/sql/log.cc index af03cecd462..eca3cf32228 100644 --- a/sql/log.cc +++ b/sql/log.cc @@ -122,6 +122,20 @@ static int binlog_prepare(THD *thd, bool all) return 0; } +/** + This function is called once after each statement. + + It has the responsibility to flush the transaction cache to the + binlog file on commits. + + @param thd The client thread that executes the transaction. + @param all true if this is the last statement before a COMMIT + statement; false if either this is a statement in a + transaction but not the last, or if this is a statement + not inside a BEGIN block and autocommit is on. + + @see handlerton::commit +*/ static int binlog_commit(THD *thd, bool all) { IO_CACHE *trans_log= (IO_CACHE*)thd->ha_data[binlog_hton.slot]; @@ -134,7 +148,15 @@ static int binlog_commit(THD *thd, bool all) // we're here because trans_log was flushed in MYSQL_LOG::log_xid() DBUG_RETURN(0); } - if (all) + /* + Write commit event if at least one of the following holds: + - the user sends an explicit COMMIT; or + - the autocommit flag is on, and we are not inside a BEGIN. + However, if the user has not sent an explicit COMMIT, and we are + either inside a BEGIN or run with autocommit off, then this is not + the end of a transaction and we should not write a commit event. + */ + if (all || !(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) { Query_log_event qev(thd, STRING_WITH_LEN("COMMIT"), TRUE, FALSE); qev.error_code= 0; // see comment in MYSQL_LOG::write(THD, IO_CACHE) @@ -144,6 +166,22 @@ static int binlog_commit(THD *thd, bool all) DBUG_RETURN(binlog_end_trans(thd, trans_log, &invisible_commit)); } +/** + This function is called when a transaction involving a transactional + table is rolled back. + + It has the responsibility to flush the transaction cache to the + binlog file. However, if the transaction does not involve + non-transactional tables, nothing needs to be logged. + + @param thd The client thread that executes the transaction. + @param all true if this is the last statement before a COMMIT + statement; false if either this is a statement in a + transaction but not the last, or if this is a statement + not inside a BEGIN block and autocommit is on. + + @see handlerton::rollback +*/ static int binlog_rollback(THD *thd, bool all) { int error=0; @@ -1817,9 +1855,11 @@ uint MYSQL_LOG::next_file_id() IMPLEMENTATION - To support transaction over replication, we wrap the transaction with BEGIN/COMMIT or BEGIN/ROLLBACK in the binary log. - We want to write a BEGIN/ROLLBACK block when a non-transactional table - was updated in a transaction which was rolled back. This is to ensure - that the same updates are run on the slave. + If a transaction that only involves transactional tables is + rolled back, we do not binlog it. However, we write a + BEGIN/ROLLBACK block when a non-transactional table was updated + in a transaction which was rolled back. This is to ensure that + the same updates are run on the slave. */ bool MYSQL_LOG::write(THD *thd, IO_CACHE *cache, Log_event *commit_event) @@ -1837,32 +1877,34 @@ bool MYSQL_LOG::write(THD *thd, IO_CACHE *cache, Log_event *commit_event) byte header[LOG_EVENT_HEADER_LEN]; /* - Log "BEGIN" at the beginning of the transaction. - which may contain more than 1 SQL statement. + Log "BEGIN" at the beginning of every transaction. Here, a + transaction is either a BEGIN..COMMIT block or a single + statement in autocommit mode. */ - if (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) - { - Query_log_event qinfo(thd, STRING_WITH_LEN("BEGIN"), TRUE, FALSE); - /* - Imagine this is rollback due to net timeout, after all statements of - the transaction succeeded. Then we want a zero-error code in BEGIN. - In other words, if there was a really serious error code it's already - in the statement's events, there is no need to put it also in this - internally generated event, and as this event is generated late it - would lead to false alarms. - This is safer than thd->clear_error() against kills at shutdown. - */ - qinfo.error_code= 0; - /* - Now this Query_log_event has artificial log_pos 0. It must be adjusted - to reflect the real position in the log. Not doing it would confuse the - slave: it would prevent this one from knowing where he is in the - master's binlog, which would result in wrong positions being shown to - the user, MASTER_POS_WAIT undue waiting etc. - */ - if (qinfo.write(&log_file)) - goto err; - } + Query_log_event qinfo(thd, STRING_WITH_LEN("BEGIN"), TRUE, FALSE); + /* + Imagine this is rollback due to net timeout, after all + statements of the transaction succeeded. Then we want a + zero-error code in BEGIN. In other words, if there was a + really serious error code it's already in the statement's + events, there is no need to put it also in this internally + generated event, and as this event is generated late it would + lead to false alarms. + + This is safer than thd->clear_error() against kills at shutdown. + */ + qinfo.error_code= 0; + /* + Now this Query_log_event has artificial log_pos 0. It must be + adjusted to reflect the real position in the log. Not doing it + would confuse the slave: it would prevent this one from + knowing where he is in the master's binlog, which would result + in wrong positions being shown to the user, MASTER_POS_WAIT + undue waiting etc. + */ + if (qinfo.write(&log_file)) + goto err; + /* Read from the file used to cache the queries .*/ if (reinit_io_cache(cache, READ_CACHE, 0, 0, 0)) goto err; diff --git a/sql/log_event.cc b/sql/log_event.cc index 965dfb5f5cf..a950094a018 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -3793,6 +3793,7 @@ Xid_log_event(const char* buf, #ifndef MYSQL_CLIENT bool Xid_log_event::write(IO_CACHE* file) { + DBUG_EXECUTE_IF("do_not_write_xid", return 0;); return write_header(file, sizeof(xid)) || my_b_safe_write(file, (byte*) &xid, sizeof(xid)); } -- cgit v1.2.1 From 40d89c44ea03dcd3ad069bb59883272fc0a52b19 Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 21 Dec 2007 22:34:43 +0200 Subject: BUG#30435 loading large LOAD DATA INFILE breaks slave with read_buffer_size set on master BUG#33413 show binlog events fails if binlog has event size of close to max_allowed_packet The size of Append_block replication event was determined solely by read_buffer_size whereas the rest of replication code deals with max_allowed_packet. When the former parameter was set to larger than the latter there were two artifacts: the master could not read events from binlog; show master events did not show. Fixed with - fragmenting the used io-cached buffer into pieces each size of less than max_allowed_packet (bug#30435) - incrementing show-binlog-events handling thread's max_allowed_packet with the max estimated for the replication header size include/my_sys.h: accessor-macros added in order not to mess with the io cache's implementation details in code that merely exploits the io-cache. sql/sql_repl.cc: BUG#33413: incrementing thd->variables.max_allowed_packet with the max estimation for the replication header size (from bug#19402); refactoring log_loaded_block() to fragment the io_cache buffer in case read_buffer_size > max_allowed_packet. mysql-test/r/rpl_loaddata_map.result: New BitKeeper file ``mysql-test/r/rpl_loaddata_map.result'' mysql-test/t/rpl_loaddata_map-master.opt: specific options to trigger BUG#30435, BUG#33413 situations mysql-test/t/rpl_loaddata_map-slave.opt: max_allowed_packet to be compatible with the master's version. mysql-test/t/rpl_loaddata_map.test: regression tests for two bugs. --- sql/sql_repl.cc | 69 ++++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 44 insertions(+), 25 deletions(-) (limited to 'sql') diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc index 903d254db8f..c1ba33ce27d 100644 --- a/sql/sql_repl.cc +++ b/sql/sql_repl.cc @@ -1355,6 +1355,11 @@ bool mysql_show_binlog_events(THD* thd) if ((file=open_binlog(&log, linfo.log_file_name, &errmsg)) < 0) goto err; + /* + to account binlog event header size + */ + thd->variables.max_allowed_packet += MAX_LOG_EVENT_HEADER; + pthread_mutex_lock(log_lock); /* @@ -1365,7 +1370,6 @@ bool mysql_show_binlog_events(THD* thd) This code will fail on a mixed relay log (one which has Format_desc then Rotate then Format_desc). */ - ev = Log_event::read_log_event(&log,(pthread_mutex_t*)0,description_event); if (ev) { @@ -1556,37 +1560,52 @@ err: DBUG_RETURN(TRUE); } - +/** + Load data's io cache specific hook to be executed + before a chunk of data is being read into the cache's buffer + The fuction instantianates and writes into the binlog + replication events along LOAD DATA processing. + + @param file pointer to io-cache + @return 0 +*/ int log_loaded_block(IO_CACHE* file) { + DBUG_ENTER("log_loaded_block"); LOAD_FILE_INFO *lf_info; - uint block_len ; - - /* file->request_pos contains position where we started last read */ - char* buffer = (char*) file->request_pos; - if (!(block_len = (char*) file->read_end - (char*) buffer)) - return 0; - lf_info = (LOAD_FILE_INFO*) file->arg; + uint block_len; + /* buffer contains position where we started last read */ + char* buffer= my_b_get_buffer_start(file); + uint max_event_size= current_thd->variables.max_allowed_packet; + lf_info= (LOAD_FILE_INFO*) file->arg; if (lf_info->last_pos_in_file != HA_POS_ERROR && - lf_info->last_pos_in_file >= file->pos_in_file) + lf_info->last_pos_in_file >= my_b_get_pos_in_file(file)) return 0; - lf_info->last_pos_in_file = file->pos_in_file; - if (lf_info->wrote_create_file) - { - Append_block_log_event a(lf_info->thd, lf_info->thd->db, buffer, - block_len, lf_info->log_delayed); - mysql_bin_log.write(&a); - } - else + + for (block_len= my_b_get_bytes_in_buffer(file); block_len > 0; + buffer += min(block_len, max_event_size), + block_len -= min(block_len, max_event_size)) { - Begin_load_query_log_event b(lf_info->thd, lf_info->thd->db, - buffer, block_len, - lf_info->log_delayed); - mysql_bin_log.write(&b); - lf_info->wrote_create_file = 1; - DBUG_SYNC_POINT("debug_lock.created_file_event",10); + lf_info->last_pos_in_file= my_b_get_pos_in_file(file); + if (lf_info->wrote_create_file) + { + Append_block_log_event a(lf_info->thd, lf_info->thd->db, buffer, + min(block_len, max_event_size), + lf_info->log_delayed); + mysql_bin_log.write(&a); + } + else + { + Begin_load_query_log_event b(lf_info->thd, lf_info->thd->db, + buffer, + min(block_len, max_event_size), + lf_info->log_delayed); + mysql_bin_log.write(&b); + lf_info->wrote_create_file= 1; + DBUG_SYNC_POINT("debug_lock.created_file_event",10); + } } - return 0; + DBUG_RETURN(0); } #endif /* HAVE_REPLICATION */ -- cgit v1.2.1 From 7e555be488181ca12bb533d847a704c68f3adfb0 Mon Sep 17 00:00:00 2001 From: unknown Date: Sun, 6 Jan 2008 20:16:28 +0800 Subject: Replace one overlooked return with DBUG_RETURN in function log_loaded_block --- sql/sql_repl.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sql') diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc index 7787a0980fd..f2312afa878 100644 --- a/sql/sql_repl.cc +++ b/sql/sql_repl.cc @@ -1578,7 +1578,7 @@ int log_loaded_block(IO_CACHE* file) lf_info= (LOAD_FILE_INFO*) file->arg; if (lf_info->last_pos_in_file != HA_POS_ERROR && lf_info->last_pos_in_file >= my_b_get_pos_in_file(file)) - return 0; + DBUG_RETURN(0); for (block_len= my_b_get_bytes_in_buffer(file); block_len > 0; buffer += min(block_len, max_event_size), -- cgit v1.2.1 From ac167eca6edba627d737f72fe7ae7dfc20da91b5 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 9 Jan 2008 12:55:04 +0100 Subject: Post-merge fixes to make tests pass. mysql-test/r/binlog_start_comment.result: Result change. mysql-test/suite/rpl/r/rpl_row_tabledefs_2myisam.result: Result change. mysql-test/suite/rpl/r/rpl_row_tabledefs_3innodb.result: Result change. mysql-test/suite/rpl/r/rpl_timezone.result: Result change. mysql-test/suite/rpl_ndb/r/rpl_ndb_transaction.result: Result change. mysql-test/suite/rpl_ndb/t/rpl_ndb_transaction.test: Masking out columns with binlog positions from slave status. mysql-test/t/binlog_start_comment.test: Added missing drop table causing subsequent tests to fail. sql/log_event.cc: Changing last_err* fields to client_last_err* sql/log_event_old.cc: Changing last_err* fields to client_last_err* --- sql/log_event.cc | 6 +++--- sql/log_event_old.cc | 33 +++++++++++++++++---------------- 2 files changed, 20 insertions(+), 19 deletions(-) (limited to 'sql') diff --git a/sql/log_event.cc b/sql/log_event.cc index c78c0d0862a..a8099e9db8a 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -112,14 +112,14 @@ static void inline slave_rows_error_report(enum loglevel level, int ha_error, const char *log_name, ulong pos) { const char *handler_error= HA_ERR(ha_error); - rli->report(level, thd->net.last_errno, + rli->report(level, thd->net.client_last_errno, "Could not execute %s event on table %s.%s;" "%s%s handler error %s; " "the event's master log %s, end_log_pos %lu", type, table->s->db.str, table->s->table_name.str, - thd->net.last_error[0] != 0 ? thd->net.last_error : "", - thd->net.last_error[0] != 0 ? ";" : "", + thd->net.client_last_error[0] != 0 ? thd->net.client_last_error : "", + thd->net.client_last_error[0] != 0 ? ";" : "", handler_error == NULL? "" : handler_error, log_name, pos); } diff --git a/sql/log_event_old.cc b/sql/log_event_old.cc index 5091d5a5107..7621bdc6291 100644 --- a/sql/log_event_old.cc +++ b/sql/log_event_old.cc @@ -1529,10 +1529,10 @@ int Old_rows_log_event::do_apply_event(Relay_log_info const *rli) 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; + uint actual_error= thd->net.client_last_errno; rli->report(ERROR_LEVEL, actual_error, "Error '%s' in %s event: when locking tables", - (actual_error ? thd->net.last_error : + (actual_error ? thd->net.client_last_error : "unexpected success or fatal error"), get_type_str()); thd->is_fatal_error= 1; @@ -1573,10 +1573,10 @@ int Old_rows_log_event::do_apply_event(Relay_log_info const *rli) 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; + uint actual_error= thd->net.client_last_errno; rli->report(ERROR_LEVEL, actual_error, "Error '%s' on reopening tables", - (actual_error ? thd->net.last_error : + (actual_error ? thd->net.client_last_error : "unexpected success or fatal error")); thd->is_slave_error= 1; } @@ -1729,10 +1729,10 @@ int Old_rows_log_event::do_apply_event(Relay_log_info const *rli) break; default: - rli->report(ERROR_LEVEL, thd->net.last_errno, + rli->report(ERROR_LEVEL, thd->net.client_last_errno, "Error in %s event: row application failed. %s", get_type_str(), - thd->net.last_error ? thd->net.last_error : ""); + thd->net.client_last_error ? thd->net.client_last_error : ""); thd->is_slave_error= 1; break; } @@ -1779,12 +1779,12 @@ int Old_rows_log_event::do_apply_event(Relay_log_info const *rli) if (error) { /* error has occured during the transaction */ - rli->report(ERROR_LEVEL, thd->net.last_errno, + rli->report(ERROR_LEVEL, thd->net.client_last_errno, "Error in %s event: error during transaction execution " "on table %s.%s. %s", get_type_str(), table->s->db.str, table->s->table_name.str, - thd->net.last_error ? thd->net.last_error : ""); + thd->net.client_last_error ? thd->net.client_last_error : ""); /* If one day we honour --skip-slave-errors in row-based replication, and @@ -1909,12 +1909,13 @@ Old_rows_log_event::do_update_pos(Relay_log_info *rli) rli->stmt_done(log_pos, when); /* - Clear any errors pushed in thd->net.last_err* if for example "no key - found" (as this is allowed). This is a safety measure; apparently - those errors (e.g. when executing a Delete_rows_log_event_old of a - non-existing row, like in rpl_row_mystery22.test, - thd->net.last_error = "Can't find record in 't1'" and last_errno=1032) - do not become visible. We still prefer to wipe them out. + Clear any errors pushed in thd->net.client_last_err* if for + example "no key found" (as this is allowed). This is a safety + measure; apparently those errors (e.g. when executing a + Delete_rows_log_event_old of a non-existing row, like in + rpl_row_mystery22.test, thd->net.client_last_error = "Can't + find record in 't1'" and last_errno=1032) do not become + visible. We still prefer to wipe them out. */ thd->clear_error(); } @@ -2646,8 +2647,8 @@ Write_rows_log_event_old::do_exec_row(const Relay_log_info *const rli) DBUG_ASSERT(m_table != NULL); int error= write_row(rli, TRUE /* overwrite */); - if (error && !thd->net.last_errno) - thd->net.last_errno= error; + if (error && !thd->net.client_last_errno) + thd->net.client_last_errno= error; return error; } -- cgit v1.2.1 From 3a6e84a2b36d6bf49bedc6f0e4f97b79220456d2 Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 10 Jan 2008 16:39:44 +0100 Subject: BUG#27779: Slave cannot read old rows log events. Problem: Replication fails when master is mysql-5.1-wl2325-5.0-drop6 and slave is mysql-5.1-new-rpl. The reason is that, in mysql-5.1-wl2325-5.0-drop6, the event type id's were different than in mysql-5.1-new-rpl. Fix (in mysql-5.1-new-rpl): (1) detect that the server that generated the events uses the old format, by checking the server version of the format_description_log_event This patch recognizes mysql-5.1-wl2325-5.0-drop6p13-alpha, mysql-5.1-wl2325-5.0-drop6, mysql-5.1-wl2325-5.0, mysql-5.1-wl2325-no-dd. (2) if the generating server is old, map old event types to new event types using a permutation array. I've also added a test case which reads binlogs for four different versions. mysql-test/suite/binlog/std_data/binlog_old_version_5_1-telco.000001: BitKeeper file /home/sven/bk/b27779-old_row_events/5.1-new-rpl/mysql-test/suite/binlog/std_data/binlog_old_version_5_1-telco.000001 mysql-test/suite/binlog/std_data/binlog_old_version_5_1-wl2325_row.000001: BitKeeper file /home/sven/bk/b27779-old_row_events/5.1-new-rpl/mysql-test/suite/binlog/std_data/binlog_old_version_5_1-wl2325_row.000001 mysql-test/suite/binlog/std_data/binlog_old_version_5_1-wl2325_stm.000001: BitKeeper file /home/sven/bk/b27779-old_row_events/5.1-new-rpl/mysql-test/suite/binlog/std_data/binlog_old_version_5_1-wl2325_stm.000001 mysql-test/suite/binlog/std_data/binlog_old_version_5_1_17.000001: BitKeeper file /home/sven/bk/b27779-old_row_events/5.1-new-rpl/mysql-test/suite/binlog/std_data/binlog_old_version_5_1_17.000001 mysql-test/suite/binlog/std_data/binlog_old_version_5_1_23.000001: BitKeeper file /home/sven/bk/b27779-old_row_events/5.1-new-rpl/mysql-test/suite/binlog/std_data/binlog_old_version_5_1_23.000001 sql/log_event.cc: Added code to read events generated by mysql-5.1-wl2325-5.0-drop6p13-alpha, mysql-5.1-wl2325-5.0-drop6, mysql-5.1-wl2325-5.0, mysql-5.1-wl2325-no-dd. More precisely, the event type id's had different numbers in those versions. To fix, we add a permutation array which maps old_id to new_id when the format_description_log_event indicates that the originating server is of the old type. We also need to permute the post_header_len array accordingly. sql/log_event.h: sql/log_event.h@1.169, 2008-01-09 11:34:37+01:00, sven@riska.(none) +5 -1 Added declaration needed in log_event.cc. Also, the destructor of Format_description_log_event is sometimes called when post_header_len is null, so we must pass the MY_ALLOW_ZERO_PTR flag to my_free. mysql-test/suite/binlog/r/binlog_old_versions.result: Result file for new test. mysql-test/suite/binlog/t/binlog_old_versions.test: New test case that loads binlogs from several old versions. --- sql/log_event.cc | 86 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-- sql/log_event.h | 6 +++- 2 files changed, 89 insertions(+), 3 deletions(-) (limited to 'sql') diff --git a/sql/log_event.cc b/sql/log_event.cc index 31c14bbd81d..45478020a36 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -1071,6 +1071,29 @@ Log_event* Log_event::read_log_event(const char* buf, uint event_len, } else { + /* + In some previuos versions (see comment in + Format_description_log_event::Format_description_log_event(char*,...)), + event types were assigned different id numbers than in the + present version. In order to replicate from such versions to the + present version, we must map those event type id's to our event + type id's. The mapping is done with the event_type_permutation + array, which was set up when the Format_description_log_event + was read. + */ + if (description_event->event_type_permutation) + { + IF_DBUG({ + int new_event_type= + description_event->event_type_permutation[event_type]; + DBUG_PRINT("info", + ("converting event type %d to %d (%s)", + event_type, new_event_type, + get_type_str((Log_event_type)new_event_type))); + }); + event_type= description_event->event_type_permutation[event_type]; + } + switch(event_type) { case QUERY_EVENT: ev = new Query_log_event(buf, event_len, description_event, QUERY_EVENT); @@ -2771,7 +2794,7 @@ int Start_log_event_v3::do_apply_event(Relay_log_info const *rli) Format_description_log_event:: Format_description_log_event(uint8 binlog_ver, const char* server_ver) - :Start_log_event_v3() + :Start_log_event_v3(), event_type_permutation(0) { binlog_version= binlog_ver; switch (binlog_ver) { @@ -2896,7 +2919,7 @@ Format_description_log_event(const char* buf, const Format_description_log_event* description_event) - :Start_log_event_v3(buf, description_event) + :Start_log_event_v3(buf, description_event), event_type_permutation(0) { DBUG_ENTER("Format_description_log_event::Format_description_log_event(char*,...)"); buf+= LOG_EVENT_MINIMAL_HEADER_LEN; @@ -2911,6 +2934,65 @@ Format_description_log_event(const char* buf, number_of_event_types* sizeof(*post_header_len), MYF(0)); calc_server_version_split(); + + /* + In some previous versions, the events were given other event type + id numbers than in the present version. When replicating from such + a version, we therefore set up an array that maps those id numbers + to the id numbers of the present server. + + If post_header_len is null, it means malloc failed, and is_valid + will fail, so there is no need to do anything. + + The trees which have wrong event id's are: + mysql-5.1-wl2325-5.0-drop6p13-alpha, mysql-5.1-wl2325-5.0-drop6, + mysql-5.1-wl2325-5.0, mysql-5.1-wl2325-no-dd (`grep -C2 + BEGIN_LOAD_QUERY_EVENT /home/bk/ * /sql/log_event.h`). The + corresponding version (`grep mysql, configure.in` in those trees) + strings are 5.2.2-a_drop6p13-alpha, 5.2.2-a_drop6p13c, + 5.1.5-a_drop5p20, 5.1.2-a_drop5p5. + */ + if (post_header_len && + (strncmp(server_version, "5.1.2-a_drop5", 13) == 0 || + strncmp(server_version, "5.1.5-a_drop5", 13) == 0 || + strncmp(server_version, "5.2.2-a_drop6", 13) == 0)) + { + if (number_of_event_types != 22) + { + DBUG_PRINT("info", (" number_of_event_types=%d", + number_of_event_types)); + /* this makes is_valid() return false. */ + my_free(post_header_len, MYF(MY_ALLOW_ZERO_PTR)); + post_header_len= NULL; + DBUG_VOID_RETURN; + } + static const uint8 perm[23]= + { + UNKNOWN_EVENT, START_EVENT_V3, QUERY_EVENT, STOP_EVENT, ROTATE_EVENT, + INTVAR_EVENT, LOAD_EVENT, SLAVE_EVENT, CREATE_FILE_EVENT, + APPEND_BLOCK_EVENT, EXEC_LOAD_EVENT, DELETE_FILE_EVENT, + NEW_LOAD_EVENT, + RAND_EVENT, USER_VAR_EVENT, + FORMAT_DESCRIPTION_EVENT, + TABLE_MAP_EVENT, + PRE_GA_WRITE_ROWS_EVENT, + PRE_GA_UPDATE_ROWS_EVENT, + PRE_GA_DELETE_ROWS_EVENT, + XID_EVENT, + BEGIN_LOAD_QUERY_EVENT, + EXECUTE_LOAD_QUERY_EVENT, + }; + event_type_permutation= perm; + /* + Since we use (permuted) event id's to index the post_header_len + array, we need to permute the post_header_len array too. + */ + uint8 post_header_len_temp[23]; + for (int i= 1; i < 23; i++) + post_header_len_temp[perm[i] - 1]= post_header_len[i - 1]; + for (int i= 0; i < 22; i++) + post_header_len[i] = post_header_len_temp[i]; + } DBUG_VOID_RETURN; } diff --git a/sql/log_event.h b/sql/log_event.h index 4a75f330203..31c1ab7173a 100644 --- a/sql/log_event.h +++ b/sql/log_event.h @@ -2106,12 +2106,16 @@ public: /* The list of post-headers' lengthes */ uint8 *post_header_len; uchar server_version_split[3]; + const uint8 *event_type_permutation; 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)); } + ~Format_description_log_event() + { + my_free((uchar*)post_header_len, MYF(MY_ALLOW_ZERO_PTR)); + } Log_event_type get_type_code() { return FORMAT_DESCRIPTION_EVENT;} #ifndef MYSQL_CLIENT bool write(IO_CACHE* file); -- cgit v1.2.1 From d2b4d051ea9b40ab8f3950270fa2d0777f3108bc Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 25 Jan 2008 15:02:26 +0800 Subject: BUG#33862 completely failed DROP USER statement gets replicated The problem is when create/rename/drop users, the statement was logged regardless of error, even if no data has been changed, the statement was logged. After this patch, create/rename/drop users don't write the binlog if the statement makes no changes, if the statement does make any changes, log the statement with possible error code. This patch is based on the patch for BUG#29749, which is not pushed sql/sql_acl.cc: when create/rename/drop users, don't write the binlog if the statement make no changes mysql-test/r/rpl_user.result: New BitKeeper file ``mysql-test/r/rpl_user.result'' mysql-test/t/rpl_user.test: New BitKeeper file ``mysql-test/t/rpl_user.test'' --- sql/sql_acl.cc | 24 +++++++++++++++++------- 1 file changed, 17 insertions(+), 7 deletions(-) (limited to 'sql') diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc index 1850821a287..a5140d6f7d0 100644 --- a/sql/sql_acl.cc +++ b/sql/sql_acl.cc @@ -5333,6 +5333,7 @@ bool mysql_create_user(THD *thd, List &list) LEX_USER *user_name, *tmp_user_name; List_iterator user_list(list); TABLE_LIST tables[GRANT_TABLES]; + bool some_users_created= FALSE; DBUG_ENTER("mysql_create_user"); /* CREATE USER may be skipped on replication client. */ @@ -5361,6 +5362,7 @@ bool mysql_create_user(THD *thd, List &list) continue; } + some_users_created= TRUE; sql_mode= thd->variables.sql_mode; if (replace_user_table(thd, tables[0].table, *user_name, 0, 0, 1, 0)) { @@ -5371,7 +5373,10 @@ bool mysql_create_user(THD *thd, List &list) VOID(pthread_mutex_unlock(&acl_cache->lock)); - if (mysql_bin_log.is_open()) + if (result) + my_error(ER_CANNOT_USER, MYF(0), "CREATE USER", wrong_users.c_ptr_safe()); + + if (some_users_created && mysql_bin_log.is_open()) { Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE); mysql_bin_log.write(&qinfo); @@ -5379,8 +5384,6 @@ bool mysql_create_user(THD *thd, List &list) rw_unlock(&LOCK_grant); close_thread_tables(thd); - if (result) - my_error(ER_CANNOT_USER, MYF(0), "CREATE USER", wrong_users.c_ptr_safe()); DBUG_RETURN(result); } @@ -5405,6 +5408,7 @@ bool mysql_drop_user(THD *thd, List &list) LEX_USER *user_name, *tmp_user_name; List_iterator user_list(list); TABLE_LIST tables[GRANT_TABLES]; + bool some_users_deleted= FALSE; DBUG_ENTER("mysql_drop_user"); /* DROP USER may be skipped on replication client. */ @@ -5426,7 +5430,9 @@ bool mysql_drop_user(THD *thd, List &list) { append_user(&wrong_users, user_name); result= TRUE; + continue; } + some_users_deleted= TRUE; } /* Rebuild 'acl_check_hosts' since 'acl_users' has been modified */ @@ -5440,7 +5446,7 @@ bool mysql_drop_user(THD *thd, List &list) DBUG_PRINT("info", ("thd->net.last_errno: %d", thd->net.last_errno)); DBUG_PRINT("info", ("thd->net.last_error: %s", thd->net.last_error)); - if (mysql_bin_log.is_open()) + if (some_users_deleted && mysql_bin_log.is_open()) { Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE); mysql_bin_log.write(&qinfo); @@ -5473,6 +5479,7 @@ bool mysql_rename_user(THD *thd, List &list) LEX_USER *user_to, *tmp_user_to; List_iterator user_list(list); TABLE_LIST tables[GRANT_TABLES]; + bool some_users_renamed= FALSE; DBUG_ENTER("mysql_rename_user"); /* RENAME USER may be skipped on replication client. */ @@ -5506,7 +5513,9 @@ bool mysql_rename_user(THD *thd, List &list) { append_user(&wrong_users, user_from); result= TRUE; + continue; } + some_users_renamed= TRUE; } /* Rebuild 'acl_check_hosts' since 'acl_users' has been modified */ @@ -5514,7 +5523,10 @@ bool mysql_rename_user(THD *thd, List &list) VOID(pthread_mutex_unlock(&acl_cache->lock)); - if (mysql_bin_log.is_open()) + if (result) + my_error(ER_CANNOT_USER, MYF(0), "RENAME USER", wrong_users.c_ptr_safe()); + + if (some_users_renamed && mysql_bin_log.is_open()) { Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE); mysql_bin_log.write(&qinfo); @@ -5522,8 +5534,6 @@ bool mysql_rename_user(THD *thd, List &list) rw_unlock(&LOCK_grant); close_thread_tables(thd); - if (result) - my_error(ER_CANNOT_USER, MYF(0), "RENAME USER", wrong_users.c_ptr_safe()); DBUG_RETURN(result); } -- cgit v1.2.1 From 5a039fa28bd9660c2f939452c4f0af732cbecfc3 Mon Sep 17 00:00:00 2001 From: unknown Date: Tue, 29 Jan 2008 11:56:48 +0800 Subject: BUG#26489 Corruption in relay logs Here is the scenario that causes the failure.(by Mats) 1. The to-be corrupt log event (let's call it X), is split into two packets B and C on the network level (net_write_buff()). The parts are X = (x',x''). The part x' ends up in packet B and part x'' ends up in packet C. Prior to the corrupt event X, the event Y has been written successfully, but has been split into two packets as well, which we call (y',y''). 2. The master sends packet A = (y'',x') to the slave, increases the packet sequence number, the slave receives the packet, but fails to reply before the master gets a timeout. 3. Since the master got a timeout, it reports failure, and aborts sending the binary log by exiting mysql_binlog_send(). However, it leaves the buffer intact, still holding y'' (but not x', since the write_pos is not increased). 4. After exiting mysql_binlog_send(), the master does a disconnection of the client thread, which involves sending an error message e to the client (i.e., the slave). 5. In this case, net_write_buff() is used again, but this time the old contents of the packet is used so that the new packet is D = (y'',e). Note that this will use a new packet sequence number, since the packet number was increased in step 2. 6. The slave receives the tail y'' of the Y log event, concatenates this with x' (which it already received), and writes the event (x',y'') it to the relay log since it hasn't noticed anything is amiss. 7. It then tries to read more bytes, which is either e (if the length given for X just happened to match the length given for Y, or just plain garbage because the slave is out of sync with what is actually sent. 8. After a while, the SQL thread tries to execute the event (x',y''), which is very likely to be just nonsense. The problem can be fixed by not resetting net->error after the call of mysql_binlog_send, so the error message will not be sent and the connection will be closed. sql/sql_parse.cc: Do not reset net->error, if net->error == 2, we should not try to use the connection again --- sql/sql_parse.cc | 1 - 1 file changed, 1 deletion(-) (limited to 'sql') diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index 16a64c48cdd..a3547787e86 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -1999,7 +1999,6 @@ bool dispatch_command(enum enum_server_command command, THD *thd, unregister_slave(thd,1,1); /* fake COM_QUIT -- if we get here, the thread needs to terminate */ error = TRUE; - net->error = 0; break; } #endif -- cgit v1.2.1 From 101c30ccc48d38c3ea98ebd89a350120a45aa591 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 30 Jan 2008 16:03:00 +0100 Subject: Post-merge changes. BitKeeper/deleted/.del-show_binlog_events2.inc: Delete: mysql-test/include/show_binlog_events2.inc client/mysqlbinlog.cc: char -> uchar for raw memory. sql/item_cmpfunc.cc: Adding cast to remove warning when converting negative integer to unsigned type. sql/log_event.cc: char -> uchar for raw memory. sql/log_event.h: char -> uchar for raw memory. sql/rpl_utility.cc: Adding cast to remove warning when converting negative integer to unsigned type. sql/slave.cc: char -> uchar for raw memory. sql/sql_repl.cc: char -> uchar for raw memory. sql-common/client.c: char -> uchar for raw memory. --- sql/item_cmpfunc.cc | 2 +- sql/log_event.cc | 10 +++++----- sql/log_event.h | 10 +++++----- sql/rpl_utility.cc | 2 +- sql/slave.cc | 4 ++-- sql/sql_repl.cc | 2 +- 6 files changed, 15 insertions(+), 15 deletions(-) (limited to 'sql') diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc index 006846b147f..bca00b08f78 100644 --- a/sql/item_cmpfunc.cc +++ b/sql/item_cmpfunc.cc @@ -947,7 +947,7 @@ get_datetime_value(THD *thd, Item ***item_arg, Item **cache_arg, *is_null= item->null_value; } if (*is_null) - return -1; + return ~(ulonglong) -1; /* Convert strings to the integer DATE/DATETIME representation. Even if both dates provided in strings we can't compare them directly as diff --git a/sql/log_event.cc b/sql/log_event.cc index 45478020a36..82d29322b4a 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -5064,7 +5064,7 @@ Create_file_log_event(THD* thd_arg, sql_exchange* ex, const char* db_arg, const char* table_name_arg, List& fields_arg, enum enum_duplicates handle_dup, bool ignore, - char* block_arg, uint block_len_arg, bool using_trans) + uchar* block_arg, uint block_len_arg, bool using_trans) :Load_log_event(thd_arg,ex,db_arg,table_name_arg,fields_arg,handle_dup, ignore, using_trans), fake_base(0), block(block_arg), event_buf(0), block_len(block_len_arg), @@ -5163,7 +5163,7 @@ Create_file_log_event::Create_file_log_event(const char* buf, uint len, create_file_header_len + 1); if (len < block_offset) DBUG_VOID_RETURN; - block = (char*)buf + block_offset; + block = (uchar*)buf + block_offset; block_len = len - block_offset; } else @@ -5321,7 +5321,7 @@ err: #ifndef MYSQL_CLIENT Append_block_log_event::Append_block_log_event(THD *thd_arg, const char *db_arg, - char *block_arg, + uchar *block_arg, uint block_len_arg, bool using_trans) :Log_event(thd_arg,0, using_trans), block(block_arg), @@ -5347,7 +5347,7 @@ Append_block_log_event::Append_block_log_event(const char* buf, uint len, if (len < total_header_len) DBUG_VOID_RETURN; file_id= uint4korr(buf + common_header_len + AB_FILE_ID_OFFSET); - block= (char*)buf + total_header_len; + block= (uchar*)buf + total_header_len; block_len= len - total_header_len; DBUG_VOID_RETURN; } @@ -5739,7 +5739,7 @@ err: #ifndef MYSQL_CLIENT Begin_load_query_log_event:: -Begin_load_query_log_event(THD* thd_arg, const char* db_arg, char* block_arg, +Begin_load_query_log_event(THD* thd_arg, const char* db_arg, uchar* block_arg, uint block_len_arg, bool using_trans) :Append_block_log_event(thd_arg, db_arg, block_arg, block_len_arg, using_trans) diff --git a/sql/log_event.h b/sql/log_event.h index 31c1ab7173a..efb8675780e 100644 --- a/sql/log_event.h +++ b/sql/log_event.h @@ -2519,7 +2519,7 @@ protected: */ bool fake_base; public: - char* block; + uchar* block; const char *event_buf; uint block_len; uint file_id; @@ -2530,7 +2530,7 @@ public: const char* table_name_arg, List& fields_arg, enum enum_duplicates handle_dup, bool ignore, - char* block_arg, uint block_len_arg, + uchar* block_arg, uint block_len_arg, bool using_trans); #ifdef HAVE_REPLICATION void pack_info(Protocol* protocol); @@ -2585,7 +2585,7 @@ private: class Append_block_log_event: public Log_event { public: - char* block; + uchar* block; uint block_len; uint file_id; /* @@ -2602,7 +2602,7 @@ public: const char* db; #ifndef MYSQL_CLIENT - Append_block_log_event(THD* thd, const char* db_arg, char* block_arg, + Append_block_log_event(THD* thd, const char* db_arg, uchar* block_arg, uint block_len_arg, bool using_trans); #ifdef HAVE_REPLICATION void pack_info(Protocol* protocol); @@ -2726,7 +2726,7 @@ 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, + uchar* block_arg, uint block_len_arg, bool using_trans); #ifdef HAVE_REPLICATION Begin_load_query_log_event(THD* thd); diff --git a/sql/rpl_utility.cc b/sql/rpl_utility.cc index b3ca26d4c2c..b548550ef54 100644 --- a/sql/rpl_utility.cc +++ b/sql/rpl_utility.cc @@ -164,7 +164,7 @@ uint32 table_def::calc_field_size(uint col, uchar *master_data) const break; } default: - length= -1; + length= ~(uint32) -1; } return length; } diff --git a/sql/slave.cc b/sql/slave.cc index 14fa1c45c36..75e16e149fa 100644 --- a/sql/slave.cc +++ b/sql/slave.cc @@ -2823,7 +2823,7 @@ static int process_io_create_file(Master_info* mi, Create_file_log_event* cev) } if (unlikely(cev_not_written)) { - cev->block = (char*)net->read_pos; + cev->block = net->read_pos; cev->block_len = num_bytes; if (unlikely(mi->rli.relay_log.append(cev))) { @@ -2837,7 +2837,7 @@ static int process_io_create_file(Master_info* mi, Create_file_log_event* cev) } else { - aev.block = (char*)net->read_pos; + aev.block = net->read_pos; aev.block_len = num_bytes; aev.log_pos = cev->log_pos; if (unlikely(mi->rli.relay_log.append(&aev))) diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc index 49c4f089298..534a8da645f 100644 --- a/sql/sql_repl.cc +++ b/sql/sql_repl.cc @@ -1595,7 +1595,7 @@ int log_loaded_block(IO_CACHE* file) LOAD_FILE_INFO *lf_info; uint block_len; /* buffer contains position where we started last read */ - char* buffer= my_b_get_buffer_start(file); + uchar* buffer= my_b_get_buffer_start(file); uint max_event_size= current_thd->variables.max_allowed_packet; lf_info= (LOAD_FILE_INFO*) file->arg; if (lf_info->thd->current_stmt_binlog_row_based) -- cgit v1.2.1 From b0283afb9c19033047d304eb0d31b29b971bf971 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 30 Jan 2008 17:35:25 +0100 Subject: Fixing return value. sql/item_cmpfunc.cc: Minor fix to return correct value in case of error. sql/rpl_utility.cc: Minor fix to return correct value in case of error. --- sql/item_cmpfunc.cc | 2 +- sql/rpl_utility.cc | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'sql') diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc index bca00b08f78..c16500a2712 100644 --- a/sql/item_cmpfunc.cc +++ b/sql/item_cmpfunc.cc @@ -947,7 +947,7 @@ get_datetime_value(THD *thd, Item ***item_arg, Item **cache_arg, *is_null= item->null_value; } if (*is_null) - return ~(ulonglong) -1; + return ~(ulonglong) 0; /* Convert strings to the integer DATE/DATETIME representation. Even if both dates provided in strings we can't compare them directly as diff --git a/sql/rpl_utility.cc b/sql/rpl_utility.cc index b548550ef54..4f4083d9b8f 100644 --- a/sql/rpl_utility.cc +++ b/sql/rpl_utility.cc @@ -164,7 +164,7 @@ uint32 table_def::calc_field_size(uint col, uchar *master_data) const break; } default: - length= ~(uint32) -1; + length= ~(uint32) 0; } return length; } -- cgit v1.2.1 From 34b9c6f50403001eaf1114d2f6241b6e0938cc5d Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 31 Jan 2008 07:19:29 +0100 Subject: Fixes to make code compile on Windows. sql/sql_repl.cc: Adding cast to remove compile error on Windows platform. --- sql/sql_repl.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sql') diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc index f2312afa878..5bbff69f197 100644 --- a/sql/sql_repl.cc +++ b/sql/sql_repl.cc @@ -1573,7 +1573,7 @@ int log_loaded_block(IO_CACHE* file) LOAD_FILE_INFO *lf_info; uint block_len; /* buffer contains position where we started last read */ - char* buffer= my_b_get_buffer_start(file); + char* buffer= (char*) my_b_get_buffer_start(file); uint max_event_size= current_thd->variables.max_allowed_packet; lf_info= (LOAD_FILE_INFO*) file->arg; if (lf_info->last_pos_in_file != HA_POS_ERROR && -- cgit v1.2.1