← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/log_event.cc

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/log_event.cc
31
31
#include "rpl_filter.h"
32
32
#include "rpl_utility.h"
33
33
#include "rpl_record.h"
34
 
#include <my_dir.h>
 
34
#include <mysys/my_dir.h>
35
35
 
36
36
#endif /* MYSQL_CLIENT */
37
37
 
38
 
#include <base64.h>
39
 
#include <my_bitmap.h>
 
38
#include <mysys/base64.h>
 
39
#include <mysys/my_bitmap.h>
40
40
 
41
41
#define log_cs  &my_charset_latin1
42
42
 
413
413
*/
414
414
 
415
415
static inline int read_str(const char **buf, const char *buf_end,
416
 
                           const char **str, uint8 *len)
 
416
                           const char **str, uint8_t *len)
417
417
{
418
418
  if (*buf + ((uint) (uchar) **buf) >= buf_end)
419
419
    return 1;
420
 
  *len= (uint8) **buf;
 
420
  *len= (uint8_t) **buf;
421
421
  *str= (*buf)+1;
422
422
  (*buf)+= (uint) *len+1;
423
423
  return 0;
454
454
                    String const *from, String *to)
455
455
{
456
456
  char *beg, *ptr;
457
 
  uint32 const orig_len= to->length();
 
457
  uint32_t const orig_len= to->length();
458
458
  if (to->reserve(orig_len + from->length()*2+3))
459
459
    return 1;
460
460
 
482
482
 
483
483
#ifdef MYSQL_CLIENT
484
484
 
485
 
static void print_set_option(IO_CACHE* file, uint32 bits_changed,
486
 
                             uint32 option, uint32 flags, const char* name,
 
485
static void print_set_option(IO_CACHE* file, uint32_t bits_changed,
 
486
                             uint32_t option, uint32_t flags, const char* name,
487
487
                             bool* need_comma)
488
488
{
489
489
  if (bits_changed & option)
549
549
*/
550
550
 
551
551
#ifndef MYSQL_CLIENT
552
 
Log_event::Log_event(THD* thd_arg, uint16 flags_arg, bool using_trans)
 
552
Log_event::Log_event(THD* thd_arg, uint16_t flags_arg, bool using_trans)
553
553
  :log_pos(0), temp_buf(0), exec_time(0), flags(flags_arg), thd(thd_arg)
554
554
{
555
555
  server_id=    thd->server_id;
726
726
  protocol->store((uint64_t) pos);
727
727
  event_type = get_type_str();
728
728
  protocol->store(event_type, strlen(event_type), &my_charset_bin);
729
 
  protocol->store((uint32) server_id);
 
729
  protocol->store((uint32_t) server_id);
730
730
  protocol->store((uint64_t) log_pos);
731
731
  pack_info(protocol);
732
732
  return protocol->write();
744
744
{
745
745
  field_list->push_back(new Item_empty_string("Log_name", 20));
746
746
  field_list->push_back(new Item_return_int("Pos", MY_INT32_NUM_DECIMAL_DIGITS,
747
 
                                            MYSQL_TYPE_LONGLONG));
 
747
                                            DRIZZLE_TYPE_LONGLONG));
748
748
  field_list->push_back(new Item_empty_string("Event_type", 20));
749
749
  field_list->push_back(new Item_return_int("Server_id", 10,
750
 
                                            MYSQL_TYPE_LONG));
 
750
                                            DRIZZLE_TYPE_LONG));
751
751
  field_list->push_back(new Item_return_int("End_log_pos",
752
752
                                            MY_INT32_NUM_DECIMAL_DIGITS,
753
 
                                            MYSQL_TYPE_LONGLONG));
 
753
                                            DRIZZLE_TYPE_LONGLONG));
754
754
  field_list->push_back(new Item_empty_string("Info", 20));
755
755
}
756
756
 
1278
1278
                             bool more)
1279
1279
{
1280
1280
  const uchar *ptr= (const uchar *)temp_buf;
1281
 
  uint32 size= uint4korr(ptr + EVENT_LEN_OFFSET);
 
1281
  uint32_t size= uint4korr(ptr + EVENT_LEN_OFFSET);
1282
1282
 
1283
1283
  size_t const tmp_str_sz= base64_needed_encoded_length((int) size);
1284
1284
  char *const tmp_str= (char *) my_malloc(tmp_str_sz, MYF(MY_WME));
1395
1395
  assert(src);
1396
1396
  *((*dst)++)= code;
1397
1397
  *((*dst)++)= (uchar) len;
1398
 
  bmove(*dst, src, len);
 
1398
  memcpy(*dst, src, len);
1399
1399
  (*dst)+= len;
1400
1400
}
1401
1401
 
