← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/rpl_rli.h

  • Committer: Monty Taylor
  • Date: 2008-07-09 16:33:52 UTC
  • mto: (77.6.1 glibclient-merge)
  • mto: This revision was merged to the branch mainline in revision 112.
  • Revision ID: monty@inaugust.com-20080709163352-yv7jbu81frc1l4ec
Finished the warnings work!

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/rpl_rli.h
149
149
    max_binlog_size.
150
150
  */
151
151
  char group_relay_log_name[FN_REFLEN];
152
 
  uint64_t group_relay_log_pos;
 
152
  ulonglong group_relay_log_pos;
153
153
  char event_relay_log_name[FN_REFLEN];
154
 
  uint64_t event_relay_log_pos;
155
 
  uint64_t future_event_relay_log_pos;
 
154
  ulonglong event_relay_log_pos;
 
155
  ulonglong future_event_relay_log_pos;
156
156
 
157
157
#ifdef HAVE_purify
158
158
  bool is_fake; /* Mark that this is a fake relay log info structure */
174
174
    threads, the SQL thread sets it to unblock the I/O thread and make it
175
175
    temporarily forget about the constraint.
176
176
  */
177
 
  uint64_t log_space_limit,log_space_total;
 
177
  ulonglong log_space_limit,log_space_total;
178
178
  bool ignore_log_space_limit;
179
179
 
180
180
  /*
183
183
    committing event (the COMMIT query event, or the event if in autocommit
184
184
    mode).
185
185
  */
186
 
  uint64_t future_group_master_log_pos;
 
186
#if MYSQL_VERSION_ID < 40100
 
187
  ulonglong future_master_log_pos;
 
188
#else
 
189
  ulonglong future_group_master_log_pos;
 
190
#endif
187
191
 
188
192
  time_t last_master_timestamp;
189
193
 
195
199
    errors, and have been manually applied by DBA already.
196
200
  */
197
201
  volatile uint32 slave_skip_counter;
198
 
  volatile uint32_t abort_pos_wait;     /* Incremented on change master */
199
 
  volatile uint32_t slave_run_id;               /* Incremented on slave start */
 
202
  volatile ulong abort_pos_wait;        /* Incremented on change master */
 
203
  volatile ulong slave_run_id;          /* Incremented on slave start */
200
204
  pthread_mutex_t log_space_lock;
201
205
  pthread_cond_t log_space_cond;
202
206
  THD * sql_thd;
203
 
  int32_t events_till_abort;
 
207
#ifndef DBUG_OFF
 
208
  int events_till_abort;
 
209
#endif  
204
210
 
205
211
  /* if not set, the value of other members of the structure are undefined */
206
212
  bool inited;
207
213
  volatile bool abort_slave;
208
 
  volatile uint32_t slave_running;
 
214
  volatile uint slave_running;
209
215
 
210
216
  /* 
211
217
     Condition and its parameters from START SLAVE UNTIL clause.
220
226
  
221
227
  enum {UNTIL_NONE= 0, UNTIL_MASTER_POS, UNTIL_RELAY_POS} until_condition;
222
228
  char until_log_name[FN_REFLEN];
223
 
  uint64_t until_log_pos;
224
 
  /* extension extracted from log_name and converted to int32_t */
225
 
  uint32_t until_log_name_extension;   
 
229
  ulonglong until_log_pos;
 
230
  /* extension extracted from log_name and converted to int */
 
231
  ulong until_log_name_extension;   
226
232
  /* 
227
233
     Cached result of comparison of until_log_name and current log name
228
234
     -2 means unitialised, -1,0,1 are comarison results 
241
247
    counter: how many times the slave has retried a transaction (any) since
242
248
    slave started.
243
249
  */
244
 
  uint32_t trans_retries, retried_trans;
 
250
  ulong trans_retries, retried_trans;
245
251
 
246
252
  /*
247
253
    If the end of the hot relay log is made of master's events ignored by the
252
258
    are both protected by rli->relay_log.LOCK_log.
253
259
  */
254
260
  char ign_master_log_name_end[FN_REFLEN];
255
 
  uint64_t ign_master_log_pos_end;
 
261
  ulonglong ign_master_log_pos_end;
256
262
 
257
263
  Relay_log_info();
258
264
  ~Relay_log_info();
282
288
    event_relay_log_pos= future_event_relay_log_pos;
283
289
  }
284
290
 
285
 
  void inc_group_relay_log_pos(uint64_t log_pos,
 
291
  void inc_group_relay_log_pos(ulonglong log_pos,
286
292
                               bool skip_lock=0);
287
293
 
288
 
  int32_t wait_for_pos(THD* thd, String* log_name, longlong log_pos, 
 
294
  int wait_for_pos(THD* thd, String* log_name, longlong log_pos, 
289
295
                   longlong timeout);
290
296
  void close_temporary_tables();
291
297
 
292
298
  /* Check if UNTIL condition is satisfied. See slave.cc for more. */
293
299
  bool is_until_satisfied(my_off_t master_beg_pos);
294
 
  inline uint64_t until_pos()
 
300
  inline ulonglong until_pos()
295
301
  {
296
302
    return ((until_condition == UNTIL_MASTER_POS) ? group_master_log_pos :
297
303
            group_relay_log_pos);
298
304
  }
299
305
 
300
306
  RPL_TABLE_LIST *tables_to_lock;           /* RBR: Tables to lock  */
301
 
  uint32_t tables_to_lock_count;        /* RBR: Count of tables to lock */
 
307
  uint tables_to_lock_count;        /* RBR: Count of tables to lock */
302
308
  table_mapping m_table_map;      /* RBR: Mapping table-id to table */
303
309
 
304
310
  inline table_def *get_tabledef(TABLE *tbl)
406
412
 
407
413
 
408
414
// Defined in rpl_rli.cc
409
 
int32_t init_relay_log_info(Relay_log_info* rli, const char* info_fname);
 
415
int init_relay_log_info(Relay_log_info* rli, const char* info_fname);
410
416
 
411
417
 
412
418
#endif /* RPL_RLI_H */