← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/log_event.cc

Merged uint fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/log_event.cc
123
123
  const char *handler_error= HA_ERR(ha_error);
124
124
  char buff[MAX_SLAVE_ERRMSG], *slider;
125
125
  const char *buff_end= buff + sizeof(buff);
126
 
  uint len;
 
126
  uint32_t len;
127
127
  List_iterator_fast<DRIZZLE_ERROR> it(thd->warn_list);
128
128
  DRIZZLE_ERROR *err;
129
129
  buff[0]= 0;
225
225
  flag_set m_flags;
226
226
};
227
227
 
228
 
uint debug_not_change_ts_if_art_event= 1; // bug#29309 simulation
 
228
uint32_t debug_not_change_ts_if_art_event= 1; // bug#29309 simulation
229
229
 
230
230
/*
231
231
  pretty_print_str()
292
292
    Pointer to start of extension
293
293
*/
294
294
 
295
 
static char *slave_load_file_stem(char *buf, uint file_id,
 
295
static char *slave_load_file_stem(char *buf, uint32_t file_id,
296
296
                                  int event_server_id, const char *ext)
297
297
{
298
298
  char *res;
318
318
{
319
319
  MY_DIR *dirp;
320
320
  FILEINFO *file;
321
 
  uint i;
 
321
  uint32_t i;
322
322
  char fname[FN_REFLEN], prefbuf[31], *p;
323
323
 
324
324
  if (!(dirp=my_dir(slave_load_tmpdir,MYF(MY_WME))))
355
355
  write_str()
356
356
*/
357
357
 
358
 
static bool write_str(IO_CACHE *file, const char *str, uint length)
 
358
static bool write_str(IO_CACHE *file, const char *str, uint32_t length)
359
359
{
360
360
  unsigned char tmp[1];
361
361
  tmp[0]= (unsigned char) length;
384
384
  Transforms a string into "" or its expression in 0x... form.
385
385
*/
386
386
 
387
 
char *str_to_hex(char *to, const char *from, uint len)
 
387
char *str_to_hex(char *to, const char *from, uint32_t len)
388
388
{
389
389
  if (len)
390
390
  {
850
850
    of 13 bytes, whereas LOG_EVENT_MINIMAL_HEADER_LEN is 19 bytes (it's
851
851
    "minimal" over the set {MySQL >=4.0}).
852
852
  */
853
 
  uint header_size= cmin(description_event->common_header_len,
 
853
  uint32_t header_size= cmin(description_event->common_header_len,
854
854
                        LOG_EVENT_MINIMAL_HEADER_LEN);
855
855
 
856
856
  LOCK_MUTEX;
864
864
    */
865
865
    return(0);
866
866
  }
867
 
  uint data_len = uint4korr(head + EVENT_LEN_OFFSET);
 
867
  uint32_t data_len = uint4korr(head + EVENT_LEN_OFFSET);
868
868
  char *buf= 0;
869
869
  const char *error= 0;
870
870
  Log_event *res=  0;
871
871
#ifndef max_allowed_packet
872
872
  THD *thd=current_thd;
873
 
  uint max_allowed_packet= thd ? thd->variables.max_allowed_packet : ~(ulong)0;
 
873
  uint32_t max_allowed_packet= thd ? thd->variables.max_allowed_packet : ~(ulong)0;
874
874
#endif
875
875
 
876
876
  if (data_len > max_allowed_packet)
929
929
  constructors.
930
930
*/
931
931
 
932
 
Log_event* Log_event::read_log_event(const char* buf, uint event_len,
 
932
Log_event* Log_event::read_log_event(const char* buf, uint32_t event_len,
933
933
                                     const char **error,
934
934
                                     const Format_description_log_event *description_event)
935
935
{
945
945
    return(NULL); // general sanity check - will fail on a partial read
946
946
  }
947
947
 
948
 
  uint event_type= buf[EVENT_TYPE_OFFSET];
 
948
  uint32_t event_type= buf[EVENT_TYPE_OFFSET];
949
949
  if (event_type > description_event->number_of_event_types &&
950
950
      event_type != FORMAT_DESCRIPTION_EVENT)
951
951
  {
1113
1113
  Utility function for the next method (Query_log_event::write()) .
1114
1114
*/
1115
1115
static void write_str_with_code_and_len(char **dst, const char *src,
1116
 
                                        int len, uint code)
 
1116
                                        int len, uint32_t code)
1117
1117
{
1118
1118
  assert(src);
1119
1119
  *((*dst)++)= code;
1433
1433
static int
1434
1434
get_str_len_and_pointer(const Log_event::Byte **src,
1435
1435
                        const char **dst,
1436
 
                        uint *len,
 
1436
                        uint32_t *len,
1437
1437
                        const Log_event::Byte *end)
1438
1438
{
1439
1439
  if (*src >= end)
1440
1440
    return -1;       // Will be UINT_MAX in two-complement arithmetics
1441
 
  uint length= **src;
 
1441
  uint32_t length= **src;
1442
1442
  if (length > 0)
1443
1443
  {
1444
1444
    if (*src + length >= end)
1452
1452
 
1453
1453
static void copy_str_and_move(const char **src, 
1454
1454
                              Log_event::Byte **dst, 
1455
 
                              uint len)
 
1455
                              uint32_t len)
1456
1456
{
1457
1457
  memcpy(*dst, *src, len);
1458
1458
  *src= (const char *)*dst;
1481
1481
/**
1482
1482
  This is used by the SQL slave thread to prepare the event before execution.
1483
1483
*/
1484
 
Query_log_event::Query_log_event(const char* buf, uint event_len,
 
1484
Query_log_event::Query_log_event(const char* buf, uint32_t event_len,
1485
1485
                                 const Format_description_log_event
1486
1486
                                 *description_event,
1487
1487
                                 Log_event_type event_type)
2247
2247
 
2248
2248
Format_description_log_event::
2249
2249
Format_description_log_event(const char* buf,
2250
 
                             uint event_len,
 
2250
                             uint32_t event_len,
2251
2251
                             const
2252
2252
                             Format_description_log_event*
2253
2253
                             description_event)
2482
2482
{
2483
2483
  char *p= server_version, *r;
2484
2484
  ulong number;
2485
 
  for (uint i= 0; i<=2; i++)
 
2485
  for (uint32_t i= 0; i<=2; i++)
2486
2486
  {
2487
2487
    number= strtoul(p, &r, 10);
2488
2488
    server_version_split[i]= (unsigned char)number;
2516
2516
  Load_log_event::pack_info()
2517
2517
*/
2518
2518
 
2519
 
uint Load_log_event::get_query_buffer_length()
 
2519
uint32_t Load_log_event::get_query_buffer_length()
2520
2520
{
2521
2521
  return
2522
2522
    5 + db_len + 3 +                        // "use DB; "
2599
2599
 
2600
2600
  if (num_fields)
2601
2601
  {
2602
 
    uint i;
 
2602
    uint32_t i;
2603
2603
    const char *field= fields;
2604
2604
    pos= my_stpcpy(pos, " (");
2605
2605
    for (i = 0; i < num_fields; i++)
2762
2762
    The caller must do buf[event_len] = 0 before he starts using the
2763
2763
    constructed event.
2764
2764
*/
2765
 
Load_log_event::Load_log_event(const char *buf, uint event_len,
 
2765
Load_log_event::Load_log_event(const char *buf, uint32_t event_len,
2766
2766
                               const Format_description_log_event *description_event)
2767
2767
  :Log_event(buf, description_event), num_fields(0), fields(0),
2768
2768
   field_lens(0),field_block_len(0),
2792
2792
                                   int body_offset,
2793
2793
                                   const Format_description_log_event *description_event)
2794
2794
{
2795
 
  uint data_len;
 
2795
  uint32_t data_len;
2796
2796
  char* buf_end = (char*)buf + event_len;
2797
2797
  /* this is the beginning of the post-header */
2798
2798
  const char* data_head = buf + description_event->common_header_len;
2817
2817
  data_len = event_len - body_offset;
2818
2818
  if (num_fields > data_len) // simple sanity check against corruption
2819
2819
    return(1);
2820
 
  for (uint i = 0; i < num_fields; i++)
 
2820
  for (uint32_t i = 0; i < num_fields; i++)
2821
2821
    field_block_len += (uint)field_lens[i] + 1;
2822
2822
 
2823
2823
  fields = (char*)field_lens + num_fields;
2845
2845
                                List<Item> &field_list,
2846
2846
                                Name_resolution_context *context)
2847
2847
{
2848
 
  uint i;
 
2848
  uint32_t i;
2849
2849
  const char* field = fields;
2850
2850
  for (i= 0; i < num_fields; i++)
2851
2851
  {
3173
3173
 
3174
3174
 
3175
3175
Rotate_log_event::Rotate_log_event(const char* new_log_ident_arg,
3176
 
                                   uint ident_len_arg, uint64_t pos_arg,
3177
 
                                   uint flags_arg)
 
3176
                                   uint32_t ident_len_arg, uint64_t pos_arg,
 
3177
                                   uint32_t flags_arg)
3178
3178
  :Log_event(), new_log_ident(new_log_ident_arg),
3179
3179
   pos(pos_arg),ident_len(ident_len_arg ? ident_len_arg :
3180
3180
                          (uint) strlen(new_log_ident_arg)), flags(flags_arg)
3185
3185
}
3186
3186
 
3187
3187
 
3188
 
Rotate_log_event::Rotate_log_event(const char* buf, uint event_len,
 
3188
Rotate_log_event::Rotate_log_event(const char* buf, uint32_t event_len,
3189
3189
                                   const Format_description_log_event* description_event)
3190
3190
  :Log_event(buf, description_event) ,new_log_ident(0), flags(DUP_NAME)
3191
3191
{
3192
3192
  // The caller will ensure that event_len is what we have at EVENT_LEN_OFFSET
3193
3193
  uint8_t header_size= description_event->common_header_len;
3194
3194
  uint8_t post_header_len= description_event->post_header_len[ROTATE_EVENT-1];
3195
 
  uint ident_offset;
 
3195
  uint32_t ident_offset;
3196
3196
  if (event_len < header_size)
3197
3197
    return;
3198
3198
  buf += header_size;
3543
3543
void User_var_log_event::pack_info(Protocol* protocol)
3544
3544
{
3545
3545
  char *buf= 0;
3546
 
  uint val_offset= 4 + name_len;
3547
 
  uint event_len= val_offset;
 
3546
  uint32_t val_offset= 4 + name_len;
 
3547
  uint32_t event_len= val_offset;
3548
3548
 
3549
3549
  if (is_null)
3550
3550
  {
3654
3654
  char buf1[UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE + 
3655
3655
            UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE];
3656
3656
  unsigned char buf2[(8 > DECIMAL_MAX_FIELD_SIZE + 2) ? 8 : DECIMAL_MAX_FIELD_SIZE +2], *pos= buf2;
3657
 
  uint buf1_length;
 
3657
  uint32_t buf1_length;
3658
3658
  ulong event_length;
3659
3659
 
3660
3660
  int4store(buf, name_len);
3903
3903
 
3904
3904
 
3905
3905
/** This code is not used, so has not been updated to be format-tolerant. */
3906
 
Slave_log_event::Slave_log_event(const char* buf, uint event_len)
 
3906
Slave_log_event::Slave_log_event(const char* buf, uint32_t event_len)
3907
3907
  :Log_event(buf,0) /*unused event*/ ,mem_pool(0),master_host(0)
3908
3908
{
3909
3909
  if (event_len < LOG_EVENT_HEADER_LEN)
3973
3973
                      const char* db_arg, const char* table_name_arg,
3974
3974
                      List<Item>& fields_arg, enum enum_duplicates handle_dup,
3975
3975
                      bool ignore,
3976
 
                      unsigned char* block_arg, uint block_len_arg, bool using_trans)
 
3976
                      unsigned char* block_arg, uint32_t block_len_arg, bool using_trans)
3977
3977
  :Load_log_event(thd_arg,ex,db_arg,table_name_arg,fields_arg,handle_dup, ignore,
3978
3978
                  using_trans),
3979
3979
   fake_base(0), block(block_arg), event_buf(0), block_len(block_len_arg),
4030
4030
  Create_file_log_event ctor
4031
4031
*/
4032
4032
 
4033
 
Create_file_log_event::Create_file_log_event(const char* buf, uint len,
 
4033
Create_file_log_event::Create_file_log_event(const char* buf, uint32_t len,
4034
4034
                                             const Format_description_log_event* description_event)
4035
4035
  :Load_log_event(buf,0,description_event),fake_base(0),block(0),inited_from_old(0)
4036
4036
{
4037
 
  uint block_offset;
4038
 
  uint header_len= description_event->common_header_len;
 
4037
  uint32_t block_offset;
 
4038
  uint32_t header_len= description_event->common_header_len;
4039
4039
  uint8_t load_header_len= description_event->post_header_len[LOAD_EVENT-1];
4040
4040
  uint8_t create_file_header_len= description_event->post_header_len[CREATE_FILE_EVENT-1];
4041
4041
  if (!(event_buf= (char*) my_memdup(buf, len, MYF(MY_WME))) ||
4183
4183
Append_block_log_event::Append_block_log_event(THD *thd_arg,
4184
4184
                                               const char *db_arg,
4185
4185
                                               unsigned char *block_arg,
4186
 
                                               uint block_len_arg,
 
4186
                                               uint32_t block_len_arg,
4187
4187
                                               bool using_trans)
4188
4188
  :Log_event(thd_arg,0, using_trans), block(block_arg),
4189
4189
   block_len(block_len_arg), file_id(thd_arg->file_id), db(db_arg)
4195
4195
  Append_block_log_event ctor
4196
4196
*/
4197
4197
 
4198
 
Append_block_log_event::Append_block_log_event(const char* buf, uint len,
 
4198
Append_block_log_event::Append_block_log_event(const char* buf, uint32_t len,
4199
4199
                                               const Format_description_log_event* description_event)
4200
4200
  :Log_event(buf, description_event),block(0)
4201
4201
{
4202
4202
  uint8_t common_header_len= description_event->common_header_len; 
4203
4203
  uint8_t append_block_header_len=
4204
4204
    description_event->post_header_len[APPEND_BLOCK_EVENT-1];
4205
 
  uint total_header_len= common_header_len+append_block_header_len;
 
4205
  uint32_t total_header_len= common_header_len+append_block_header_len;
4206
4206
  if (len < total_header_len)
4207
4207
    return;
4208
4208
  file_id= uint4korr(buf + common_header_len + AB_FILE_ID_OFFSET);
4233
4233
void Append_block_log_event::pack_info(Protocol *protocol)
4234
4234
{
4235
4235
  char buf[256];
4236
 
  uint length;
 
4236
  uint32_t length;
4237
4237
  length= (uint) sprintf(buf, ";file_id=%u;block_len=%u", file_id,
4238
4238
                             block_len);
4239
4239
  protocol->store(buf, length, &my_charset_bin);
4318
4318
  Delete_file_log_event ctor
4319
4319
*/
4320
4320
 
4321
 
Delete_file_log_event::Delete_file_log_event(const char* buf, uint len,
 
4321
Delete_file_log_event::Delete_file_log_event(const char* buf, uint32_t len,
4322
4322
                                             const Format_description_log_event* description_event)
4323
4323
  :Log_event(buf, description_event),file_id(0)
4324
4324
{
4350
4350
void Delete_file_log_event::pack_info(Protocol *protocol)
4351
4351
{
4352
4352
  char buf[64];
4353
 
  uint length;
 
4353
  uint32_t length;
4354
4354
  length= (uint) sprintf(buf, ";file_id=%u", (uint) file_id);
4355
4355
  protocol->store(buf, (int32_t) length, &my_charset_bin);
4356
4356
}
4390
4390
  Execute_load_log_event ctor
4391
4391
*/
4392
4392
 
4393
 
Execute_load_log_event::Execute_load_log_event(const char* buf, uint len,
 
4393
Execute_load_log_event::Execute_load_log_event(const char* buf, uint32_t len,
4394
4394
                                               const Format_description_log_event* description_event)
4395
4395
  :Log_event(buf, description_event), file_id(0)
4396
4396
{
4422
4422
void Execute_load_log_event::pack_info(Protocol *protocol)
4423
4423
{
4424
4424
  char buf[64];
4425
 
  uint length;
 
4425
  uint32_t length;
4426
4426
  length= (uint) sprintf(buf, ";file_id=%u", (uint) file_id);
4427
4427
  protocol->store(buf, (int32_t) length, &my_charset_bin);
4428
4428
}
4526
4526
 
4527
4527
Begin_load_query_log_event::
4528
4528
Begin_load_query_log_event(THD* thd_arg, const char* db_arg, unsigned char* block_arg,
4529
 
                           uint block_len_arg, bool using_trans)
 
4529
                           uint32_t block_len_arg, bool using_trans)
4530
4530
  :Append_block_log_event(thd_arg, db_arg, block_arg, block_len_arg,
4531
4531
                          using_trans)
4532
4532
{
4535
4535
 
4536
4536
 
4537
4537
Begin_load_query_log_event::
4538
 
Begin_load_query_log_event(const char* buf, uint len,
 
4538
Begin_load_query_log_event(const char* buf, uint32_t len,
4539
4539
                           const Format_description_log_event* desc_event)
4540
4540
  :Append_block_log_event(buf, len, desc_event)
4541
4541
{
4566
4566
 
4567
4567
Execute_load_query_log_event::
4568
4568
Execute_load_query_log_event(THD *thd_arg, const char* query_arg,
4569
 
                             ulong query_length_arg, uint fn_pos_start_arg,
4570
 
                             uint fn_pos_end_arg,
 
4569
                             ulong query_length_arg, uint32_t fn_pos_start_arg,
 
4570
                             uint32_t fn_pos_end_arg,
4571
4571
                             enum_load_dup_handling dup_handling_arg,
4572
4572
                             bool using_trans, bool suppress_use,
4573
4573
                             THD::killed_state killed_err_arg):
4580
4580
 
4581
4581
 
4582
4582
Execute_load_query_log_event::
4583
 
Execute_load_query_log_event(const char* buf, uint event_len,
 
4583
Execute_load_query_log_event(const char* buf, uint32_t event_len,
4584
4584
                             const Format_description_log_event* desc_event):
4585
4585
  Query_log_event(buf, event_len, desc_event, EXECUTE_LOAD_QUERY_EVENT),
4586
4586
  file_id(0), fn_pos_start(0), fn_pos_end(0)
4839
4839
}
4840
4840
 
4841
4841
 
4842
 
Rows_log_event::Rows_log_event(const char *buf, uint event_len,
 
4842
Rows_log_event::Rows_log_event(const char *buf, uint32_t event_len,
4843
4843
                               Log_event_type event_type,
4844
4844
                               const Format_description_log_event
4845
4845
                               *description_event)
5091
5091
            Error reporting borrowed from Query_log_event with many excessive
5092
5092
            simplifications (we don't honour --slave-skip-errors)
5093
5093
          */
5094
 
          uint actual_error= thd->main_da.sql_errno();
 
5094
          uint32_t actual_error= thd->main_da.sql_errno();
5095
5095
          rli->report(ERROR_LEVEL, actual_error,
5096
5096
                      _("Error '%s' in %s event: when locking tables"),
5097
5097
                      (actual_error
5127
5127
      TableList *tables= rli->tables_to_lock;
5128
5128
      close_tables_for_reopen(thd, &tables);
5129
5129
 
5130
 
      uint tables_count= rli->tables_to_lock_count;
 
5130
      uint32_t tables_count= rli->tables_to_lock_count;
5131
5131
      if ((error= open_tables(thd, &tables, &tables_count, 0)))
5132
5132
      {
5133
5133
        if (thd->is_slave_error || thd->is_fatal_error)
5136
5136
            Error reporting borrowed from Query_log_event with many excessive
5137
5137
            simplifications (we don't honour --slave-skip-errors)
5138
5138
          */
5139
 
          uint actual_error= thd->main_da.sql_errno();
 
5139
          uint32_t actual_error= thd->main_da.sql_errno();
5140
5140
          rli->report(ERROR_LEVEL, actual_error,
5141
5141
                      _("Error '%s' on reopening tables"),
5142
5142
                      (actual_error
5681
5681
    that is not on the slave and is null and thus not in the row data during
5682
5682
    replication.
5683
5683
  */
5684
 
  uint num_null_bytes= (m_table->s->fields + 7) / 8;
 
5684
  uint32_t num_null_bytes= (m_table->s->fields + 7) / 8;
5685
5685
  m_data_size+= num_null_bytes;
5686
5686
  m_meta_memory= (unsigned char *)my_multi_malloc(MYF(MY_WME),
5687
5687
                                 &m_null_bits, num_null_bytes,
5716
5716
/*
5717
5717
  Constructor used by slave to read the event from the binary log.
5718
5718
 */
5719
 
Table_map_log_event::Table_map_log_event(const char *buf, uint event_len,
 
5719
Table_map_log_event::Table_map_log_event(const char *buf, uint32_t event_len,
5720
5720
                                         const Format_description_log_event
5721
5721
                                         *description_event)
5722
5722
 
5790
5790
    {
5791
5791
      m_field_metadata_size= net_field_length(&ptr_after_colcnt);
5792
5792
      assert(m_field_metadata_size <= (m_colcnt * 2));
5793
 
      uint num_null_bytes= (m_colcnt + 7) / 8;
 
5793
      uint32_t num_null_bytes= (m_colcnt + 7) / 8;
5794
5794
      m_meta_memory= (unsigned char *)my_multi_malloc(MYF(MY_WME),
5795
5795
                                     &m_null_bits, num_null_bytes,
5796
5796
                                     &m_field_metadata, m_field_metadata_size,
5896
5896
      internally in the open_tables() function, hence we take a copy
5897
5897
      of the pointer to make sure that it's not lost.
5898
5898
    */
5899
 
    uint count;
 
5899
    uint32_t count;
5900
5900
    assert(thd->lex->query_tables != table_list);
5901
5901
    TableList *tmp_table_list= table_list;
5902
5902
    if ((error= open_tables(thd, &tmp_table_list, &count, 0)))
5907
5907
          Error reporting borrowed from Query_log_event with many excessive
5908
5908
          simplifications (we don't honour --slave-skip-errors)
5909
5909
        */
5910
 
        uint actual_error= thd->main_da.sql_errno();
 
5910
        uint32_t actual_error= thd->main_da.sql_errno();
5911
5911
        rli->report(ERROR_LEVEL, actual_error,
5912
5912
                    _("Error '%s' on opening table `%s`.`%s`"),
5913
5913
                    (actual_error
6048
6048
/*
6049
6049
  Constructor used by slave to read the event from the binary log.
6050
6050
 */
6051
 
Write_rows_log_event::Write_rows_log_event(const char *buf, uint event_len,
 
6051
Write_rows_log_event::Write_rows_log_event(const char *buf, uint32_t event_len,
6052
6052
                                           const Format_description_log_event
6053
6053
                                           *description_event)
6054
6054
: Rows_log_event(buf, event_len, WRITE_ROWS_EVENT, description_event)
6137
6137
  Check if there are more UNIQUE keys after the given key.
6138
6138
*/
6139
6139
static int
6140
 
last_uniq_key(Table *table, uint keyno)
 
6140
last_uniq_key(Table *table, uint32_t keyno)
6141
6141
{
6142
6142
  while (++keyno < table->s->keys)
6143
6143
    if (table->key_info[keyno].flags & HA_NOSAME)
6714
6714
/*
6715
6715
  Constructor used by slave to read the event from the binary log.
6716
6716
 */
6717
 
Delete_rows_log_event::Delete_rows_log_event(const char *buf, uint event_len,
 
6717
Delete_rows_log_event::Delete_rows_log_event(const char *buf, uint32_t event_len,
6718
6718
                                             const Format_description_log_event
6719
6719
                                             *description_event)
6720
6720
  : Rows_log_event(buf, event_len, DELETE_ROWS_EVENT, description_event)
6817
6817
/*
6818
6818
  Constructor used by slave to read the event from the binary log.
6819
6819
 */
6820
 
Update_rows_log_event::Update_rows_log_event(const char *buf, uint event_len,
 
6820
Update_rows_log_event::Update_rows_log_event(const char *buf, uint32_t event_len,
6821
6821
                                             const
6822
6822
                                             Format_description_log_event
6823
6823
                                             *description_event)
6904
6904
}
6905
6905
 
6906
6906
 
6907
 
Incident_log_event::Incident_log_event(const char *buf, uint event_len,
 
6907
Incident_log_event::Incident_log_event(const char *buf, uint32_t event_len,
6908
6908
                                       const Format_description_log_event *descr_event)
6909
6909
  : Log_event(buf, descr_event)
6910
6910
{
6984
6984
  return(write_str(file, m_message.str, m_message.length));
6985
6985
}
6986
6986
 
6987
 
Heartbeat_log_event::Heartbeat_log_event(const char* buf, uint event_len,
 
6987
Heartbeat_log_event::Heartbeat_log_event(const char* buf, uint32_t event_len,
6988
6988
                    const Format_description_log_event* description_event)
6989
6989
  :Log_event(buf, description_event)
6990
6990
{