1618
1618
             (suppress_use ? LOG_EVENT_SUPPRESS_USE_F : 0),
1619
1619
             using_trans),
1620
1620
   data_buf(0), query(query_arg), catalog(thd_arg->catalog),
1621
 
   db(thd_arg->db), q_len((uint32) query_length),
 
1621
   db(thd_arg->db), q_len((uint32_t) query_length),
1622
1622
   thread_id(thd_arg->thread_id),
1623
1623
   /* save the original thread id; we already know the server id */
1624
1624
   slave_proxy_id(thd_arg->variables.pseudo_thread_id),
1645
1645
    @todo this means that if we have no catalog, then it is replicated
1646
1646
    as an existing catalog of length zero. is that safe? /sven
1647
1647
  */
1648
 
  catalog_len = (catalog) ? (uint32) strlen(catalog) : 0;
 
1648
  catalog_len = (catalog) ? (uint32_t) strlen(catalog) : 0;
1649
1649
  /* status_vars_len is set just before writing the event */
1650
 
  db_len = (db) ? (uint32) strlen(db) : 0;
 
1650
  db_len = (db) ? (uint32_t) strlen(db) : 0;
1651
1651
  if (thd_arg->variables.collation_database != thd_arg->db_charset)
1652
1652
    charset_database_number= thd_arg->variables.collation_database->number;
1653
1653
  
1658
1658
    But it's likely that we don't want to use 32 bits for 3 bits; in the future
1659
1659
    we will probably want to reclaim the 29 bits. So we need the &.
1660
1660
  */
1661
 
  flags2= (uint32) (thd_arg->options & OPTIONS_WRITTEN_TO_BIN_LOG);
 
1661
  flags2= (uint32_t) (thd_arg->options & OPTIONS_WRITTEN_TO_BIN_LOG);
1662
1662
  assert(thd_arg->variables.character_set_client->number < 256*256);
1663
1663
  assert(thd_arg->variables.collation_connection->number < 256*256);
1664
1664
  assert(thd_arg->variables.collation_server->number < 256*256);
1770
1770
   time_zone_len(0), lc_time_names_number(0), charset_database_number(0)
1771
1771
{
1772
1772
  ulong data_len;
1773
 
  uint32 tmp;
1774
 
  uint8 common_header_len, post_header_len;
 
1773
  uint32_t tmp;
 
1774
  uint8_t common_header_len, post_header_len;
1775
1775
  Log_event::Byte *start;
1776
1776
  const Log_event::Byte *end;
1777
1777
  bool catalog_nz= 1;
1952
1952
  // TODO: print the catalog ??
1953
1953
  char buff[40],*end;                           // Enough for SET TIMESTAMP
1954
1954
  bool different_db= 1;
1955
 
  uint32 tmp;
 
1955
  uint32_t tmp;
1956
1956
 
1957
1957
  if (!print_event_info->short_form)
1958
1958
  {
2000
2000
    else /* that's the first Query event we read */
2001
2001
    {
2002
2002
      print_event_info->flags2_inited= 1;
2003
 
      tmp= ~((uint32)0); /* all bits have changed */
 
2003
      tmp= ~((uint32_t)0); /* all bits have changed */
2004
2004
    }
2005
2005
 
2006
2006
    if (unlikely(tmp)) /* some bits have changed */
2045
2045
 
2046
2046
  if (likely(charset_inited) &&
2047
2047
      (unlikely(!print_event_info->charset_inited ||
2048
 
                bcmp((uchar*) print_event_info->charset, (uchar*) charset, 6))))
 
2048
                memcmp((uchar*) print_event_info->charset, (uchar*) charset, 6))))
2049
2049
  {
2050
2050
    CHARSET_INFO *cs_info= get_charset(uint2korr(charset), MYF(MY_WME));
2051
2051
    if (cs_info)
2068
2068
  }
2069
2069
  if (time_zone_len)
