log_event.h 11.5 KB
Newer Older
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


#ifndef _LOG_EVENT_H
#define _LOG_EVENT_H

#if defined(__GNUC__) && !defined(MYSQL_CLIENT)
#pragma interface			/* gcc class implementation */
#endif

#define LOG_READ_EOF    -1
#define LOG_READ_BOGUS  -2
#define LOG_READ_IO     -3
#define LOG_READ_MEM    -5

#define LOG_EVENT_OFFSET 4
31
#define BINLOG_VERSION    1
bk@work.mysql.com's avatar
bk@work.mysql.com committed
32

33
#define LOG_EVENT_HEADER_LEN 13
34 35
#define QUERY_HEADER_LEN     (sizeof(uint32) + sizeof(uint32) + \
 sizeof(uchar) + sizeof(uint16))
36 37 38 39 40 41 42 43 44 45
#define LOAD_HEADER_LEN      (sizeof(uint32) + sizeof(uint32) + \
  + sizeof(uint32) + 2 + sizeof(uint32))
#define EVENT_LEN_OFFSET     9
#define EVENT_TYPE_OFFSET    4
#define MAX_EVENT_LEN        4*1024*1024 
#define QUERY_EVENT_OVERHEAD  LOG_EVENT_HEADER_LEN+QUERY_HEADER_LEN
#define ROTATE_EVENT_OVERHEAD LOG_EVENT_HEADER_LEN
#define LOAD_EVENT_OVERHEAD   (LOG_EVENT_HEADER_LEN+LOAD_HEADER_LEN+sizeof(sql_ex_info))


bk@work.mysql.com's avatar
bk@work.mysql.com committed
46 47 48 49 50 51 52 53 54 55
enum Log_event_type { START_EVENT = 1, QUERY_EVENT =2,
		      STOP_EVENT=3, ROTATE_EVENT = 4, INTVAR_EVENT=5,
                      LOAD_EVENT=6};
enum Int_event_type { INVALID_INT_EVENT = 0, LAST_INSERT_ID_EVENT = 1, INSERT_ID_EVENT = 2
 };

#ifndef MYSQL_CLIENT
class String;
#endif

56 57
extern uint32 server_id;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
58 59 60 61 62
class Log_event
{
public:
  time_t when;
  ulong exec_time;
63 64
  int valid_exec_time; // if false, the exec time setting is bogus 
  uint32 server_id;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
65 66 67 68 69 70

