« back to all changes in this revision
Viewing changes to server/log_event.cc
- browse files at revision 77.1.66
- compare with another revision
- compare with revision 77.3.19
- download diff
- download tarball
- view history from revision 77.1.66
- Committer: Monty Taylor
- Date: 2008-07-11 10:33:22 UTC
- mfrom: (132 drizzle)
- mto: (77.6.1 glibclient-merge)
- mto: This revision was merged to the branch mainline in revision 134.
- Revision ID: monty@inaugust.com-20080711103322-0a3sppn0usxty41l
Merged from trunk.
- files removed:
- client/mysqlshow.c
- files modified:
- client/Makefile.am
added
removed
server/log_event.cc
194
194
Write_on_release_cache(IO_CACHE *cache, FILE *file, flag_set flags = 0)
195
195
: m_cache(cache), m_file(file), m_flags(flags)
196
196
{
197
reinit_io_cache(m_cache, WRITE_CACHE, 0L, FALSE, TRUE);
197
reinit_io_cache(m_cache, WRITE_CACHE, 0L, false, true);
198
198
}
199
199
200
200
~Write_on_release_cache()
233
233
flag_set m_flags;
234
234
};
235
235
236
#ifndef DBUG_OFF
237
236
uint debug_not_change_ts_if_art_event= 1; // bug#29309 simulation
238
#endif
239
237
240
238
/*
241
239
pretty_print_str()
630
628
*/
631
629
log_pos+= data_written; /* purecov: inspected */
632
630
}
633
DBUG_PRINT("info", ("log_pos: %lu", (ulong) log_pos));
634
631
635
632
flags= uint2korr(buf + FLAGS_OFFSET);
636
633
if ((buf[EVENT_TYPE_OFFSET] == FORMAT_DESCRIPTION_EVENT) ||
679
676
rli->last_master_timestamp for only one time -
680
677
the first FLUSH LOGS in the test.
681
678
*/
682
DBUG_EXECUTE_IF("let_first_flush_log_change_timestamp",
683
if (debug_not_change_ts_if_art_event == 1
684
&& is_artificial_event())
685
{
686
debug_not_change_ts_if_art_event= 0;
687
});
688
#ifndef DBUG_OFF
679
if (debug_not_change_ts_if_art_event == 1
680
&& is_artificial_event())
681
debug_not_change_ts_if_art_event= 0;
689
682
rli->stmt_done(log_pos,
690
683
is_artificial_event() &&
691
684
debug_not_change_ts_if_art_event > 0 ? 0 : when);
692
#else
693
rli->stmt_done(log_pos, is_artificial_event()? 0 : when);
694
#endif
695
DBUG_EXECUTE_IF("let_first_flush_log_change_timestamp",
696
if (debug_not_change_ts_if_art_event == 0)
697
{
698
debug_not_change_ts_if_art_event= 2;
699
});
685
if (debug_not_change_ts_if_art_event == 0)
686
debug_not_change_ts_if_art_event= 2;
700
687
}
701
688
return 0; // Cannot fail currently
702
689
}
705
692
Log_event::enum_skip_reason
706
693
Log_event::do_shall_skip(Relay_log_info *rli)
707
694
{
708
DBUG_PRINT("info", ("ev->server_id=%lu, ::server_id=%lu,"
709
" rli->replicate_same_server_id=%d,"
710
" rli->slave_skip_counter=%d",
711
(ulong) server_id, (ulong) ::server_id,
712
rli->replicate_same_server_id,
713
rli->slave_skip_counter));
714
695
if ((server_id == ::server_id && !rli->replicate_same_server_id) || (rli->slave_skip_counter == 1 && rli->is_in_group()))
715
696
return EVENT_SKIP_IGNORE;
716
697
else if (rli->slave_skip_counter > 0)
773
754
field_list->push_back(new Item_empty_string("Info", 20));
774
755
}
775
756
776
777
757
/*
778
758
Log_event::write()
779
759
*/
782
762
{
783
763
uchar header[LOG_EVENT_HEADER_LEN];
784
764
ulong now;
785
DBUG_ENTER("Log_event::write_header");
786
765
787
766
/* Store number of bytes that will be written by this event */
788
767
data_written= event_data_length + sizeof(header);
818
797
relay log, we use the (new) my_b_safe_tell().
819
798
820
799
Note that this raises a question on the correctness of all these
821
DBUG_ASSERT(my_b_tell()=rli->event_relay_log_pos).
800
assert(my_b_tell()=rli->event_relay_log_pos).
822
801
823
802
If in a transaction, the log_pos which we calculate below is not
824
803
very good (because then my_b_safe_tell() returns start position
848
827
int4store(header+ LOG_POS_OFFSET, log_pos);
849
828
int2store(header+ FLAGS_OFFSET, flags);
850
829
851
DBUG_RETURN(my_b_safe_write(file, header, sizeof(header)) != 0);
830
return(my_b_safe_write(file, header, sizeof(header)) != 0);
852
831
}
853
832
854
833
863
842
ulong data_len;
864
843
int result=0;
865
844
char buf[LOG_EVENT_MINIMAL_HEADER_LEN];
866
DBUG_ENTER("Log_event::read_log_event");
867
845
868
846
if (log_lock)
869
847
pthread_mutex_lock(log_lock);
874
852
will know it can go into cond_wait to be woken up on the next
875
853
update to the log.
876
854
*/
877
DBUG_PRINT("error",("file->error: %d", file->error));
878
855
if (!file->error)
879
856
result= LOG_READ_EOF;
880
857
else
885
862
if (data_len < LOG_EVENT_MINIMAL_HEADER_LEN ||
886
863
data_len > current_thd->variables.max_allowed_packet)
887
864
{
888
DBUG_PRINT("error",("data_len: %ld", data_len));
889
865
result= ((data_len < LOG_EVENT_MINIMAL_HEADER_LEN) ? LOG_READ_BOGUS :
890
866
LOG_READ_TOO_LARGE);
891
867
goto end;
925
901
end:
926
902
if (log_lock)
927
903
pthread_mutex_unlock(log_lock);
928
DBUG_RETURN(result);
904
return(result);
929
905
}
930
906
#endif /* !MYSQL_CLIENT */
931
907
952
928
*description_event)
953
929
#endif
954
930
{
955
DBUG_ENTER("Log_event::read_log_event");
956
DBUG_ASSERT(description_event != 0);
931
assert(description_event != 0);
957
932
char head[LOG_EVENT_MINIMAL_HEADER_LEN];
958
933
/*
959
934
First we only want to read at most LOG_EVENT_MINIMAL_HEADER_LEN, just to
966
941
LOG_EVENT_MINIMAL_HEADER_LEN);
967
942
968
943
LOCK_MUTEX;
969
DBUG_PRINT("info", ("my_b_tell: %lu", (ulong) my_b_tell(file)));
970
944
if (my_b_read(file, (uchar *) head, header_size))
971
945
{
972
DBUG_PRINT("info", ("Log_event::read_log_event(IO_CACHE*,Format_desc*) \
973
failed my_b_read"));
974
946
UNLOCK_MUTEX;
975
947
/*
976
948
No error here; it could be that we are at the file's end. However
977
949
if the next my_b_read() fails (below), it will be an error as we
978
950
were able to read the first bytes.
979
951
*/
980
DBUG_RETURN(0);
952
return(0);
981
953
}
982
954
uint data_len = uint4korr(head + EVENT_LEN_OFFSET);
983
955
char *buf= 0;
1020
992
UNLOCK_MUTEX;
1021
993
if (!res)
1022
994
{
1023
DBUG_ASSERT(error != 0);
995
assert(error != 0);
1024
996
sql_print_error("Error in Log_event::read_log_event(): "
1025
997
"'%s', data_len: %d, event_type: %d",
1026
998
error,data_len,head[EVENT_TYPE_OFFSET]);
1035
1007
*/
1036
1008
file->error= -1;
1037
1009
}
1038
DBUG_RETURN(res);
1010
return(res);
1039
1011
}
1040
1012
1041
1013
1049
1021
const Format_description_log_event *description_event)
1050
1022
{
1051
1023
Log_event* ev;
1052
DBUG_ENTER("Log_event::read_log_event(char*,...)");
1053
DBUG_ASSERT(description_event != 0);
1054
DBUG_PRINT("info", ("binlog_version: %d", description_event->binlog_version));
1055
DBUG_DUMP("data", (unsigned char*) buf, event_len);
1024
assert(description_event != 0);
1056
1025
1057
1026
/* Check the integrity */
1058
1027
if (event_len < EVENT_LEN_OFFSET ||
1060
1029
(uint) event_len != uint4korr(buf+EVENT_LEN_OFFSET))
1061
1030
{
1062
1031
*error="Sanity check failed"; // Needed to free buffer
1063
DBUG_RETURN(NULL); // general sanity check - will fail on a partial read
1032
return(NULL); // general sanity check - will fail on a partial read
1064
1033
}
1065
1034
1066
1035
uint event_type= buf[EVENT_TYPE_OFFSET];
1071
1040
It is unsafe to use the description_event if its post_header_len
1072
1041
array does not include the event type.
1073
1042
*/
1074
DBUG_PRINT("error", ("event type %d found, but the current "
1075
"Format_description_log_event supports only %d event "
1076
"types", event_type,
1077
description_event->number_of_event_types));
1078
1043
ev= NULL;
1079
1044
}
1080
1045
else
1091
1056
*/
1092
1057
if (description_event->event_type_permutation)
1093
1058
{
1094
IF_DBUG({
1095
int new_event_type=
1096
description_event->event_type_permutation[event_type];
1097
DBUG_PRINT("info",
1098
("converting event type %d to %d (%s)",
1099
event_type, new_event_type,
1100
get_type_str((Log_event_type)new_event_type)));
1101
});
1059
int new_event_type= description_event->event_type_permutation[event_type];
1102
1060
event_type= description_event->event_type_permutation[event_type];
1103
1061
}
1104
1062
1177
1135
ev = new Incident_log_event(buf, event_len, description_event);
1178
1136
break;
1179
1137
default:
1180
DBUG_PRINT("error",("Unknown event code: %d",
1181
(int) buf[EVENT_TYPE_OFFSET]));
1182
1138
ev= NULL;
1183
1139
break;
1184
1140
}
1185
1141
}
1186
1142
1187
DBUG_PRINT("read_event", ("%s(type_code: %d; event_len: %d)",
1188
ev ? ev->get_type_str() : "<unknown>",
1189
buf[EVENT_TYPE_OFFSET],
1190
event_len));
1191
1143
/*
1192
1144
is_valid() are small event-specific sanity tests which are
1193
1145
important; for example there are some my_malloc() in constructors
1199
1151
*/
1200
1152
if (!ev || !ev->is_valid())
1201
1153
{
1202
DBUG_PRINT("error",("Found invalid event in binary log"));
1203
1204
1154
delete ev;
1205
1155
#ifdef MYSQL_CLIENT
1206
1156
if (!force_opt) /* then mysqlbinlog dies */
1207
1157
{
1208
1158
*error= "Found invalid event in binary log";
1209
DBUG_RETURN(0);
1159
return(0);
1210
1160
}
1211
1161
ev= new Unknown_log_event(buf, description_event);
1212
1162
#else
1213
1163
*error= "Found invalid event in binary log";
1214
DBUG_RETURN(0);
1164
return(0);
1215
1165
#endif
1216
1166
}
1217
DBUG_RETURN(ev);
1167
return(ev);
1218
1168
}
1219
1169
1220
1170
#ifdef MYSQL_CLIENT
1229
1179
{
1230
1180
char llbuff[22];
1231
1181
my_off_t hexdump_from= print_event_info->hexdump_from;
1232
DBUG_ENTER("Log_event::print_header");
1233
1182
1234
1183
my_b_printf(file, "#");
1235
1184
print_timestamp(file);
1264
1213
ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6],
1265
1214
ptr[7], ptr[8], ptr[9], ptr[10], ptr[11], ptr[12], ptr[13],
1266
1215
ptr[14], ptr[15], ptr[16], ptr[17], ptr[18]);
1267
DBUG_ASSERT(bytes_written >= 0);
1268
DBUG_ASSERT(static_cast<size_t>(bytes_written) < sizeof(emit_buf));
1216
assert(bytes_written >= 0);
1217
assert(static_cast<size_t>(bytes_written) < sizeof(emit_buf));
1269
1218
my_b_write(file, (uchar*) emit_buf, bytes_written);
1270
1219
ptr += LOG_EVENT_MINIMAL_HEADER_LEN;
1271
1220
hexdump_from += LOG_EVENT_MINIMAL_HEADER_LEN;
1295
1244
"# %8.8lx %-48.48s |%16s|\n",
1296
1245
(unsigned long) (hexdump_from + (i & 0xfffffff0)),
1297
1246
hex_string, char_string);
1298
DBUG_ASSERT(bytes_written >= 0);
1299
DBUG_ASSERT(static_cast<size_t>(bytes_written) < sizeof(emit_buf));
1247
assert(bytes_written >= 0);
1248
assert(static_cast<size_t>(bytes_written) < sizeof(emit_buf));
1300
1249
my_b_write(file, (uchar*) emit_buf, bytes_written);
1301
1250
hex_string[0]= 0;
1302
1251
char_string[0]= 0;
1315
1264
"# %8.8lx %-48.48s |%s|\n",
1316
1265
(unsigned long) (hexdump_from + (i & 0xfffffff0)),
1317
1266
hex_string, char_string);
1318
DBUG_ASSERT(bytes_written >= 0);
1319
DBUG_ASSERT(static_cast<size_t>(bytes_written) < sizeof(emit_buf));
1267
assert(bytes_written >= 0);
1268
assert(static_cast<size_t>(bytes_written) < sizeof(emit_buf));
1320
1269
my_b_write(file, (uchar*) emit_buf, bytes_written);
1321
1270
}
1322
1271
/*
1325
1274
*/
1326
1275
my_b_write(file, reinterpret_cast<const uchar*>("# "), 2);
1327
1276
}
1328
DBUG_VOID_RETURN;
1277
return;
1329
1278
}
1330
1279
1331
1280
1335
1284
{
1336
1285
const uchar *ptr= (const uchar *)temp_buf;
1337
1286
uint32 size= uint4korr(ptr + EVENT_LEN_OFFSET);
1338
DBUG_ENTER("Log_event::print_base64");
1339
1287
1340
1288
size_t const tmp_str_sz= base64_needed_encoded_length((int) size);
1341
1289
char *const tmp_str= (char *) my_malloc(tmp_str_sz, MYF(MY_WME));
1342
1290
if (!tmp_str) {
1343
1291
fprintf(stderr, "\nError: Out of memory. "
1344
1292
"Could not print correct binlog event.\n");
1345
DBUG_VOID_RETURN;
1293
return;
1346
1294
}
1347
1295
1348
1296
if (base64_encode(ptr, (size_t) size, tmp_str))
1349
1297
{
1350
DBUG_ASSERT(0);
1298
assert(0);
1351
1299
}
1352
1300
1353
1301
if (my_b_tell(file) == 0)
1359
1307
my_b_printf(file, "'%s\n", print_event_info->delimiter);
1360
1308
1361
1309
my_free(tmp_str, MYF(0));
1362
DBUG_VOID_RETURN;
1310
return;
1363
1311
}
1364
1312
1365
1313
1370
1318
void Log_event::print_timestamp(IO_CACHE* file, time_t* ts)
1371
1319
{
1372
1320
struct tm *res;
1373
DBUG_ENTER("Log_event::print_timestamp");
1374
1321
if (!ts)
1375
1322
ts = &when;
1376
1323
#ifdef MYSQL_SERVER // This is always false
1387
1334
res->tm_hour,
1388
1335
res->tm_min,
1389
1336
res->tm_sec);
1390
DBUG_VOID_RETURN;
1337
return;
1391
1338
}
1392
1339
1393
1340
#endif /* MYSQL_CLIENT */
1450
1397
static void write_str_with_code_and_len(char **dst, const char *src,
1451
1398
int len, uint code)
1452
1399
{
1453
DBUG_ASSERT(src);
1400
assert(src);
1454
1401
*((*dst)++)= code;
1455
1402
*((*dst)++)= (uchar) len;
1456
1403
bmove(*dst, src, len);
1588
1535
if (time_zone_len)
1589
1536
{
1590
1537
/* In the TZ sys table, column Name is of length 64 so this should be ok */
1591
DBUG_ASSERT(time_zone_len <= MAX_TIME_ZONE_NAME_LENGTH);
1538
assert(time_zone_len <= MAX_TIME_ZONE_NAME_LENGTH);
1592
1539
*start++= Q_TIME_ZONE_CODE;
1593
1540
*start++= time_zone_len;
1594
1541
memcpy(start, time_zone_str, time_zone_len);
1596
1543
}
1597
1544
if (lc_time_names_number)
1598
1545
{
1599
DBUG_ASSERT(lc_time_names_number <= 0xFFFF);
1546
assert(lc_time_names_number <= 0xFFFF);
1600
1547
*start++= Q_LC_TIME_NAMES_CODE;
1601
1548
int2store(start, lc_time_names_number);
1602
1549
start+= 2;
1603
1550
}
1604
1551
if (charset_database_number)
1605
1552
{
1606
DBUG_ASSERT(charset_database_number <= 0xFFFF);
1553
assert(charset_database_number <= 0xFFFF);
1607
1554
*start++= Q_CHARSET_DATABASE_CODE;
1608
1555
int2store(start, charset_database_number);
1609
1556
start+= 2;
1620
1567
1621
1568
/* Store length of status variables */
1622
1569
status_vars_len= (uint) (start-start_of_status);
1623
DBUG_ASSERT(status_vars_len <= MAX_SIZE_LOG_EVENT_STATUS);
1570
assert(status_vars_len <= MAX_SIZE_LOG_EVENT_STATUS);
1624
1571
int2store(buf + Q_STATUS_VARS_LEN_OFFSET, status_vars_len);
1625
1572
1626
1573
/*
1717
1664
we will probably want to reclaim the 29 bits. So we need the &.
1718
1665
*/
1719
1666
flags2= (uint32) (thd_arg->options & OPTIONS_WRITTEN_TO_BIN_LOG);
1720
DBUG_ASSERT(thd_arg->variables.character_set_client->number < 256*256);
1721
DBUG_ASSERT(thd_arg->variables.collation_connection->number < 256*256);
1722
DBUG_ASSERT(thd_arg->variables.collation_server->number < 256*256);
1723
DBUG_ASSERT(thd_arg->variables.character_set_client->mbminlen == 1);
1667
assert(thd_arg->variables.character_set_client->number < 256*256);
1668
assert(thd_arg->variables.collation_connection->number < 256*256);
1669
assert(thd_arg->variables.collation_server->number < 256*256);
1670
assert(thd_arg->variables.character_set_client->mbminlen == 1);
1724
1671
int2store(charset, thd_arg->variables.character_set_client->number);
1725
1672
int2store(charset+2, thd_arg->variables.collation_connection->number);
1726
1673
int2store(charset+4, thd_arg->variables.collation_server->number);
1736
1683
}
1737
1684
else
1738
1685
time_zone_len= 0;
1739
DBUG_PRINT("info",("Query_log_event has flags2: %lu sql_mode: %lu",
1740
(ulong) flags2, sql_mode));
1741
1686
}
1742
1687
#endif /* MYSQL_CLIENT */
1743
1688
1799
1744
}
1800
1745
1801
1746
1802
#ifndef DBUG_OFF
1803
1747
static char const *
1804
1748
code_name(int code)
1805
1749
{
1818
1762
sprintf(buf, "CODE#%d", code);
1819
1763
return buf;
1820
1764
}
1821
#endif
1822
1765
1823
1766
/**
1824
1767
Macro to check that there is enough space to read from memory.
1829
1772
*/
1830
1773
#define CHECK_SPACE(PTR,END,CNT) \
1831
1774
do { \
1832
DBUG_PRINT("info", ("Read %s", code_name(pos[-1]))); \
1833
DBUG_ASSERT((PTR) + (CNT) <= (END)); \
1775
assert((PTR) + (CNT) <= (END)); \
1834
1776
if ((PTR) + (CNT) > (END)) { \
1835
DBUG_PRINT("info", ("query= 0")); \
1836
1777
query= 0; \
1837
DBUG_VOID_RETURN; \
1778
return; \
1838
1779
} \
1839
1780
} while (0)
1840
1781
1858
1799
Log_event::Byte *start;
1859
1800
const Log_event::Byte *end;
1860
1801
bool catalog_nz= 1;
1861
DBUG_ENTER("Query_log_event::Query_log_event(char*,...)");
1862
1802
1863
1803
common_header_len= description_event->common_header_len;
1864
1804
post_header_len= description_event->post_header_len[event_type-1];
1865
DBUG_PRINT("info",("event_len: %u common_header_len: %d post_header_len: %d",
1866
event_len, common_header_len, post_header_len));
1867
1805
1868
1806
/*
1869
1807
We test if the event's length is sensible, and if so we compute data_len.
1871
1809
We use QUERY_HEADER_MINIMAL_LEN which is the same for 3.23, 4.0 & 5.0.
1872
1810
*/
1873
1811
if (event_len < (uint)(common_header_len + post_header_len))
1874
DBUG_VOID_RETURN;
1812
return;
1875
1813
data_len = event_len - (common_header_len + post_header_len);
1876
1814
buf+= common_header_len;
1877
1815
1897
1835
*/
1898
1836
if (status_vars_len > min(data_len, MAX_SIZE_LOG_EVENT_STATUS))
1899
1837
{
1900
DBUG_PRINT("info", ("status_vars_len (%u) > data_len (%lu); query= 0",
1901
status_vars_len, data_len));
1902
1838
query= 0;
1903
DBUG_VOID_RETURN;
1839
return;
1904
1840
}
1905
1841
data_len-= status_vars_len;
1906
DBUG_PRINT("info", ("Query_log_event has status_vars_len: %u",
1907
(uint) status_vars_len));
1908
1842
tmp-= 2;
1909
1843
}
1910
1844
/*
1924
1858
CHECK_SPACE(pos, end, 4);
1925
1859
flags2_inited= 1;
1926
1860
flags2= uint4korr(pos);
1927
DBUG_PRINT("info",("In Query_log_event, read flags2: %lu", (ulong) flags2));
1928
1861
pos+= 4;
1929
1862
break;
1930
1863
case Q_SQL_MODE_CODE:
1931
1864
{
1932
#ifndef DBUG_OFF
1933
1865
char buff[22];
1934
#endif
1935
1866
CHECK_SPACE(pos, end, 8);
1936
1867
sql_mode_inited= 1;
1937
1868
sql_mode= (ulong) uint8korr(pos); // QQ: Fix when sql_mode is ulonglong
1938
DBUG_PRINT("info",("In Query_log_event, read sql_mode: %s",
1939
llstr(sql_mode, buff)));
1940
1869
pos+= 8;
1941
1870
break;
1942
1871
}
1943
1872
case Q_CATALOG_NZ_CODE:
1944
DBUG_PRINT("info", ("case Q_CATALOG_NZ_CODE; pos: 0x%lx; end: 0x%lx",
1945
(ulong) pos, (ulong) end));
1946
1873
if (get_str_len_and_pointer(&pos, &catalog, &catalog_len, end))
1947
1874
{
1948
DBUG_PRINT("info", ("query= 0"));
1949
1875
query= 0;
1950
DBUG_VOID_RETURN;
1876
return;
1951
1877
}
1952
1878
break;
1953
1879
case Q_AUTO_INCREMENT:
1968
1894
{
1969
1895
if (get_str_len_and_pointer(&pos, &time_zone_str, &time_zone_len, end))
1970
1896
{
1971
DBUG_PRINT("info", ("Q_TIME_ZONE_CODE: query= 0"));
1972
1897
query= 0;
1973
DBUG_VOID_RETURN;
1898
return;
1974
1899
}
1975
1900
break;
1976
1901
}
1994
1919
break;
1995
1920
default:
1996
1921
/* That's why you must write status vars in growing order of code */
1997
DBUG_PRINT("info",("Query_log_event has unknown status vars (first has\
1998
code: %u), skipping the rest of them", (uint) *(pos-1)));
1999
1922
pos= (const uchar*) end; // Break loop
2000
1923
}
2001
1924
}
2004
1927
time_zone_len + 1 +
2005
1928
data_len + 1,
2006
1929
MYF(MY_WME))))
2007
DBUG_VOID_RETURN;
1930
return;
2008
1931
if (catalog_len) // If catalog is given
2009
1932
{
2010
1933
/**
2037
1960
db= (char *)start;
2038
1961
query= (char *)(start + db_len + 1);
2039
1962
q_len= data_len - db_len -1;
2040
DBUG_VOID_RETURN;
1963
return;
2041
1964
}
2042
1965
2043
1966
2058
1981
2059
1982
if (!print_event_info->short_form)
2060
1983
{
2061
print_header(file, print_event_info, FALSE);
1984
print_header(file, print_event_info, false);
2062
1985
my_b_printf(file, "\t%s\tthread_id=%lu\texec_time=%lu\terror_code=%d\n",
2063
1986
get_type_str(), (ulong) thread_id, (ulong) exec_time,
2064
1987
error_code);
2267
2190
access it.
2268
2191
*/
2269
2192
const_cast<Relay_log_info*>(rli)->future_group_master_log_pos= log_pos;
2270
DBUG_PRINT("info", ("log_pos: %lu", (ulong) log_pos));
2271
2193
2272
2194
clear_all_errors(thd, const_cast<Relay_log_info*>(rli));
2273
2195
const_cast<Relay_log_info*>(rli)->clear_tables_to_lock();
2291
2213
thd->query_id = next_query_id();
2292
2214
VOID(pthread_mutex_unlock(&LOCK_thread_count));
2293
2215
thd->variables.pseudo_thread_id= thread_id; // for temp tables
2294
DBUG_PRINT("query",("%s",thd->query));
2295
2216
2296
2217
if (ignored_error_code((expected_error= error_code)) ||
2297
2218
!check_expected_error(thd,rli,expected_error))
2410
2331
code, and none of them should be ignored.
2411
2332
*/
2412
2333
actual_error= thd->is_error() ? thd->main_da.sql_errno() : 0;
2413
DBUG_PRINT("info",("expected_error: %d sql_errno: %d",
2414
expected_error, actual_error));
2415
2334
if ((expected_error != actual_error) &&
2416
2335
expected_error &&
2417
2336
!ignored_error_code(actual_error) &&
2435
2354
else if (expected_error == actual_error ||
2436
2355
ignored_error_code(actual_error))
2437
2356
{
2438
DBUG_PRINT("info",("error ignored"));
2439
2357
clear_all_errors(thd, const_cast<Relay_log_info*>(rli));
2440
2358
thd->killed= THD::NOT_KILLED;
2441
2359
}
2489
2407
*/
2490
2408
thd->catalog= 0;
2491
2409
thd->set_db(NULL, 0); /* will free the current database */
2492
DBUG_PRINT("info", ("end: query= 0"));
2493
2410
thd->query= 0; // just to be sure
2494
2411
thd->query_length= 0;
2495
2412
VOID(pthread_mutex_unlock(&LOCK_thread_count));
2528
2445
Log_event::enum_skip_reason
2529
2446
Query_log_event::do_shall_skip(Relay_log_info *rli)
2530
2447
{
2531
DBUG_ENTER("Query_log_event::do_shall_skip");
2532
DBUG_PRINT("debug", ("query: %s; q_len: %d", query, q_len));
2533
DBUG_ASSERT(query && q_len > 0);
2448
assert(query && q_len > 0);
2534
2449
2535
2450
if (rli->slave_skip_counter > 0)
2536
2451
{
2537
2452
if (strcmp("BEGIN", query) == 0)
2538
2453
{
2539
2454
thd->options|= OPTION_BEGIN;
2540
DBUG_RETURN(Log_event::continue_group(rli));
2455
return(Log_event::continue_group(rli));
2541
2456
}
2542
2457
2543
2458
if (strcmp("COMMIT", query) == 0 || strcmp("ROLLBACK", query) == 0)
2544
2459
{
2545
2460
thd->options&= ~OPTION_BEGIN;
2546
DBUG_RETURN(Log_event::EVENT_SKIP_COUNT);
2461
return(Log_event::EVENT_SKIP_COUNT);
2547
2462
}
2548
2463
}
2549
DBUG_RETURN(Log_event::do_shall_skip(rli));
2464
return(Log_event::do_shall_skip(rli));
2550
2465
}
2551
2466
2552
2467
#endif
2589
2504
#ifdef MYSQL_CLIENT
2590
2505
void Start_log_event_v3::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
2591
2506
{
2592
DBUG_ENTER("Start_log_event_v3::print");
2593
2594
2507
Write_on_release_cache cache(&print_event_info->head_cache, file,
2595
2508
Write_on_release_cache::FLUSH_F);
2596
2509
2597
2510
if (!print_event_info->short_form)
2598
2511
{
2599
print_header(&cache, print_event_info, FALSE);
2512
print_header(&cache, print_event_info, false);
2600
2513
my_b_printf(&cache, "\tStart: binlog v %d, server v %s created ",
2601
2514
binlog_version, server_version);
2602
2515
print_timestamp(&cache);
2626
2539
!print_event_info->short_form)
2627
2540
{
2628
2541
my_b_printf(&cache, "BINLOG '\n");
2629
print_base64(&cache, print_event_info, FALSE);
2630
print_event_info->printed_fd_event= TRUE;
2542
print_base64(&cache, print_event_info, false);
2543
print_event_info->printed_fd_event= true;
2631
2544
}
2632
DBUG_VOID_RETURN;
2545
return;
2633
2546
}
2634
2547
#endif /* MYSQL_CLIENT */
2635
2548
2696
2609
2697
2610
int Start_log_event_v3::do_apply_event(Relay_log_info const *rli)
2698
2611
{
2699
DBUG_ENTER("Start_log_event_v3::do_apply_event");
2700
2612
switch (binlog_version)
2701
2613
{
2702
2614
case 3:
2736
2648
break;
2737
2649
default:
2738
2650
/* this case is impossible */
2739
DBUG_RETURN(1);
2651
return(1);
2740
2652
}
2741
DBUG_RETURN(0);
2653
return(0);
2742
2654
}
2743
2655
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
2744
2656
2770
2682
switch (binlog_ver) {
2771
2683
case 4: /* MySQL 5.0 */
2772
2684
memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
2773
DBUG_EXECUTE_IF("pretend_version_50034_in_binlog",
2774
strmov(server_version, "5.0.34"););
2775
2685
common_header_len= LOG_EVENT_HEADER_LEN;
2776
2686
number_of_event_types= LOG_EVENT_TYPES;
2777
2687
/* we'll catch my_malloc() error in is_valid() */
2798
2708
post_header_len[WRITE_ROWS_EVENT-1]= ROWS_HEADER_LEN;
2799
2709
post_header_len[UPDATE_ROWS_EVENT-1]= ROWS_HEADER_LEN;
2800
2710
post_header_len[DELETE_ROWS_EVENT-1]= ROWS_HEADER_LEN;
2801
/*
2802
We here have the possibility to simulate a master of before we changed
2803
the table map id to be stored in 6 bytes: when it was stored in 4
2804
bytes (=> post_header_len was 6). This is used to test backward
2805
compatibility.
2806
This code can be removed after a few months (today is Dec 21st 2005),
2807
when we know that the 4-byte masters are not deployed anymore (check
2808
with Tomas Ulin first!), and the accompanying test (rpl_row_4_bytes)
2809
too.
2810
*/
2811
DBUG_EXECUTE_IF("old_row_based_repl_4_byte_map_id_master",
2812
post_header_len[TABLE_MAP_EVENT-1]=
2813
post_header_len[WRITE_ROWS_EVENT-1]=
2814
post_header_len[UPDATE_ROWS_EVENT-1]=
2815
post_header_len[DELETE_ROWS_EVENT-1]= 6;);
2816
2711
post_header_len[BEGIN_LOAD_QUERY_EVENT-1]= post_header_len[APPEND_BLOCK_EVENT-1];
2817
2712
post_header_len[EXECUTE_LOAD_QUERY_EVENT-1]= EXECUTE_LOAD_QUERY_HEADER_LEN;
2818
2713
post_header_len[INCIDENT_EVENT-1]= INCIDENT_HEADER_LEN;
2894
2789
description_event)
2895
2790
:Start_log_event_v3(buf, description_event), event_type_permutation(0)
2896
2791
{
2897
DBUG_ENTER("Format_description_log_event::Format_description_log_event(char*,...)");
2898
2792
buf+= LOG_EVENT_MINIMAL_HEADER_LEN;
2899
2793
if ((common_header_len=buf[ST_COMMON_HEADER_LEN_OFFSET]) < OLD_HEADER_LEN)
2900
DBUG_VOID_RETURN; /* sanity check */
2794
return; /* sanity check */
2901
2795
number_of_event_types=
2902
2796
event_len-(LOG_EVENT_MINIMAL_HEADER_LEN+ST_COMMON_HEADER_LEN_OFFSET+1);
2903
DBUG_PRINT("info", ("common_header_len=%d number_of_event_types=%d",
2904
common_header_len, number_of_event_types));
2905
2797
/* If alloc fails, we'll detect it in is_valid() */
2906
2798
post_header_len= (uint8*) my_memdup((uchar*)buf+ST_COMMON_HEADER_LEN_OFFSET+1,
2907
2799
number_of_event_types*
2977
2869
{
2978
2870
if (number_of_event_types != 22)
2979
2871
{
2980
DBUG_PRINT("info", (" number_of_event_types=%d",
2981
number_of_event_types));
2982
2872
/* this makes is_valid() return false. */
2983
2873
my_free(post_header_len, MYF(MY_ALLOW_ZERO_PTR));
2984
2874
post_header_len= NULL;
2985
DBUG_VOID_RETURN;
2875
return;
2986
2876
}
2987
2877
static const uint8 perm[23]=
2988
2878
{
3011
2901
for (int i= 0; i < 22; i++)
3012
2902
post_header_len[i] = post_header_len_temp[i];
3013
2903
}
3014
DBUG_VOID_RETURN;
2904
return;
3015
2905
}
3016
2906
3017
2907
#ifndef MYSQL_CLIENT
3038
2928
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
3039
2929
int Format_description_log_event::do_apply_event(Relay_log_info const *rli)
3040
2930
{
3041
DBUG_ENTER("Format_description_log_event::do_apply_event");
3042
3043
2931
/*
3044
2932
As a transaction NEVER spans on 2 or more binlogs:
3045
2933
if we have an active transaction at this point, the master died
3077
2965
0, then 96, then jump to first really asked event (which is
3078
2966
>96). So this is ok.
3079
2967
*/
3080
DBUG_RETURN(Start_log_event_v3::do_apply_event(rli));
2968
return(Start_log_event_v3::do_apply_event(rli));
3081
2969
}
3082
DBUG_RETURN(0);
2970
return(0);
3083
2971
}
3084
2972
3085
2973
int Format_description_log_event::do_update_pos(Relay_log_info *rli)
3138
3026
{
3139
3027
number= strtoul(p, &r, 10);
3140
3028
server_version_split[i]= (uchar)number;
3141
DBUG_ASSERT(number < 256); // fit in uchar
3029
assert(number < 256); // fit in uchar
3142
3030
p= r;
3143
DBUG_ASSERT(!((i == 0) && (*r != '.'))); // should be true in practice
3031
assert(!((i == 0) && (*r != '.'))); // should be true in practice
3144
3032
if (*r == '.')
3145
3033
p++; // skip the dot
3146
3034
}
3147
DBUG_PRINT("info",("Format_description_log_event::server_version_split:"
3148
" '%s' %d %d %d", server_version,
3149
server_version_split[0],
3150
server_version_split[1], server_version_split[2]));
3151
3035
}
3152
3036
3153
3037
3283
3167
3284
3168
if (!(buf= (char*) my_malloc(get_query_buffer_length(), MYF(MY_WME))))
3285
3169
return;
3286
print_query(TRUE, buf, &end, 0, 0);
3170
print_query(true, buf, &end, 0, 0);
3287
3171
protocol->store(buf, end-buf, &my_charset_bin);
3288
3172
my_free(buf, MYF(0));
3289
3173
}
3346
3230
num_fields(0),fields(0),
3347
3231
field_lens(0),field_block_len(0),
3348
3232
table_name(table_name_arg ? table_name_arg : ""),
3349
db(db_arg), fname(ex->file_name), local_fname(FALSE)
3233
db(db_arg), fname(ex->file_name), local_fname(false)
3350
3234
{
3351
3235
time_t end_time;
3352
3236
time(&end_time);
3427
3311
const Format_description_log_event *description_event)
3428
3312
:Log_event(buf, description_event), num_fields(0), fields(0),
3429
3313
field_lens(0),field_block_len(0),
3430
table_name(0), db(0), fname(0), local_fname(FALSE)
3314
table_name(0), db(0), fname(0), local_fname(false)
3431
3315
{
3432
DBUG_ENTER("Load_log_event");
3433
3316
/*
3434
3317
I (Guilhem) manually tested replication of LOAD DATA INFILE for 3.23->5.0,
3435
3318
4.0->5.0 and 5.0->5.0 and it works.
3442
3325
LOAD_HEADER_LEN + LOG_EVENT_HEADER_LEN),
3443
3326
description_event);
3444
3327
/* otherwise it's a derived class, will call copy_log_event() itself */
3445
DBUG_VOID_RETURN;
3328
return;
3446
3329
}
3447
3330
3448
3331
3454
3337
int body_offset,
3455
3338
const Format_description_log_event *description_event)
3456
3339
{
3457
DBUG_ENTER("Load_log_event::copy_log_event");
3458
3340
uint data_len;
3459
3341
char* buf_end = (char*)buf + event_len;
3460
3342
/* this is the beginning of the post-header */
3467
3349
num_fields = uint4korr(data_head + L_NUM_FIELDS_OFFSET);
3468
3350
3469
3351
if ((int) event_len < body_offset)
3470
DBUG_RETURN(1);
3352
return(1);
3471
3353
/*
3472
3354
Sql_ex.init() on success returns the pointer to the first byte after
3473
3355
the sql_ex structure, which is the start of field lengths array.
3475
3357
if (!(field_lens= (uchar*)sql_ex.init((char*)buf + body_offset,
3476
3358
buf_end,
3477
3359
buf[EVENT_TYPE_OFFSET] != LOAD_EVENT)))
3478
DBUG_RETURN(1);
3360
return(1);
3479
3361
3480
3362
data_len = event_len - body_offset;
3481
3363
if (num_fields > data_len) // simple sanity check against corruption
3482
DBUG_RETURN(1);
3364
return(1);
3483
3365
for (uint i = 0; i < num_fields; i++)
3484
3366
field_block_len += (uint)field_lens[i] + 1;
3485
3367
3490
3372
fname_len = strlen(fname);
3491
3373
// null termination is accomplished by the caller doing buf[event_len]=0
3492
3374
3493
DBUG_RETURN(0);
3375
return(0);
3494
3376
}
3495
3377
3496
3378
3510
3392
{
3511
3393
Write_on_release_cache cache(&print_event_info->head_cache, file_arg);
3512
3394
3513
DBUG_ENTER("Load_log_event::print");
3514
3395
if (!print_event_info->short_form)
3515
3396
{
3516
print_header(&cache, print_event_info, FALSE);
3397
print_header(&cache, print_event_info, false);
3517
3398
my_b_printf(&cache, "\tQuery\tthread_id=%ld\texec_time=%ld\n",
3518
3399
thread_id, exec_time);
3519
3400
}
3593
3474
}
3594
3475
3595
3476
my_b_printf(&cache, "%s\n", print_event_info->delimiter);
3596
DBUG_VOID_RETURN;
3477
return;
3597
3478
}
3598
3479
#endif /* MYSQL_CLIENT */
3599
3480
3662
3543
new_db.length= db_len;
3663
3544
new_db.str= (char *) rpl_filter->get_rewrite_db(db, &new_db.length);
3664
3545
thd->set_db(new_db.str, new_db.length);
3665
DBUG_ASSERT(thd->query == 0);
3546
assert(thd->query == 0);
3666
3547
thd->query_length= 0; // Should not be needed
3667
3548
thd->is_slave_error= 0;
3668
3549
clear_all_errors(thd, const_cast<Relay_log_info*>(rli));
3669
3550
3670
3551
/* see Query_log_event::do_apply_event() and BUG#13360 */
3671
DBUG_ASSERT(!rli->m_table_map.count());
3552
assert(!rli->m_table_map.count());
3672
3553
/*
3673
3554
Usually lex_start() is called by mysql_parse(), but we need it here
3674
3555
as the present method does not call mysql_parse().
3683
3564
Query_log_event::do_apply_event()
3684
3565
*/
3685
3566
const_cast<Relay_log_info*>(rli)->future_group_master_log_pos= log_pos;
3686
DBUG_PRINT("info", ("log_pos: %lu", (ulong) log_pos));
3687
3567
}
3688
3568
3689
3569
/*
3758
3638
goto error;
3759
3639
}
3760
3640
3761
print_query(FALSE, load_data_query, &end, (char **)&thd->lex->fname_start,
3641
print_query(false, load_data_query, &end, (char **)&thd->lex->fname_start,
3762
3642
(char **)&thd->lex->fname_end);
3763
3643
*end= 0;
3764
3644
thd->query_length= end - load_data_query;
3876
3756
VOID(pthread_mutex_unlock(&LOCK_thread_count));
3877
3757
close_thread_tables(thd);
3878
3758
3879
DBUG_EXECUTE_IF("LOAD_DATA_INFILE_has_fatal_error",
3880
thd->is_slave_error= 0; thd->is_fatal_error= 1;);
3881
3882
3759
if (thd->is_slave_error)
3883
3760
{
3884
3761
/* this err/sql_errno code is copy-paste from net_send_error() */
3956
3833
3957
3834
if (print_event_info->short_form)
3958
3835
return;
3959
print_header(&cache, print_event_info, FALSE);
3836
print_header(&cache, print_event_info, false);
3960
3837
my_b_printf(&cache, "\tRotate to ");
3961
3838
if (new_log_ident)
3962
3839
my_b_write(&cache, (uchar*) new_log_ident, (uint)ident_len);
3979
3856
pos(pos_arg),ident_len(ident_len_arg ? ident_len_arg :
3980
3857
(uint) strlen(new_log_ident_arg)), flags(flags_arg)
3981
3858
{
3982
#ifndef DBUG_OFF
3983
3859
char buff[22];
3984
DBUG_ENTER("Rotate_log_event::Rotate_log_event(...,flags)");
3985
DBUG_PRINT("enter",("new_log_ident: %s pos: %s flags: %lu", new_log_ident_arg,
3986
llstr(pos_arg, buff), (ulong) flags));
3987
#endif
3988
3860
if (flags & DUP_NAME)
3989
3861
new_log_ident= my_strndup(new_log_ident_arg, ident_len, MYF(MY_WME));
3990
DBUG_VOID_RETURN;
3862
return;
3991
3863
}
3992
3864
#endif
3993
3865
3996
3868
const Format_description_log_event* description_event)
3997
3869
:Log_event(buf, description_event) ,new_log_ident(0), flags(DUP_NAME)
3998
3870
{
3999
DBUG_ENTER("Rotate_log_event::Rotate_log_event(char*,...)");
4000
3871
// The caller will ensure that event_len is what we have at EVENT_LEN_OFFSET
4001
3872
uint8 header_size= description_event->common_header_len;
4002
3873
uint8 post_header_len= description_event->post_header_len[ROTATE_EVENT-1];
4003
3874
uint ident_offset;
4004
3875
if (event_len < header_size)
4005
DBUG_VOID_RETURN;
3876
return;
4006
3877
buf += header_size;
4007
3878
pos = post_header_len ? uint8korr(buf + R_POS_OFFSET) : 4;
4008
3879
ident_len = (uint)(event_len -
4010
3881
ident_offset = post_header_len;
4011
3882
set_if_smaller(ident_len,FN_REFLEN-1);
4012
3883
new_log_ident= my_strndup(buf + ident_offset, (uint) ident_len, MYF(MY_WME));
4013
DBUG_PRINT("debug", ("new_log_ident: '%s'", new_log_ident));
4014
DBUG_VOID_RETURN;
3884
return;
4015
3885
}
4016
3886
4017
3887
4048
3918
*/
4049
3919
int Rotate_log_event::do_update_pos(Relay_log_info *rli)
4050
3920
{
4051
DBUG_ENTER("Rotate_log_event::do_update_pos");
4052
#ifndef DBUG_OFF
4053
3921
char buf[32];
4054
#endif
4055
4056
DBUG_PRINT("info", ("server_id=%lu; ::server_id=%lu",
4057
(ulong) this->server_id, (ulong) ::server_id));
4058
DBUG_PRINT("info", ("new_log_ident: %s", this->new_log_ident));
4059
DBUG_PRINT("info", ("pos: %s", llstr(this->pos, buf)));
4060
3922
4061
3923
pthread_mutex_lock(&rli->data_lock);
4062
3924
rli->event_relay_log_pos= my_b_tell(rli->cur_log);
4079
3941
if ((server_id != ::server_id || rli->replicate_same_server_id) &&
4080
3942
!rli->is_in_group())
4081
3943
{
4082
DBUG_PRINT("info", ("old group_master_log_name: '%s' "
4083
"old group_master_log_pos: %lu",
4084
rli->group_master_log_name,
4085
(ulong) rli->group_master_log_pos));
4086
3944
memcpy(rli->group_master_log_name, new_log_ident, ident_len+1);
4087
3945
rli->notify_group_master_log_name_update();
4088
3946
rli->group_master_log_pos= pos;
4090
3948
sizeof(rli->group_relay_log_name) - 1);
4091
3949
rli->notify_group_relay_log_name_update();
4092
3950
rli->group_relay_log_pos= rli->event_relay_log_pos;
4093
DBUG_PRINT("info", ("new group_master_log_name: '%s' "
4094
"new group_master_log_pos: %lu",
4095
rli->group_master_log_name,
4096
(ulong) rli->group_master_log_pos));
4097
3951
/*
4098
3952
Reset thd->options and sql_mode etc, because this could be the signal of
4099
3953
a master's downgrade from 5.0 to 4.0.
4110
3964
pthread_cond_broadcast(&rli->data_cond);
4111
3965
flush_relay_log_info(rli);
4112
3966
4113
DBUG_RETURN(0);
3967
return(0);
4114
3968
}
4115
3969
4116
3970
4127
3981
case Log_event::EVENT_SKIP_IGNORE:
4128
3982
return Log_event::EVENT_SKIP_IGNORE;
4129
3983
}
4130
DBUG_ASSERT(0);
3984
assert(0);
4131
3985
return Log_event::EVENT_SKIP_NOT; // To keep compiler happy
4132
3986
}
4133
3987
4212
4066
4213
4067
if (!print_event_info->short_form)
4214
4068
{
4215
print_header(&cache, print_event_info, FALSE);
4069
print_header(&cache, print_event_info, false);
4216
4070
my_b_printf(&cache, "\tIntvar\n");
4217
4071
}
4218
4072
4332
4186
char llbuff[22],llbuff2[22];
4333
4187
if (!print_event_info->short_form)
4334
4188
{
4335
print_header(&cache, print_event_info, FALSE);
4189
print_header(&cache, print_event_info, false);
4336
4190
my_b_printf(&cache, "\tRand\n");
4337
4191
}
4338
4192
my_b_printf(&cache, "SET @@RAND_SEED1=%s, @@RAND_SEED2=%s%s\n",
4417
4271
#ifndef MYSQL_CLIENT
4418
4272
bool Xid_log_event::write(IO_CACHE* file)
4419
4273
{
4420
DBUG_EXECUTE_IF("do_not_write_xid", return 0;);
4421
4274
return write_header(file, sizeof(xid)) ||
4422
4275
my_b_safe_write(file, (uchar*) &xid, sizeof(xid));
4423
4276
}
4435
4288
char buf[64];
4436
4289
longlong10_to_str(xid, buf, 10);
4437
4290
4438
print_header(&cache, print_event_info, FALSE);
4291
print_header(&cache, print_event_info, false);
4439
4292
my_b_printf(&cache, "\tXid = %s\n", buf);
4440
4293
}
4441
4294
my_b_printf(&cache, "COMMIT%s\n", print_event_info->delimiter);
4455
4308
Log_event::enum_skip_reason
4456
4309
Xid_log_event::do_shall_skip(Relay_log_info *rli)
4457
4310
{
4458
DBUG_ENTER("Xid_log_event::do_shall_skip");
4459
4311
if (rli->slave_skip_counter > 0) {
4460
4312
thd->options&= ~OPTION_BEGIN;
4461
DBUG_RETURN(Log_event::EVENT_SKIP_COUNT);
4313
return(Log_event::EVENT_SKIP_COUNT);
4462
4314
}
4463
DBUG_RETURN(Log_event::do_shall_skip(rli));
4315
return(Log_event::do_shall_skip(rli));
4464
4316
}
4465
4317
#endif /* !MYSQL_CLIENT */
4466
4318
4535
4387
break;
4536
4388
case ROW_RESULT:
4537
4389
default:
4538
DBUG_ASSERT(1);
4390
assert(1);
4539
4391
return;
4540
4392
}
4541
4393
}
4623
4475
break;
4624
4476
case ROW_RESULT:
4625
4477
default:
4626
DBUG_ASSERT(1);
4478
assert(1);
4627
4479
return 0;
4628
4480
}
4629
4481
int4store(buf1 + 2 + UV_CHARSET_NUMBER_SIZE, val_len);
4654
4506
4655
4507
if (!print_event_info->short_form)
4656
4508
{
4657
print_header(&cache, print_event_info, FALSE);
4509
print_header(&cache, print_event_info, false);
4658
4510
my_b_printf(&cache, "\tUser_var\n");
4659
4511
}
4660
4512
4741
4593
break;
4742
4594
case ROW_RESULT:
4743
4595
default:
4744
DBUG_ASSERT(1);
4596
assert(1);
4745
4597
return;
4746
4598
}
4747
4599
}
4804
4656
break;
4805
4657
case ROW_RESULT:
4806
4658
default:
4807
DBUG_ASSERT(1);
4659
assert(1);
4808
4660
return 0;
4809
4661
}
4810
4662
}
4859
4711
4860
4712
if (print_event_info->short_form)
4861
4713
return;
4862
print_header(&cache, print_event_info, FALSE);
4714
print_header(&cache, print_event_info, false);
4863
4715
my_b_printf(&cache, "\n# %s", "Unknown event\n");
4864
4716
}
4865
4717
#endif
4890
4742
Relay_log_info* rli)
4891
4743
:Log_event(thd_arg, 0, 0) , mem_pool(0), master_host(0)
4892
4744
{
4893
DBUG_ENTER("Slave_log_event");
4894
4745
if (!rli->inited) // QQ When can this happen ?
4895
DBUG_VOID_RETURN;
4746
return;
4896
4747
4897
4748
Master_info* mi = rli->mi;
4898
4749
// TODO: re-write this better without holding both locks at the same time
4910
4761
memcpy(master_log, rli->group_master_log_name, master_log_len + 1);
4911
4762
master_port = mi->port;
4912
4763
master_pos = rli->group_master_log_pos;
4913
DBUG_PRINT("info", ("master_log: %s pos: %lu", master_log,
4914
(ulong) master_pos));
4915
4764
}
4916
4765
else
4917
4766
sql_print_error("Out of memory while recording slave event");
4918
4767
pthread_mutex_unlock(&rli->data_lock);
4919
4768
pthread_mutex_unlock(&mi->data_lock);
4920
DBUG_VOID_RETURN;
4769
return;
4921
4770
}
4922
4771
#endif /* !MYSQL_CLIENT */
4923
4772
4936
4785
char llbuff[22];
4937
4786
if (print_event_info->short_form)
4938
4787
return;
4939
print_header(&cache, print_event_info, FALSE);
4788
print_header(&cache, print_event_info, false);
4940
4789
my_b_printf(&cache, "\n\
4941
4790
Slave: master_host: '%s' master_port: %d master_log: '%s' master_pos: %s\n",
4942
4791
master_host, master_port, master_log, llstr(master_pos, llbuff));
5023
4872
if (print_event_info->short_form)
5024
4873
return;
5025
4874
5026
print_header(&cache, print_event_info, FALSE);
4875
print_header(&cache, print_event_info, false);
5027
4876
my_b_printf(&cache, "\tStop\n");
5028
4877
}
5029
4878
#endif /* MYSQL_CLIENT */
5084
4933
fake_base(0), block(block_arg), event_buf(0), block_len(block_len_arg),
5085
4934
file_id(thd_arg->file_id = mysql_bin_log.next_file_id())
5086
4935
{
5087
DBUG_ENTER("Create_file_log_event");
5088
4936
sql_ex.force_new_format();
5089
DBUG_VOID_RETURN;
4937
return;
5090
4938
}
5091
4939
5092
4940
5142
4990
const Format_description_log_event* description_event)
5143
4991
:Load_log_event(buf,0,description_event),fake_base(0),block(0),inited_from_old(0)
5144
4992
{
5145
DBUG_ENTER("Create_file_log_event::Create_file_log_event(char*,...)");
5146
4993
uint block_offset;
5147
4994
uint header_len= description_event->common_header_len;
5148
4995
uint8 load_header_len= description_event->post_header_len[LOAD_EVENT-1];
5155
5002
(header_len+load_header_len) +
5156
5003
create_file_header_len)),
5157
5004
description_event))
5158
DBUG_VOID_RETURN;
5005
return;
5159
5006
if (description_event->binlog_version!=1)
5160
5007
{
5161
5008
file_id= uint4korr(buf +
5176
5023
Load_log_event::get_data_size() +
5177
5024
create_file_header_len + 1);
5178
5025
if (len < block_offset)
5179
DBUG_VOID_RETURN;
5026
return;
5180
5027
block = (uchar*)buf + block_offset;
5181
5028
block_len = len - block_offset;
5182
5029
}
5185
5032
sql_ex.force_new_format();
5186
5033
inited_from_old = 1;
5187
5034
}
5188
DBUG_VOID_RETURN;
5035
return;
5189
5036
}
5190
5037
5191
5038
5353
5200
const Format_description_log_event* description_event)
5354
5201
:Log_event(buf, description_event),block(0)
5355
5202
{
5356
DBUG_ENTER("Append_block_log_event::Append_block_log_event(char*,...)");
5357
5203
uint8 common_header_len= description_event->common_header_len;
5358
5204
uint8 append_block_header_len=
5359
5205
description_event->post_header_len[APPEND_BLOCK_EVENT-1];
5360
5206
uint total_header_len= common_header_len+append_block_header_len;
5361
5207
if (len < total_header_len)
5362
DBUG_VOID_RETURN;
5208
return;
5363
5209
file_id= uint4korr(buf + common_header_len + AB_FILE_ID_OFFSET);
5364
5210
block= (uchar*)buf + total_header_len;
5365
5211
block_len= len - total_header_len;
5366
DBUG_VOID_RETURN;
5212
return;
5367
5213
}
5368
5214
5369
5215
5395
5241
5396
5242
if (print_event_info->short_form)
5397
5243
return;
5398
print_header(&cache, print_event_info, FALSE);
5244
print_header(&cache, print_event_info, false);
5399
5245
my_b_printf(&cache, "\n#%s: file_id: %d block_len: %d\n",
5400
5246
get_type_str(), file_id, block_len);
5401
5247
}
5436
5282
char proc_info[17+FN_REFLEN+10], *fname= proc_info+17;
5437
5283
int fd;
5438
5284
int error = 1;
5439
DBUG_ENTER("Append_block_log_event::do_apply_event");
5440
5285
5441
5286
fname= strmov(proc_info, "Making temp file ");
5442
5287
slave_load_file_stem(fname, file_id, server_id, ".data");
5475
5320
if (fd >= 0)
5476
5321
my_close(fd, MYF(0));
5477
5322
thd_proc_info(thd, 0);
5478
DBUG_RETURN(error);
5323
return(error);
5479
5324
}
5480
5325
#endif
5481
5326
5539
5384
5540
5385
if (print_event_info->short_form)
5541
5386
return;
5542
print_header(&cache, print_event_info, FALSE);
5387
print_header(&cache, print_event_info, false);
5543
5388
my_b_printf(&cache, "\n#Delete_file: file_id=%u\n", file_id);
5544
5389
}
5545
5390
#endif /* MYSQL_CLIENT */
5636
5481
5637
5482
if (print_event_info->short_form)
5638
5483
return;
5639
print_header(&cache, print_event_info, FALSE);
5484
print_header(&cache, print_event_info, false);
5640
5485
my_b_printf(&cache, "\n#Exec_load: file_id=%d\n",
5641
5486
file_id);
5642
5487
}
5936
5781
buf= (char*) my_malloc(q_len + 1 - (fn_pos_end - fn_pos_start) +
5937
5782
(FN_REFLEN + 10) + 10 + 8 + 5, MYF(MY_WME));
5938
5783
5939
DBUG_EXECUTE_IF("LOAD_DATA_INFILE_has_fatal_error", my_free(buf, MYF(0)); buf= NULL;);
5940
5941
5784
/* Replace filename and LOCAL keyword in query before executing it */
5942
5785
if (buf == NULL)
5943
5786
{
6097
5940
solution, to be able to terminate a started statement in the
6098
5941
binary log: the extraneous events will be removed in the future.
6099
5942
*/
6100
DBUG_ASSERT(tbl_arg && tbl_arg->s && tid != ~0UL ||
5943
assert(tbl_arg && tbl_arg->s && tid != ~0UL ||
6101
5944
!tbl_arg && !cols && tid == ~0UL);
6102
5945
6103
5946
if (thd_arg->options & OPTION_NO_FOREIGN_KEY_CHECKS)
6110
5953
m_width,
6111
5954
false)))
6112
5955
{
6113
DBUG_PRINT_BITSET("debug", "init cols: %s", cols);
6114
5956
/* Cols can be zero if this is a dummy binrows event */
6115
5957
if (likely(cols != NULL))
6116
5958
{
6140
5982
, m_curr_row(NULL), m_curr_row_end(NULL), m_key(NULL)
6141
5983
#endif
6142
5984
{
6143
DBUG_ENTER("Rows_log_event::Rows_log_event(const char*,...)");
6144
5985
uint8 const common_header_len= description_event->common_header_len;
6145
5986
uint8 const post_header_len= description_event->post_header_len[event_type-1];
6146
5987
6147
DBUG_PRINT("enter",("event_len: %u common_header_len: %d "
6148
"post_header_len: %d",
6149
event_len, common_header_len,
6150
post_header_len));
6151
6152
5988
const char *post_start= buf + common_header_len;
6153
5989
post_start+= RW_MAPID_OFFSET;
6154
5990
if (post_header_len == 6)
6169
6005
(const uchar *)buf + common_header_len + post_header_len;
6170
6006
uchar const *const ptr_width= var_start;
6171
6007
uchar *ptr_after_width= (uchar*) ptr_width;
6172
DBUG_PRINT("debug", ("Reading from %p", ptr_after_width));
6173
6008
m_width = net_field_length(&ptr_after_width);
6174
DBUG_PRINT("debug", ("m_width=%lu", m_width));
6175
6009
/* if bitmap_init fails, catched in is_valid() */
6176
6010
if (likely(!bitmap_init(&m_cols,
6177
6011
m_width <= sizeof(m_bitbuf)*8 ? m_bitbuf : NULL,
6178
6012
m_width,
6179
6013
false)))
6180
6014
{
6181
DBUG_PRINT("debug", ("Reading from %p", ptr_after_width));
6182
6015
memcpy(m_cols.bitmap, ptr_after_width, (m_width + 7) / 8);
6183
6016
create_last_word_mask(&m_cols);
6184
6017
ptr_after_width+= (m_width + 7) / 8;
6185
DBUG_DUMP("m_cols", (uchar*) m_cols.bitmap, no_bytes_in_map(&m_cols));
6186
6018
}
6187
6019
else
6188
6020
{
6189
6021
// Needed because bitmap_init() does not set it to null on failure
6190
6022
m_cols.bitmap= NULL;
6191
DBUG_VOID_RETURN;
6023
return;
6192
6024
}
6193
6025
6194
6026
m_cols_ai.bitmap= m_cols.bitmap; /* See explanation in is_valid() */
6195
6027
6196
6028
if (event_type == UPDATE_ROWS_EVENT)
6197
6029
{
6198
DBUG_PRINT("debug", ("Reading from %p", ptr_after_width));
6199
6200
6030
/* if bitmap_init fails, caught in is_valid() */
6201
6031
if (likely(!bitmap_init(&m_cols_ai,
6202
6032
m_width <= sizeof(m_bitbuf_ai)*8 ? m_bitbuf_ai : NULL,
6203
6033
m_width,
6204
6034
false)))
6205
6035
{
6206
DBUG_PRINT("debug", ("Reading from %p", ptr_after_width));
6207
6036
memcpy(m_cols_ai.bitmap, ptr_after_width, (m_width + 7) / 8);
6208
6037
create_last_word_mask(&m_cols_ai);
6209
6038
ptr_after_width+= (m_width + 7) / 8;
6210
DBUG_DUMP("m_cols_ai", (uchar*) m_cols_ai.bitmap,
6211
no_bytes_in_map(&m_cols_ai));
6212
6039
}
6213
6040
else
6214
6041
{
6215
6042
// Needed because bitmap_init() does not set it to null on failure
6216
6043
m_cols_ai.bitmap= 0;
6217
DBUG_VOID_RETURN;
6044
return;
6218
6045
}
6219
6046
}
6220
6047
6221
6048
const uchar* const ptr_rows_data= (const uchar*) ptr_after_width;
6222
6049
6223
6050
size_t const data_size= event_len - (ptr_rows_data - (const uchar *) buf);
6224
DBUG_PRINT("info",("m_table_id: %lu m_flags: %d m_width: %lu data_size: %lu",
6225
m_table_id, m_flags, m_width, (ulong) data_size));
6226
6051
6227
6052
m_rows_buf= (uchar*) my_malloc(data_size, MYF(MY_WME));
6228
6053
if (likely((bool)m_rows_buf))
6237
6062
else
6238
6063
m_cols.bitmap= 0; // to not free it
6239
6064
6240
DBUG_VOID_RETURN;
6065
return;
6241
6066
}
6242
6067
6243
6068
Rows_log_event::~Rows_log_event()
6255
6080
uchar buf[sizeof(m_width)+1];
6256
6081
uchar *end= net_store_length(buf, (m_width + 7) / 8);
6257
6082
6258
DBUG_EXECUTE_IF("old_row_based_repl_4_byte_map_id_master",
6259
return 6 + no_bytes_in_map(&m_cols) + (end - buf) +
6260
(type_code == UPDATE_ROWS_EVENT ? no_bytes_in_map(&m_cols_ai) : 0) +
6261
(m_rows_cur - m_rows_buf););
6262
6083
int data_size= ROWS_HEADER_LEN;
6263
6084
data_size+= no_bytes_in_map(&m_cols);
6264
6085
data_size+= end - buf;
6279
6100
log only the primary key value instead of the entire "before image". This
6280
6101
would save binlog space. TODO
6281
6102
*/
6282
DBUG_ENTER("Rows_log_event::do_add_row_data");
6283
DBUG_PRINT("enter", ("row_data: 0x%lx length: %lu", (ulong) row_data,
6284
(ulong) length));
6285
6103
6286
6104
/*
6287
6105
If length is zero, there is nothing to write, so we just
6291
6109
if (length == 0)
6292
6110
{
6293
6111
m_row_count++;
6294
DBUG_RETURN(0);
6112
return(0);
6295
6113
}
6296
6114
6297
/*
6298
Don't print debug messages when running valgrind since they can
6299
trigger false warnings.
6300
*/
6301
#ifndef HAVE_purify
6302
DBUG_DUMP("row_data", row_data, min(length, 32));
6303
#endif
6304
6305
DBUG_ASSERT(m_rows_buf <= m_rows_cur);
6306
DBUG_ASSERT(!m_rows_buf || m_rows_end && m_rows_buf <= m_rows_end);
6307
DBUG_ASSERT(m_rows_cur <= m_rows_end);
6115
assert(m_rows_buf <= m_rows_cur);
6116
assert(!m_rows_buf || m_rows_end && m_rows_buf <= m_rows_end);
6117
assert(m_rows_cur <= m_rows_end);
6308
6118
6309
6119
/* The cast will always work since m_rows_cur <= m_rows_end */
6310
6120
if (static_cast<size_t>(m_rows_end - m_rows_cur) <= length)
6317
6127
uchar* const new_buf= (uchar*)my_realloc((uchar*)m_rows_buf, (uint) new_alloc,
6318
6128
MYF(MY_ALLOW_ZERO_PTR|MY_WME));
6319
6129
if (unlikely(!new_buf))
6320
DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6130
return(HA_ERR_OUT_OF_MEM);
6321
6131
6322
6132
/* If the memory moved, we need to move the pointers */
6323
6133
if (new_buf != m_rows_buf)
6333
6143
m_rows_end= m_rows_buf + new_alloc;
6334
6144
}
6335
6145
6336
DBUG_ASSERT(m_rows_cur + length <= m_rows_end);
6146
assert(m_rows_cur + length <= m_rows_end);
6337
6147
memcpy(m_rows_cur, row_data, length);
6338
6148
m_rows_cur+= length;
6339
6149
m_row_count++;
6340
DBUG_RETURN(0);
6150
return(0);
6341
6151
}
6342
6152
#endif
6343
6153
6344
6154
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
6345
6155
int Rows_log_event::do_apply_event(Relay_log_info const *rli)
6346
6156
{
6347
DBUG_ENTER("Rows_log_event::do_apply_event(Relay_log_info*)");
6348
6157
int error= 0;
6349
6158
/*
6350
6159
If m_table_id == ~0UL, then we have a dummy event that does not
6358
6167
This one is supposed to be set: just an extra check so that
6359
6168
nothing strange has happened.
6360
6169
*/
6361
DBUG_ASSERT(get_flags(STMT_END_F));
6170
assert(get_flags(STMT_END_F));
6362
6171
6363
6172
const_cast<Relay_log_info*>(rli)->clear_tables_to_lock();
6364
6173
close_thread_tables(thd);
6365
6174
thd->clear_error();
6366
DBUG_RETURN(0);
6175
return(0);
6367
6176
}
6368
6177
6369
6178
/*
6371
6180
do_apply_event(). We still check here to prevent future coding
6372
6181
errors.
6373
6182
*/
6374
DBUG_ASSERT(rli->sql_thd == thd);
6183
assert(rli->sql_thd == thd);
6375
6184
6376
6185
/*
6377
6186
If there is no locks taken, this is the first binrow event seen
6406
6215
else
6407
6216
thd->options&= ~OPTION_RELAXED_UNIQUE_CHECKS;
6408
6217
/* A small test to verify that objects have consistent types */
6409
DBUG_ASSERT(sizeof(thd->options) == sizeof(OPTION_RELAXED_UNIQUE_CHECKS));
6218
assert(sizeof(thd->options) == sizeof(OPTION_RELAXED_UNIQUE_CHECKS));
6410
6219
6411
6220
6412
6221
while ((error= lock_tables(thd, rli->tables_to_lock,
6435
6244
get_type_str());
6436
6245
}
6437
6246
const_cast<Relay_log_info*>(rli)->clear_tables_to_lock();
6438
DBUG_RETURN(error);
6247
return(error);
6439
6248
}
6440
6249
6441
6250
/*
6472
6281
thd->is_slave_error= 1;
6473
6282
}
6474
6283
const_cast<Relay_log_info*>(rli)->clear_tables_to_lock();
6475
DBUG_RETURN(error);
6284
return(error);
6476
6285
}
6477
6286
}
6478
6287
6494
6303
thd->lock= 0;
6495
6304
thd->is_slave_error= 1;
6496
6305
const_cast<Relay_log_info*>(rli)->clear_tables_to_lock();
6497
DBUG_RETURN(ERR_BAD_TABLE_DEF);
6306
return(ERR_BAD_TABLE_DEF);
6498
6307
}
6499
6308
}
6500
6309
}
6561
6370
thd->options&= ~OPTION_ALLOW_BATCH;
6562
6371
6563
6372
/* A small test to verify that objects have consistent types */
6564
DBUG_ASSERT(sizeof(thd->options) == sizeof(OPTION_RELAXED_UNIQUE_CHECKS));
6373
assert(sizeof(thd->options) == sizeof(OPTION_RELAXED_UNIQUE_CHECKS));
6565
6374
6566
6375
/*
6567
6376
Now we are in a statement and will stay in a statement until we
6587
6396
longer if slave has extra columns.
6588
6397
*/
6589
6398
6590
DBUG_PRINT_BITSET("debug", "Setting table's write_set from: %s", &m_cols);
6591
6592
6399
bitmap_set_all(table->read_set);
6593
6400
bitmap_set_all(table->write_set);
6594
6401
if (!get_flags(COMPLETE_ROWS_F))
6637
6444
case HA_ERR_FOREIGN_DUPLICATE_KEY:
6638
6445
case HA_ERR_NO_REFERENCED_ROW:
6639
6446
case HA_ERR_ROW_IS_REFERENCED:
6640
6641
DBUG_PRINT("info", ("error: %s", HA_ERR(error)));
6642
6447
if (bit_is_set(slave_exec_mode, SLAVE_EXEC_MODE_IDEMPOTENT) == 1)
6643
6448
{
6644
6449
if (global_system_variables.log_warnings)
6660
6465
(i.e., error==0 at this point) we must call unpack_current_row() to set
6661
6466
m_curr_row_end.
6662
6467
*/
6663
6664
DBUG_PRINT("info", ("error: %d", error));
6665
DBUG_PRINT("info", ("curr_row: 0x%lu; curr_row_end: 0x%lu; rows_end: 0x%lu",
6666
(ulong) m_curr_row, (ulong) m_curr_row_end, (ulong) m_rows_end));
6667
6668
6468
if (!m_curr_row_end && !error)
6669
6469
unpack_current_row(rli, &m_cols);
6670
6470
6671
6471
// at this moment m_curr_row_end should be set
6672
DBUG_ASSERT(error || m_curr_row_end != NULL);
6673
DBUG_ASSERT(error || m_curr_row < m_curr_row_end);
6674
DBUG_ASSERT(error || m_curr_row_end <= m_rows_end);
6472
assert(error || m_curr_row_end != NULL);
6473
assert(error || m_curr_row < m_curr_row_end);
6474
assert(error || m_curr_row_end <= m_rows_end);
6675
6475
6676
6476
m_curr_row= m_curr_row_end;
6677
6477
6678
6478
} // row processing loop
6679
6479
6680
DBUG_EXECUTE_IF("STOP_SLAVE_after_first_Rows_event",
6681
const_cast<Relay_log_info*>(rli)->abort_slave= 1;);
6682
6480
error= do_after_row_operations(rli, error);
6683
6481
if (!cache_stmt)
6684
6482
{
6685
DBUG_PRINT("info", ("Marked that we need to keep log"));
6686
6483
thd->options|= OPTION_KEEP_LOG;
6687
6484
}
6688
6485
} // if (table)
6717
6514
thd->reset_current_stmt_binlog_row_based();
6718
6515
const_cast<Relay_log_info*>(rli)->cleanup_context(thd, error);
6719
6516
thd->is_slave_error= 1;
6720
DBUG_RETURN(error);
6517
return(error);
6721
6518
}
6722
6519
6723
6520
/*
6747
6544
const_cast<Relay_log_info*>(rli)->last_event_start_time= my_time(0);
6748
6545
}
6749
6546
6750
DBUG_RETURN(0);
6547
return(0);
6751
6548
}
6752
6549
6753
6550
Log_event::enum_skip_reason
6767
6564
int
6768
6565
Rows_log_event::do_update_pos(Relay_log_info *rli)
6769
6566
{
6770
DBUG_ENTER("Rows_log_event::do_update_pos");
6771
6567
int error= 0;
6772
6568
6773
DBUG_PRINT("info", ("flags: %s",
6774
get_flags(STMT_END_F) ? "STMT_END_F " : ""));
6775
6776
6569
if (get_flags(STMT_END_F))
6777
6570
{
6778
6571
/*
6847
6640
rli->inc_event_relay_log_pos();
6848
6641
}
6849
6642
6850
DBUG_RETURN(error);
6643
return(error);
6851
6644
}
6852
6645
6853
6646
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
6856
6649
bool Rows_log_event::write_data_header(IO_CACHE *file)
6857
6650
{
6858
6651
uchar buf[ROWS_HEADER_LEN]; // No need to init the buffer
6859
DBUG_ASSERT(m_table_id != ~0UL);
6860
DBUG_EXECUTE_IF("old_row_based_repl_4_byte_map_id_master",
6861
{
6862
int4store(buf + 0, m_table_id);
6863
int2store(buf + 4, m_flags);
6864
return (my_b_safe_write(file, buf, 6));
6865
});
6652
assert(m_table_id != ~0UL);
6866
6653
int6store(buf + RW_MAPID_OFFSET, (ulonglong)m_table_id);
6867
6654
int2store(buf + RW_FLAGS_OFFSET, m_flags);
6868
6655
return (my_b_safe_write(file, buf, ROWS_HEADER_LEN));
6878
6665
my_ptrdiff_t const data_size= m_rows_cur - m_rows_buf;
6879
6666
bool res= false;
6880
6667
uchar *const sbuf_end= net_store_length(sbuf, (size_t) m_width);
6881
DBUG_ASSERT(static_cast<size_t>(sbuf_end - sbuf) <= sizeof(sbuf));
6668
assert(static_cast<size_t>(sbuf_end - sbuf) <= sizeof(sbuf));
6882
6669
6883
DBUG_DUMP("m_width", sbuf, (size_t) (sbuf_end - sbuf));
6884
6670
res= res || my_b_safe_write(file, sbuf, (size_t) (sbuf_end - sbuf));
6885
6671
6886
DBUG_PRINT_BITSET("debug", "writing cols: %s", &m_cols);
6887
6672
res= res || my_b_safe_write(file, (uchar*) m_cols.bitmap,
6888
6673
no_bytes_in_map(&m_cols));
6889
6674
/*
6891
6676
*/
6892
6677
if (get_type_code() == UPDATE_ROWS_EVENT)
6893
6678
{
6894
DBUG_DUMP("m_cols_ai", (uchar*) m_cols_ai.bitmap,
6895
no_bytes_in_map(&m_cols_ai));
6896
6679
res= res || my_b_safe_write(file, (uchar*) m_cols_ai.bitmap,
6897
6680
no_bytes_in_map(&m_cols_ai));
6898
6681
}
6899
DBUG_DUMP("rows", m_rows_buf, data_size);
6900
6682
res= res || my_b_safe_write(file, m_rows_buf, (size_t) data_size);
6901
6683
6902
6684
return res;
7004
6786
*/
7005
6787
int Table_map_log_event::save_field_metadata()
7006
6788
{
7007
DBUG_ENTER("Table_map_log_event::save_field_metadata");
7008
6789
int index= 0;
7009
6790
for (unsigned int i= 0 ; i < m_table->s->fields ; i++)
7010
6791
index+= m_table->s->field[i]->save_field_metadata(&m_field_metadata[index]);
7011
DBUG_RETURN(index);
6792
return(index);
7012
6793
}
7013
6794
#endif /* !defined(MYSQL_CLIENT) */
7014
6795
7037
6818
m_null_bits(0),
7038
6819
m_meta_memory(NULL)
7039
6820
{
7040
DBUG_ASSERT(m_table_id != ~0UL);
6821
assert(m_table_id != ~0UL);
7041
6822
/*
7042
6823
In TABLE_SHARE, "db" and "table_name" are 0-terminated (see this comment in
7043
6824
table.cc / alloc_table_share():
7044
6825
Use the fact the key is db/0/table_name/0
7045
6826
As we rely on this let's assert it.
7046
6827
*/
7047
DBUG_ASSERT((tbl->s->db.str == 0) ||
6828
assert((tbl->s->db.str == 0) ||
7048
6829
(tbl->s->db.str[tbl->s->db.length] == 0));
7049
DBUG_ASSERT(tbl->s->table_name.str[tbl->s->table_name.length] == 0);
6830
assert(tbl->s->table_name.str[tbl->s->table_name.length] == 0);
7050
6831
7051
6832
7052
6833
m_data_size= TABLE_MAP_HEADER_LEN;
7053
DBUG_EXECUTE_IF("old_row_based_repl_4_byte_map_id_master", m_data_size= 6;);
7054
6834
m_data_size+= m_dblen + 2; // Include length and terminating \0
7055
6835
m_data_size+= m_tbllen + 2; // Include length and terminating \0
7056
6836
m_data_size+= 1 + m_colcnt; // COLCNT and column types
7082
6862
Create an array for the field metadata and store it.
7083
6863
*/
7084
6864
m_field_metadata_size= save_field_metadata();
7085
DBUG_ASSERT(m_field_metadata_size <= (m_colcnt * 2));
6865
assert(m_field_metadata_size <= (m_colcnt * 2));
7086
6866
7087
6867
/*
7088
6868
Now set the size of the data to the size of the field metadata array
7120
6900
m_null_bits(0), m_meta_memory(NULL)
7121
6901
{
7122
6902
unsigned int bytes_read= 0;
7123
DBUG_ENTER("Table_map_log_event::Table_map_log_event(const char*,uint,...)");
7124
6903
7125
6904
uint8 common_header_len= description_event->common_header_len;
7126
6905
uint8 post_header_len= description_event->post_header_len[TABLE_MAP_EVENT-1];
7127
DBUG_PRINT("info",("event_len: %u common_header_len: %d post_header_len: %d",
7128
event_len, common_header_len, post_header_len));
7129
7130
/*
7131
Don't print debug messages when running valgrind since they can
7132
trigger false warnings.
7133
*/
7134
#ifndef HAVE_purify
7135
DBUG_DUMP("event buffer", (uchar*) buf, event_len);
7136
#endif
7137
6906
7138
6907
/* Read the post-header */
7139
6908
const char *post_start= buf + common_header_len;
7147
6916
}
7148
6917
else
7149
6918
{
7150
DBUG_ASSERT(post_header_len == TABLE_MAP_HEADER_LEN);
6919
assert(post_header_len == TABLE_MAP_HEADER_LEN);
7151
6920
m_table_id= (ulong) uint6korr(post_start);
7152
6921
post_start+= TM_FLAGS_OFFSET;
7153
6922
}
7154
6923
7155
DBUG_ASSERT(m_table_id != ~0UL);
6924
assert(m_table_id != ~0UL);
7156
6925
7157
6926
m_flags= uint2korr(post_start);
7158
6927
7172
6941
uchar *ptr_after_colcnt= (uchar*) ptr_colcnt;
7173
6942
m_colcnt= net_field_length(&ptr_after_colcnt);
7174
6943
7175
DBUG_PRINT("info",("m_dblen: %lu off: %ld m_tbllen: %lu off: %ld m_colcnt: %lu off: %ld",
7176
(ulong) m_dblen, (long) (ptr_dblen-(const uchar*)vpart),
7177
(ulong) m_tbllen, (long) (ptr_tbllen-(const uchar*)vpart),
7178
m_colcnt, (long) (ptr_colcnt-(const uchar*)vpart)));
7179
7180
6944
/* Allocate mem for all fields in one go. If fails, caught in is_valid() */
7181
6945
m_memory= (uchar*) my_multi_malloc(MYF(MY_WME),
7182
6946
&m_dbnam, (uint) m_dblen + 1,
7193
6957
7194
6958
ptr_after_colcnt= ptr_after_colcnt + m_colcnt;
7195
6959
bytes_read= ptr_after_colcnt - (uchar *)buf;
7196
DBUG_PRINT("info", ("Bytes read: %d.\n", bytes_read));
7197
6960
if (bytes_read < event_len)
7198
6961
{
7199
6962
m_field_metadata_size= net_field_length(&ptr_after_colcnt);
7200
DBUG_ASSERT(m_field_metadata_size <= (m_colcnt * 2));
6963
assert(m_field_metadata_size <= (m_colcnt * 2));
7201
6964
uint num_null_bytes= (m_colcnt + 7) / 8;
7202
6965
m_meta_memory= (uchar *)my_multi_malloc(MYF(MY_WME),
7203
6966
&m_null_bits, num_null_bytes,
7209
6972
}
7210
6973
}
7211
6974
7212
DBUG_VOID_RETURN;
6975
return;
7213
6976
}
7214
6977
#endif
7215
6978
7237
7000
char *db_mem, *tname_mem;
7238
7001
size_t dummy_len;
7239
7002
void *memory;
7240
DBUG_ENTER("Table_map_log_event::do_apply_event(Relay_log_info*)");
7241
DBUG_ASSERT(rli->sql_thd == thd);
7003
assert(rli->sql_thd == thd);
7242
7004
7243
7005
/* Step the query id to mark what columns that are actually used. */
7244
7006
pthread_mutex_lock(&LOCK_thread_count);
7250
7012
&db_mem, (uint) NAME_LEN + 1,
7251
7013
&tname_mem, (uint) NAME_LEN + 1,
7252
7014
NullS)))
7253
DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7015
return(HA_ERR_OUT_OF_MEM);
7254
7016
7255
7017
bzero(table_list, sizeof(*table_list));
7256
7018
table_list->db = db_mem;
7308
7070
of the pointer to make sure that it's not lost.
7309
7071
*/
7310
7072
uint count;
7311
DBUG_ASSERT(thd->lex->query_tables != table_list);
7073
assert(thd->lex->query_tables != table_list);
7312
7074
TABLE_LIST *tmp_table_list= table_list;
7313
7075
if ((error= open_tables(thd, &tmp_table_list, &count, 0)))
7314
7076
{
7335
7097
This will fail later otherwise, the 'in_use' field should be
7336
7098
set to the current thread.
7337
7099
*/
7338
DBUG_ASSERT(m_table->in_use);
7100
assert(m_table->in_use);
7339
7101
7340
7102
/*
7341
7103
Use placement new to construct the table_def instance in the
7348
7110
*/
7349
7111
new (&table_list->m_tabledef) table_def(m_coltype, m_colcnt,
7350
7112
m_field_metadata, m_field_metadata_size, m_null_bits);
7351
table_list->m_tabledef_valid= TRUE;
7113
table_list->m_tabledef_valid= true;
7352
7114
7353
7115
/*
7354
7116
We record in the slave's information that the table should be
7360
7122
/* 'memory' is freed in clear_tables_to_lock */
7361
7123
}
7362
7124
7363
DBUG_RETURN(error);
7125
return(error);
7364
7126
7365
7127
err:
7366
7128
my_free(memory, MYF(MY_WME));
7367
DBUG_RETURN(error);
7129
return(error);
7368
7130
}
7369
7131
7370
7132
Log_event::enum_skip_reason
7388
7150
#ifndef MYSQL_CLIENT
7389
7151
bool Table_map_log_event::write_data_header(IO_CACHE *file)
7390
7152
{
7391
DBUG_ASSERT(m_table_id != ~0UL);
7153
assert(m_table_id != ~0UL);
7392
7154
uchar buf[TABLE_MAP_HEADER_LEN];
7393
DBUG_EXECUTE_IF("old_row_based_repl_4_byte_map_id_master",
7394
{
7395
int4store(buf + 0, m_table_id);
7396
int2store(buf + 4, m_flags);
7397
return (my_b_safe_write(file, buf, 6));
7398
});
7399
7155
int6store(buf + TM_MAPID_OFFSET, (ulonglong)m_table_id);
7400
7156
int2store(buf + TM_FLAGS_OFFSET, m_flags);
7401
7157
return (my_b_safe_write(file, buf, TABLE_MAP_HEADER_LEN));
7403
7159
7404
7160
bool Table_map_log_event::write_data_body(IO_CACHE *file)
7405
7161
{
7406
DBUG_ASSERT(m_dbnam != NULL);
7407
DBUG_ASSERT(m_tblnam != NULL);
7162
assert(m_dbnam != NULL);
7163
assert(m_tblnam != NULL);
7408
7164
/* We use only one byte per length for storage in event: */
7409
DBUG_ASSERT(m_dblen < 128);
7410
DBUG_ASSERT(m_tbllen < 128);
7165
assert(m_dblen < 128);
7166
assert(m_tbllen < 128);
7411
7167
7412
7168
uchar const dbuf[]= { (uchar) m_dblen };
7413
7169
uchar const tbuf[]= { (uchar) m_tbllen };
7414
7170
7415
7171
uchar cbuf[sizeof(m_colcnt)];
7416
7172
uchar *const cbuf_end= net_store_length(cbuf, (size_t) m_colcnt);
7417
DBUG_ASSERT(static_cast<size_t>(cbuf_end - cbuf) <= sizeof(cbuf));
7173
assert(static_cast<size_t>(cbuf_end - cbuf) <= sizeof(cbuf));
7418
7174
7419
7175
/*
7420
7176
Store the size of the field metadata.
7462
7218
{
7463
7219
if (!print_event_info->short_form)
7464
7220
{
7465
print_header(&print_event_info->head_cache, print_event_info, TRUE);
7221
print_header(&print_event_info->head_cache, print_event_info, true);
7466
7222
my_b_printf(&print_event_info->head_cache,
7467
7223
"\tTable_map: `%s`.`%s` mapped to number %lu\n",
7468
7224
m_dbnam, m_tblnam, m_table_id);
7469
print_base64(&print_event_info->body_cache, print_event_info, TRUE);
7225
print_base64(&print_event_info->body_cache, print_event_info, true);
7470
7226
}
7471
7227
}
7472
7228
#endif
7655
7411
Rows_log_event::write_row(const Relay_log_info *const rli,
7656
7412
const bool overwrite)
7657
7413
{
7658
DBUG_ENTER("write_row");
7659
DBUG_ASSERT(m_table != NULL && thd != NULL);
7414
assert(m_table != NULL && thd != NULL);
7660
7415
7661
7416
TABLE *table= m_table; // pointer to event's table
7662
7417
int error;
7677
7432
*/
7678
7433
if ((error= prepare_record(table, &m_cols, m_width,
7679
7434
table->file->ht->db_type != DB_TYPE_NDBCLUSTER)))
7680
DBUG_RETURN(error);
7435
return(error);
7681
7436
7682
7437
/* unpack row into table->record[0] */
7683
7438
error= unpack_current_row(rli, &m_cols);
7685
7440
// Temporary fix to find out why it fails [/Matz]
7686
7441
memcpy(m_table->write_set->bitmap, m_cols.bitmap, (m_table->write_set->n_bits + 7) / 8);
7687
7442
7688
#ifndef DBUG_OFF
7689
DBUG_DUMP("record[0]", table->record[0], table->s->reclength);
7690
DBUG_PRINT_BITSET("debug", "write_set = %s", table->write_set);
7691
DBUG_PRINT_BITSET("debug", "read_set = %s", table->read_set);
7692
#endif
7693
7694
7443
/*
7695
7444
Try to write record. If a corresponding record already exists in the table,
7696
7445
we try to change it using ha_update_row() if possible. Otherwise we delete
7706
7455
(keynum= table->file->get_dup_key(error)) < 0 ||
7707
7456
!overwrite)
7708
7457
{
7709
DBUG_PRINT("info",("get_dup_key returns %d)", keynum));
7710
7458
/*
7711
7459
Deadlock, waiting for lock or just an error from the handler
7712
7460
such as HA_ERR_FOUND_DUPP_KEY when overwrite is false.
7715
7463
- or because the information which key is not available
7716
7464
*/
7717
7465
table->file->print_error(error, MYF(0));
7718
DBUG_RETURN(error);
7466
return(error);
7719
7467
}
7720
7468
/*
7721
7469
We need to retrieve the old row into record[1] to be able to
7729
7477
*/
7730
7478
if (table->file->ha_table_flags() & HA_DUPLICATE_POS)
7731
7479
{
7732
DBUG_PRINT("info",("Locating offending record using rnd_pos()"));
7733
7480
if (table->file->inited && (error= table->file->ha_index_end()))
7734
DBUG_RETURN(error);
7735
if ((error= table->file->ha_rnd_init(FALSE)))
7736
DBUG_RETURN(error);
7481
return(error);
7482
if ((error= table->file->ha_rnd_init(false)))
7483
return(error);
7737
7484
7738
7485
error= table->file->rnd_pos(table->record[1], table->file->dup_ref);
7739
7486
table->file->ha_rnd_end();
7740
7487
if (error)
7741
7488
{
7742
DBUG_PRINT("info",("rnd_pos() returns error %d",error));
7743
7489
table->file->print_error(error, MYF(0));
7744
DBUG_RETURN(error);
7490
return(error);
7745
7491
}
7746
7492
}
7747
7493
else
7748
7494
{
7749
DBUG_PRINT("info",("Locating offending record using index_read_idx()"));
7750
7751
7495
if (table->file->extra(HA_EXTRA_FLUSH_CACHE))
7752
7496
{
7753
DBUG_PRINT("info",("Error when setting HA_EXTRA_FLUSH_CACHE"));
7754
DBUG_RETURN(my_errno);
7497
return(my_errno);
7755
7498
}
7756
7499
7757
7500
if (key.get() == NULL)
7759
7502
key.assign(static_cast<char*>(my_alloca(table->s->max_unique_length)));
7760
7503
if (key.get() == NULL)
7761
7504
{
7762
DBUG_PRINT("info",("Can't allocate key buffer"));
7763
DBUG_RETURN(ENOMEM);
7505
return(ENOMEM);
7764
7506
}
7765
7507
}
7766
7508
7772
7514
HA_READ_KEY_EXACT);
7773
7515
if (error)
7774
7516
{
7775
DBUG_PRINT("info",("index_read_idx() returns error %d",error));
7776
7517
table->file->print_error(error, MYF(0));
7777
DBUG_RETURN(error);
7518
return(error);
7778
7519
}
7779
7520
}
7780
7521
7794
7535
error= unpack_current_row(rli, &m_cols);
7795
7536
}
7796
7537
7797
#ifndef DBUG_OFF
7798
DBUG_PRINT("debug",("preparing for update: before and after image"));
7799
DBUG_DUMP("record[1] (before)", table->record[1], table->s->reclength);
7800
DBUG_DUMP("record[0] (after)", table->record[0], table->s->reclength);
7801
#endif
7802
7803
7538
/*
7804
7539
REPLACE is defined as either INSERT or DELETE + INSERT. If
7805
7540
possible, we can replace it with an UPDATE, but that will not
7818
7553
if (last_uniq_key(table, keynum) &&
7819
7554
!table->file->referenced_by_foreign_key())
7820
7555
{
7821
DBUG_PRINT("info",("Updating row using ha_update_row()"));
7822
7556
error=table->file->ha_update_row(table->record[1],
7823
7557
table->record[0]);
7824
7558
switch (error) {
7825
7559
7826
7560
case HA_ERR_RECORD_IS_THE_SAME:
7827
DBUG_PRINT("info",("ignoring HA_ERR_RECORD_IS_THE_SAME error from"
7828
" ha_update_row()"));
7829
7561
error= 0;
7830
7562
7831
7563
case 0:
7832
7564
break;
7833
7565
7834
7566
default:
7835
DBUG_PRINT("info",("ha_update_row() returns error %d",error));
7836
7567
table->file->print_error(error, MYF(0));
7837
7568
}
7838
7569
7839
DBUG_RETURN(error);
7570
return(error);
7840
7571
}
7841
7572
else
7842
7573
{
7843
DBUG_PRINT("info",("Deleting offending row and trying to write new one again"));
7844
7574
if ((error= table->file->ha_delete_row(table->record[1])))
7845
7575
{
7846
DBUG_PRINT("info",("ha_delete_row() returns error %d",error));
7847
7576
table->file->print_error(error, MYF(0));
7848
DBUG_RETURN(error);
7577
return(error);
7849
7578
}
7850
7579
/* Will retry ha_write_row() with the offending row removed. */
7851
7580
}
7852
7581
}
7853
7582
7854
DBUG_RETURN(error);
7583
return(error);
7855
7584
}
7856
7585
7857
7586
#endif
7859
7588
int
7860
7589
Write_rows_log_event::do_exec_row(const Relay_log_info *const rli)
7861
7590
{
7862
DBUG_ASSERT(m_table != NULL);
7591
assert(m_table != NULL);
7863
7592
int error=
7864
7593
write_row(rli, /* if 1 then overwrite */
7865
7594
bit_is_set(slave_exec_mode, SLAVE_EXEC_MODE_IDEMPOTENT) == 1);
7866
7595
7867
7596
if (error && !thd->is_error())
7868
7597
{
7869
DBUG_ASSERT(0);
7598
assert(0);
7870
7599
my_error(ER_UNKNOWN_ERROR, MYF(0));
7871
7600
}
7872
7601
7905
7634
TODO[record format ndb]: Remove it once NDB returns correct
7906
7635
records. Check that the other engines also return correct records.
7907
7636
*/
7908
7909
DBUG_DUMP("record[0]", table->record[0], table->s->reclength);
7910
DBUG_DUMP("record[1]", table->record[1], table->s->reclength);
7911
7912
bool result= FALSE;
7637
bool result= false;
7913
7638
uchar saved_x[2], saved_filler[2];
7914
7639
7915
7640
if (table->s->null_bytes > 0)
7935
7660
table->null_flags+table->s->rec_buff_length,
7936
7661
table->s->null_bytes))
7937
7662
{
7938
result= TRUE; // Diff in NULL value
7663
result= true; // Diff in NULL value
7939
7664
goto record_compare_exit;
7940
7665
}
7941
7666
7944
7669
{
7945
7670
if ((*ptr)->cmp_binary_offset(table->s->rec_buff_length))
7946
7671
{
7947
result= TRUE;
7672
result= true;
7948
7673
goto record_compare_exit;
7949
7674
}
7950
7675
}
7997
7722
7998
7723
int Rows_log_event::find_row(const Relay_log_info *rli)
7999
7724
{
8000
DBUG_ENTER("Rows_log_event::find_row");
8001
8002
DBUG_ASSERT(m_table && m_table->in_use != NULL);
7725
assert(m_table && m_table->in_use != NULL);
8003
7726
8004
7727
TABLE *table= m_table;
8005
7728
int error;
8006
7729
8007
7730
/* unpack row - missing fields get default values */
8008
prepare_record(table, &m_cols, m_width, FALSE /* don't check errors */);
7731
prepare_record(table, &m_cols, m_width, false/* don't check errors */);
8009
7732
error= unpack_current_row(rli, &m_cols);
8010
7733
8011
7734
// Temporary fix to find out why it fails [/Matz]
8012
7735
memcpy(m_table->read_set->bitmap, m_cols.bitmap, (m_table->read_set->n_bits + 7) / 8);
8013
7736
8014
#ifndef DBUG_OFF
8015
DBUG_PRINT("info",("looking for the following record"));
8016
DBUG_DUMP("record[0]", table->record[0], table->s->reclength);
8017
DBUG_DUMP("read_set", (uchar*) table->read_set->bitmap, (table->read_set->n_bits + 7) / 8);
8018
#endif
8019
8020
7737
if ((table->file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_POSITION) &&
8021
7738
table->s->primary_key < MAX_KEY)
8022
7739
{
8034
7751
8035
7752
ADD>>> store_record(table,record[1]);
8036
7753
int error= table->file->rnd_pos(table->record[0], table->file->ref);
8037
ADD>>> DBUG_ASSERT(memcmp(table->record[1], table->record[0],
7754
ADD>>> assert(memcmp(table->record[1], table->record[0],
8038
7755
table->s->reclength) == 0);
8039
7756
*/
8040
7757
8041
DBUG_PRINT("info",("locating record using primary key (position)"));
8042
7758
int error= table->file->rnd_pos_by_record(table->record[0]);
8043
7759
table->file->ha_rnd_end();
8044
7760
if (error)
8045
7761
{
8046
DBUG_PRINT("info",("rnd_pos returns error %d",error));
8047
7762
table->file->print_error(error, MYF(0));
8048
7763
}
8049
DBUG_RETURN(error);
7764
return(error);
8050
7765
}
8051
7766
8052
7767
// We can't use position() - try other methods.
8059
7774
8060
7775
if (table->s->keys > 0)
8061
7776
{
8062
DBUG_PRINT("info",("locating record using primary key (index_read)"));
8063
8064
7777
/* We have a key: search the table using the index */
8065
if (!table->file->inited && (error= table->file->ha_index_init(0, FALSE)))
7778
if (!table->file->inited && (error= table->file->ha_index_init(0, false)))
8066
7779
{
8067
DBUG_PRINT("info",("ha_index_init returns error %d",error));
8068
7780
table->file->print_error(error, MYF(0));
8069
7781
goto err;
8070
7782
}
8071
7783
8072
7784
/* Fill key data for the row */
8073
7785
8074
DBUG_ASSERT(m_key);
7786
assert(m_key);
8075
7787
key_copy(m_key, table->record[0], table->key_info, 0);
8076
7788
8077
7789
/*
8078
Don't print debug messages when running valgrind since they can
8079
trigger false warnings.
8080
*/
8081
#ifndef HAVE_purify
8082
DBUG_DUMP("key data", m_key, table->key_info->key_length);
8083
#endif
8084
8085
/*
8086
7790
We need to set the null bytes to ensure that the filler bit are
8087
7791
all set when returning. There are storage engines that just set
8088
7792
the necessary bits on the bytes and don't set the filler bits
8096
7800
HA_WHOLE_KEY,
8097
7801
HA_READ_KEY_EXACT)))
8098
7802
{
8099
DBUG_PRINT("info",("no record matching the key found in the table"));
8100
7803
table->file->print_error(error, MYF(0));
8101
7804
table->file->ha_index_end();
8102
7805
goto err;
8103
7806
}
8104
7807
8105
/*
8106
Don't print debug messages when running valgrind since they can
8107
trigger false warnings.
8108
*/
8109
#ifndef HAVE_purify
8110
DBUG_PRINT("info",("found first matching record"));
8111
DBUG_DUMP("record[0]", table->record[0], table->s->reclength);
8112
#endif
8113
7808
/*
8114
7809
Below is a minor "optimization". If the key (i.e., key number
8115
7810
0) has the HA_NOSAME flag set, we know that we have found the
8135
7830
and find the one which is identical to the row given. A copy of the
8136
7831
record we are looking for is stored in record[1].
8137
7832
*/
8138
DBUG_PRINT("info",("non-unique index, scanning it to find matching record"));
8139
8140
7833
while (record_compare(table))
8141
7834
{
8142
7835
/*
8156
7849
8157
7850
if ((error= table->file->index_next(table->record[0])))
8158
7851
{
8159
DBUG_PRINT("info",("no record matching the given row found"));
8160
7852
table->file->print_error(error, MYF(0));
8161
7853
table->file->ha_index_end();
8162
7854
goto err;
8170
7862
}
8171
7863
else
8172
7864
{
8173
DBUG_PRINT("info",("locating record using table scan (rnd_next)"));
8174
8175
7865
int restart_count= 0; // Number of times scanning has restarted from top
8176
7866
8177
7867
/* We don't have a key: search the table using rnd_next() */
8178
7868
if ((error= table->file->ha_rnd_init(1)))
8179
7869
{
8180
DBUG_PRINT("info",("error initializing table scan"
8181
" (ha_rnd_init returns %d)",error));
8182
7870
table->file->print_error(error, MYF(0));
8183
7871
goto err;
8184
7872
}
8200
7888
break;
8201
7889
8202
7890
default:
8203
DBUG_PRINT("info", ("Failed to get next record"
8204
" (rnd_next returns %d)",error));
8205
7891
table->file->print_error(error, MYF(0));
8206
7892
table->file->ha_rnd_end();
8207
7893
goto err;
8213
7899
Note: above record_compare will take into accout all record fields
8214
7900
which might be incorrect in case a partial row was given in the event
8215
7901
*/
8216
8217
/*
8218
Have to restart the scan to be able to fetch the next row.
8219
*/
8220
if (restart_count == 2)
8221
{
8222
DBUG_PRINT("info", ("Record not found"));
8223
}
8224
else
8225
{
8226
DBUG_DUMP("record found", table->record[0], table->s->reclength);
8227
}
8228
7902
table->file->ha_rnd_end();
8229
7903
8230
DBUG_ASSERT(error == HA_ERR_END_OF_FILE || error == HA_ERR_RECORD_DELETED || error == 0);
7904
assert(error == HA_ERR_END_OF_FILE || error == HA_ERR_RECORD_DELETED || error == 0);
8231
7905
goto err;
8232
7906
}
8233
7907
ok:
8234
7908
table->default_column_bitmaps();
8235
DBUG_RETURN(0);
7909
return(0);
8236
7910
err:
8237
7911
table->default_column_bitmaps();
8238
DBUG_RETURN(error);
7912
return(error);
8239
7913
}
8240
7914
8241
7915
#endif
8305
7979
int Delete_rows_log_event::do_exec_row(const Relay_log_info *const rli)
8306
7980
{
8307
7981
int error;
8308
DBUG_ASSERT(m_table != NULL);
7982
assert(m_table != NULL);
8309
7983
8310
7984
if (!(error= find_row(rli)))
8311
7985
{
8417
8091
int
8418
8092
Update_rows_log_event::do_exec_row(const Relay_log_info *const rli)
8419
8093
{
8420
DBUG_ASSERT(m_table != NULL);
8094
assert(m_table != NULL);
8421
8095
8422
8096
int error= find_row(rli);
8423
8097
if (error)
8451
8125
Now we have the right row to update. The old row (the one we're
8452
8126
looking for) is in record[1] and the new row is in record[0].
8453
8127
*/
8454
#ifndef HAVE_purify
8455
/*
8456
Don't print debug messages when running valgrind since they can
8457
trigger false warnings.
8458
*/
8459
DBUG_PRINT("info",("Updating row in table"));
8460
DBUG_DUMP("old record", m_table->record[1], m_table->s->reclength);
8461
DBUG_DUMP("new values", m_table->record[0], m_table->s->reclength);
8462
#endif
8463
8128
8464
8129
// Temporary fix to find out why it fails [/Matz]
8465
8130
memcpy(m_table->read_set->bitmap, m_cols.bitmap, (m_table->read_set->n_bits + 7) / 8);
8487
8152
const Format_description_log_event *descr_event)
8488
8153
: Log_event(buf, descr_event)
8489
8154
{
8490
DBUG_ENTER("Incident_log_event::Incident_log_event");
8491
8155
uint8 const common_header_len=
8492
8156
descr_event->common_header_len;
8493
8157
uint8 const post_header_len=
8494
8158
descr_event->post_header_len[INCIDENT_EVENT-1];
8495
8159
8496
DBUG_PRINT("info",("event_len: %u; common_header_len: %d; post_header_len: %d",
8497
event_len, common_header_len, post_header_len));
8498
8499
8160
m_incident= static_cast<Incident>(uint2korr(buf + common_header_len));
8500
8161
char const *ptr= buf + common_header_len + post_header_len;
8501
8162
char const *const str_end= buf + event_len;
8504
8165
read_str(&ptr, str_end, &str, &len);
8505
8166
m_message.str= const_cast<char*>(str);
8506
8167
m_message.length= len;
8507
DBUG_PRINT("info", ("m_incident: %d", m_incident));
8508
DBUG_VOID_RETURN;
8168
return;
8509
8169
}
8510
8170
8511
8171
8522
8182
"LOST_EVENTS"
8523
8183
};
8524
8184
8525
DBUG_PRINT("info", ("m_incident: %d", m_incident));
8526
8527
DBUG_ASSERT(0 <= m_incident);
8528
DBUG_ASSERT((size_t) m_incident <= sizeof(description)/sizeof(*description));
8185
assert(0 <= m_incident);
8186
assert((size_t) m_incident <= sizeof(description)/sizeof(*description));
8529
8187
8530
8188
return description[m_incident];
8531
8189
}
8556
8214
return;
8557
8215
8558
8216
Write_on_release_cache cache(&print_event_info->head_cache, file);
8559
print_header(&cache, print_event_info, FALSE);
8217
print_header(&cache, print_event_info, false);
8560
8218
my_b_printf(&cache, "\n# Incident: %s", description());
8561
8219
}
8562
8220
#endif
8565
8223
int
8566
8224
Incident_log_event::do_apply_event(Relay_log_info const *rli)
8567
8225
{
8568
DBUG_ENTER("Incident_log_event::do_apply_event");
8569
8226
rli->report(ERROR_LEVEL, ER_SLAVE_INCIDENT,
8570
8227
ER(ER_SLAVE_INCIDENT),
8571
8228
description(),
8572
8229
m_message.length > 0 ? m_message.str : "<none>");
8573
DBUG_RETURN(1);
8230
return(1);
8574
8231
}
8575
8232
#endif
8576
8233
8577
8234
bool
8578
8235
Incident_log_event::write_data_header(IO_CACHE *file)
8579
8236
{
8580
DBUG_ENTER("Incident_log_event::write_data_header");
8581
DBUG_PRINT("enter", ("m_incident: %d", m_incident));
8582
8237
uchar buf[sizeof(int16)];
8583
8238
int2store(buf, (int16) m_incident);
8584
DBUG_RETURN(my_b_safe_write(file, buf, sizeof(buf)));
8239
return(my_b_safe_write(file, buf, sizeof(buf)));
8585
8240
}
8586
8241
8587
8242
bool
8588
8243
Incident_log_event::write_data_body(IO_CACHE *file)
8589
8244
{
8590
DBUG_ENTER("Incident_log_event::write_data_body");
8591
DBUG_RETURN(write_str(file, m_message.str, m_message.length));
8245
return(write_str(file, m_message.str, m_message.length));
8592
8246
}
8593
8247
8594
8248
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
8616
8270
lc_time_names_number(~0),
8617
8271
charset_database_number(ILLEGAL_CHARSET_INFO_NUMBER),
8618
8272
thread_id(0), thread_id_printed(false),
8619
base64_output_mode(BASE64_OUTPUT_UNSPEC), printed_fd_event(FALSE)
8273
base64_output_mode(BASE64_OUTPUT_UNSPEC), printed_fd_event(false)
8620
8274
{
8621
8275
/*
8622
8276
Currently we only use static PRINT_EVENT_INFO objects, so zeroed at
Loggerhead is a web-based interface for Breezy
Version: 2.0.1