« back to all changes in this revision
Viewing changes to drizzled/log_event.cc
- browse files at revision 613
- compare with another revision
- compare with revision 595
- download diff
- download tarball
- view history from revision 613
- Committer: Brian Aker
- Date: 2008-11-25 02:31:14 UTC
- Revision ID: brian@tangent.org-20081125023114-2f7sx8fye2jytgyw
Removed dead event structure pieces from replication.
- files modified:
- drizzled/log_event.cc
added
removed
drizzled/log_event.cc
443
443
case STOP_EVENT: return "Stop";
444
444
case QUERY_EVENT: return "Query";
445
445
case ROTATE_EVENT: return "Rotate";
446
case INTVAR_EVENT: return "Intvar";
447
446
case LOAD_EVENT: return "Load";
448
447
case NEW_LOAD_EVENT: return "New_load";
449
448
case SLAVE_EVENT: return "Slave";
451
450
case APPEND_BLOCK_EVENT: return "Append_block";
452
451
case DELETE_FILE_EVENT: return "Delete_file";
453
452
case EXEC_LOAD_EVENT: return "Exec_load";
454
case RAND_EVENT: return "RAND";
455
453
case XID_EVENT: return "Xid";
456
case USER_VAR_EVENT: return "User var";
457
454
case FORMAT_DESCRIPTION_EVENT: return "Format_desc";
458
455
case TABLE_MAP_EVENT: return "Table_map";
459
case PRE_GA_WRITE_ROWS_EVENT: return "Write_rows_event_old";
460
case PRE_GA_UPDATE_ROWS_EVENT: return "Update_rows_event_old";
461
case PRE_GA_DELETE_ROWS_EVENT: return "Delete_rows_event_old";
462
456
case WRITE_ROWS_EVENT: return "Write_rows";
463
457
case UPDATE_ROWS_EVENT: return "Update_rows";
464
458
case DELETE_ROWS_EVENT: return "Delete_rows";
997
991
case STOP_EVENT:
998
992
ev = new Stop_log_event(buf, description_event);
999
993
break;
1000
case INTVAR_EVENT:
1001
ev = new Intvar_log_event(buf, description_event);
1002
break;
1003
994
case XID_EVENT:
1004
995
ev = new Xid_log_event(buf, description_event);
1005
996
break;
1006
case RAND_EVENT:
1007
ev = new Rand_log_event(buf, description_event);
1008
break;
1009
case USER_VAR_EVENT:
1010
ev = new User_var_log_event(buf, description_event);
1011
break;
1012
997
case FORMAT_DESCRIPTION_EVENT:
1013
998
ev = new Format_description_log_event(buf, event_len, description_event);
1014
999
break;
1981
1966
post_header_len[QUERY_EVENT-1]= QUERY_HEADER_MINIMAL_LEN;
1982
1967
post_header_len[STOP_EVENT-1]= 0;
1983
1968
post_header_len[ROTATE_EVENT-1]= (binlog_ver==1) ? 0 : ROTATE_HEADER_LEN;
1984
post_header_len[INTVAR_EVENT-1]= 0;
1985
1969
post_header_len[LOAD_EVENT-1]= LOAD_HEADER_LEN;
1986
1970
post_header_len[SLAVE_EVENT-1]= 0;
1987
1971
post_header_len[CREATE_FILE_EVENT-1]= CREATE_FILE_HEADER_LEN;
1989
1973
post_header_len[EXEC_LOAD_EVENT-1]= EXEC_LOAD_HEADER_LEN;
1990
1974
post_header_len[DELETE_FILE_EVENT-1]= DELETE_FILE_HEADER_LEN;
1991
1975
post_header_len[NEW_LOAD_EVENT-1]= post_header_len[LOAD_EVENT-1];
1992
post_header_len[RAND_EVENT-1]= 0;
1993
post_header_len[USER_VAR_EVENT-1]= 0;
1994
1976
}
1995
1977
break;
1996
1978
default: /* Includes binlog version 2 i.e. 4.0.x x<=1 */
2115
2097
static const uint8_t perm[23]=
2116
2098
{
2117
2099
UNKNOWN_EVENT, START_EVENT_V3, QUERY_EVENT, STOP_EVENT, ROTATE_EVENT,
2118
INTVAR_EVENT, LOAD_EVENT, SLAVE_EVENT, CREATE_FILE_EVENT,
2100
LOAD_EVENT, SLAVE_EVENT, CREATE_FILE_EVENT,
2119
2101
APPEND_BLOCK_EVENT, EXEC_LOAD_EVENT, DELETE_FILE_EVENT,
2120
2102
NEW_LOAD_EVENT,
2121
RAND_EVENT, USER_VAR_EVENT,
2122
2103
FORMAT_DESCRIPTION_EVENT,
2123
2104
TABLE_MAP_EVENT,
2124
PRE_GA_WRITE_ROWS_EVENT,
2125
PRE_GA_UPDATE_ROWS_EVENT,
2126
PRE_GA_DELETE_ROWS_EVENT,
2127
2105
XID_EVENT,
2128
2106
BEGIN_LOAD_QUERY_EVENT,
2129
2107
EXECUTE_LOAD_QUERY_EVENT,
3073
3051
3074
3052
3075
3053
/**************************************************************************
3076
Intvar_log_event methods
3077
**************************************************************************/
3078
3079
/*
3080
Intvar_log_event::pack_info()
3081
*/
3082
3083
void Intvar_log_event::pack_info(Protocol *protocol)
3084
{
3085
char buf[256], *pos;
3086
pos= strmake(buf, get_var_type_name(), sizeof(buf)-23);
3087
*pos++= '=';
3088
pos= int64_t10_to_str(val, pos, -10);
3089
protocol->store(buf, (uint) (pos-buf), &my_charset_bin);
3090
}
3091
3092
3093
/*
3094
Intvar_log_event::Intvar_log_event()
3095
*/
3096
3097
Intvar_log_event::Intvar_log_event(const char* buf,
3098
const Format_description_log_event* description_event)
3099
:Log_event(buf, description_event)
3100
{
3101
buf+= description_event->common_header_len;
3102
type= buf[I_TYPE_OFFSET];
3103
val= uint8korr(buf+I_VAL_OFFSET);
3104
}
3105
3106
3107
/*
3108
Intvar_log_event::get_var_type_name()
3109
*/
3110
3111
const char* Intvar_log_event::get_var_type_name()
3112
{
3113
switch(type) {
3114
case LAST_INSERT_ID_EVENT: return "LAST_INSERT_ID";
3115
case INSERT_ID_EVENT: return "INSERT_ID";
3116
default: /* impossible */ return "UNKNOWN";
3117
}
3118
}
3119
3120
3121
/*
3122
Intvar_log_event::write()
3123
*/
3124
3125
bool Intvar_log_event::write(IO_CACHE* file)
3126
{
3127
unsigned char buf[9];
3128
buf[I_TYPE_OFFSET]= (unsigned char) type;
3129
int8store(buf + I_VAL_OFFSET, val);
3130
return (write_header(file, sizeof(buf)) ||
3131
my_b_safe_write(file, buf, sizeof(buf)));
3132
}
3133
3134
3135
/*
3136
Intvar_log_event::print()
3137
*/
3138
3139
/*
3140
Intvar_log_event::do_apply_event()
3141
*/
3142
3143
int Intvar_log_event::do_apply_event(Relay_log_info const *rli)
3144
{
3145
/*
3146
We are now in a statement until the associated query log event has
3147
been processed.
3148
*/
3149
const_cast<Relay_log_info*>(rli)->set_flag(Relay_log_info::IN_STMT);
3150
3151
switch (type) {
3152
case LAST_INSERT_ID_EVENT:
3153
session->stmt_depends_on_first_successful_insert_id_in_prev_stmt= 1;
3154
session->first_successful_insert_id_in_prev_stmt= val;
3155
break;
3156
case INSERT_ID_EVENT:
3157
session->force_one_auto_inc_interval(val);
3158
break;
3159
}
3160
return 0;
3161
}
3162
3163
int Intvar_log_event::do_update_pos(Relay_log_info *rli)
3164
{
3165
rli->inc_event_relay_log_pos();
3166
return 0;
3167
}
3168
3169
3170
Log_event::enum_skip_reason
3171
Intvar_log_event::do_shall_skip(Relay_log_info *rli)
3172
{
3173
/*
3174
It is a common error to set the slave skip counter to 1 instead of
3175
2 when recovering from an insert which used a auto increment,
3176
rand, or user var. Therefore, if the slave skip counter is 1, we
3177
just say that this event should be skipped by ignoring it, meaning
3178
that we do not change the value of the slave skip counter since it
3179
will be decreased by the following insert event.
3180
*/
3181
return continue_group(rli);
3182
}
3183
3184
3185
/**************************************************************************
3186
Rand_log_event methods
3187
**************************************************************************/
3188
3189
void Rand_log_event::pack_info(Protocol *protocol)
3190
{
3191
char buf1[256], *pos;
3192
pos= my_stpcpy(buf1,"rand_seed1=");
3193
pos= int10_to_str((long) seed1, pos, 10);
3194
pos= my_stpcpy(pos, ",rand_seed2=");
3195
pos= int10_to_str((long) seed2, pos, 10);
3196
protocol->store(buf1, (uint) (pos-buf1), &my_charset_bin);
3197
}
3198
3199
3200
Rand_log_event::Rand_log_event(const char* buf,
3201
const Format_description_log_event* description_event)
3202
:Log_event(buf, description_event)
3203
{
3204
buf+= description_event->common_header_len;
3205
seed1= uint8korr(buf+RAND_SEED1_OFFSET);
3206
seed2= uint8korr(buf+RAND_SEED2_OFFSET);
3207
}
3208
3209
3210
bool Rand_log_event::write(IO_CACHE* file)
3211
{
3212
unsigned char buf[16];
3213
int8store(buf + RAND_SEED1_OFFSET, seed1);
3214
int8store(buf + RAND_SEED2_OFFSET, seed2);
3215
return (write_header(file, sizeof(buf)) ||
3216
my_b_safe_write(file, buf, sizeof(buf)));
3217
}
3218
3219
3220
int Rand_log_event::do_apply_event(Relay_log_info const *rli)
3221
{
3222
/*
3223
We are now in a statement until the associated query log event has
3224
been processed.
3225
*/
3226
const_cast<Relay_log_info*>(rli)->set_flag(Relay_log_info::IN_STMT);
3227
3228
session->rand.seed1= (ulong) seed1;
3229
session->rand.seed2= (ulong) seed2;
3230
return 0;
3231
}
3232
3233
int Rand_log_event::do_update_pos(Relay_log_info *rli)
3234
{
3235
rli->inc_event_relay_log_pos();
3236
return 0;
3237
}
3238
3239
3240
Log_event::enum_skip_reason
3241
Rand_log_event::do_shall_skip(Relay_log_info *rli)
3242
{
3243
/*
3244
It is a common error to set the slave skip counter to 1 instead of
3245
2 when recovering from an insert which used a auto increment,
3246
rand, or user var. Therefore, if the slave skip counter is 1, we
3247
just say that this event should be skipped by ignoring it, meaning
3248
that we do not change the value of the slave skip counter since it
3249
will be decreased by the following insert event.
3250
*/
3251
return continue_group(rli);
3252
}
3253
3254
3255
/**************************************************************************
3256
3054
Xid_log_event methods
3257
3055
**************************************************************************/
3258
3056
3308
3106
3309
3107
3310
3108
/**************************************************************************
3311
User_var_log_event methods
3312
**************************************************************************/
3313
3314
void User_var_log_event::pack_info(Protocol* protocol)
3315
{
3316
char *buf= 0;
3317
uint32_t val_offset= 4 + name_len;
3318
uint32_t event_len= val_offset;
3319
3320
if (is_null)
3321
{
3322
if (!(buf= (char*) my_malloc(val_offset + 5, MYF(MY_WME))))
3323
return;
3324
my_stpcpy(buf + val_offset, "NULL");
3325
event_len= val_offset + 4;
3326
}
3327
else
3328
{
3329
switch (type) {
3330
case REAL_RESULT:
3331
double real_val;
3332
float8get(real_val, val);
3333
if (!(buf= (char*) my_malloc(val_offset + MY_GCVT_MAX_FIELD_WIDTH + 1,
3334
MYF(MY_WME))))
3335
return;
3336
event_len+= my_gcvt(real_val, MY_GCVT_ARG_DOUBLE, MY_GCVT_MAX_FIELD_WIDTH,
3337
buf + val_offset, NULL);
3338
break;
3339
case INT_RESULT:
3340
if (!(buf= (char*) my_malloc(val_offset + 22, MYF(MY_WME))))
3341
return;
3342
event_len= int64_t10_to_str(uint8korr(val), buf + val_offset,-10)-buf;
3343
break;
3344
case DECIMAL_RESULT:
3345
{
3346
if (!(buf= (char*) my_malloc(val_offset + DECIMAL_MAX_STR_LENGTH,
3347
MYF(MY_WME))))
3348
return;
3349
String str(buf+val_offset, DECIMAL_MAX_STR_LENGTH, &my_charset_bin);
3350
my_decimal dec;
3351
binary2my_decimal(E_DEC_FATAL_ERROR, (unsigned char*) (val+2), &dec, val[0],
3352
val[1]);
3353
my_decimal2string(E_DEC_FATAL_ERROR, &dec, 0, 0, 0, &str);
3354
event_len= str.length() + val_offset;
3355
break;
3356
}
3357
case STRING_RESULT:
3358
/* 15 is for 'COLLATE' and other chars */
3359
buf= (char*) my_malloc(event_len+val_len*2+1+2*MY_CS_NAME_SIZE+15,
3360
MYF(MY_WME));
3361
const CHARSET_INFO *cs;
3362
if (!buf)
3363
return;
3364
if (!(cs= get_charset(charset_number, MYF(0))))
3365
{
3366
my_stpcpy(buf+val_offset, "???");
3367
event_len+= 3;
3368
}
3369
else
3370
{
3371
char *p= strxmov(buf + val_offset, "_", cs->csname, " ", NULL);
3372
p= str_to_hex(p, val, val_len);
3373
p= strxmov(p, " COLLATE ", cs->name, NULL);
3374
event_len= p-buf;
3375
}
3376
break;
3377
case ROW_RESULT:
3378
default:
3379
assert(1);
3380
return;
3381
}
3382
}
3383
buf[0]= '@';
3384
buf[1]= '`';
3385
memcpy(buf+2, name, name_len);
3386
buf[2+name_len]= '`';
3387
buf[3+name_len]= '=';
3388
protocol->store(buf, event_len, &my_charset_bin);
3389
free(buf);
3390
}
3391
3392
3393
User_var_log_event::
3394
User_var_log_event(const char* buf,
3395
const Format_description_log_event* description_event)
3396
:Log_event(buf, description_event)
3397
{
3398
buf+= description_event->common_header_len;
3399
name_len= uint4korr(buf);
3400
name= (char *) buf + UV_NAME_LEN_SIZE;
3401
buf+= UV_NAME_LEN_SIZE + name_len;
3402
is_null= (bool) *buf;
3403
if (is_null)
3404
{
3405
type= STRING_RESULT;
3406
charset_number= my_charset_bin.number;
3407
val_len= 0;
3408
val= 0;
3409
}
3410
else
3411
{
3412
type= (Item_result) buf[UV_VAL_IS_NULL];
3413
charset_number= uint4korr(buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE);
3414
val_len= uint4korr(buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE +
3415
UV_CHARSET_NUMBER_SIZE);
3416
val= (char *) (buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE +
3417
UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE);
3418
}
3419
}
3420
3421
3422
bool User_var_log_event::write(IO_CACHE* file)
3423
{
3424
char buf[UV_NAME_LEN_SIZE];
3425
char buf1[UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE +
3426
UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE];
3427
unsigned char buf2[(8 > DECIMAL_MAX_FIELD_SIZE + 2) ? 8 : DECIMAL_MAX_FIELD_SIZE +2], *pos= buf2;
3428
uint32_t buf1_length;
3429
ulong event_length;
3430
3431
int4store(buf, name_len);
3432
3433
if ((buf1[0]= is_null))
3434
{
3435
buf1_length= 1;
3436
val_len= 0; // Length of 'pos'
3437
}
3438
else
3439
{
3440
buf1[1]= type;
3441
int4store(buf1 + 2, charset_number);
3442
3443
switch (type) {
3444
case REAL_RESULT:
3445
float8store(buf2, *(double*) val);
3446
break;
3447
case INT_RESULT:
3448
int8store(buf2, *(int64_t*) val);
3449
break;
3450
case DECIMAL_RESULT:
3451
{
3452
my_decimal *dec= (my_decimal *)val;
3453
dec->fix_buffer_pointer();
3454
buf2[0]= (char)(dec->intg + dec->frac);
3455
buf2[1]= (char)dec->frac;
3456
decimal2bin((decimal_t*)val, buf2+2, buf2[0], buf2[1]);
3457
val_len= decimal_bin_size(buf2[0], buf2[1]) + 2;
3458
break;
3459
}
3460
case STRING_RESULT:
3461
pos= (unsigned char*) val;
3462
break;
3463
case ROW_RESULT:
3464
default:
3465
assert(1);
3466
return 0;
3467
}
3468
int4store(buf1 + 2 + UV_CHARSET_NUMBER_SIZE, val_len);
3469
buf1_length= 10;
3470
}
3471
3472
/* Length of the whole event */
3473
event_length= sizeof(buf)+ name_len + buf1_length + val_len;
3474
3475
return (write_header(file, event_length) ||
3476
my_b_safe_write(file, (unsigned char*) buf, sizeof(buf)) ||
3477
my_b_safe_write(file, (unsigned char*) name, name_len) ||
3478
my_b_safe_write(file, (unsigned char*) buf1, buf1_length) ||
3479
my_b_safe_write(file, pos, val_len));
3480
}
3481
3482
3483
3484
/*
3485
User_var_log_event::do_apply_event()
3486
*/
3487
3488
int User_var_log_event::do_apply_event(Relay_log_info const *rli)
3489
{
3490
Item *it= 0;
3491
const CHARSET_INFO *charset;
3492
if (!(charset= get_charset(charset_number, MYF(MY_WME))))
3493
return 1;
3494
LEX_STRING user_var_name;
3495
user_var_name.str= name;
3496
user_var_name.length= name_len;
3497
double real_val;
3498
int64_t int_val;
3499
3500
/*
3501
We are now in a statement until the associated query log event has
3502
been processed.
3503
*/
3504
const_cast<Relay_log_info*>(rli)->set_flag(Relay_log_info::IN_STMT);
3505
3506
if (is_null)
3507
{
3508
it= new Item_null();
3509
}
3510
else
3511
{
3512
switch (type) {
3513
case REAL_RESULT:
3514
float8get(real_val, val);
3515
it= new Item_float(real_val, 0);
3516
val= (char*) &real_val; // Pointer to value in native format
3517
val_len= 8;
3518
break;
3519
case INT_RESULT:
3520
int_val= (int64_t) uint8korr(val);
3521
it= new Item_int(int_val);
3522
val= (char*) &int_val; // Pointer to value in native format
3523
val_len= 8;
3524
break;
3525
case DECIMAL_RESULT:
3526
{
3527
Item_decimal *dec= new Item_decimal((unsigned char*) val+2, val[0], val[1]);
3528
it= dec;
3529
val= (char *)dec->val_decimal(NULL);
3530
val_len= sizeof(my_decimal);
3531
break;
3532
}
3533
case STRING_RESULT:
3534
it= new Item_string(val, val_len, charset);
3535
break;
3536
case ROW_RESULT:
3537
default:
3538
assert(1);
3539
return 0;
3540
}
3541
}
3542
Item_func_set_user_var e(user_var_name, it);
3543
/*
3544
Item_func_set_user_var can't substitute something else on its place =>
3545
0 can be passed as last argument (reference on item)
3546
*/
3547
e.fix_fields(session, 0);
3548
/*
3549
A variable can just be considered as a table with
3550
a single record and with a single column. Thus, like
3551
a column value, it could always have IMPLICIT derivation.
3552
*/
3553
e.update_hash(val, val_len, type, charset, DERIVATION_IMPLICIT, 0);
3554
free_root(session->mem_root,0);
3555
3556
return 0;
3557
}
3558
3559
int User_var_log_event::do_update_pos(Relay_log_info *rli)
3560
{
3561
rli->inc_event_relay_log_pos();
3562
return 0;
3563
}
3564
3565
Log_event::enum_skip_reason
3566
User_var_log_event::do_shall_skip(Relay_log_info *rli)
3567
{
3568
/*
3569
It is a common error to set the slave skip counter to 1 instead
3570
of 2 when recovering from an insert which used a auto increment,
3571
rand, or user var. Therefore, if the slave skip counter is 1, we
3572
just say that this event should be skipped by ignoring it, meaning
3573
that we do not change the value of the slave skip counter since it
3574
will be decreased by the following insert event.
3575
*/
3576
return continue_group(rli);
3577
}
3578
3579
3580
/**************************************************************************
3581
3109
Slave_log_event methods
3582
3110
**************************************************************************/
3583
3111
4470
3998
my_b_safe_write(file,(unsigned char*) &opt_flags,1));
4471
3999
}
4472
4000
else
4473
{
4474
/**
4475
@todo This is sensitive to field padding. We should write a
4476
char[7], not an old_sql_ex. /sven
4477
*/
4478
old_sql_ex old_ex;
4479
old_ex.field_term= *field_term;
4480
old_ex.enclosed= *enclosed;
4481
old_ex.line_term= *line_term;
4482
old_ex.line_start= *line_start;
4483
old_ex.escaped= *escaped;
4484
old_ex.opt_flags= opt_flags;
4485
old_ex.empty_flags=empty_flags;
4486
return my_b_safe_write(file, (unsigned char*) &old_ex, sizeof(old_ex)) != 0;
4487
}
4001
assert(0);
4488
4002
}
4489
4003
4490
4004
Loggerhead is a web-based interface for Breezy
Version: 2.0.1