  int write(FILE* file);
  int write_header(FILE* file);
  virtual int write_data(FILE* file __attribute__((unused))) { return 0; }
  virtual Log_event_type get_type_code() = 0;
  Log_event(time_t when_arg, ulong exec_time_arg = 0,
71 72 73 74 75 76
	    int valid_exec_time_arg = 0, uint32 server_id = 0): when(when_arg),
    exec_time(exec_time_arg), valid_exec_time(valid_exec_time_arg)
  {
    if(!server_id) this->server_id = ::server_id;
    else this->server_id = server_id;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
77

78
  Log_event(const char* buf): valid_exec_time(0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
79 80
  {
   when = uint4korr(buf);
81
   server_id = uint4korr(buf + 5);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
82 83 84 85 86 87 88
  }

  virtual ~Log_event() {}

  virtual int get_data_size() { return 0;}
  virtual void print(FILE* file, bool short_form = 0) = 0;

89 90
  void print_timestamp(FILE* file, time_t *ts = 0);
  void print_header(FILE* file);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
91

92 93
  // if mutex is 0, the read will proceed without mutex
  static Log_event* read_log_event(FILE* file, pthread_mutex_t* log_lock);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
94 95 96
  static Log_event* read_log_event(const char* buf, int max_buf);

#ifndef MYSQL_CLIENT
97 98
  static int read_log_event(FILE* file, String* packet,
			    pthread_mutex_t* log_lock);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
99 100 101 102 103 104 105 106 107 108 109 110
#endif
  
};


class Query_log_event: public Log_event
{
protected:
  char* data_buf;
public:
  const char* query;
  const char* db;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
111
  uint32 q_len; // if we already know the length of the query string
bk@work.mysql.com's avatar
bk@work.mysql.com committed
112 113
  // we pass it here, so we would not have to call strlen()
  // otherwise, set it to 0, in which case, we compute it with strlen()
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
114
  uint32 db_len;
115
  uint16 error_code;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
116 117 118 119
  int thread_id;
#if !defined(MYSQL_CLIENT)
  THD* thd;
  Query_log_event(THD* thd_arg, const char* query_arg):
120
    Log_event(thd_arg->start_time,0,0,thd_arg->server_id), data_buf(0),
bk@work.mysql.com's avatar
bk@work.mysql.com committed
121
    query(query_arg),  db(thd_arg->db), q_len(thd_arg->query_length),
122
    error_code(thd_arg->net.last_errno),
bk@work.mysql.com's avatar
bk@work.mysql.com committed
123 124 125 126
    thread_id(thd_arg->thread_id), thd(thd_arg)
  {
    time_t end_time;
    time(&end_time);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
127
    exec_time = (ulong) (end_time  - thd->start_time);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
128
    valid_exec_time = 1;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
129
    db_len = (db) ? (uint32) strlen(db) : 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
130 131 132
  }
#endif

133
  Query_log_event(FILE* file, time_t when, uint32 server_id);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
134 135 136 137 138 139 140 141 142 143 144 145 146 147
  Query_log_event(const char* buf, int max_buf);
  ~Query_log_event()
  {
    if (data_buf)
    {
      my_free((gptr)data_buf, MYF(0));
    }
  }
  Log_event_type get_type_code() { return QUERY_EVENT; }
  int write(FILE* file);
  int write_data(FILE* file); // returns 0 on success, -1 on error
  int get_data_size()
  {
    return q_len + db_len + 2 +
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
148 149
      sizeof(uint32) // thread_id
      + sizeof(uint32) // exec_time
150
      + sizeof(uint16) // error_code
bk@work.mysql.com's avatar
bk@work.mysql.com committed
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
      ;
  }

  void print(FILE* file, bool short_form = 0);
};

#define DUMPFILE_FLAG 0x1
#define OPT_ENCLOSED_FLAG 0x2
#define REPLACE_FLAG  0x4
#define IGNORE_FLAG   0x8

#define FIELD_TERM_EMPTY 0x1
#define ENCLOSED_EMPTY   0x2
#define LINE_TERM_EMPTY  0x4
#define LINE_START_EMPTY 0x8
#define ESCAPED_EMPTY    0x10


struct sql_ex_info
  {
    char field_term;
    char enclosed;
    char line_term;
    char line_start;
    char escaped;
    char opt_flags; // flags for the options
    char empty_flags; // flags to indicate which of the terminating charact
  } ;

class Load_log_event: public Log_event
{
protected:
  char* data_buf;
public:
  int thread_id;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
186 187 188 189
  uint32 table_name_len;
  uint32 db_len;
  uint32 fname_len;
  uint32 num_fields;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
190 191
  const char* fields;
  const uchar* field_lens;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
192
  uint32 field_block_len;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
193 194 195 196 197
  

  const char* table_name;
  const char* db;
  const char* fname;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
198
  uint32 skip_lines;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
  sql_ex_info sql_ex;
  
#if !defined(MYSQL_CLIENT)
  THD* thd;
  String field_lens_buf;
  String fields_buf;
  Load_log_event(THD* thd, sql_exchange* ex, const char* table_name,
		 List<Item>& fields, enum enum_duplicates handle_dup ):
    Log_event(thd->start_time),data_buf(0),thread_id(thd->thread_id),
    num_fields(0),fields(0),field_lens(0),field_block_len(0),
    table_name(table_name),
    db(thd->db),
    fname(ex->file_name),
    thd(thd)
  {
    time_t end_time;
    time(&end_time);
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
216
    exec_time = (ulong) (end_time  - thd->start_time);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
217
    valid_exec_time = 1;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
218 219
    db_len = (db) ? (uint32) strlen(db) : 0;
    table_name_len = (table_name) ? (uint32) strlen(table_name) : 0;
220
    fname_len = (fname) ? (uint) strlen(fname) : 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
    sql_ex.field_term = (*ex->field_term)[0];
    sql_ex.enclosed = (*ex->enclosed)[0];
    sql_ex.line_term = (*ex->line_term)[0];
    sql_ex.line_start = (*ex->line_start)[0];
    sql_ex.escaped = (*ex->escaped)[0];
    sql_ex.opt_flags = 0;
    if(ex->dumpfile)
      sql_ex.opt_flags |= DUMPFILE_FLAG;
    if(ex->opt_enclosed)
      sql_ex.opt_flags |= OPT_ENCLOSED_FLAG;

    sql_ex.empty_flags = 0;

    switch(handle_dup)
      {
      case DUP_IGNORE: sql_ex.opt_flags |= IGNORE_FLAG; break;
      case DUP_REPLACE: sql_ex.opt_flags |= REPLACE_FLAG; break;
      case DUP_ERROR: break;	
      }

    if(!ex->field_term->length())
      sql_ex.empty_flags |= FIELD_TERM_EMPTY;
    if(!ex->enclosed->length())
      sql_ex.empty_flags |= ENCLOSED_EMPTY;
    if(!ex->line_term->length())
      sql_ex.empty_flags |= LINE_TERM_EMPTY;
    if(!ex->line_start->length())
      sql_ex.empty_flags |= LINE_START_EMPTY;
    if(!ex->escaped->length())
      sql_ex.empty_flags |= ESCAPED_EMPTY;
    
    skip_lines = ex->skip_lines;

    List_iterator<Item> li(fields);
    field_lens_buf.length(0);
    fields_buf.length(0);
    Item* item;
    while((item = li++))
      {
	num_fields++;
261
	uchar len = (uchar) strlen(item->name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
262 263 264 265 266 267 268 269 270 271 272
	field_block_len += len + 1;
	fields_buf.append(item->name, len + 1);
	field_lens_buf.append((char*)&len, 1);
      }

    field_lens = (const uchar*)field_lens_buf.ptr();
    this->fields = fields_buf.ptr();
  }
  void set_fields(List<Item> &fields);
#endif

273
  Load_log_event(FILE* file, time_t when, uint32 server_id);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
  Load_log_event(const char* buf, int max_buf);
  ~Load_log_event()
  {
    if (data_buf)
    {
      my_free((gptr)data_buf, MYF(0));
    }
  }
  Log_event_type get_type_code() { return LOAD_EVENT; }
  int write_data(FILE* file); // returns 0 on success, -1 on error
  int get_data_size()
  {
    return table_name_len + 2 + db_len + 2 + fname_len
      + sizeof(thread_id) // thread_id
      + sizeof(exec_time) // exec_time
      + sizeof(skip_lines)
      + sizeof(field_block_len)
      + sizeof(sql_ex) + field_block_len + num_fields*sizeof(uchar) ;
      ;
  }

  void print(FILE* file, bool short_form = 0);
};

298
extern char server_version[50];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
299 300 301 302

class Start_log_event: public Log_event
{
public:
303 304 305 306 307
  uint16 binlog_version;
  char server_version[50];
  uint32 created;
  
  Start_log_event() :Log_event(time(NULL)),binlog_version(BINLOG_VERSION)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
308
  {
309 310
    created = when;
    memcpy(server_version, ::server_version, sizeof(server_version));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
311
  }
312 313
  Start_log_event(FILE* file, time_t when_arg, uint32 server_id) :
    Log_event(when_arg, 0, 0, server_id)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
314
  {
315 316 317 318 319 320 321 322
    char buf[sizeof(server_version) + sizeof(binlog_version) +
	    sizeof(created)];
    my_fseek(file, 4L, MY_SEEK_CUR, MYF(MY_WME)); // skip the event length
    if (my_fread(file, (byte*) buf, sizeof(buf), MYF(MY_NABP | MY_WME)))
      return;				
    binlog_version = uint2korr(buf);
    memcpy(server_version, buf + 2, sizeof(server_version));
    created = uint4korr(buf + 2 + sizeof(server_version));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
323
  }
324 325
  Start_log_event(const char* buf);
  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
326 327
  ~Start_log_event() {}
  Log_event_type get_type_code() { return START_EVENT;}
328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
  int write_data(FILE* file)
  {
    if(my_fwrite(file, (byte*) &binlog_version, sizeof(binlog_version),
		 MYF(MY_NABP | MY_WME)) ||
       my_fwrite(file, (byte*) server_version, sizeof(server_version),
		 MYF(MY_NABP | MY_WME)) ||
       my_fwrite(file, (byte*) &created, sizeof(created),
		 MYF(MY_NABP | MY_WME)))
      return -1;
    return 0;
  }
  int get_data_size()
  {
    return sizeof(binlog_version) + sizeof(server_version) +
      sizeof(created);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
344 345 346 347 348 349 350 351 352 353 354
  void print(FILE* file, bool short_form = 0);
};

class Intvar_log_event: public Log_event
{
public:
  ulonglong val;
  uchar type;
  Intvar_log_event(uchar type_arg, ulonglong val_arg)
    :Log_event(time(NULL)),val(val_arg),type(type_arg)
  {}
355
  Intvar_log_event(FILE* file, time_t when, uint32 server_id);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
  Intvar_log_event(const char* buf);
  ~Intvar_log_event() {}
  Log_event_type get_type_code() { return INTVAR_EVENT;}
  int get_data_size() { return  sizeof(type) + sizeof(val);}
  int write_data(FILE* file);
  
  
  void print(FILE* file, bool short_form = 0);
};

class Stop_log_event: public Log_event
{
public:
  Stop_log_event() :Log_event(time(NULL))
  {}
371 372
  Stop_log_event(FILE* file, time_t when_arg, uint32 server_id):
    Log_event(when_arg,0,0,server_id)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
  {
    my_fseek(file, 4L, MY_SEEK_CUR, MYF(MY_WME)); // skip the event length
  }
  Stop_log_event(const char* buf):Log_event(buf)
  {
  }
  ~Stop_log_event() {}
  Log_event_type get_type_code() { return STOP_EVENT;}
  void print(FILE* file, bool short_form = 0);
};

class Rotate_log_event: public Log_event
{
public:
  const char* new_log_ident;
  uchar ident_len;
  bool alloced;
  
  Rotate_log_event(const char* new_log_ident_arg, uint ident_len_arg = 0) :
    Log_event(time(NULL)),
    new_log_ident(new_log_ident_arg),
394
    ident_len(ident_len_arg ? ident_len_arg : (uint) strlen(new_log_ident_arg)),
bk@work.mysql.com's avatar
bk@work.mysql.com committed
395 396 397
    alloced(0)
  {}
  
398
  Rotate_log_event(FILE* file, time_t when, uint32 server_id) ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
399 400 401 402 403 404 405 406 407 408 409 410 411 412
  Rotate_log_event(const char* buf, int max_buf);
  ~Rotate_log_event()
  {
    if (alloced)
      my_free((gptr) new_log_ident, MYF(0));
  }
  Log_event_type get_type_code() { return ROTATE_EVENT;}
  int get_data_size() { return  ident_len;}
  int write_data(FILE* file);
  
  void print(FILE* file, bool short_form = 0);
};

#endif