« back to all changes in this revision
Viewing changes to drizzled/log_event.cc
- browse files at revision 319.1.1
- compare with another revision
- compare with revision 2318.8.15
- download diff
- download tarball
- view history from revision 319.1.1
- Committer: Grant Limberg
- Date: 2008-08-12 21:13:01 UTC
- mto: (322.1.1 codestyle)
- mto: This revision was merged to the branch mainline in revision 324.
- Revision ID: grant@glsoftware.net-20080812211301-ym3wsowelkgp16s2
renamed all instances of MYSQL_ to DRIZZLE_
- files modified:
- client/Makefile.am
added
removed
drizzled/log_event.cc
14
14
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
15
15
16
16
17
#ifndef MYSQL_CLIENT
17
#ifndef DRIZZLE_CLIENT
18
18
19
19
#include <drizzled/server_includes.h>
20
20
#include "rpl_rli.h"
25
25
#include <mysys/my_dir.h>
26
26
#include <drizzled/drizzled_error_messages.h>
27
27
28
#endif /* !MYSQL_CLIENT */
28
#endif /* !DRIZZLE_CLIENT */
29
29
30
30
#include <mysys/base64.h>
31
31
#include <mysys/my_bitmap.h>
44
44
#define FMT_G_BUFSIZE(PREC) (3 + (PREC) + 5 + 1)
45
45
46
46
47
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
47
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
48
48
static const char *HA_ERR(int i)
49
49
{
50
50
switch (i) {
231
231
pretty_print_str()
232
232
*/
233
233
234
#ifdef MYSQL_CLIENT
234
#ifdef DRIZZLE_CLIENT
235
235
static void pretty_print_str(IO_CACHE* cache, const char* str, int len)
236
236
{
237
237
const char* end = str + len;
254
254
}
255
255
my_b_printf(cache, "\'");
256
256
}
257
#endif /* MYSQL_CLIENT */
257
#endif /* DRIZZLE_CLIENT */
258
258
259
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
259
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
260
260
261
261
static void clear_all_errors(THD *thd, Relay_log_info *rli)
262
262
{
282
282
pretty_print_str()
283
283
*/
284
284
285
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
285
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
286
286
static char *pretty_print_str(char *packet, const char *str, int len)
287
287
{
288
288
const char *end= str + len;
307
307
*pos++= '\'';
308
308
return pos;
309
309
}
310
#endif /* !MYSQL_CLIENT */
311
312
313
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
310
#endif /* !DRIZZLE_CLIENT */
311
312
313
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
314
314
315
315
/**
316
316
Creates a temporary name for load data infile:.
343
343
#endif
344
344
345
345
346
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
346
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
347
347
348
348
/**
349
349
Delete all temporary files used for SQL_LOAD.
433
433
return to; // pointer to end 0 of 'to'
434
434
}
435
435
436
#ifndef MYSQL_CLIENT
436
#ifndef DRIZZLE_CLIENT
437
437
438
438
/**
439
439
Append a version of the 'from' string suitable for use in a query to
472
472
commands just before it prints a query.
473
473
*/
474
474
475
#ifdef MYSQL_CLIENT
475
#ifdef DRIZZLE_CLIENT
476
476
477
477
static void print_set_option(IO_CACHE* file, uint32_t bits_changed,
478
478
uint32_t option, uint32_t flags, const char* name,
540
540
Log_event::Log_event()
541
541
*/
542
542
543
#ifndef MYSQL_CLIENT
543
#ifndef DRIZZLE_CLIENT
544
544
Log_event::Log_event(THD* thd_arg, uint16_t flags_arg, bool using_trans)
545
545
:log_pos(0), temp_buf(0), exec_time(0), flags(flags_arg), thd(thd_arg)
546
546
{
569
569
when= 0;
570
570
log_pos= 0;
571
571
}
572
#endif /* !MYSQL_CLIENT */
572
#endif /* !DRIZZLE_CLIENT */
573
573
574
574
575
575
/*
580
580
const Format_description_log_event* description_event)
581
581
:temp_buf(0), cache_stmt(0)
582
582
{
583
#ifndef MYSQL_CLIENT
583
#ifndef DRIZZLE_CLIENT
584
584
thd = 0;
585
585
#endif
586
586
when = uint4korr(buf);
643
643
/* otherwise, go on with reading the header from buf (nothing now) */
644
644
}
645
645
646
#ifndef MYSQL_CLIENT
646
#ifndef DRIZZLE_CLIENT
647
647
#ifdef HAVE_REPLICATION
648
648
649
649
int Log_event::do_update_pos(Relay_log_info *rli)
895
895
pthread_mutex_unlock(log_lock);
896
896
return(result);
897
897
}
898
#endif /* !MYSQL_CLIENT */
898
#endif /* !DRIZZLE_CLIENT */
899
899
900
#ifndef MYSQL_CLIENT
900
#ifndef DRIZZLE_CLIENT
901
901
#define UNLOCK_MUTEX if (log_lock) pthread_mutex_unlock(log_lock);
902
902
#define LOCK_MUTEX if (log_lock) pthread_mutex_lock(log_lock);
903
903
#else
905
905
#define LOCK_MUTEX
906
906
#endif
907
907
908
#ifndef MYSQL_CLIENT
908
#ifndef DRIZZLE_CLIENT
909
909
/**
910
910
@note
911
911
Allocates memory; The caller is responsible for clean-up.
1139
1139
if (!ev || !ev->is_valid())
1140
1140
{
1141
1141
delete ev;
1142
#ifdef MYSQL_CLIENT
1142
#ifdef DRIZZLE_CLIENT
1143
1143
if (!force_opt) /* then mysqlbinlog dies */
1144
1144
{
1145
1145
*error= "Found invalid event in binary log";
1154
1154
return(ev);
1155
1155
}
1156
1156
1157
#ifdef MYSQL_CLIENT
1157
#ifdef DRIZZLE_CLIENT
1158
1158
1159
1159
/*
1160
1160
Log_event::print_header()
1307
1307
struct tm *res;
1308
1308
if (!ts)
1309
1309
ts = &when;
1310
#ifdef MYSQL_SERVER // This is always false
1310
#ifdef DRIZZLE_SERVER // This is always false
1311
1311
struct tm tm_tmp;
1312
1312
localtime_r(ts,(res= &tm_tmp));
1313
1313
#else
1324
1324
return;
1325
1325
}
1326
1326
1327
#endif /* MYSQL_CLIENT */
1328
1329
1330
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
1327
#endif /* DRIZZLE_CLIENT */
1328
1329
1330
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
1331
1331
inline Log_event::enum_skip_reason
1332
1332
Log_event::continue_group(Relay_log_info *rli)
1333
1333
{
1341
1341
Query_log_event methods
1342
1342
**************************************************************************/
1343
1343
1344
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
1344
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
1345
1345
1346
1346
/**
1347
1347
This (which is used only for SHOW BINLOG EVENTS) could be updated to
1376
1376
}
1377
1377
#endif
1378
1378
1379
#ifndef MYSQL_CLIENT
1379
#ifndef DRIZZLE_CLIENT
1380
1380
1381
1381
/**
1382
1382
Utility function for the next method (Query_log_event::write()) .
1671
1671
else
1672
1672
time_zone_len= 0;
1673
1673
}
1674
#endif /* MYSQL_CLIENT */
1674
#endif /* DRIZZLE_CLIENT */
1675
1675
1676
1676
1677
1677
/* 2 utility functions for the next method */
1931
1931
}
1932
1932
1933
1933
1934
#ifdef MYSQL_CLIENT
1934
#ifdef DRIZZLE_CLIENT
1935
1935
/**
1936
1936
Query_log_event::print().
1937
1937
2094
2094
my_b_write(&cache, (uchar*) query, q_len);
2095
2095
my_b_printf(&cache, "\n%s\n", print_event_info->delimiter);
2096
2096
}
2097
#endif /* MYSQL_CLIENT */
2097
#endif /* DRIZZLE_CLIENT */
2098
2098
2099
2099
2100
2100
/*
2101
2101
Query_log_event::do_apply_event()
2102
2102
*/
2103
2103
2104
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
2104
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
2105
2105
2106
2106
int Query_log_event::do_apply_event(Relay_log_info const *rli)
2107
2107
{
2437
2437
Start_log_event_v3 methods
2438
2438
**************************************************************************/
2439
2439
2440
#ifndef MYSQL_CLIENT
2440
#ifndef DRIZZLE_CLIENT
2441
2441
Start_log_event_v3::Start_log_event_v3()
2442
2442
:Log_event(), created(0), binlog_version(BINLOG_VERSION),
2443
2443
artificial_event(0), dont_set_created(0)
2450
2450
Start_log_event_v3::pack_info()
2451
2451
*/
2452
2452
2453
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
2453
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
2454
2454
void Start_log_event_v3::pack_info(Protocol *protocol)
2455
2455
{
2456
2456
char buf[12 + ST_SERVER_VER_LEN + 14 + 22], *pos;
2467
2467
Start_log_event_v3::print()
2468
2468
*/
2469
2469
2470
#ifdef MYSQL_CLIENT
2470
#ifdef DRIZZLE_CLIENT
2471
2471
void Start_log_event_v3::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
2472
2472
{
2473
2473
Write_on_release_cache cache(&print_event_info->head_cache, file,
2510
2510
}
2511
2511
return;
2512
2512
}
2513
#endif /* MYSQL_CLIENT */
2513
#endif /* DRIZZLE_CLIENT */
2514
2514
2515
2515
/*
2516
2516
Start_log_event_v3::Start_log_event_v3()
2538
2538
Start_log_event_v3::write()
2539
2539
*/
2540
2540
2541
#ifndef MYSQL_CLIENT
2541
#ifndef DRIZZLE_CLIENT
2542
2542
bool Start_log_event_v3::write(IO_CACHE* file)
2543
2543
{
2544
2544
char buff[START_V3_HEADER_LEN];
2553
2553
#endif
2554
2554
2555
2555
2556
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
2556
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
2557
2557
2558
2558
/**
2559
2559
Start_log_event_v3::do_apply_event() .
2618
2618
}
2619
2619
return(0);
2620
2620
}
2621
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
2621
#endif /* defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT) */
2622
2622
2623
2623
/***************************************************************************
2624
2624
Format_description_log_event methods
2870
2870
return;
2871
2871
}
2872
2872
2873
#ifndef MYSQL_CLIENT
2873
#ifndef DRIZZLE_CLIENT
2874
2874
bool Format_description_log_event::write(IO_CACHE* file)
2875
2875
{
2876
2876
/*
2891
2891
}
2892
2892
#endif
2893
2893
2894
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
2894
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
2895
2895
int Format_description_log_event::do_apply_event(Relay_log_info const *rli)
2896
2896
{
2897
2897
/*
3022
3022
Load_log_event::pack_info()
3023
3023
*/
3024
3024
3025
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3025
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
3026
3026
uint Load_log_event::get_query_buffer_length()
3027
3027
{
3028
3028
return
3137
3137
protocol->store(buf, end-buf, &my_charset_bin);
3138
3138
my_free(buf, MYF(0));
3139
3139
}
3140
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
3141
3142
3143
#ifndef MYSQL_CLIENT
3140
#endif /* defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT) */
3141
3142
3143
#ifndef DRIZZLE_CLIENT
3144
3144
3145
3145
/*
3146
3146
Load_log_event::write_data_header()
3265
3265
field_lens = (const uchar*)field_lens_buf.ptr();
3266
3266
fields = fields_buf.ptr();
3267
3267
}
3268
#endif /* !MYSQL_CLIENT */
3268
#endif /* !DRIZZLE_CLIENT */
3269
3269
3270
3270
3271
3271
/**
3346
3346
Load_log_event::print()
3347
3347
*/
3348
3348
3349
#ifdef MYSQL_CLIENT
3349
#ifdef DRIZZLE_CLIENT
3350
3350
void Load_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
3351
3351
{
3352
3352
print(file, print_event_info, 0);
3442
3442
my_b_printf(&cache, "%s\n", print_event_info->delimiter);
3443
3443
return;
3444
3444
}
3445
#endif /* MYSQL_CLIENT */
3445
#endif /* DRIZZLE_CLIENT */
3446
3446
3447
#ifndef MYSQL_CLIENT
3447
#ifndef DRIZZLE_CLIENT
3448
3448
3449
3449
/**
3450
3450
Load_log_event::set_fields()
3469
3469
field+= field_lens[i] + 1;
3470
3470
}
3471
3471
}
3472
#endif /* !MYSQL_CLIENT */
3473
3474
3475
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3472
#endif /* !DRIZZLE_CLIENT */
3473
3474
3475
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
3476
3476
/**
3477
3477
Does the data loading job when executing a LOAD DATA on the slave.
3478
3478
3772
3772
Rotate_log_event::pack_info()
3773
3773
*/
3774
3774
3775
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3775
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
3776
3776
void Rotate_log_event::pack_info(Protocol *protocol)
3777
3777
{
3778
3778
char buf1[256], buf[22];
3790
3790
Rotate_log_event::print()
3791
3791
*/
3792
3792
3793
#ifdef MYSQL_CLIENT
3793
#ifdef DRIZZLE_CLIENT
3794
3794
void Rotate_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
3795
3795
{
3796
3796
char buf[22];
3805
3805
my_b_write(&cache, (uchar*) new_log_ident, (uint)ident_len);
3806
3806
my_b_printf(&cache, " pos: %s\n", llstr(pos, buf));
3807
3807
}
3808
#endif /* MYSQL_CLIENT */
3808
#endif /* DRIZZLE_CLIENT */
3809
3809
3810
3810
3811
3811
3814
3814
*/
3815
3815
3816
3816
3817
#ifndef MYSQL_CLIENT
3817
#ifndef DRIZZLE_CLIENT
3818
3818
Rotate_log_event::Rotate_log_event(const char* new_log_ident_arg,
3819
3819
uint ident_len_arg, uint64_t pos_arg,
3820
3820
uint flags_arg)
3854
3854
Rotate_log_event::write()
3855
3855
*/
3856
3856
3857
#ifndef MYSQL_CLIENT
3857
#ifndef DRIZZLE_CLIENT
3858
3858
bool Rotate_log_event::write(IO_CACHE* file)
3859
3859
{
3860
3860
char buf[ROTATE_HEADER_LEN];
3866
3866
#endif
3867
3867
3868
3868
3869
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3869
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
3870
3870
3871
3871
/*
3872
3872
Got a rotate log event from the master.
3959
3959
Intvar_log_event::pack_info()
3960
3960
*/
3961
3961
3962
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3962
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
3963
3963
void Intvar_log_event::pack_info(Protocol *protocol)
3964
3964
{
3965
3965
char buf[256], *pos;
4003
4003
Intvar_log_event::write()
4004
4004
*/
4005
4005
4006
#ifndef MYSQL_CLIENT
4006
#ifndef DRIZZLE_CLIENT
4007
4007
bool Intvar_log_event::write(IO_CACHE* file)
4008
4008
{
4009
4009
uchar buf[9];
4019
4019
Intvar_log_event::print()
4020
4020
*/
4021
4021
4022
#ifdef MYSQL_CLIENT
4022
#ifdef DRIZZLE_CLIENT
4023
4023
void Intvar_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
4024
4024
{
4025
4025
char llbuff[22];
4056
4056
Intvar_log_event::do_apply_event()
4057
4057
*/
4058
4058
4059
#if defined(HAVE_REPLICATION)&& !defined(MYSQL_CLIENT)
4059
#if defined(HAVE_REPLICATION)&& !defined(DRIZZLE_CLIENT)
4060
4060
int Intvar_log_event::do_apply_event(Relay_log_info const *rli)
4061
4061
{
4062
4062
/*
4105
4105
Rand_log_event methods
4106
4106
**************************************************************************/
4107
4107
4108
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4108
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
4109
4109
void Rand_log_event::pack_info(Protocol *protocol)
4110
4110
{
4111
4111
char buf1[256], *pos;
4128
4128
}
4129
4129
4130
4130
4131
#ifndef MYSQL_CLIENT
4131
#ifndef DRIZZLE_CLIENT
4132
4132
bool Rand_log_event::write(IO_CACHE* file)
4133
4133
{
4134
4134
uchar buf[16];
4140
4140
#endif
4141
4141
4142
4142
4143
#ifdef MYSQL_CLIENT
4143
#ifdef DRIZZLE_CLIENT
4144
4144
void Rand_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
4145
4145
{
4146
4146
Write_on_release_cache cache(&print_event_info->head_cache, file,
4156
4156
llstr(seed1, llbuff),llstr(seed2, llbuff2),
4157
4157
print_event_info->delimiter);
4158
4158
}
4159
#endif /* MYSQL_CLIENT */
4160
4161
4162
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4159
#endif /* DRIZZLE_CLIENT */
4160
4161
4162
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
4163
4163
int Rand_log_event::do_apply_event(Relay_log_info const *rli)
4164
4164
{
4165
4165
/*
4194
4194
return continue_group(rli);
4195
4195
}
4196
4196
4197
#endif /* !MYSQL_CLIENT */
4197
#endif /* !DRIZZLE_CLIENT */
4198
4198
4199
4199
4200
4200
/**************************************************************************
4201
4201
Xid_log_event methods
4202
4202
**************************************************************************/
4203
4203
4204
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4204
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
4205
4205
void Xid_log_event::pack_info(Protocol *protocol)
4206
4206
{
4207
4207
char buf[128], *pos;
4231
4231
}
4232
4232
4233
4233
4234
#ifndef MYSQL_CLIENT
4234
#ifndef DRIZZLE_CLIENT
4235
4235
bool Xid_log_event::write(IO_CACHE* file)
4236
4236
{
4237
4237
return write_header(file, sizeof(xid)) ||
4240
4240
#endif
4241
4241
4242
4242
4243
#ifdef MYSQL_CLIENT
4243
#ifdef DRIZZLE_CLIENT
4244
4244
void Xid_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
4245
4245
{
4246
4246
Write_on_release_cache cache(&print_event_info->head_cache, file,
4256
4256
}
4257
4257
my_b_printf(&cache, "COMMIT%s\n", print_event_info->delimiter);
4258
4258
}
4259
#endif /* MYSQL_CLIENT */
4260
4261
4262
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4259
#endif /* DRIZZLE_CLIENT */
4260
4261
4262
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
4263
4263
int Xid_log_event::do_apply_event(Relay_log_info const *rli __attribute__((unused)))
4264
4264
{
4265
4265
/* For a slave Xid_log_event is COMMIT */
4277
4277
}
4278
4278
return(Log_event::do_shall_skip(rli));
4279
4279
}
4280
#endif /* !MYSQL_CLIENT */
4280
#endif /* !DRIZZLE_CLIENT */
4281
4281
4282
4282
4283
4283
/**************************************************************************
4284
4284
User_var_log_event methods
4285
4285
**************************************************************************/
4286
4286
4287
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4287
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
4288
4288
void User_var_log_event::pack_info(Protocol* protocol)
4289
4289
{
4290
4290
char *buf= 0;
4362
4362
protocol->store(buf, event_len, &my_charset_bin);
4363
4363
my_free(buf, MYF(0));
4364
4364
}
4365
#endif /* !MYSQL_CLIENT */
4365
#endif /* !DRIZZLE_CLIENT */
4366
4366
4367
4367
4368
4368
User_var_log_event::
4394
4394
}
4395
4395
4396
4396
4397
#ifndef MYSQL_CLIENT
4397
#ifndef DRIZZLE_CLIENT
4398
4398
bool User_var_log_event::write(IO_CACHE* file)
4399
4399
{
4400
4400
char buf[UV_NAME_LEN_SIZE];
4461
4461
User_var_log_event::print()
4462
4462
*/
4463
4463
4464
#ifdef MYSQL_CLIENT
4464
#ifdef DRIZZLE_CLIENT
4465
4465
void User_var_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
4466
4466
{
4467
4467
Write_on_release_cache cache(&print_event_info->head_cache, file,
4568
4568
User_var_log_event::do_apply_event()
4569
4569
*/
4570
4570
4571
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4571
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
4572
4572
int User_var_log_event::do_apply_event(Relay_log_info const *rli)
4573
4573
{
4574
4574
Item *it= 0;
4659
4659
*/
4660
4660
return continue_group(rli);
4661
4661
}
4662
#endif /* !MYSQL_CLIENT */
4662
#endif /* !DRIZZLE_CLIENT */
4663
4663
4664
4664
4665
4665
/**************************************************************************
4667
4667
**************************************************************************/
4668
4668
4669
4669
#ifdef HAVE_REPLICATION
4670
#ifdef MYSQL_CLIENT
4670
#ifdef DRIZZLE_CLIENT
4671
4671
void Unknown_log_event::print(FILE* file_arg, PRINT_EVENT_INFO* print_event_info)
4672
4672
{
4673
4673
Write_on_release_cache cache(&print_event_info->head_cache, file_arg);
4679
4679
}
4680
4680
#endif
4681
4681
4682
#ifndef MYSQL_CLIENT
4682
#ifndef DRIZZLE_CLIENT
4683
4683
void Slave_log_event::pack_info(Protocol *protocol)
4684
4684
{
4685
4685
char buf[256+HOSTNAME_LENGTH], *pos;
4693
4693
pos= int64_t10_to_str(master_pos, pos, 10);
4694
4694
protocol->store(buf, pos-buf, &my_charset_bin);
4695
4695
}
4696
#endif /* !MYSQL_CLIENT */
4697
4698
4699
#ifndef MYSQL_CLIENT
4696
#endif /* !DRIZZLE_CLIENT */
4697
4698
4699
#ifndef DRIZZLE_CLIENT
4700
4700
/**
4701
4701
@todo
4702
4702
re-write this better without holding both locks at the same time
4731
4731
pthread_mutex_unlock(&mi->data_lock);
4732
4732
return;
4733
4733
}
4734
#endif /* !MYSQL_CLIENT */
4734
#endif /* !DRIZZLE_CLIENT */
4735
4735
4736
4736
4737
4737
Slave_log_event::~Slave_log_event()
4740
4740
}
4741
4741
4742
4742
4743
#ifdef MYSQL_CLIENT
4743
#ifdef DRIZZLE_CLIENT
4744
4744
void Slave_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
4745
4745
{
4746
4746
Write_on_release_cache cache(&print_event_info->head_cache, file);
4753
4753
Slave: master_host: '%s' master_port: %d master_log: '%s' master_pos: %s\n",
4754
4754
master_host, master_port, master_log, llstr(master_pos, llbuff));
4755
4755
}
4756
#endif /* MYSQL_CLIENT */
4756
#endif /* DRIZZLE_CLIENT */
4757
4757
4758
4758
4759
4759
int Slave_log_event::get_data_size()
4762
4762
}
4763
4763
4764
4764
4765
#ifndef MYSQL_CLIENT
4765
#ifndef DRIZZLE_CLIENT
4766
4766
bool Slave_log_event::write(IO_CACHE* file)
4767
4767
{
4768
4768
ulong event_length= get_data_size();
4808
4808
}
4809
4809
4810
4810
4811
#ifndef MYSQL_CLIENT
4811
#ifndef DRIZZLE_CLIENT
4812
4812
int Slave_log_event::do_apply_event(Relay_log_info const *rli __attribute__((unused)))
4813
4813
{
4814
4814
if (mysql_bin_log.is_open())
4815
4815
mysql_bin_log.write(this);
4816
4816
return 0;
4817
4817
}
4818
#endif /* !MYSQL_CLIENT */
4818
#endif /* !DRIZZLE_CLIENT */
4819
4819
4820
4820
4821
4821
/**************************************************************************
4826
4826
Stop_log_event::print()
4827
4827
*/
4828
4828
4829
#ifdef MYSQL_CLIENT
4829
#ifdef DRIZZLE_CLIENT
4830
4830
void Stop_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
4831
4831
{
4832
4832
Write_on_release_cache cache(&print_event_info->head_cache, file,
4838
4838
print_header(&cache, print_event_info, false);
4839
4839
my_b_printf(&cache, "\tStop\n");
4840
4840
}
4841
#endif /* MYSQL_CLIENT */
4842
4843
4844
#ifndef MYSQL_CLIENT
4841
#endif /* DRIZZLE_CLIENT */
4842
4843
4844
#ifndef DRIZZLE_CLIENT
4845
4845
/*
4846
4846
The master stopped. We used to clean up all temporary tables but
4847
4847
this is useless as, as the master has shut down properly, it has
4872
4872
return 0;
4873
4873
}
4874
4874
4875
#endif /* !MYSQL_CLIENT */
4875
#endif /* !DRIZZLE_CLIENT */
4876
4876
#endif /* HAVE_REPLICATION */
4877
4877
4878
4878
4884
4884
Create_file_log_event ctor
4885
4885
*/
4886
4886
4887
#ifndef MYSQL_CLIENT
4887
#ifndef DRIZZLE_CLIENT
4888
4888
Create_file_log_event::
4889
4889
Create_file_log_event(THD* thd_arg, sql_exchange* ex,
4890
4890
const char* db_arg, const char* table_name_arg,
4943
4943
return res;
4944
4944
}
4945
4945
4946
#endif /* !MYSQL_CLIENT */
4946
#endif /* !DRIZZLE_CLIENT */
4947
4947
4948
4948
/*
4949
4949
Create_file_log_event ctor
5003
5003
Create_file_log_event::print()
5004
5004
*/
5005
5005
5006
#ifdef MYSQL_CLIENT
5006
#ifdef DRIZZLE_CLIENT
5007
5007
void Create_file_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info,
5008
5008
bool enable_local)
5009
5009
{
5035
5035
{
5036
5036
print(file, print_event_info, 0);
5037
5037
}
5038
#endif /* MYSQL_CLIENT */
5038
#endif /* DRIZZLE_CLIENT */
5039
5039
5040
5040
5041
5041
/*
5042
5042
Create_file_log_event::pack_info()
5043
5043
*/
5044
5044
5045
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
5045
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
5046
5046
void Create_file_log_event::pack_info(Protocol *protocol)
5047
5047
{
5048
5048
char buf[NAME_LEN*2 + 30 + 21*2], *pos;
5056
5056
pos= int10_to_str((long) block_len, pos, 10);
5057
5057
protocol->store(buf, (uint) (pos-buf), &my_charset_bin);
5058
5058
}
5059
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
5059
#endif /* defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT) */
5060
5060
5061
5061
5062
5062
/*
5063
5063
Create_file_log_event::do_apply_event()
5064
5064
*/
5065
5065
5066
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
5066
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
5067
5067
int Create_file_log_event::do_apply_event(Relay_log_info const *rli)
5068
5068
{
5069
5069
char proc_info[17+FN_REFLEN+10], *fname_buf;
5131
5131
thd_proc_info(thd, 0);
5132
5132
return error == 0;
5133
5133
}
5134
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
5134
#endif /* defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT) */
5135
5135
5136
5136
5137
5137
/**************************************************************************
5142
5142
Append_block_log_event ctor
5143
5143
*/
5144
5144
5145
#ifndef MYSQL_CLIENT
5145
#ifndef DRIZZLE_CLIENT
5146
5146
Append_block_log_event::Append_block_log_event(THD *thd_arg,
5147
5147
const char *db_arg,
5148
5148
uchar *block_arg,
5180
5180
Append_block_log_event::write()
5181
5181
*/
5182
5182
5183
#ifndef MYSQL_CLIENT
5183
#ifndef DRIZZLE_CLIENT
5184
5184
bool Append_block_log_event::write(IO_CACHE* file)
5185
5185
{
5186
5186
uchar buf[APPEND_BLOCK_HEADER_LEN];
5196
5196
Append_block_log_event::print()
5197
5197
*/
5198
5198
5199
#ifdef MYSQL_CLIENT
5199
#ifdef DRIZZLE_CLIENT
5200
5200
void Append_block_log_event::print(FILE* file,
5201
5201
PRINT_EVENT_INFO* print_event_info)
5202
5202
{
5208
5208
my_b_printf(&cache, "\n#%s: file_id: %d block_len: %d\n",
5209
5209
get_type_str(), file_id, block_len);
5210
5210
}
5211
#endif /* MYSQL_CLIENT */
5211
#endif /* DRIZZLE_CLIENT */
5212
5212
5213
5213
5214
5214
/*
5215
5215
Append_block_log_event::pack_info()
5216
5216
*/
5217
5217
5218
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
5218
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
5219
5219
void Append_block_log_event::pack_info(Protocol *protocol)
5220
5220
{
5221
5221
char buf[256];
5295
5295
Delete_file_log_event ctor
5296
5296
*/
5297
5297
5298
#ifndef MYSQL_CLIENT
5298
#ifndef DRIZZLE_CLIENT
5299
5299
Delete_file_log_event::Delete_file_log_event(THD *thd_arg, const char* db_arg,
5300
5300
bool using_trans)
5301
5301
:Log_event(thd_arg, 0, using_trans), file_id(thd_arg->file_id), db(db_arg)
5323
5323
Delete_file_log_event::write()
5324
5324
*/
5325
5325
5326
#ifndef MYSQL_CLIENT
5326
#ifndef DRIZZLE_CLIENT
5327
5327
bool Delete_file_log_event::write(IO_CACHE* file)
5328
5328
{
5329
5329
uchar buf[DELETE_FILE_HEADER_LEN];
5338
5338
Delete_file_log_event::print()
5339
5339
*/
5340
5340
5341
#ifdef MYSQL_CLIENT
5341
#ifdef DRIZZLE_CLIENT
5342
5342
void Delete_file_log_event::print(FILE* file,
5343
5343
PRINT_EVENT_INFO* print_event_info)
5344
5344
{
5349
5349
print_header(&cache, print_event_info, false);
5350
5350
my_b_printf(&cache, "\n#Delete_file: file_id=%u\n", file_id);
5351
5351
}
5352
#endif /* MYSQL_CLIENT */
5352
#endif /* DRIZZLE_CLIENT */
5353
5353
5354
5354
/*
5355
5355
Delete_file_log_event::pack_info()
5356
5356
*/
5357
5357
5358
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
5358
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
5359
5359
void Delete_file_log_event::pack_info(Protocol *protocol)
5360
5360
{
5361
5361
char buf[64];
5369
5369
Delete_file_log_event::do_apply_event()
5370
5370
*/
5371
5371
5372
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
5372
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
5373
5373
int Delete_file_log_event::do_apply_event(Relay_log_info const *rli __attribute__((unused)))
5374
5374
{
5375
5375
char fname[FN_REFLEN+10];
5379
5379
(void) my_delete(fname, MYF(MY_WME));
5380
5380
return 0;
5381
5381
}
5382
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
5382
#endif /* defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT) */
5383
5383
5384
5384
5385
5385
/**************************************************************************
5390
5390
Execute_load_log_event ctor
5391
5391
*/
5392
5392
5393
#ifndef MYSQL_CLIENT
5393
#ifndef DRIZZLE_CLIENT
5394
5394
Execute_load_log_event::Execute_load_log_event(THD *thd_arg,
5395
5395
const char* db_arg,
5396
5396
bool using_trans)
5420
5420
Execute_load_log_event::write()
5421
5421
*/
5422
5422
5423
#ifndef MYSQL_CLIENT
5423
#ifndef DRIZZLE_CLIENT
5424
5424
bool Execute_load_log_event::write(IO_CACHE* file)
5425
5425
{
5426
5426
uchar buf[EXEC_LOAD_HEADER_LEN];
5435
5435
Execute_load_log_event::print()
5436
5436
*/
5437
5437
5438
#ifdef MYSQL_CLIENT
5438
#ifdef DRIZZLE_CLIENT
5439
5439
void Execute_load_log_event::print(FILE* file,
5440
5440
PRINT_EVENT_INFO* print_event_info)
5441
5441
{
5453
5453
Execute_load_log_event::pack_info()
5454
5454
*/
5455
5455
5456
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
5456
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
5457
5457
void Execute_load_log_event::pack_info(Protocol *protocol)
5458
5458
{
5459
5459
char buf[64];
5551
5551
return error;
5552
5552
}
5553
5553
5554
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
5554
#endif /* defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT) */
5555
5555
5556
5556
5557
5557
/**************************************************************************
5558
5558
Begin_load_query_log_event methods
5559
5559
**************************************************************************/
5560
5560
5561
#ifndef MYSQL_CLIENT
5561
#ifndef DRIZZLE_CLIENT
5562
5562
Begin_load_query_log_event::
5563
5563
Begin_load_query_log_event(THD* thd_arg, const char* db_arg, uchar* block_arg,
5564
5564
uint block_len_arg, bool using_trans)
5578
5578
}
5579
5579
5580
5580
5581
#if defined( HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
5581
#if defined( HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
5582
5582
int Begin_load_query_log_event::get_create_or_append() const
5583
5583
{
5584
5584
return 1; /* create the file */
5585
5585
}
5586
#endif /* defined( HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
5587
5588
5589
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
5586
#endif /* defined( HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT) */
5587
5588
5589
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
5590
5590
Log_event::enum_skip_reason
5591
5591
Begin_load_query_log_event::do_shall_skip(Relay_log_info *rli)
5592
5592
{
5604
5604
**************************************************************************/
5605
5605
5606
5606
5607
#ifndef MYSQL_CLIENT
5607
#ifndef DRIZZLE_CLIENT
5608
5608
Execute_load_query_log_event::
5609
5609
Execute_load_query_log_event(THD *thd_arg, const char* query_arg,
5610
5610
ulong query_length_arg, uint fn_pos_start_arg,
5618
5618
fn_pos_end(fn_pos_end_arg), dup_handling(dup_handling_arg)
5619
5619
{
5620
5620
}
5621
#endif /* !MYSQL_CLIENT */
5621
#endif /* !DRIZZLE_CLIENT */
5622
5622
5623
5623
5624
5624
Execute_load_query_log_event::
5650
5650
}
5651
5651
5652
5652
5653
#ifndef MYSQL_CLIENT
5653
#ifndef DRIZZLE_CLIENT
5654
5654
bool
5655
5655
Execute_load_query_log_event::write_post_header_for_derived(IO_CACHE* file)
5656
5656
{
5664
5664
#endif
5665
5665
5666
5666
5667
#ifdef MYSQL_CLIENT
5667
#ifdef DRIZZLE_CLIENT
5668
5668
void Execute_load_query_log_event::print(FILE* file,
5669
5669
PRINT_EVENT_INFO* print_event_info)
5670
5670
{
5706
5706
#endif
5707
5707
5708
5708
5709
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
5709
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
5710
5710
void Execute_load_query_log_event::pack_info(Protocol *protocol)
5711
5711
{
5712
5712
char *buf, *pos;
5883
5883
Rows_log_event member functions
5884
5884
**************************************************************************/
5885
5885
5886
#ifndef MYSQL_CLIENT
5886
#ifndef DRIZZLE_CLIENT
5887
5887
Rows_log_event::Rows_log_event(THD *thd_arg, TABLE *tbl_arg, ulong tid,
5888
5888
MY_BITMAP const *cols, bool is_transactional)
5889
5889
: Log_event(thd_arg, 0, is_transactional),
5935
5935
*description_event)
5936
5936
: Log_event(buf, description_event),
5937
5937
m_row_count(0),
5938
#ifndef MYSQL_CLIENT
5938
#ifndef DRIZZLE_CLIENT
5939
5939
m_table(NULL),
5940
5940
#endif
5941
5941
m_table_id(0), m_rows_buf(0), m_rows_cur(0), m_rows_end(0)
5942
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
5942
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
5943
5943
, m_curr_row(NULL), m_curr_row_end(NULL), m_key(NULL)
5944
5944
#endif
5945
5945
{
6013
6013
m_rows_buf= (uchar*) my_malloc(data_size, MYF(MY_WME));
6014
6014
if (likely((bool)m_rows_buf))
6015
6015
{
6016
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
6016
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
6017
6017
m_curr_row= m_rows_buf;
6018
6018
#endif
6019
6019
m_rows_end= m_rows_buf + data_size;
6053
6053
}
6054
6054
6055
6055
6056
#ifndef MYSQL_CLIENT
6056
#ifndef DRIZZLE_CLIENT
6057
6057
int Rows_log_event::do_add_row_data(uchar *row_data, size_t length)
6058
6058
{
6059
6059
/*
6112
6112
}
6113
6113
#endif
6114
6114
6115
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
6115
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
6116
6116
int Rows_log_event::do_apply_event(Relay_log_info const *rli)
6117
6117
{
6118
6118
int error= 0;
6604
6604
return(error);
6605
6605
}
6606
6606
6607
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
6607
#endif /* !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION) */
6608
6608
6609
#ifndef MYSQL_CLIENT
6609
#ifndef DRIZZLE_CLIENT
6610
6610
bool Rows_log_event::write_data_header(IO_CACHE *file)
6611
6611
{
6612
6612
uchar buf[ROWS_HEADER_LEN]; // No need to init the buffer
6647
6647
}
6648
6648
#endif
6649
6649
6650
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
6650
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
6651
6651
void Rows_log_event::pack_info(Protocol *protocol)
6652
6652
{
6653
6653
char buf[256];
6659
6659
}
6660
6660
#endif
6661
6661
6662
#ifdef MYSQL_CLIENT
6662
#ifdef DRIZZLE_CLIENT
6663
6663
void Rows_log_event::print_helper(FILE *file,
6664
6664
PRINT_EVENT_INFO *print_event_info,
6665
6665
char const *const name)
6720
6720
type used is uint32_t.
6721
6721
*/
6722
6722
6723
#if !defined(MYSQL_CLIENT)
6723
#if !defined(DRIZZLE_CLIENT)
6724
6724
/**
6725
6725
Save the field metadata based on the real_type of the field.
6726
6726
The metadata saved depends on the type of the field. Some fields
6752
6752
index+= m_table->s->field[i]->save_field_metadata(&m_field_metadata[index]);
6753
6753
return(index);
6754
6754
}
6755
#endif /* !defined(MYSQL_CLIENT) */
6755
#endif /* !defined(DRIZZLE_CLIENT) */
6756
6756
6757
6757
/*
6758
6758
Constructor used to build an event for writing to the binary log.
6759
6759
Mats says tbl->s lives longer than this event so it's ok to copy pointers
6760
6760
(tbl->s->db etc) and not pointer content.
6761
6761
*/
6762
#if !defined(MYSQL_CLIENT)
6762
#if !defined(DRIZZLE_CLIENT)
6763
6763
Table_map_log_event::Table_map_log_event(THD *thd, TABLE *tbl, ulong tid,
6764
6764
bool is_transactional __attribute__((unused)),
6765
6765
uint16_t flags)
6840
6840
m_null_bits[(i / 8)]+= 1 << (i % 8);
6841
6841
6842
6842
}
6843
#endif /* !defined(MYSQL_CLIENT) */
6843
#endif /* !defined(DRIZZLE_CLIENT) */
6844
6844
6845
6845
/*
6846
6846
Constructor used by slave to read the event from the binary log.
6851
6851
*description_event)
6852
6852
6853
6853
: Log_event(buf, description_event),
6854
#ifndef MYSQL_CLIENT
6854
#ifndef DRIZZLE_CLIENT
6855
6855
m_table(NULL),
6856
6856
#endif
6857
6857
m_dbnam(NULL), m_dblen(0), m_tblnam(NULL), m_tbllen(0),
6954
6954
4 Daisy-chaining RBR with SBR not possible
6955
6955
*/
6956
6956
6957
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
6957
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
6958
6958
int Table_map_log_event::do_apply_event(Relay_log_info const *rli)
6959
6959
{
6960
6960
RPL_TABLE_LIST *table_list;
7106
7106
return 0;
7107
7107
}
7108
7108
7109
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
7109
#endif /* !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION) */
7110
7110
7111
#ifndef MYSQL_CLIENT
7111
#ifndef DRIZZLE_CLIENT
7112
7112
bool Table_map_log_event::write_data_header(IO_CACHE *file)
7113
7113
{
7114
7114
assert(m_table_id != ~0UL);
7151
7151
}
7152
7152
#endif
7153
7153
7154
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
7154
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
7155
7155
7156
7156
/*
7157
7157
Print some useful information for the SHOW BINARY LOG information
7158
7158
field.
7159
7159
*/
7160
7160
7161
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
7161
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
7162
7162
void Table_map_log_event::pack_info(Protocol *protocol)
7163
7163
{
7164
7164
char buf[256];
7173
7173
#endif
7174
7174
7175
7175
7176
#ifdef MYSQL_CLIENT
7176
#ifdef DRIZZLE_CLIENT
7177
7177
void Table_map_log_event::print(FILE * /* unused */,
7178
7178
PRINT_EVENT_INFO *print_event_info)
7179
7179
{
7195
7195
/*
7196
7196
Constructor used to build an event for writing to the binary log.
7197
7197
*/
7198
#if !defined(MYSQL_CLIENT)
7198
#if !defined(DRIZZLE_CLIENT)
7199
7199
Write_rows_log_event::Write_rows_log_event(THD *thd_arg, TABLE *tbl_arg,
7200
7200
ulong tid_arg,
7201
7201
bool is_transactional)
7216
7216
}
7217
7217
#endif
7218
7218
7219
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
7219
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
7220
7220
int
7221
7221
Write_rows_log_event::do_before_row_operations(const Slave_reporting_capability *const)
7222
7222
{
7294
7294
return error? error : local_error;
7295
7295
}
7296
7296
7297
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
7297
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
7298
7298
7299
7299
/*
7300
7300
Check if there are more UNIQUE keys after the given key.
7562
7562
return error;
7563
7563
}
7564
7564
7565
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
7565
#endif /* !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION) */
7566
7566
7567
#ifdef MYSQL_CLIENT
7567
#ifdef DRIZZLE_CLIENT
7568
7568
void Write_rows_log_event::print(FILE *file, PRINT_EVENT_INFO* print_event_info)
7569
7569
{
7570
7570
Rows_log_event::print_helper(file, print_event_info, "Write_rows");
7575
7575
Delete_rows_log_event member functions
7576
7576
**************************************************************************/
7577
7577
7578
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
7578
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
7579
7579
/*
7580
7580
Compares table->record[0] and table->record[1]
7581
7581
7878
7878
Constructor used to build an event for writing to the binary log.
7879
7879
*/
7880
7880
7881
#ifndef MYSQL_CLIENT
7881
#ifndef DRIZZLE_CLIENT
7882
7882
Delete_rows_log_event::Delete_rows_log_event(THD *thd_arg, TABLE *tbl_arg,
7883
7883
ulong tid,
7884
7884
bool is_transactional)
7885
7885
: Rows_log_event(thd_arg, tbl_arg, tid, tbl_arg->read_set, is_transactional)
7886
7886
{
7887
7887
}
7888
#endif /* #if !defined(MYSQL_CLIENT) */
7888
#endif /* #if !defined(DRIZZLE_CLIENT) */
7889
7889
7890
7890
/*
7891
7891
Constructor used by slave to read the event from the binary log.
7899
7899
}
7900
7900
#endif
7901
7901
7902
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
7902
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
7903
7903
7904
7904
int
7905
7905
Delete_rows_log_event::do_before_row_operations(const Slave_reporting_capability *const)
7951
7951
return error;
7952
7952
}
7953
7953
7954
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
7954
#endif /* !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION) */
7955
7955
7956
#ifdef MYSQL_CLIENT
7956
#ifdef DRIZZLE_CLIENT
7957
7957
void Delete_rows_log_event::print(FILE *file,
7958
7958
PRINT_EVENT_INFO* print_event_info)
7959
7959
{
7969
7969
/*
7970
7970
Constructor used to build an event for writing to the binary log.
7971
7971
*/
7972
#if !defined(MYSQL_CLIENT)
7972
#if !defined(DRIZZLE_CLIENT)
7973
7973
Update_rows_log_event::Update_rows_log_event(THD *thd_arg, TABLE *tbl_arg,
7974
7974
ulong tid,
7975
7975
bool is_transactional)
7994
7994
}
7995
7995
}
7996
7996
}
7997
#endif /* !defined(MYSQL_CLIENT) */
7997
#endif /* !defined(DRIZZLE_CLIENT) */
7998
7998
7999
7999
8000
8000
Update_rows_log_event::~Update_rows_log_event()
8018
8018
}
8019
8019
#endif
8020
8020
8021
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
8021
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
8022
8022
8023
8023
int
8024
8024
Update_rows_log_event::do_before_row_operations(const Slave_reporting_capability *const)
8097
8097
return error;
8098
8098
}
8099
8099
8100
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
8100
#endif /* !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION) */
8101
8101
8102
#ifdef MYSQL_CLIENT
8102
#ifdef DRIZZLE_CLIENT
8103
8103
void Update_rows_log_event::print(FILE *file,
8104
8104
PRINT_EVENT_INFO* print_event_info)
8105
8105
{
8149
8149
}
8150
8150
8151
8151
8152
#ifndef MYSQL_CLIENT
8152
#ifndef DRIZZLE_CLIENT
8153
8153
void Incident_log_event::pack_info(Protocol *protocol)
8154
8154
{
8155
8155
char buf[256];
8165
8165
#endif
8166
8166
8167
8167
8168
#ifdef MYSQL_CLIENT
8168
#ifdef DRIZZLE_CLIENT
8169
8169
void
8170
8170
Incident_log_event::print(FILE *file,
8171
8171
PRINT_EVENT_INFO *print_event_info)
8179
8179
}
8180
8180
#endif
8181
8181
8182
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
8182
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
8183
8183
int
8184
8184
Incident_log_event::do_apply_event(Relay_log_info const *rli)
8185
8185
{
8205
8205
return(write_str(file, m_message.str, m_message.length));
8206
8206
}
8207
8207
8208
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
8208
#if defined(HAVE_REPLICATION) && !defined(DRIZZLE_CLIENT)
8209
8209
Heartbeat_log_event::Heartbeat_log_event(const char* buf, uint event_len,
8210
8210
const Format_description_log_event* description_event)
8211
8211
:Log_event(buf, description_event)
8218
8218
#endif
8219
8219
8220
8220
8221
#ifdef MYSQL_CLIENT
8221
#ifdef DRIZZLE_CLIENT
8222
8222
/**
8223
8223
The default values for these variables should be values that are
8224
8224
*incorrect*, i.e., values that cannot occur in an event. This way,
Loggerhead is a web-based interface for Breezy
Version: 2.0.1