Relay_log_info Class Reference

Inheritance diagram for Relay_log_info:

Collaboration diagram for Relay_log_info:

Public Types
enum	enum_state_flag { IN_STMT, STATE_FLAGS_COUNT }
enum	{   UNTIL_NONE = 0, UNTIL_MASTER_POS, UNTIL_RELAY_POS, UNTIL_SQL_BEFORE_GTIDS,   UNTIL_SQL_AFTER_GTIDS, UNTIL_SQL_AFTER_MTS_GAPS, UNTIL_DONE }
enum	{ UNTIL_LOG_NAMES_CMP_UNKNOWN = -2, UNTIL_LOG_NAMES_CMP_LESS = -1, UNTIL_LOG_NAMES_CMP_EQUAL = 0, UNTIL_LOG_NAMES_CMP_GREATER = 1 }
enum	{ MTS_NOT_IN_GROUP, MTS_IN_GROUP, MTS_END_GROUP, MTS_KILLED_GROUP }

Public Member Functions
bool	belongs_to_client ()
int	add_logged_gtid (rpl_sidno sidno, rpl_gno gno)
const Gtid_set *	get_gtid_set () const
int	init_relay_log_pos (const char *log, ulonglong pos, bool need_data_lock, const char **errmsg, bool look_for_description_event)
void	clear_until_condition ()
void	clear_sql_delay ()
void	notify_group_relay_log_name_update ()
void	notify_group_master_log_name_update ()
void	inc_event_relay_log_pos ()
int	inc_group_relay_log_pos (ulonglong log_pos, bool need_data_lock)
int	wait_for_pos (THD *thd, String *log_name, longlong log_pos, longlong timeout)
int	wait_for_gtid_set (THD *thd, String *gtid, longlong timeout)
void	close_temporary_tables ()
bool	is_until_satisfied (THD *thd, Log_event *ev)
ulonglong	until_pos ()
bool	get_table_data (TABLE *table_arg, table_def **tabledef_var, TABLE **conv_table_var) const
void	cached_charset_invalidate ()
bool	cached_charset_compare (char *charset) const
void	cleanup_context (THD *, bool)
void	slave_close_thread_tables (THD *)
void	clear_tables_to_lock ()
int	purge_relay_logs (THD *thd, bool just_reset, const char **errmsg)
void	init_workers (ulong)
void	deinit_workers ()
bool	is_mts_recovery () const
bool	is_parallel_exec () const
bool	is_mts_in_group ()
void	reset_notified_relay_log_change ()
void	reset_notified_checkpoint (ulong, time_t, bool)
bool	mts_finalize_recovery ()
void	cleanup_after_query ()
void	cleanup_after_session ()
int	stmt_done (my_off_t event_log_pos)
void	set_flag (enum_state_flag flag)
bool	get_flag (enum_state_flag flag)
void	clear_flag (enum_state_flag flag)
bool	is_in_group () const
int	count_relay_log_space ()
int	rli_init_info ()
void	end_info ()
int	flush_info (bool force=FALSE)
int	flush_current_log ()
void	set_master_info (Master_info *info)
ulonglong	get_future_event_relay_log_pos ()
void	set_future_event_relay_log_pos (ulonglong log_pos)
const char *	get_group_master_log_name ()
ulonglong	get_group_master_log_pos ()
void	set_group_master_log_name (const char *log_file_name)
void	set_group_master_log_pos (ulonglong log_pos)
const char *	get_group_relay_log_name ()
ulonglong	get_group_relay_log_pos ()
void	set_group_relay_log_name (const char *log_file_name)
void	set_group_relay_log_name (const char *log_file_name, size_t len)
void	set_group_relay_log_pos (ulonglong log_pos)
const char *	get_event_relay_log_name ()
ulonglong	get_event_relay_log_pos ()
void	set_event_relay_log_name (const char *log_file_name)
void	set_event_relay_log_name (const char *log_file_name, size_t len)
void	set_event_relay_log_pos (ulonglong log_pos)
const char *	get_rpl_log_name ()
ulonglong	get_future_master_log_pos ()
void	start_sql_delay (time_t delay_end)
int32	get_sql_delay ()
void	set_sql_delay (time_t _sql_delay)
time_t	get_sql_delay_end ()
	Relay_log_info (bool is_slave_recovery, uint param_id)