2070
2070
  {
2071
 
    if (bcmp((uchar*) print_event_info->time_zone_str,
2072
 
             (uchar*) time_zone_str, time_zone_len+1))
 
2071
    if (memcmp((uchar*) print_event_info->time_zone_str,
 
2072
               (uchar*) time_zone_str, time_zone_len+1))
2073
2073
    {
2074
2074
      my_b_printf(file,"SET @@session.time_zone='%s'%s\n",
2075
2075
                  time_zone_str, print_event_info->delimiter);
2123
2123
  Compare the values of "affected rows" around here. Something
2124
2124
  like:
2125
2125
  @code
2126
 
     if ((uint32) affected_in_event != (uint32) affected_on_slave)
 
2126
     if ((uint32_t) affected_in_event != (uint32_t) affected_on_slave)
2127
2127
     {
2128
2128
     sql_print_error("Slave: did not get the expected number of affected \
2129
2129
     rows running query from master - expected %d, got %d (this numbers \
2136
2136
  to ignore it you would use --slave-skip-errors...
2137
2137
*/
2138
2138
int Query_log_event::do_apply_event(Relay_log_info const *rli,
2139
 
                                      const char *query_arg, uint32 q_len_arg)
 
2139
                                      const char *query_arg, uint32_t q_len_arg)
2140
2140
{
2141
2141
  LEX_STRING new_db;
2142
2142
  int expected_error,actual_error= 0;
2348
2348
    /*
2349
2349
      TODO: compare the values of "affected rows" around here. Something
2350
2350
      like:
2351
 
      if ((uint32) affected_in_event != (uint32) affected_on_slave)
 
2351
      if ((uint32_t) affected_in_event != (uint32_t) affected_on_slave)
2352
2352
      {
2353
2353
      sql_print_error("Slave: did not get the expected number of affected \
2354
2354
      rows running query from master - expected %d, got %d (this numbers \
2650
2650
*/
2651
2651
 
2652
2652
Format_description_log_event::
2653
 
Format_description_log_event(uint8 binlog_ver, const char* server_ver)
 
2653
Format_description_log_event(uint8_t binlog_ver, const char* server_ver)
2654
2654
  :Start_log_event_v3(), event_type_permutation(0)
2655
2655
{
2656
2656
  binlog_version= binlog_ver;
2660
2660
    common_header_len= LOG_EVENT_HEADER_LEN;
2661
2661
    number_of_event_types= LOG_EVENT_TYPES;
2662
2662
    /* we'll catch my_malloc() error in is_valid() */
2663
 
    post_header_len=(uint8*) my_malloc(number_of_event_types*sizeof(uint8),
 
2663
    post_header_len=(uint8_t*) my_malloc(number_of_event_types*sizeof(uint8_t),
2664
2664
                                       MYF(MY_ZEROFILL));
2665
2665
    /*
2666
2666
      This long list of assignments is not beautiful, but I see no way to
2710
2710
      make the slave detect less corruptions).
2711
2711
    */
2712
2712
    number_of_event_types= FORMAT_DESCRIPTION_EVENT - 1;
2713
 
    post_header_len=(uint8*) my_malloc(number_of_event_types*sizeof(uint8),
 
2713
    post_header_len=(uint8_t*) my_malloc(number_of_event_types*sizeof(uint8_t),
2714
2714
                                       MYF(0));
2715
2715
    if (post_header_len)
2716
2716
    {
2770
2770
  number_of_event_types=
2771
2771
    event_len-(LOG_EVENT_MINIMAL_HEADER_LEN+ST_COMMON_HEADER_LEN_OFFSET+1);
2772
2772
  /* If alloc fails, we'll detect it in is_valid() */
2773
 
  post_header_len= (uint8*) my_memdup((uchar*)buf+ST_COMMON_HEADER_LEN_OFFSET+1,
 
2773
  post_header_len= (uint8_t*) my_memdup((uchar*)buf+ST_COMMON_HEADER_LEN_OFFSET+1,
2774
2774
                                      number_of_event_types*
2775
2775
                                      sizeof(*post_header_len), MYF(0));
2776
2776
  calc_server_version_split();
2849
2849
      post_header_len= NULL;
2850
2850
      return;
2851
2851
    }
2852
 
    static const uint8 perm[23]=
 
2852
    static const uint8_t perm[23]=
2853
2853
      {
2854
2854
        UNKNOWN_EVENT, START_EVENT_V3, QUERY_EVENT, STOP_EVENT, ROTATE_EVENT,
2855
2855
        INTVAR_EVENT, LOAD_EVENT, SLAVE_EVENT, CREATE_FILE_EVENT,
2870
2870
      Since we use (permuted) event id's to index the post_header_len
2871
2871
      array, we need to permute the post_header_len array too.
2872
2872
    */
2873
 
    uint8 post_header_len_temp[23];
 
2873
    uint8_t post_header_len_temp[23];
2874
2874
    for (int i= 1; i < 23; i++)
2875
2875
      post_header_len_temp[perm[i] - 1]= post_header_len[i - 1];
2876
2876
    for (int i= 0; i < 22; i++)
2929
2929
    perform, we don't call Start_log_event_v3::do_apply_event()
2930
2930
    (this was just to update the log's description event).
2931
2931
  */
2932
 
  if (server_id != (uint32) ::server_id)
 
2932
  if (server_id != (uint32_t) ::server_id)
2933
2933
  {
2934
2934
    /*
2935
2935
      If the event was not requested by the slave i.e. the master sent
2951
2951
  delete rli->relay_log.description_event_for_exec;
2952
2952
  rli->relay_log.description_event_for_exec= this;
2953
2953
 
2954
 
  if (server_id == (uint32) ::server_id)
 
2954
  if (server_id == (uint32_t) ::server_id)
2955
2955
  {
2956
2956
    /*
2957
2957
      We only increase the relay log position if we are skipping
2976
2976
}
2977
2977
 
2978
2978
Log_event::enum_skip_reason
2979
 
Format_description_log_event::do_shall_skip(Relay_log_info *rli __attribute__((__unused__)))
 
2979
Format_description_log_event::do_shall_skip(Relay_log_info *rli __attribute__((unused)))
2980
2980
{
2981
2981
  return Log_event::EVENT_SKIP_NOT;
2982
2982
}
3211
3211
  time(&end_time);
3212
3212
  exec_time = (ulong) (end_time  - thd_arg->start_time);
3213
3213
  /* db can never be a zero pointer in 4.0 */
3214
 
  db_len = (uint32) strlen(db);
3215
 
  table_name_len = (uint32) strlen(table_name);
 
3214
  db_len = (uint32_t) strlen(db);
 
3215
  table_name_len = (uint32_t) strlen(table_name);
3216
3216
  fname_len = (fname) ? (uint) strlen(fname) : 0;
3217
3217
  sql_ex.field_term = (char*) ex->field_term->ptr();
3218
 
  sql_ex.field_term_len = (uint8) ex->field_term->length();
 
3218
  sql_ex.field_term_len = (uint8_t) ex->field_term->length();
3219
3219
  sql_ex.enclosed = (char*) ex->enclosed->ptr();
3220
 
  sql_ex.enclosed_len = (uint8) ex->enclosed->length();
 
3220
  sql_ex.enclosed_len = (uint8_t) ex->enclosed->length();
3221
3221
  sql_ex.line_term = (char*) ex->line_term->ptr();
3222
 
  sql_ex.line_term_len = (uint8) ex->line_term->length();
 
3222
  sql_ex.line_term_len = (uint8_t) ex->line_term->length();
3223
3223
  sql_ex.line_start = (char*) ex->line_start->ptr();
3224
 
  sql_ex.line_start_len = (uint8) ex->line_start->length();
 
3224
  sql_ex.line_start_len = (uint8_t) ex->line_start->length();
3225
3225
  sql_ex.escaped = (char*) ex->escaped->ptr();
3226
 
  sql_ex.escaped_len = (uint8) ex->escaped->length();
 
3226
  sql_ex.escaped_len = (uint8_t) ex->escaped->length();
3227
3227
  sql_ex.opt_flags = 0;
3228
3228
  sql_ex.cached_new_format = -1;
3229
3229
    
3579
3579
    mysql_reset_errors(thd, 0);
3580
3580
 
3581
3581
    TABLE_LIST tables;
3582
 
    bzero((char*) &tables,sizeof(tables));
 
3582
    memset((char*) &tables, 0, sizeof(tables));
3583
3583
    tables.db= thd->strmake(thd->db, thd->db_length);
3584
3584
    tables.alias = tables.table_name = (char*) table_name;
3585
3585
    tables.lock_type = TL_WRITE;
3843
3843
  :Log_event(buf, description_event) ,new_log_ident(0), flags(DUP_NAME)
3844
3844
{
3845
3845
  // The caller will ensure that event_len is what we have at EVENT_LEN_OFFSET
3846
 
  uint8 header_size= description_event->common_header_len;
3847
 
  uint8 post_header_len= description_event->post_header_len[ROTATE_EVENT-1];
 
3846
  uint8_t header_size= description_event->common_header_len;
 
3847
  uint8_t post_header_len= description_event->post_header_len[ROTATE_EVENT-1];
3848
3848
  uint ident_offset;
3849
3849
  if (event_len < header_size)
3850
3850
    return;
4269
4269
 
4270
4270
 
4271
4271
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
4272
 
int Xid_log_event::do_apply_event(Relay_log_info const *rli __attribute__((__unused__)))
 
4272
int Xid_log_event::do_apply_event(Relay_log_info const *rli __attribute__((unused)))
4273
4273
{
4274
4274
  /* For a slave Xid_log_event is COMMIT */
4275
4275
  general_log_print(thd, COM_QUERY,
4818
4818
 
4819
4819
 
4820
4820
#ifndef MYSQL_CLIENT
4821
 
int Slave_log_event::do_apply_event(Relay_log_info const *rli __attribute__((__unused__)))
 
4821
int Slave_log_event::do_apply_event(Relay_log_info const *rli __attribute__((unused)))
4822
4822
{
4823
4823
  if (mysql_bin_log.is_open())
4824
4824
    mysql_bin_log.write(this);
4964
4964
{
4965
4965
  uint block_offset;
4966
4966
  uint header_len= description_event->common_header_len;
4967
 
  uint8 load_header_len= description_event->post_header_len[LOAD_EVENT-1];
4968
 
  uint8 create_file_header_len= description_event->post_header_len[CREATE_FILE_EVENT-1];
 
4967
  uint8_t load_header_len= description_event->post_header_len[LOAD_EVENT-1];
 
4968
  uint8_t create_file_header_len= description_event->post_header_len[CREATE_FILE_EVENT-1];
4969
4969
  if (!(event_buf= (char*) my_memdup(buf, len, MYF(MY_WME))) ||
4970
4970
      copy_log_event(event_buf,len,
4971
4971
                     ((buf[EVENT_TYPE_OFFSET] == LOAD_EVENT) ?
5081
5081
  IO_CACHE file;
5082
5082
  int error = 1;
5083
5083
 
5084
 
  bzero((char*)&file, sizeof(file));
 
5084
  memset((char*)&file, 0, sizeof(file));
5085
5085
  fname_buf= strmov(proc_info, "Making temp file ");
5086
5086
  ext= slave_load_file_stem(fname_buf, file_id, server_id, ".info");
5087
5087
  thd_proc_info(thd, proc_info);
5172
5172
                                               const Format_description_log_event* description_event)
5173
5173
  :Log_event(buf, description_event),block(0)
5174
5174
{
5175
 
  uint8 common_header_len= description_event->common_header_len; 
5176
 
  uint8 append_block_header_len=
 
5175
  uint8_t common_header_len= description_event->common_header_len; 
 
5176
  uint8_t append_block_header_len=
5177
5177
    description_event->post_header_len[APPEND_BLOCK_EVENT-1];
5178
5178
  uint total_header_len= common_header_len+append_block_header_len;
5179
5179
  if (len < total_header_len)
5320
5320
                                             const Format_description_log_event* description_event)
5321
5321
  :Log_event(buf, description_event),file_id(0)
5322
5322
{
5323
 
  uint8 common_header_len= description_event->common_header_len;
5324
 
  uint8 delete_file_header_len= description_event->post_header_len[DELETE_FILE_EVENT-1];
 
5323
  uint8_t common_header_len= description_event->common_header_len;
 
5324
  uint8_t delete_file_header_len= description_event->post_header_len[DELETE_FILE_EVENT-1];
5325
5325
  if (len < (uint)(common_header_len + delete_file_header_len))
5326
5326
    return;
5327
5327
  file_id= uint4korr(buf + common_header_len + DF_FILE_ID_OFFSET);
5370
5370
  char buf[64];
5371
5371
  uint length;
5372
5372
  length= (uint) sprintf(buf, ";file_id=%u", (uint) file_id);
5373
 
  protocol->store(buf, (int32) length, &my_charset_bin);
 
5373
  protocol->store(buf, (int32_t) length, &my_charset_bin);
5374
5374
}
5375
5375
#endif
5376
5376
 
5379
5379
*/
5380
5380
 
5381
5381
#if defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT)
5382
 
int Delete_file_log_event::do_apply_event(Relay_log_info const *rli __attribute__((__unused__)))
 
5382
int Delete_file_log_event::do_apply_event(Relay_log_info const *rli __attribute__((unused)))
5383
5383
{
5384
5384
  char fname[FN_REFLEN+10];
5385
5385
  char *ext= slave_load_file_stem(fname, file_id, server_id, ".data");
5417
5417
                                               const Format_description_log_event* description_event)
5418
5418
  :Log_event(buf, description_event), file_id(0)
5419
5419
{
5420
 
  uint8 common_header_len= description_event->common_header_len;
5421
 
  uint8 exec_load_header_len= description_event->post_header_len[EXEC_LOAD_EVENT-1];
 
5420
  uint8_t common_header_len= description_event->common_header_len;
 
5421
  uint8_t exec_load_header_len= description_event->post_header_len[EXEC_LOAD_EVENT-1];
5422
5422
  if (len < (uint)(common_header_len+exec_load_header_len))
5423
5423
    return;
5424
5424
  file_id= uint4korr(buf + common_header_len + EL_FILE_ID_OFFSET);
5468
5468
  char buf[64];
5469
5469
  uint length;
5470
5470
  length= (uint) sprintf(buf, ";file_id=%u", (uint) file_id);
5471
 
  protocol->store(buf, (int32) length, &my_charset_bin);
 
5471
  protocol->store(buf, (int32_t) length, &my_charset_bin);
5472
5472
}
5473
5473
 
5474
5474
 
5952
5952
    , m_curr_row(NULL), m_curr_row_end(NULL), m_key(NULL)
5953
5953
#endif
5954
5954
{
5955
 
  uint8 const common_header_len= description_event->common_header_len;
5956
 
  uint8 const post_header_len= description_event->post_header_len[event_type-1];
 
5955
  uint8_t const common_header_len= description_event->common_header_len;
 
5956
  uint8_t const post_header_len= description_event->post_header_len[event_type-1];
5957
5957
 
5958
5958
  const char *post_start= buf + common_header_len;
5959
5959
  post_start+= RW_MAPID_OFFSET;
6723
6723
  (e.g. values > 255), the endian-safe methods are used to properly encode 
6724
6724
  the values on the master and decode them on the slave. When the field
6725
6725
  metadata values are captured on the slave, they are stored in an array of
6726
 
  type uint16. This allows the least number of casts to prevent casting bugs
 
6726
  type uint16_t. This allows the least number of casts to prevent casting bugs
6727
6727
  when the field metadata is used in comparisons of field attributes. When
6728
6728
  the field metadata is used for calculating addresses in pointer math, the
6729
 
  type used is uint32. 
 
6729
  type used is uint32_t. 
6730
6730
*/
6731
6731
 
6732
6732
#if !defined(MYSQL_CLIENT)
6770
6770
 */
6771
6771
#if !defined(MYSQL_CLIENT)
6772
6772
Table_map_log_event::Table_map_log_event(THD *thd, TABLE *tbl, ulong tid,
6773
 
                                         bool is_transactional __attribute__((__unused__)),
6774
 
                                         uint16 flags)
 
6773
                                         bool is_transactional __attribute__((unused)),
 
6774
                                         uint16_t flags)
6775
6775
  : Log_event(thd, 0, true),
6776
6776
    m_table(tbl),
6777
6777
    m_dbnam(tbl->s->db.str),
6826
6826
                                 &m_field_metadata, (m_colcnt * 2),
6827
6827
                                 NULL);
6828
6828
 
6829
 
  bzero(m_field_metadata, (m_colcnt * 2));
 
6829
  memset(m_field_metadata, 0, (m_colcnt * 2));
6830
6830
 
6831
6831
  /*
6832
6832
    Create an array for the field metadata and store it.
6843
6843
  else
6844
6844
    m_data_size+= m_field_metadata_size + 1; 
6845
6845
 
6846
 
  bzero(m_null_bits, num_null_bytes);
 
6846
  memset(m_null_bits, 0, num_null_bytes);
6847
6847
  for (unsigned int i= 0 ; i < m_table->s->fields ; ++i)
6848
6848
    if (m_table->field[i]->maybe_null())
6849
6849
      m_null_bits[(i / 8)]+= 1 << (i % 8);
6871
6871
{
6872
6872
  unsigned int bytes_read= 0;
6873
6873
 
6874
 
  uint8 common_header_len= description_event->common_header_len;
6875
 
  uint8 post_header_len= description_event->post_header_len[TABLE_MAP_EVENT-1];
 
6874
  uint8_t common_header_len= description_event->common_header_len;
 
6875
  uint8_t post_header_len= description_event->post_header_len[TABLE_MAP_EVENT-1];
6876
6876
 
6877
6877
  /* Read the post-header */
6878
6878
  const char *post_start= buf + common_header_len;
6984
6984
                                NullS)))
6985
6985
    return(HA_ERR_OUT_OF_MEM);
6986
6986
 
6987
 
  bzero(table_list, sizeof(*table_list));
 
6987
  memset(table_list, 0, sizeof(*table_list));
6988
6988
  table_list->db = db_mem;
6989
6989
  table_list->alias= table_list->table_name = tname_mem;
6990
6990
  table_list->lock_type= TL_WRITE;
8122
8122
                                       const Format_description_log_event *descr_event)
8123
8123
  : Log_event(buf, descr_event)
8124
8124
{
8125
 
  uint8 const common_header_len=
 
8125
  uint8_t const common_header_len=
8126
8126
    descr_event->common_header_len;
8127
 
  uint8 const post_header_len=
 
8127
  uint8_t const post_header_len=
8128
8128
    descr_event->post_header_len[INCIDENT_EVENT-1];
8129
8129
 
8130
8130
  m_incident= static_cast<Incident>(uint2korr(buf + common_header_len));
8131
8131
  char const *ptr= buf + common_header_len + post_header_len;
8132
8132
  char const *const str_end= buf + event_len;
8133
 
  uint8 len= 0;                   // Assignment to keep compiler happy
 
8133
  uint8_t len= 0;                   // Assignment to keep compiler happy
8134
8134
  const char *str= NULL;          // Assignment to keep compiler happy
8135
8135
  read_str(&ptr, str_end, &str, &len);
8136
8136
  m_message.str= const_cast<char*>(str);
8204
8204
bool
8205
8205
Incident_log_event::write_data_header(IO_CACHE *file)
8206
8206
{
8207
 
  uchar buf[sizeof(int16)];
8208
 
  int2store(buf, (int16) m_incident);
 
8207
  uchar buf[sizeof(int16_t)];
 
8208
  int2store(buf, (int16_t) m_incident);
8209
8209
  return(my_b_safe_write(file, buf, sizeof(buf)));
8210
8210
}
8211
8211
 
8220
8220
                    const Format_description_log_event* description_event)
8221
8221
  :Log_event(buf, description_event)
8222
8222
{
8223
 
  uint8 header_size= description_event->common_header_len;
 
8223
  uint8_t header_size= description_event->common_header_len;
8224
8224
  ident_len = event_len - header_size;
8225
8225
  set_if_smaller(ident_len,FN_REFLEN-1);
8226
8226
  log_ident= buf + header_size;
8244
8244
{
8245
8245
  /*
8246
8246
    Currently we only use static PRINT_EVENT_INFO objects, so zeroed at
8247
 
    program's startup, but these explicit bzero() is for the day someone
 
8247
    program's startup, but these explicit memset() is for the day someone
8248
8248
    creates dynamic instances.
8249
8249
  */
8250
 
  bzero(db, sizeof(db));
8251
 
  bzero(charset, sizeof(charset));
8252
 
  bzero(time_zone_str, sizeof(time_zone_str));
 
8250
  memset(db, 0, sizeof(db));
 
8251
  memset(charset, 0, sizeof(charset));
 
8252
  memset(time_zone_str, 0, sizeof(time_zone_str));
8253
8253
  delimiter[0]= ';';
8254
8254
  delimiter[1]= 0;
8255
8255
  myf const flags = MYF(MY_WME | MY_NABP);