1
/* Copyright (C) 2005 MySQL AB
3
This program is free software; you can redistribute it and/or modify
4
it under the terms of the GNU General Public License as published by
5
the Free Software Foundation; version 2 of the License.
7
This program is distributed in the hope that it will be useful,
8
but WITHOUT ANY WARRANTY; without even the implied warranty of
9
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10
GNU General Public License for more details.
12
You should have received a copy of the GNU General Public License
13
along with this program; if not, write to the Free Software
14
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
19
#include "rpl_tblmap.h"
20
#include "rpl_reporting.h"
21
#include "rpl_utility.h"
23
struct RPL_TABLE_LIST;
26
/****************************************************************************
28
Replication SQL Thread
30
Relay_log_info contains:
31
- the current relay log
32
- the current relay log offset
34
- master log sequence corresponding to the last update
35
- misc information specific to the SQL thread
37
Relay_log_info is initialized from the slave.info file if such
38
exists. Otherwise, data members are intialized with defaults. The
39
initialization is done with init_relay_log_info() call.
41
The format of slave.info file:
48
To clean up, call end_relay_log_info()
50
*****************************************************************************/
52
class Relay_log_info : public Slave_reporting_capability
56
Flags for the state of the replication.
58
enum enum_state_flag {
59
/** The replication thread is inside a statement */
62
/** Flag counter. Should always be last */
67
If flag set, then rli does not store its state in any info file.
68
This is the case only when we execute BINLOG SQL commands inside
69
a client, non-replication thread.
74
If true, events with the same server id should be replicated. This
75
field is set on creation of a relay log info structure by copying
76
the value of ::replicate_same_server_id and can be overridden if
77
necessary. For example of when this is done, check sql_binlog.cc,
78
where the BINLOG statement can be used to execute "raw" events.
80
bool replicate_same_server_id;
82
/*** The following variables can only be read when protect by data lock ****/
85
info_fd - file descriptor of the info file. set only during
86
initialization or clean up - safe to read anytime
87
cur_log_fd - file descriptor of the current read relay log
89
File info_fd,cur_log_fd;
92
Protected with internal locks.
93
Must get data_lock when resetting the logs.
95
MYSQL_BIN_LOG relay_log;
97
IO_CACHE cache_buf,*cur_log;
99
/* The following variables are safe to read any time */
101
/* IO_CACHE of the info file - set only during init or end */
105
When we restart slave thread we need to have access to the previously
106
created temporary tables. Modified only on init/end and by the SQL
107
thread, read only by SQL thread.
109
TABLE *save_temporary_tables;
112
standard lock acquistion order to avoid deadlocks:
113
run_lock, data_lock, relay_log.LOCK_log, relay_log.LOCK_index
115
pthread_mutex_t data_lock,run_lock;
118
start_cond is broadcast when SQL thread is started
119
stop_cond - when stopped
120
data_cond - when data protected by data_lock changes
122
pthread_cond_t start_cond, stop_cond, data_cond;
124
/* parent Master_info structure */
128
Needed to deal properly with cur_log getting closed and re-opened with
129
a different log under our feet
131
uint32 cur_log_old_open_count;
134
Let's call a group (of events) :
137
- an autocommiting query + its associated events (INSERT_ID,
139
We need these rli coordinates :
140
- relay log name and position of the beginning of the group we currently are
141
executing. Needed to know where we have to restart when replication has
142
stopped in the middle of a group (which has been rolled back by the slave).
143
- relay log name and position just after the event we have just
144
executed. This event is part of the current group.
145
Formerly we only had the immediately above coordinates, plus a 'pending'
146
variable, but this dealt wrong with the case of a transaction starting on a
147
relay log and finishing (commiting) on another relay log. Case which can
148
happen when, for example, the relay log gets rotated because of
151
char group_relay_log_name[FN_REFLEN];
152
ulonglong group_relay_log_pos;
153
char event_relay_log_name[FN_REFLEN];
154
ulonglong event_relay_log_pos;
155
ulonglong future_event_relay_log_pos;
158
bool is_fake; /* Mark that this is a fake relay log info structure */
162
Original log name and position of the group we're currently executing
163
(whose coordinates are group_relay_log_name/pos in the relay log)
164
in the master's binlog. These concern the *group*, because in the master's
165
binlog the log_pos that comes with each event is the position of the
166
beginning of the group.
168
char group_master_log_name[FN_REFLEN];
169
volatile my_off_t group_master_log_pos;
172
Handling of the relay_log_space_limit optional constraint.
173
ignore_log_space_limit is used to resolve a deadlock between I/O and SQL
174
threads, the SQL thread sets it to unblock the I/O thread and make it
175
temporarily forget about the constraint.
177
ulonglong log_space_limit,log_space_total;
178
bool ignore_log_space_limit;
181
When it commits, InnoDB internally stores the master log position it has
182
processed so far; the position to store is the one of the end of the
183
committing event (the COMMIT query event, or the event if in autocommit
186
#if MYSQL_VERSION_ID < 40100
187
ulonglong future_master_log_pos;
189
ulonglong future_group_master_log_pos;
192
time_t last_master_timestamp;
194
void clear_until_condition();
197
Needed for problems when slave stops and we want to restart it
198
skipping one or more events in the master log that have caused
199
errors, and have been manually applied by DBA already.
201
volatile uint32 slave_skip_counter;
202
volatile ulong abort_pos_wait; /* Incremented on change master */
203
volatile ulong slave_run_id; /* Incremented on slave start */
204
pthread_mutex_t log_space_lock;
205
pthread_cond_t log_space_cond;
208
int events_till_abort;
211
/* if not set, the value of other members of the structure are undefined */
213
volatile bool abort_slave;
214
volatile uint slave_running;
217
Condition and its parameters from START SLAVE UNTIL clause.
219
UNTIL condition is tested with is_until_satisfied() method that is
220
called by exec_relay_log_event(). is_until_satisfied() caches the result
221
of the comparison of log names because log names don't change very often;
222
this cache is invalidated by parts of code which change log names with
223
notify_*_log_name_updated() methods. (They need to be called only if SQL
227
enum {UNTIL_NONE= 0, UNTIL_MASTER_POS, UNTIL_RELAY_POS} until_condition;
228
char until_log_name[FN_REFLEN];
229
ulonglong until_log_pos;
230
/* extension extracted from log_name and converted to int */
231
ulong until_log_name_extension;
233
Cached result of comparison of until_log_name and current log name
234
-2 means unitialised, -1,0,1 are comarison results
238
UNTIL_LOG_NAMES_CMP_UNKNOWN= -2, UNTIL_LOG_NAMES_CMP_LESS= -1,
239
UNTIL_LOG_NAMES_CMP_EQUAL= 0, UNTIL_LOG_NAMES_CMP_GREATER= 1
240
} until_log_names_cmp_result;
242
char cached_charset[6];
244
trans_retries varies between 0 to slave_transaction_retries and counts how
245
many times the slave has retried the present transaction; gets reset to 0
246
when the transaction finally succeeds. retried_trans is a cumulative
247
counter: how many times the slave has retried a transaction (any) since
250
ulong trans_retries, retried_trans;
253
If the end of the hot relay log is made of master's events ignored by the
254
slave I/O thread, these two keep track of the coords (in the master's
255
binlog) of the last of these events seen by the slave I/O thread. If not,
256
ign_master_log_name_end[0] == 0.
257
As they are like a Rotate event read/written from/to the relay log, they
258
are both protected by rli->relay_log.LOCK_log.
260
char ign_master_log_name_end[FN_REFLEN];
261
ulonglong ign_master_log_pos_end;
267
Invalidate cached until_log_name and group_relay_log_name comparison
268
result. Should be called after any update of group_realy_log_name if
269
there chances that sql_thread is running.
271
inline void notify_group_relay_log_name_update()
273
if (until_condition==UNTIL_RELAY_POS)
274
until_log_names_cmp_result= UNTIL_LOG_NAMES_CMP_UNKNOWN;
278
The same as previous but for group_master_log_name.
280
inline void notify_group_master_log_name_update()
282
if (until_condition==UNTIL_MASTER_POS)
283
until_log_names_cmp_result= UNTIL_LOG_NAMES_CMP_UNKNOWN;
286
inline void inc_event_relay_log_pos()
288
event_relay_log_pos= future_event_relay_log_pos;
291
void inc_group_relay_log_pos(ulonglong log_pos,
294
int wait_for_pos(THD* thd, String* log_name, longlong log_pos,
296
void close_temporary_tables();
298
/* Check if UNTIL condition is satisfied. See slave.cc for more. */
299
bool is_until_satisfied(my_off_t master_beg_pos);
300
inline ulonglong until_pos()
302
return ((until_condition == UNTIL_MASTER_POS) ? group_master_log_pos :
303
group_relay_log_pos);
306
RPL_TABLE_LIST *tables_to_lock; /* RBR: Tables to lock */
307
uint tables_to_lock_count; /* RBR: Count of tables to lock */
308
table_mapping m_table_map; /* RBR: Mapping table-id to table */
310
inline table_def *get_tabledef(TABLE *tbl)
313
for (TABLE_LIST *ptr= tables_to_lock; ptr && !td; ptr= ptr->next_global)
314
if (ptr->table == tbl)
315
td= &((RPL_TABLE_LIST *)ptr)->m_tabledef;
320
Last charset (6 bytes) seen by slave SQL thread is cached here; it helps
321
the thread save 3 get_charset() per Query_log_event if the charset is not
322
changing from event to event (common situation).
323
When the 6 bytes are equal to 0 is used to mean "cache is invalidated".
325
void cached_charset_invalidate();
326
bool cached_charset_compare(char *charset) const;
328
void cleanup_context(THD *, bool);
329
void clear_tables_to_lock();
332
Used by row-based replication to detect that it should not stop at
333
this event, but give it a chance to send more events. The time
334
where the last event inside a group started is stored here. If the
335
variable is zero, we are not in a group (but may be in a
338
time_t last_event_start_time;
341
Helper function to do after statement completion.
343
This function is called from an event to complete the group by
344
either stepping the group position, if the "statement" is not
345
inside a transaction; or increase the event position, if the
346
"statement" is inside a transaction.
349
Master log position of the event. The position is recorded in the
350
relay log info and used to produce information for <code>SHOW
353
@param event_creation_time
354
Timestamp for the creation of the event on the master side. The
355
time stamp is recorded in the relay log info and used to compute
356
the <code>Seconds_behind_master</code> field.
358
void stmt_done(my_off_t event_log_pos,
359
time_t event_creation_time);
363
Set the value of a replication state flag.
365
@param flag Flag to set
367
void set_flag(enum_state_flag flag)
369
m_flags |= (1UL << flag);
373
Get the value of a replication state flag.
375
@param flag Flag to get value of
377
@return @c true if the flag was set, @c false otherwise.
379
bool get_flag(enum_state_flag flag)
381
return m_flags & (1UL << flag);
385
Clear the value of a replication state flag.
387
@param flag Flag to clear
389
void clear_flag(enum_state_flag flag)
391
m_flags &= ~(1UL << flag);
395
Is the replication inside a group?
397
Replication is inside a group if either:
398
- The OPTION_BEGIN flag is set, meaning we're inside a transaction
399
- The RLI_IN_STMT flag is set, meaning we're inside a statement
401
@retval true Replication thread is currently inside a group
402
@retval false Replication thread is currently not inside a group
404
bool is_in_group() const {
405
return (sql_thd->options & OPTION_BEGIN) ||
406
(m_flags & (1UL << IN_STMT));
414
// Defined in rpl_rli.cc
415
int init_relay_log_info(Relay_log_info* rli, const char* info_fname);
418
#endif /* RPL_RLI_H */
added
removed
sql/rpl_rli.h