time_t	get_row_stmt_start_timestamp ()
time_t	set_row_stmt_start_timestamp ()
void	reset_row_stmt_start_timestamp ()
void	set_long_find_row_note_printed ()
void	unset_long_find_row_note_printed ()
bool	is_long_find_row_note_printed ()
virtual void	set_rli_description_event (Format_description_log_event *fdle)
Format_description_log_event *	get_rli_description_event () const
void	adapt_to_master_version (Format_description_log_event *fdle)
Public Member Functions inherited from Rpl_info
void	set_rpl_info_handler (Rpl_info_handler *param_handler)
Rpl_info_handler *	get_rpl_info_handler ()
enum_return_check	check_info ()
int	remove_info ()
int	clean_info ()
bool	is_transactional ()
bool	update_is_transactional ()
char *	get_description_info ()
bool	copy_info (Rpl_info_handler *from, Rpl_info_handler *to)
uint	get_internal_id ()
Public Member Functions inherited from Slave_reporting_capability
	Slave_reporting_capability (char const *thread_name)
virtual void	report (loglevel level, int err_code, const char *msg,...) const ATTRIBUTE_FORMAT(printf
virtual void void	va_report (loglevel level, int err_code, const char *prefix_msg, const char *msg, va_list v_args) const
void	clear_error ()
int	has_temporary_error (THD *thd, uint error_arg=0, bool *silent=0) const
Error const &	last_error () const
bool	is_error () const

Static Public Member Functions
static size_t	get_number_info_rli_fields ()

Public Attributes
bool	replicate_same_server_id
File	cur_log_fd
MYSQL_BIN_LOG	relay_log
LOG_INFO	linfo
IO_CACHE	cache_buf
IO_CACHE *	cur_log
bool	is_relay_log_recovery
TABLE *	save_temporary_tables
Master_info *	mi
uint32	cur_log_old_open_count
ulonglong	log_space_limit
ulonglong	log_space_total
bool	ignore_log_space_limit
bool	sql_force_rotate_relay
time_t	last_master_timestamp
volatile uint32	slave_skip_counter
volatile ulong	abort_pos_wait
mysql_mutex_t	log_space_lock
mysql_cond_t	log_space_cond
enum Relay_log_info:: { ... }	until_condition
char	until_log_name [FN_REFLEN]
ulonglong	until_log_pos
ulong	until_log_name_extension
Gtid_set	until_sql_gtids
bool	until_sql_gtids_first_event
enum Relay_log_info:: { ... }	until_log_names_cmp_result
char	cached_charset [6]
ulong	trans_retries
ulong	retried_trans
char	ign_master_log_name_end [FN_REFLEN]
ulonglong	ign_master_log_pos_end
char	slave_patternload_file [FN_REFLEN]
size_t	slave_patternload_file_size
struct timespec	last_clock
RPL_TABLE_LIST *	tables_to_lock
uint	tables_to_lock_count
table_mapping	m_table_map
Rows_query_log_event *	rows_query_ev
time_t	last_event_start_time
Deferred_log_events *	deferred_events
bool	deferred_events_collecting
DYNAMIC_ARRAY	workers
volatile ulong	pending_jobs
mysql_mutex_t	pending_jobs_lock
mysql_cond_t	pending_jobs_cond
ulong	mts_slave_worker_queue_len_max
ulonglong	mts_pending_jobs_size
ulonglong	mts_pending_jobs_size_max
bool	mts_wq_oversize
Slave_worker *	last_assigned_worker
Slave_committed_queue *	gaq
DYNAMIC_ARRAY	curr_group_assigned_parts
DYNAMIC_ARRAY	curr_group_da
bool	curr_group_seen_gtid
bool	curr_group_seen_begin
bool	curr_group_isolated
bool	mts_end_group_sets_max_dbs
volatile ulong	mts_wq_underrun_w_id
volatile long	mts_wq_excess_cnt
long	mts_worker_underrun_level
ulong	mts_coordinator_basic_nap
ulong	opt_slave_parallel_workers
ulong	slave_parallel_workers
ulong	recovery_parallel_workers
uint	checkpoint_seqno
uint	checkpoint_group
MY_BITMAP	recovery_groups
bool	recovery_groups_inited
ulong	mts_recovery_group_cnt
ulong	mts_recovery_index
bool	mts_recovery_group_seen_begin
MEM_ROOT	mts_coor_mem_root
enum Relay_log_info:: { ... }	mts_group_status
ulonglong	mts_events_assigned
ulong	mts_groups_assigned
volatile ulong	mts_wq_overrun_cnt
ulong	wq_size_waits_cnt
ulong	mts_wq_no_underrun_cnt
ulong	mts_wq_overfill_cnt
DYNAMIC_ARRAY	least_occupied_workers
time_t	mts_last_online_stat
bool	reported_unsafe_warning
uchar	slave_version_split [3]
Public Attributes inherited from Rpl_info
mysql_mutex_t	data_lock
mysql_mutex_t	run_lock
mysql_mutex_t	sleep_lock
mysql_cond_t	data_cond
mysql_cond_t	start_cond
mysql_cond_t	stop_cond
mysql_cond_t	sleep_cond
THD *	info_thd
bool	inited
volatile bool	abort_slave
volatile uint	slave_running
volatile ulong	slave_run_id
int	events_until_exit
Public Attributes inherited from Slave_reporting_capability
mysql_mutex_t	err_lock

Protected Attributes
char	group_relay_log_name [FN_REFLEN]
ulonglong	group_relay_log_pos
char	event_relay_log_name [FN_REFLEN]
ulonglong	event_relay_log_pos
ulonglong	future_event_relay_log_pos
char	group_master_log_name [FN_REFLEN]
volatile my_off_t	group_master_log_pos
ulonglong	future_master_log_pos
Format_description_log_event *	rli_description_event
Protected Attributes inherited from Rpl_info
Rpl_info_handler *	handler
uint	internal_id

Friends
class	Rpl_info_factory

Additional Inherited Members
Protected Member Functions inherited from Rpl_info
	Rpl_info (const char *type, uint param_id)

Detailed Description

Definition at line 104 of file rpl_rli.h.

Member Enumeration Documentation

enum Relay_log_info::enum_state_flag

Flags for the state of the replication.

Enumerator:

IN_STMT	The replication thread is inside a statement
STATE_FLAGS_COUNT	Flag counter. Should always be last

Definition at line 112 of file rpl_rli.h.

Member Function Documentation

void Relay_log_info::adapt_to_master_version

(

Format_description_log_event *

fdle

)

adaptation for the slave applier to specific master versions.

The method lists rules of adaptation for the slave applier to specific master versions. It's executed right before a new master FD is set for slave appliers execution context. Comparison of the old and new version yields the adaptive actions direction. Current execution FD's version, V_0, is compared with the new being set up FD (the arg), let's call it V_1. In the case of downgrade features that are defined in [V_0, V_1-1] range (V_1 excluded) are "removed" by running the downgrade actions. In the upgrade case the featured defined in [V_0 + 1, V_1] range are "added" by running the upgrade actions.

Notice, that due to relay log may have two FD events, one the slave local and the other from the Master. That can lead to extra adapt_to_master_version() calls and in case Slave and Master are of different versions the extra two calls should compensate each other.

Also, at composing downgrade/upgrade actions keep in mind that at initialization Slave sets up FD of version 4.0 and then transits to the current server version. At transition all upgrading actions in the range of [4.0..current] are run.

Parameters

fdle	a pointer to new Format Description event that is being set up for execution context.

Definition at line 2287 of file rpl_rli.cc.

Here is the call graph for this function:

void Relay_log_info::cached_charset_invalidate

(

)

Last charset (6 bytes) seen by slave SQL thread is cached here; it helps the thread save 3 get_charset() per Query_log_event if the charset is not changing from event to event (common situation). When the 6 bytes are equal to 0 is used to mean "cache is invalidated".

Definition at line 1355 of file rpl_rli.cc.

void Relay_log_info::clear_flag ( enum_state_flag  flag )

inline

Clear the value of a replication state flag.

Parameters

flag	Flag to clear

Definition at line 705 of file rpl_rli.h.

void Relay_log_info::clear_sql_delay ( )

inline

Reset the delay. This is used by RESET SLAVE to clear the delay.

Definition at line 286 of file rpl_rli.h.

void Relay_log_info::clear_until_condition

(

)

Resets UNTIL condition for Relay_log_info

Definition at line 363 of file rpl_rli.cc.

void Relay_log_info::deinit_workers

(

)

The method to invoke at slave threads stop

Definition at line 161 of file rpl_rli.cc.

int Relay_log_info::flush_info

(

bool

force = FALSE

)

Stores the file and position where the execute-slave thread are in the relay log:

• As this is only called by the slave thread or on STOP SLAVE, with the log_lock grabbed and the slave thread stopped, we don't need to have a lock here.
• If there is an active transaction, then we don't update the position in the relay log. This is to ensure that we re-execute statements if we die in the middle of an transaction that was rolled back.
• As a transaction never spans binary logs, we don't have to handle the case where we do a relay-log-rotation in the middle of the transaction. If this would not be the case, we would have to ensure that we don't delete the relay log file where the transaction started when we switch to a new relay log file.

Return values

0	ok,
1	write error, otherwise. Store the file and position where the slave's SQL thread are in the relay log.

Notes:

• This function should be called either from the slave SQL thread, or when the slave thread is not running. (It reads the group_{relay|master}_log_{pos|name} and delay fields in the rli object. These may only be modified by the slave SQL thread or by a client thread when the slave SQL thread is not running.)

• If there is an active transaction, then we do not update the position in the relay log. This is to ensure that we re-execute statements if we die in the middle of an transaction that was rolled back.

• As a transaction never spans binary logs, we don't have to handle the case where we do a relay-log-rotation in the middle of the transaction. If transactions could span several binlogs, we would have to ensure that we do not delete the relay log file where the transaction started before switching to a new relay log file.

• Error can happen if writing to file fails or if flushing the file fails.

Parameters

rli	The object representing the Relay_log_info.

Todo:

Change the log file information to a binary format to avoid calling longlong2str.

Returns

0 on success, 1 on error.

Definition at line 2002 of file rpl_rli.cc.

bool Relay_log_info::get_flag ( enum_state_flag  flag )

inline

Get the value of a replication state flag.

Parameters

flag	Flag to get value of

Returns

true if the flag was set, false otherwise.

Definition at line 695 of file rpl_rli.h.

Format_description_log_event* Relay_log_info::get_rli_description_event ( ) const

inline

Return the current Format_description_log_event.

Definition at line 882 of file rpl_rli.h.

int Relay_log_info::init_relay_log_pos	(	const char *	log,
		ulonglong	pos,
		bool	need_data_lock,
		const char **	errmsg,
		bool	look_for_description_event
	)

Opens and intialize the given relay log. Specifically, it does what follows:

• Closes old open relay log files.
• If we are using the same relay log as the running IO-thread, then sets. rli->cur_log to point to the same IO_CACHE entry.
• If not, opens the 'log' binary file.

Todo:

check proper initialization of group_master_log_name/group_master_log_pos. /alfranio

Parameters

rli[in]	Relay information (will be initialized)
log[in]	Name of relay log file to read from. NULL = First log
pos[in]	Position in relay log file
need_data_lock[in]	If true, this function will acquire the relay_log.data_lock(); otherwise the caller should already have acquired it.
errmsg[out]	On error, this function will store a pointer to an error message here
look_for_description_event[in]	If true, this function will look for a Format_description_log_event. We only need this when the SQL thread starts and opens an existing relay log and has to execute it (possibly from an offset >4); then we need to read the first event of the relay log to be able to parse the events we have to execute.

Return values

0	ok,
1	error. In this case, *errmsg is set to point to the error message.

Definition at line 406 of file rpl_rli.cc.

Here is the call graph for this function:

void Relay_log_info::init_workers

(

ulong

n_workers

)

The method to invoke at slave threads start

Definition at line 146 of file rpl_rli.cc.

bool Relay_log_info::is_in_group ( ) const

inline

Is the replication inside a group?

Replication is inside a group if either:

• The OPTION_BEGIN flag is set, meaning we're inside a transaction
• The RLI_IN_STMT flag is set, meaning we're inside a statement

Return values

true	Replication thread is currently inside a group
false	Replication thread is currently not inside a group

Definition at line 720 of file rpl_rli.h.

bool Relay_log_info::is_mts_in_group ( )

inline

returns true if Coordinator is scheduling events belonging to the same group and has not reached yet its terminal event.

Definition at line 621 of file rpl_rli.h.

Here is the call graph for this function:

bool Relay_log_info::is_mts_recovery ( ) const

inline

returns true if there is any gap-group of events to execute at slave starting phase.

Definition at line 600 of file rpl_rli.h.

Here is the caller graph for this function:

bool Relay_log_info::is_parallel_exec ( ) const

inline

returns true if events are to be executed in parallel

Definition at line 608 of file rpl_rli.h.

Here is the call graph for this function:

Here is the caller graph for this function:

bool Relay_log_info::is_until_satisfied	(	THD *	thd,
		Log_event *	ev
	)

Checks if condition stated in UNTIL clause of START SLAVE is reached.

Specifically, it checks if UNTIL condition is reached. Uses caching result of last comparison of current log file name and target log file name. So cached value should be invalidated if current log file name changes (see Relay_log_info::notify_... functions).

This caching is needed to avoid of expensive string comparisons and strtol() conversions needed for log names comparison. We don't need to compare them each time this function is called, we only need to do this when current log name changes. If we have UNTIL_MASTER_POS condition we need to do this only after Rotate_log_event::do_apply_event() (which is rare, so caching gives real benifit), and if we have UNTIL_RELAY_POS condition then we should invalidate cached comarison value after inc_group_relay_log_pos() which called for each group of events (so we have some benefit if we have something like queries that use autoincrement or if we have transactions).

Should be called ONLY if until_condition != UNTIL_NONE !

Parameters

master_beg_pos

position of the beginning of to be executed event (not log_pos member of the event that points to the beginning of the following event)

Return values

true	condition met or error happened (condition seems to have bad log file name),
false	condition not met.

Definition at line 1166 of file rpl_rli.cc.

Here is the call graph for this function:

bool Relay_log_info::mts_finalize_recovery

(

)

Called when gaps execution is ended so it is crash-safe to reset the last session Workers info.

Reset recovery info from Worker info table and mark MTS recovery is completed.

Returns

false on success true when reset_notified_checkpoint failed.

Definition at line 284 of file rpl_rli.cc.

void Relay_log_info::notify_group_master_log_name_update ( )

inline

The same as notify_group_relay_log_name_update but for group_master_log_name.

Definition at line 393 of file rpl_rli.h.

void Relay_log_info::notify_group_relay_log_name_update ( )

inline

Invalidates cached until_log_name and group_relay_log_name comparison result. Should be called after any update of group_realy_log_name if there chances that sql_thread is running.

Definition at line 383 of file rpl_rli.h.

int Relay_log_info::purge_relay_logs	(	THD *	thd,
		bool	just_reset,
		const char **	errmsg
	)

Purges relay logs. It assumes to have a run lock on rli and that no slave thread are running.

Parameters

[in]	THD	connection,
[in]	just_reset	if false, it tells that logs should be purged and init_relay_log_pos() should be called, [out] errmsg store pointer to an error message.

Return values

0	successfuly executed,
1	otherwise error, where errmsg is set to point to the error message.

Definition at line 1053 of file rpl_rli.cc.

void Relay_log_info::reset_notified_checkpoint	(	ulong	shift,
		time_t	new_ts,
		bool	need_data_lock
	)

While a group is executed by a Worker the relay log can change. Coordinator notifies Workers about this event. Coordinator and Workers maintain a bitmap of executed group that is reset with a new checkpoint.

This method is called in mts_checkpoint_routine() to mark that each worker is required to adapt to a new checkpoint data whose coordinates are passed to it through GAQ index.

Worker notices the new checkpoint value at the group commit to reset the current bitmap and starts using the clean bitmap indexed from zero of being reset checkpoint_seqno.

New seconds_behind_master timestamp is installed.

Parameters

shift	number of bits to shift by Worker due to the current checkpoint change.
new_ts	new seconds_behind_master timestamp value unless zero. Zero could be due to FD event.
need_data_lock	False if caller has locked data_lock

Definition at line 220 of file rpl_rli.cc.

void Relay_log_info::reset_notified_relay_log_change

(

)

While a group is executed by a Worker the relay log can change. Coordinator notifies Workers about this event. Worker is supposed to commit to the recovery table with the new info.

Method is called when MTS coordinator senses the relay-log name has been changed. It marks each Worker member with this fact to make an action at time it will distribute a terminal event of a group to the Worker.

Worker receives the new name at the group commiting phase Slave_worker::slave_worker_ends_group().

Definition at line 192 of file rpl_rli.cc.

void Relay_log_info::set_flag ( enum_state_flag  flag )

inline

Set the value of a replication state flag.

Parameters

flag	Flag to set

Definition at line 683 of file rpl_rli.h.

void Relay_log_info::set_rli_description_event ( Format_description_log_event *  fe )

virtual

Delete the existing event and set a new one. This class is responsible for freeing the event, the caller should not do that.

Delete the existing event and set a new one. This class is responsible for freeing the event, the caller should not do that. When a new FD is from the master adaptation routine is invoked to align the slave applier execution context with the master version.

The method is run by SQL thread/MTS Coordinator. Although notice that MTS worker runs it, inefficiently (see assert), once at its destruction time. todo: fix Slave_worker and Relay_log_info inheritance relation.

Parameters

a	pointer to be installed into execution context FormatDescriptor event

Definition at line 2178 of file rpl_rli.cc.

void Relay_log_info::start_sql_delay ( time_t  delay_end )

inline

Indicate that a delay starts.

This does not actually sleep; it only sets the state of this Relay_log_info object to delaying so that the correct state can be reported by SHOW SLAVE STATUS and SHOW PROCESSLIST.

Requires rli->data_lock.

Parameters

delay_end

The time when the delay shall end.

Definition at line 807 of file rpl_rli.h.

int Relay_log_info::stmt_done

(

my_off_t

event_log_pos

)

Helper function to do after statement completion.

This function is called from an event to complete the group by either stepping the group position, if the "statement" is not inside a transaction; or increase the event position, if the "statement" is inside a transaction.

Parameters

event_log_pos

Master log position of the event. The position is recorded in the relay log info and used to produce information for SHOW SLAVE STATUS.

Definition at line 1378 of file rpl_rli.cc.

int Relay_log_info::wait_for_pos	(	THD *	thd,
		String *	log_name,
		longlong	log_pos,
		longlong	timeout
	)

Waits until the SQL thread reaches (has executed up to) the log/position or timed out.

SYNOPSIS

Parameters

[in]	thd	client thread that sent SELECT MASTER_POS_WAIT,
[in]	log_name	log name to wait for,
[in]	log_pos	position to wait for,
[in]	timeout	timeout in seconds before giving up waiting. timeout is longlong whereas it should be ulong; but this is to catch if the user submitted a negative timeout.

Return values

-2	improper arguments (log_pos<0) or slave not running, or master info changed during the function's execution, or client thread killed. -2 is translated to NULL by caller,
-1	timed out
>=0	number of log events the function had to wait before reaching the desired log/position

Definition at line 613 of file rpl_rli.cc.

Here is the call graph for this function:

Member Data Documentation

struct timespec Relay_log_info::last_clock

Identifies the last time a checkpoint routine has been executed.

Definition at line 376 of file rpl_rli.h.

Gtid_set Relay_log_info::until_sql_gtids

The START SLAVE UNTIL SQL_*_GTIDS initializes until_sql_gtids. Each time a gtid is about to be processed, we check if it is in the set. Depending on until_condition, SQL thread is stopped before or after applying the gtid.

Definition at line 329 of file rpl_rli.h.

---

The documentation for this class was generated from the following files:

• sql/rpl_rli.h
• sql/rpl_rli.cc