← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/log_event.h

  • Committer: brian
  • Date: 2008-07-03 12:39:14 UTC
  • Revision ID: brian@localhost.localdomain-20080703123914-lry82qf74f6cbyzs
Disabling myisam tools until incomming link patch from Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/log_event.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
 
1
/* Copyright (C) 2000-2006 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
19
15
 
20
16
/**
21
17
  @addtogroup Replication
29
25
*/
30
26
 
31
27
 
32
 
#ifndef DRIZZLED_LOG_EVENT_H
33
 
#define DRIZZLED_LOG_EVENT_H
34
 
 
35
 
 
36
 
#include <string>
37
 
#include <mysys/my_bitmap.h>
 
28
#ifndef _log_event_h
 
29
#define _log_event_h
 
30
 
 
31
#if defined(USE_PRAGMA_INTERFACE) && !defined(MYSQL_CLIENT)
 
32
#pragma interface                       /* gcc class implementation */
 
33
#endif
 
34
 
 
35
#include <my_bitmap.h>
38
36
#include "rpl_constants.h"
 
37
#ifndef MYSQL_CLIENT
39
38
#include "rpl_record.h"
40
39
#include "rpl_reporting.h"
41
 
 
42
 
#include <drizzled/sql_string.h>       /* append_query_string() needs String declaration */
 
40
#endif
43
41
 
44
42
/**
45
43
   Either assert or return an error.
50
48
   @param COND   Condition to check
51
49
   @param ERRNO  Error number to return in non-debug builds
52
50
*/
53
 
#define ASSERT_OR_RETURN_ERROR(COND, ERRNO) \
54
 
  assert(COND)
 
51
#ifdef DBUG_OFF
 
52
#define ASSERT_OR_RETURN_ERROR(COND, ERRNO) \
 
53
  do { if (!(COND)) return ERRNO; } while (0)
 
54
#else
 
55
#define ASSERT_OR_RETURN_ERROR(COND, ERRNO) \
 
56
  DBUG_ASSERT(COND)
 
57
#endif
55
58
 
56
59
#define LOG_READ_EOF    -1
57
60
#define LOG_READ_BOGUS  -2
155
158
  const char* line_start;
156
159
  const char* escaped;
157
160
  int cached_new_format;
158
 
  uint8_t field_term_len,enclosed_len,line_term_len,line_start_len, escaped_len;
 
161
  uint8 field_term_len,enclosed_len,line_term_len,line_start_len, escaped_len;
159
162
  char opt_flags;
160
163
  char empty_flags;
161
164
 
162
 
  /* store in new format even if old is possible */
 
165
  // store in new format even if old is possible
163
166
  void force_new_format() { cached_new_format = 1;}
164
167
  int data_size()
165
168
  {
209
212
   event's ID, LOG_EVENT_HEADER_LEN will be something like 26, but
210
213
   LOG_EVENT_MINIMAL_HEADER_LEN will remain 19.
211
214
*/
212
 
#define LOG_EVENT_MINIMAL_HEADER_LEN (uint8_t)19
 
215
#define LOG_EVENT_MINIMAL_HEADER_LEN 19
213
216
 
214
217
/* event-specific post-header sizes */
215
218
// where 3.23, 4.x and 5.0 agree
398
401
/**
399
402
  @def LOG_EVENT_THREAD_SPECIFIC_F
400
403
 
401
 
  If the query depends on the thread (for example: TEMPORARY Table).
 
404
  If the query depends on the thread (for example: TEMPORARY TABLE).
402
405
  Currently this is used by mysqlbinlog to know it must print
403
406
  SET @@PSEUDO_THREAD_ID=xx; before the query (it would not hurt to print it
404
407
  for every query but this would be slow).
453
456
 
454
457
/* Shouldn't be defined before */
455
458
#define EXPECTED_OPTIONS \
456
 
  ((1U << 14) | (1U << 26) | (1U << 27) | (1U << 19))
 
459
  ((ULL(1) << 14) | (ULL(1) << 26) | (ULL(1) << 27) | (ULL(1) << 19))
457
460
 
458
461
#if OPTIONS_WRITTEN_TO_BIN_LOG != EXPECTED_OPTIONS
459
462
#error OPTIONS_WRITTEN_TO_BIN_LOG must NOT change their values!
545
548
};
546
549
 
547
550
 
 
551
#ifndef MYSQL_CLIENT
548
552
class String;
549
 
class DRIZZLE_BIN_LOG;
 
553
class MYSQL_BIN_LOG;
550
554
class THD;
 
555
#endif
551
556
 
552
557
class Format_description_log_event;
553
558
class Relay_log_info;
554
559
 
 
560
#ifdef MYSQL_CLIENT
 
561
enum enum_base64_output_mode {
 
562
  BASE64_OUTPUT_NEVER= 0,
 
563
  BASE64_OUTPUT_AUTO= 1,
 
564
  BASE64_OUTPUT_ALWAYS= 2,
 
565
  BASE64_OUTPUT_UNSPEC= 3,
 
566
  /* insert new output modes here */
 
567
  BASE64_OUTPUT_MODE_COUNT
 
568
};
 
569
 
 
570
/*
 
571
  A structure for mysqlbinlog to know how to print events
 
572
 
 
573
  This structure is passed to the event's print() methods,
 
574
 
 
575
  There are two types of settings stored here:
 
576
  1. Last db, flags2, sql_mode etc comes from the last printed event.
 
577
     They are stored so that only the necessary USE and SET commands
 
578
     are printed.
 
579
  2. Other information on how to print the events, e.g. short_form,
 
580
     hexdump_from.  These are not dependent on the last event.
 
581
*/
 
582
typedef struct st_print_event_info
 
583
{
 
584
  /*
 
585
    Settings for database, sql_mode etc that comes from the last event
 
586
    that was printed.  We cache these so that we don't have to print
 
587
    them if they are unchanged.
 
588
  */
 
589
  // TODO: have the last catalog here ??
 
590
  char db[FN_REFLEN+1]; // TODO: make this a LEX_STRING when thd->db is
 
591
  bool flags2_inited;
 
592
  uint32 flags2;
 
593
  bool sql_mode_inited;
 
594
  ulong sql_mode;               /* must be same as THD.variables.sql_mode */
 
595
  ulong auto_increment_increment, auto_increment_offset;
 
596
  bool charset_inited;
 
597
  char charset[6]; // 3 variables, each of them storable in 2 bytes
 
598
  char time_zone_str[MAX_TIME_ZONE_NAME_LENGTH];
 
599
  uint lc_time_names_number;
 
600
  uint charset_database_number;
 
601
  uint thread_id;
 
602
  bool thread_id_printed;
 
603
 
 
604
  st_print_event_info();
 
605
 
 
606
  ~st_print_event_info() {
 
607
    close_cached_file(&head_cache);
 
608
    close_cached_file(&body_cache);
 
609
  }
 
610
  bool init_ok() /* tells if construction was successful */
 
611
    { return my_b_inited(&head_cache) && my_b_inited(&body_cache); }
 
612
 
 
613
 
 
614
  /* Settings on how to print the events */
 
615
  bool short_form;
 
616
  enum_base64_output_mode base64_output_mode;
 
617
  /*
 
618
    This is set whenever a Format_description_event is printed.
 
619
    Later, when an event is printed in base64, this flag is tested: if
 
620
    no Format_description_event has been seen, it is unsafe to print
 
621
    the base64 event, so an error message is generated.
 
622
  */
 
623
  bool printed_fd_event;
 
624
  my_off_t hexdump_from;
 
625
  uint8 common_header_len;
 
626
  char delimiter[16];
 
627
 
 
628
  /*
 
629
     These two caches are used by the row-based replication events to
 
630
     collect the header information and the main body of the events
 
631
     making up a statement.
 
632
   */
 
633
  IO_CACHE head_cache;
 
634
  IO_CACHE body_cache;
 
635
} PRINT_EVENT_INFO;
 
636
#endif
 
637
 
555
638
/**
556
639
  the struct aggregates two paramenters that identify an event
557
640
  uniquely in scope of communication of a particular master and slave couple.
744
827
    sees the offset of the BEGIN, which is logical as rollback may
745
828
    occur), except the COMMIT query which has its real offset.
746
829
  */
747
 
  off_t log_pos;
 
830
  my_off_t log_pos;
748
831
  /*
749
832
     A temp buffer for read_log_event; it is later analysed according to the
750
833
     event's type, and its content is distributed in the event-specific fields.
768
851
    The master's server id (is preserved in the relay log; used to
769
852
    prevent from infinite loops in circular replication).
770
853
  */
771
 
  uint32_t server_id;
 
854
  uint32 server_id;
772
855
 
773
856
  /**
774
857
    Some 16 flags. See the definitions above for LOG_EVENT_TIME_F,
775
858
    LOG_EVENT_FORCED_ROTATE_F, LOG_EVENT_THREAD_SPECIFIC_F, and
776
859
    LOG_EVENT_SUPPRESS_USE_F for notes.
777
860
  */
778
 
  uint16_t flags;
 
861
  uint16 flags;
779
862
 
780
863
  bool cache_stmt;
781
864
 
785
868
  */
786
869
  ulong slave_exec_mode;
787
870
 
 
871
#ifndef MYSQL_CLIENT
788
872
  THD* thd;
789
873
 
790
874
  Log_event();
791
 
  Log_event(THD* thd_arg, uint16_t flags_arg, bool cache_stmt);
 
875
  Log_event(THD* thd_arg, uint16 flags_arg, bool cache_stmt);
792
876
  /*
793
877
    read_log_event() functions read an event from a binlog or relay
794
878
    log; used by SHOW BINLOG EVENTS, the binlog_dump thread on the
812
896
    EVENTS.
813
897
  */
814
898
  static void init_show_field_list(List<Item>* field_list);
 
899
#ifdef HAVE_REPLICATION
815
900
  int net_send(Protocol *protocol, const char* log_name, my_off_t pos);
816
901
 
817
902
  /*
821
906
 
822
907
  virtual void pack_info(Protocol *protocol);
823
908
 
 
909
#endif /* HAVE_REPLICATION */
824
910
  virtual const char* get_db()
825
911
  {
826
912
    return thd ? thd->db : 0;
827
913
  }
 
914
#else
 
915
  Log_event() : temp_buf(0) {}
 
916
    /* avoid having to link mysqlbinlog against libpthread */
 
917
  static Log_event* read_log_event(IO_CACHE* file,
 
918
                                   const Format_description_log_event
 
919
                                   *description_event);
 
920
  /* print*() functions are used by mysqlbinlog */
 
921
  virtual void print(FILE* file, PRINT_EVENT_INFO* print_event_info) = 0;
 
922
  void print_timestamp(IO_CACHE* file, time_t *ts = 0);
 
923
  void print_header(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info,
 
924
                    bool is_more);
 
925
  void print_base64(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info,
 
926
                    bool is_more);
 
927
#endif
828
928
 
829
929
  static void *operator new(size_t size)
830
930
  {
831
931
    return (void*) my_malloc((uint)size, MYF(MY_WME|MY_FAE));
832
932
  }
833
933
 
834
 
  static void operator delete(void *ptr,
835
 
                              size_t size __attribute__((unused)))
 
934
  static void operator delete(void *ptr, size_t size)
836
935
  {
837
 
    free((unsigned char*) ptr);
 
936
    my_free((uchar*) ptr, MYF(MY_WME|MY_ALLOW_ZERO_PTR));
838
937
  }
839
938
 
840
939
  /* Placement version of the above operators */
841
940
  static void *operator new(size_t, void* ptr) { return ptr; }
842
941
  static void operator delete(void*, void*) { }
843
942
 
 
943
#ifndef MYSQL_CLIENT
844
944
  bool write_header(IO_CACHE* file, ulong data_length);
845
945
  virtual bool write(IO_CACHE* file)
846
946
  {
848
948
            write_data_header(file) ||
849
949
            write_data_body(file));
850
950
  }
851
 
  virtual bool write_data_header(IO_CACHE* file __attribute__((unused)))
 
951
  virtual bool write_data_header(IO_CACHE* file)
852
952
  { return 0; }
853
953
  virtual bool write_data_body(IO_CACHE* file __attribute__((unused)))
854
954
  { return 0; }
863
963
      return tmp_thd->start_time;
864
964
    return my_time(0);
865
965
  }
 
966
#endif
866
967
  virtual Log_event_type get_type_code() = 0;
867
968
  virtual bool is_valid() const = 0;
868
969
  virtual bool is_artificial_event() { return 0; }
875
976
  {
876
977
    if (temp_buf)
877
978
    {
878
 
      free(temp_buf);
 
979
      my_free(temp_buf, MYF(0));
879
980
      temp_buf = 0;
880
981
    }
881
982
  }
884
985
    is calculated during write()
885
986
  */
886
987
  virtual int get_data_size() { return 0;}
887
 
  static Log_event* read_log_event(const char* buf, uint32_t event_len,
 
988
  static Log_event* read_log_event(const char* buf, uint event_len,
888
989
                                   const char **error,
889
990
                                   const Format_description_log_event
890
991
                                   *description_event);
899
1000
 
900
1001
  /* Return start of query time or current time */
901
1002
 
 
1003
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
902
1004
public:
903
1005
 
904
1006
  /**
975
1077
    @retval 0     Event applied successfully
976
1078
    @retval errno Error code if event application failed
977
1079
  */
978
 
  virtual int do_apply_event(Relay_log_info const *rli __attribute__((unused)))
 
1080
  virtual int do_apply_event(Relay_log_info const *rli)
979
1081
  {
980
1082
    return 0;                /* Default implementation does nothing */
981
1083
  }
1037
1139
     non-zero. The caller shall decrease the counter by one.
1038
1140
   */
1039
1141
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
 
1142
#endif
1040
1143
};
1041
1144
 
1042
1145
 
1387
1490
    we pass it with q_len, so we would not have to call strlen()
1388
1491
    otherwise, set it to 0, in which case, we compute it with strlen()
1389
1492
  */
1390
 
  uint32_t q_len;
1391
 
  uint32_t db_len;
1392
 
  uint16_t error_code;
 
1493
  uint32 q_len;
 
1494
  uint32 db_len;
 
1495
  uint16 error_code;
1393
1496
  ulong thread_id;
1394
1497
  /*
1395
1498
    For events created by Query_log_event::do_apply_event (and
1404
1507
    concerned) from here.
1405
1508
  */
1406
1509
 
1407
 
  uint32_t catalog_len;                 // <= 255 char; 0 means uninited
 
1510
  uint catalog_len;                     // <= 255 char; 0 means uninited
1408
1511
 
1409
1512
  /*
1410
1513
    We want to be able to store a variable number of N-bit status vars:
1426
1529
    Query_log_event, so automatically benefit from the work already done for
1427
1530
    status variables in Query_log_event.
1428
1531
 */
1429
 
  uint16_t status_vars_len;
 
1532
  uint16 status_vars_len;
1430
1533
 
1431
1534
  /*
1432
1535
    'flags2' is a second set of flags (on top of those in Log_event), for
1441
1544
  bool sql_mode_inited;
1442
1545
  bool charset_inited;
1443
1546
 
1444
 
  uint32_t flags2;
 
1547
  uint32 flags2;
1445
1548
  /* In connections sql_mode is 32 bits now but will be 64 bits soon */
1446
1549
  ulong sql_mode;
1447
1550
  ulong auto_increment_increment, auto_increment_offset;
1448
1551
  char charset[6];
1449
 
  uint32_t time_zone_len; /* 0 means uninited */
 
1552
  uint time_zone_len; /* 0 means uninited */
1450
1553
  const char *time_zone_str;
1451
 
  uint32_t lc_time_names_number; /* 0 means en_US */
1452
 
  uint32_t charset_database_number;
 
1554
  uint lc_time_names_number; /* 0 means en_US */
 
1555
  uint charset_database_number;
1453
1556
 
 
1557
#ifndef MYSQL_CLIENT
1454
1558
 
1455
1559
  Query_log_event(THD* thd_arg, const char* query_arg, ulong query_length,
1456
1560
                  bool using_trans, bool suppress_use,
1457
1561
                  THD::killed_state killed_err_arg= THD::KILLED_NO_VALUE);
1458
1562
  const char* get_db() { return db; }
 
1563
#ifdef HAVE_REPLICATION
1459
1564
  void pack_info(Protocol* protocol);
 
1565
#endif /* HAVE_REPLICATION */
 
1566
#else
 
1567
  void print_query_header(IO_CACHE* file, PRINT_EVENT_INFO* print_event_info);
 
1568
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
1569
#endif
1460
1570
 
1461
1571
  Query_log_event();
1462
 
  Query_log_event(const char* buf, uint32_t event_len,
 
1572
  Query_log_event(const char* buf, uint event_len,
1463
1573
                  const Format_description_log_event *description_event,
1464
1574
                  Log_event_type event_type);
1465
1575
  ~Query_log_event()
1466
1576
  {
1467
1577
    if (data_buf)
1468
 
      free((unsigned char*) data_buf);
 
1578
      my_free((uchar*) data_buf, MYF(0));
1469
1579
  }
1470
1580
  Log_event_type get_type_code() { return QUERY_EVENT; }
 
1581
#ifndef MYSQL_CLIENT
1471
1582
  bool write(IO_CACHE* file);
1472
 
  virtual bool write_post_header_for_derived(IO_CACHE* file __attribute__((unused)))
1473
 
  { return false; }
 
1583
  virtual bool write_post_header_for_derived(IO_CACHE* file) { return FALSE; }
 
1584
#endif
1474
1585
  bool is_valid() const { return query != 0; }
1475
1586
 
1476
1587
  /*
1481
1592
  /* Writes derived event-specific part of post header. */
1482
1593
 
1483
1594
public:        /* !!! Public in this patch to allow old usage */
 
1595
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
1484
1596
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
1485
1597
  virtual int do_apply_event(Relay_log_info const *rli);
1486
1598
  virtual int do_update_pos(Relay_log_info *rli);
1487
1599
 
1488
1600
  int do_apply_event(Relay_log_info const *rli,
1489
1601
                       const char *query_arg,
1490
 
                       uint32_t q_len_arg);
 
1602
                       uint32 q_len_arg);
 
1603
#endif /* HAVE_REPLICATION */
1491
1604
};
1492
1605
 
1493
1606
 
 
1607
#ifdef HAVE_REPLICATION
 
1608
 
1494
1609
/**
1495
1610
  @class Slave_log_event
1496
1611
 
1539
1654
  </tr>
1540
1655
  </table>
1541
1656
*/
1542
 
 
1543
1657
class Slave_log_event: public Log_event
1544
1658
{
1545
1659
protected:
1546
1660
  char* mem_pool;
1547
 
  void init_from_mem_pool();
 
1661
  void init_from_mem_pool(int data_size);
1548
1662
public:
1549
 
  off_t master_pos;
1550
 
  std::string master_host;
1551
 
  std::string master_log;
1552
 
  uint16_t master_port;
 
1663
  my_off_t master_pos;
 
1664
  char* master_host;
 
1665
  char* master_log;
 
1666
  int master_host_len;
 
1667
  int master_log_len;
 
1668
  uint16 master_port;
1553
1669
 
 
1670
#ifndef MYSQL_CLIENT
1554
1671
  Slave_log_event(THD* thd_arg, Relay_log_info* rli);
1555
1672
  void pack_info(Protocol* protocol);
 
1673
#else
 
1674
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
1675
#endif
1556
1676
 
1557
 
  Slave_log_event(const char* buf, uint32_t event_len);
 
1677
  Slave_log_event(const char* buf, uint event_len);
1558
1678
  ~Slave_log_event();
1559
1679
  int get_data_size();
1560
 
  bool is_valid() const { return master_host.length() != 0; }
 
1680
  bool is_valid() const { return master_host != 0; }
1561
1681
  Log_event_type get_type_code() { return SLAVE_EVENT; }
 
1682
#ifndef MYSQL_CLIENT
1562
1683
  bool write(IO_CACHE* file);
 
1684
#endif
1563
1685
 
1564
1686
private:
 
1687
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
1565
1688
  virtual int do_apply_event(Relay_log_info const* rli);
 
1689
#endif
1566
1690
};
1567
1691
 
 
1692
#endif /* HAVE_REPLICATION */
 
1693
 
1568
1694
 
1569
1695
/**
1570
1696
  @class Load_log_event
1576
1702
   (1)    USE db;
1577
1703
   (2)    LOAD DATA [LOCAL] INFILE 'file_name'
1578
1704
   (3)    [REPLACE | IGNORE]
1579
 
   (4)    INTO Table 'table_name'
 
1705
   (4)    INTO TABLE 'table_name'
1580
1706
   (5)    [FIELDS
1581
1707
   (6)      [TERMINATED BY 'field_term']
1582
1708
   (7)      [[OPTIONALLY] ENCLOSED BY 'enclosed']
1768
1894
class Load_log_event: public Log_event
1769
1895
{
1770
1896
private:
1771
 
  uint32_t get_query_buffer_length();
 
1897
  uint get_query_buffer_length();
1772
1898
  void print_query(bool need_db, char *buf, char **end,
1773
1899
                   char **fn_start, char **fn_end);
1774
1900
protected:
1779
1905
public:
1780
1906
  ulong thread_id;
1781
1907
  ulong slave_proxy_id;
1782
 
  uint32_t table_name_len;
 
1908
  uint32 table_name_len;
1783
1909
  /*
1784
1910
    No need to have a catalog, as these events can only come from 4.x.
1785
1911
    TODO: this may become false if Dmitri pushes his new LOAD DATA INFILE in
1786
1912
    5.0 only (not in 4.x).
1787
1913
  */
1788
 
  uint32_t db_len;
1789
 
  uint32_t fname_len;
1790
 
  uint32_t num_fields;
 
1914
  uint32 db_len;
 
1915
  uint32 fname_len;
 
1916
  uint32 num_fields;
1791
1917
  const char* fields;
1792
 
  const unsigned char* field_lens;
1793
 
  uint32_t field_block_len;
 
1918
  const uchar* field_lens;
 
1919
  uint32 field_block_len;
1794
1920
 
1795
1921
  const char* table_name;
1796
1922
  const char* db;
1797
1923
  const char* fname;
1798
 
  uint32_t skip_lines;
 
1924
  uint32 skip_lines;
1799
1925
  sql_ex_info sql_ex;
1800
1926
  bool local_fname;
1801
1927
 
1802
1928
  /* fname doesn't point to memory inside Log_event::temp_buf  */
1803
 
  void set_fname_outside_temp_buf(const char *afname, uint32_t alen)
 
1929
  void set_fname_outside_temp_buf(const char *afname, uint alen)
1804
1930
  {
1805
1931
    fname= afname;
1806
1932
    fname_len= alen;
1807
 
    local_fname= true;
 
1933
    local_fname= TRUE;
1808
1934
  }
1809
1935
  /* fname doesn't point to memory inside Log_event::temp_buf  */
1810
1936
  int  check_fname_outside_temp_buf()
1812
1938
    return local_fname;
1813
1939
  }
1814
1940
 
 
1941
#ifndef MYSQL_CLIENT
1815
1942
  String field_lens_buf;
1816
1943
  String fields_buf;
1817
1944
 
1822
1949
  void set_fields(const char* db, List<Item> &fields_arg,
1823
1950
                  Name_resolution_context *context);
1824
1951
  const char* get_db() { return db; }
 
1952
#ifdef HAVE_REPLICATION
1825
1953
  void pack_info(Protocol* protocol);
 
1954
#endif /* HAVE_REPLICATION */
 
1955
#else
 
1956
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
1957
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info, bool commented);
 
1958
#endif
1826
1959
 
1827
1960
  /*
1828
1961
    Note that for all the events related to LOAD DATA (Load_log_event,
1830
1963
    logging of LOAD DATA is going to be changed in 4.1 or 5.0, this is only used
1831
1964
    for the common_header_len (post_header_len will not be changed).
1832
1965
  */
1833
 
  Load_log_event(const char* buf, uint32_t event_len,
 
1966
  Load_log_event(const char* buf, uint event_len,
1834
1967
                 const Format_description_log_event* description_event);
1835
1968
  ~Load_log_event()
1836
1969
  {}
1838
1971
  {
1839
1972
    return sql_ex.new_format() ? NEW_LOAD_EVENT: LOAD_EVENT;
1840
1973
  }
 
1974
#ifndef MYSQL_CLIENT
1841
1975
  bool write_data_header(IO_CACHE* file);
1842
1976
  bool write_data_body(IO_CACHE* file);
 
1977
#endif
1843
1978
  bool is_valid() const { return table_name != 0; }
1844
1979
  int get_data_size()
1845
1980
  {
1849
1984
  }
1850
1985
 
1851
1986
public:        /* !!! Public in this patch to allow old usage */
 
1987
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
1852
1988
  virtual int do_apply_event(Relay_log_info const* rli)
1853
1989
  {
1854
1990
    return do_apply_event(thd->slave_net,rli,0);
1856
1992
 
1857
1993
  int do_apply_event(NET *net, Relay_log_info const *rli,
1858
1994
                     bool use_rli_only_for_errors);
 
1995
#endif
1859
1996
};
1860
1997
 
1861
1998
extern char server_version[SERVER_VERSION_LENGTH];
1901
2038
     fixed.
1902
2039
  */
1903
2040
  time_t created;
1904
 
  uint16_t binlog_version;
 
2041
  uint16 binlog_version;
1905
2042
  char server_version[ST_SERVER_VER_LEN];
1906
2043
  /*
1907
2044
    artifical_event is 1 in the case where this is a generated event that
1915
2052
  */
1916
2053
  bool dont_set_created;
1917
2054
 
 
2055
#ifndef MYSQL_CLIENT
1918
2056
  Start_log_event_v3();
 
2057
#ifdef HAVE_REPLICATION
1919
2058
  void pack_info(Protocol* protocol);
 
2059
#endif /* HAVE_REPLICATION */
 
2060
#else
 
2061
  Start_log_event_v3() {}
 
2062
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
2063
#endif
1920
2064
 
1921
2065
  Start_log_event_v3(const char* buf,
1922
2066
                     const Format_description_log_event* description_event);
1923
2067
  ~Start_log_event_v3() {}
1924
2068
  Log_event_type get_type_code() { return START_EVENT_V3;}
 
2069
#ifndef MYSQL_CLIENT
1925
2070
  bool write(IO_CACHE* file);
 
2071
#endif
1926
2072
  bool is_valid() const { return 1; }
1927
2073
  int get_data_size()
1928
2074
  {
1931
2077
  virtual bool is_artificial_event() { return artificial_event; }
1932
2078
 
1933
2079
protected:
 
2080
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
1934
2081
  virtual int do_apply_event(Relay_log_info const *rli);
1935
2082
  virtual enum_skip_reason do_shall_skip(Relay_log_info*)
1936
2083
  {
1943
2090
    else
1944
2091
      return Log_event::EVENT_SKIP_NOT;
1945
2092
  }
 
2093
#endif
1946
2094
};
1947
2095
 
1948
2096
 
1965
2113
     LOG_EVENT_HEADER_LEN), except FORMAT_DESCRIPTION_EVENT and ROTATE_EVENT
1966
2114
     (those have a header of size LOG_EVENT_MINIMAL_HEADER_LEN).
1967
2115
  */
1968
 
  uint8_t common_header_len;
1969
 
  uint8_t number_of_event_types;
 
2116
  uint8 common_header_len;
 
2117
  uint8 number_of_event_types;
1970
2118
  /* The list of post-headers' lengthes */
1971
 
  uint8_t *post_header_len;
1972
 
  unsigned char server_version_split[3];
1973
 
  const uint8_t *event_type_permutation;
 
2119
  uint8 *post_header_len;
 
2120
  uchar server_version_split[3];
 
2121
  const uint8 *event_type_permutation;
1974
2122
 
1975
 
  Format_description_log_event(uint8_t binlog_ver, const char* server_ver=0);
1976
 
  Format_description_log_event(const char* buf, uint32_t event_len,
 
2123
  Format_description_log_event(uint8 binlog_ver, const char* server_ver=0);
 
2124
  Format_description_log_event(const char* buf, uint event_len,
1977
2125
                               const Format_description_log_event
1978
2126
                               *description_event);
1979
2127
  ~Format_description_log_event()
1980
2128
  {
1981
 
    free((unsigned char*)post_header_len);
 
2129
    my_free((uchar*)post_header_len, MYF(MY_ALLOW_ZERO_PTR));
1982
2130
  }
1983
2131
  Log_event_type get_type_code() { return FORMAT_DESCRIPTION_EVENT;}
 
2132
#ifndef MYSQL_CLIENT
1984
2133
  bool write(IO_CACHE* file);
 
2134
#endif
1985
2135
  bool is_valid() const
1986
2136
  {
1987
2137
    return ((common_header_len >= ((binlog_version==1) ? OLD_HEADER_LEN :
2001
2151
  void calc_server_version_split();
2002
2152
 
2003
2153
protected:
 
2154
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2004
2155
  virtual int do_apply_event(Relay_log_info const *rli);
2005
2156
  virtual int do_update_pos(Relay_log_info *rli);
2006
2157
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
 
2158
#endif
2007
2159
};
2008
2160
 
2009
2161
 
2047
2199
class Intvar_log_event: public Log_event
2048
2200
{
2049
2201
public:
2050
 
  uint64_t val;
2051
 
  unsigned char type;
 
2202
  ulonglong val;
 
2203
  uchar type;
2052
2204
 
2053
 
  Intvar_log_event(THD* thd_arg,unsigned char type_arg, uint64_t val_arg)
 
2205
#ifndef MYSQL_CLIENT
 
2206
  Intvar_log_event(THD* thd_arg,uchar type_arg, ulonglong val_arg)
2054
2207
    :Log_event(thd_arg,0,0),val(val_arg),type(type_arg)
2055
2208
  {}
 
2209
#ifdef HAVE_REPLICATION
2056
2210
  void pack_info(Protocol* protocol);
 
2211
#endif /* HAVE_REPLICATION */
 
2212
#else
 
2213
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
2214
#endif
2057
2215
 
2058
2216
  Intvar_log_event(const char* buf,
2059
2217
                   const Format_description_log_event *description_event);
2061
2219
  Log_event_type get_type_code() { return INTVAR_EVENT;}
2062
2220
  const char* get_var_type_name();
2063
2221
  int get_data_size() { return  9; /* sizeof(type) + sizeof(val) */;}
 
2222
#ifndef MYSQL_CLIENT
2064
2223
  bool write(IO_CACHE* file);
 
2224
#endif
2065
2225
  bool is_valid() const { return 1; }
2066
2226
 
2067
2227
private:
 
2228
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2068
2229
  virtual int do_apply_event(Relay_log_info const *rli);
2069
2230
  virtual int do_update_pos(Relay_log_info *rli);
2070
2231
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
 
2232
#endif
2071
2233
};
2072
2234
 
2073
2235
 
2112
2274
class Rand_log_event: public Log_event
2113
2275
{
2114
2276
 public:
2115
 
  uint64_t seed1;
2116
 
  uint64_t seed2;
 
2277
  ulonglong seed1;
 
2278
  ulonglong seed2;
2117
2279
 
2118
 
  Rand_log_event(THD* thd_arg, uint64_t seed1_arg, uint64_t seed2_arg)
 
2280
#ifndef MYSQL_CLIENT
 
2281
  Rand_log_event(THD* thd_arg, ulonglong seed1_arg, ulonglong seed2_arg)
2119
2282
    :Log_event(thd_arg,0,0),seed1(seed1_arg),seed2(seed2_arg)
2120
2283
  {}
 
2284
#ifdef HAVE_REPLICATION
2121
2285
  void pack_info(Protocol* protocol);
 
2286
#endif /* HAVE_REPLICATION */
 
2287
#else
 
2288
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
2289
#endif
2122
2290
 
2123
2291
  Rand_log_event(const char* buf,
2124
2292
                 const Format_description_log_event *description_event);
2125
2293
  ~Rand_log_event() {}
2126
2294
  Log_event_type get_type_code() { return RAND_EVENT;}
2127
 
  int get_data_size() { return 16; /* sizeof(uint64_t) * 2*/ }
 
2295
  int get_data_size() { return 16; /* sizeof(ulonglong) * 2*/ }
 
2296
#ifndef MYSQL_CLIENT
2128
2297
  bool write(IO_CACHE* file);
 
2298
#endif
2129
2299
  bool is_valid() const { return 1; }
2130
2300
 
2131
2301
private:
 
2302
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2132
2303
  virtual int do_apply_event(Relay_log_info const *rli);
2133
2304
  virtual int do_update_pos(Relay_log_info *rli);
2134
2305
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
 
2306
#endif
2135
2307
};
2136
2308
 
2137
2309
/**
2142
2314
 
2143
2315
  @section Xid_log_event_binary_format Binary Format  
2144
2316
*/
 
2317
#ifdef MYSQL_CLIENT
 
2318
typedef ulonglong my_xid; // this line is the same as in handler.h
 
2319
#endif
 
2320
 
2145
2321
class Xid_log_event: public Log_event
2146
2322
{
2147
2323
 public:
2148
2324
   my_xid xid;
2149
2325
 
 
2326
#ifndef MYSQL_CLIENT
2150
2327
  Xid_log_event(THD* thd_arg, my_xid x): Log_event(thd_arg,0,0), xid(x) {}
 
2328
#ifdef HAVE_REPLICATION
2151
2329
  void pack_info(Protocol* protocol);
 
2330
#endif /* HAVE_REPLICATION */
 
2331
#else
 
2332
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
2333
#endif
2152
2334
 
2153
2335
  Xid_log_event(const char* buf,
2154
2336
                const Format_description_log_event *description_event);
2155
2337
  ~Xid_log_event() {}
2156
2338
  Log_event_type get_type_code() { return XID_EVENT;}
2157
2339
  int get_data_size() { return sizeof(xid); }
 
2340
#ifndef MYSQL_CLIENT
2158
2341
  bool write(IO_CACHE* file);
 
2342
#endif
2159
2343
  bool is_valid() const { return 1; }
2160
2344
 
2161
2345
private:
 
2346
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2162
2347
  virtual int do_apply_event(Relay_log_info const *rli);
2163
2348
  enum_skip_reason do_shall_skip(Relay_log_info *rli);
 
2349
#endif
2164
2350
};
2165
2351
 
2166
2352
/**
2176
2362
{
2177
2363
public:
2178
2364
  char *name;
2179
 
  uint32_t name_len;
 
2365
  uint name_len;
2180
2366
  char *val;
2181
2367
  ulong val_len;
2182
2368
  Item_result type;
2183
 
  uint32_t charset_number;
 
2369
  uint charset_number;
2184
2370
  bool is_null;
2185
 
  User_var_log_event(THD* thd_arg __attribute__((unused)),
2186
 
                     char *name_arg, uint32_t name_len_arg,
 
2371
#ifndef MYSQL_CLIENT
 
2372
  User_var_log_event(THD* thd_arg, char *name_arg, uint name_len_arg,
2187
2373
                     char *val_arg, ulong val_len_arg, Item_result type_arg,
2188
 
                     uint32_t charset_number_arg)
 
2374
                     uint charset_number_arg)
2189
2375
    :Log_event(), name(name_arg), name_len(name_len_arg), val(val_arg),
2190
2376
    val_len(val_len_arg), type(type_arg), charset_number(charset_number_arg)
2191
2377
    { is_null= !val; }
2192
2378
  void pack_info(Protocol* protocol);
 
2379
#else
 
2380
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
2381
#endif
2193
2382
 
2194
2383
  User_var_log_event(const char* buf,
2195
2384
                     const Format_description_log_event *description_event);
2196
2385
  ~User_var_log_event() {}
2197
2386
  Log_event_type get_type_code() { return USER_VAR_EVENT;}
 
2387
#ifndef MYSQL_CLIENT
2198
2388
  bool write(IO_CACHE* file);
 
2389
#endif
2199
2390
  bool is_valid() const { return 1; }
2200
2391
 
2201
2392
private:
 
2393
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2202
2394
  virtual int do_apply_event(Relay_log_info const *rli);
2203
2395
  virtual int do_update_pos(Relay_log_info *rli);
2204
2396
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
 
2397
#endif
2205
2398
};
2206
2399
 
2207
2400
 
2216
2409
class Stop_log_event: public Log_event
2217
2410
{
2218
2411
public:
 
2412
#ifndef MYSQL_CLIENT
2219
2413
  Stop_log_event() :Log_event()
2220
2414
  {}
 
2415
#else
 
2416
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
2417
#endif
2221
2418
 
2222
2419
  Stop_log_event(const char* buf,
2223
2420
                 const Format_description_log_event *description_event):
2228
2425
  bool is_valid() const { return 1; }
2229
2426
 
2230
2427
private:
 
2428
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2231
2429
  virtual int do_update_pos(Relay_log_info *rli);
2232
 
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli __attribute__((unused)))
 
2430
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli)
2233
2431
  {
2234
2432
    /*
2235
2433
      Events from ourself should be skipped, but they should not
2240
2438
    else
2241
2439
      return Log_event::EVENT_SKIP_NOT;
2242
2440
  }
 
2441
#endif
2243
2442
};
2244
2443
 
2245
2444
/**
2298
2497
    DUP_NAME= 2 // if constructor should dup the string argument
2299
2498
  };
2300
2499
  const char* new_log_ident;
2301
 
  uint64_t pos;
2302
 
  uint32_t ident_len;
2303
 
  uint32_t flags;
 
2500
  ulonglong pos;
 
2501
  uint ident_len;
 
2502
  uint flags;
 
2503
#ifndef MYSQL_CLIENT
2304
2504
  Rotate_log_event(const char* new_log_ident_arg,
2305
 
                   uint32_t ident_len_arg,
2306
 
                   uint64_t pos_arg, uint32_t flags);
 
2505
                   uint ident_len_arg,
 
2506
                   ulonglong pos_arg, uint flags);
 
2507
#ifdef HAVE_REPLICATION
2307
2508
  void pack_info(Protocol* protocol);
 
2509
#endif /* HAVE_REPLICATION */
 
2510
#else
 
2511
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
2512
#endif
2308
2513
 
2309
 
  Rotate_log_event(const char* buf, uint32_t event_len,
 
2514
  Rotate_log_event(const char* buf, uint event_len,
2310
2515
                   const Format_description_log_event* description_event);
2311
2516
  ~Rotate_log_event()
2312
2517
  {
2313
2518
    if (flags & DUP_NAME)
2314
 
      free((unsigned char*) new_log_ident);
 
2519
      my_free((uchar*) new_log_ident, MYF(MY_ALLOW_ZERO_PTR));
2315
2520
  }
2316
2521
  Log_event_type get_type_code() { return ROTATE_EVENT;}
2317
2522
  int get_data_size() { return  ident_len + ROTATE_HEADER_LEN;}
2318
2523
  bool is_valid() const { return new_log_ident != 0; }
 
2524
#ifndef MYSQL_CLIENT
2319
2525
  bool write(IO_CACHE* file);
 
2526
#endif
2320
2527
 
2321
2528
private:
 
2529
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2322
2530
  virtual int do_update_pos(Relay_log_info *rli);
2323
2531
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
 
2532
#endif
2324
2533
};
2325
2534
 
2326
2535
 
2342
2551
  */
2343
2552
  bool fake_base;
2344
2553
public:
2345
 
  unsigned char* block;
 
2554
  uchar* block;
2346
2555
  const char *event_buf;
2347
 
  uint32_t block_len;
2348
 
  uint32_t file_id;
 
2556
  uint block_len;
 
2557
  uint file_id;
2349
2558
  bool inited_from_old;
2350
2559
 
 
2560
#ifndef MYSQL_CLIENT
2351
2561
  Create_file_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
2352
2562
                        const char* table_name_arg,
2353
2563
                        List<Item>& fields_arg,
2354
2564
                        enum enum_duplicates handle_dup, bool ignore,
2355
 
                        unsigned char* block_arg, uint32_t block_len_arg,
 
2565
                        uchar* block_arg, uint block_len_arg,
2356
2566
                        bool using_trans);
 
2567
#ifdef HAVE_REPLICATION
2357
2568
  void pack_info(Protocol* protocol);
 
2569
#endif /* HAVE_REPLICATION */
 
2570
#else
 
2571
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
2572
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info,
 
2573
             bool enable_local);
 
2574
#endif
2358
2575
 
2359
 
  Create_file_log_event(const char* buf, uint32_t event_len,
 
2576
  Create_file_log_event(const char* buf, uint event_len,
2360
2577
                        const Format_description_log_event* description_event);
2361
2578
  ~Create_file_log_event()
2362
2579
  {
2363
 
    free((char*) event_buf);
 
2580
    my_free((char*) event_buf, MYF(MY_ALLOW_ZERO_PTR));
2364
2581
  }
2365
2582
 
2366
2583
  Log_event_type get_type_code()
2374
2591
            4 + 1 + block_len);
2375
2592
  }
2376
2593
  bool is_valid() const { return inited_from_old || block != 0; }
 
2594
#ifndef MYSQL_CLIENT
2377
2595
  bool write_data_header(IO_CACHE* file);
2378
2596
  bool write_data_body(IO_CACHE* file);
2379
2597
  /*
2381
2599
    write it as Load event - used on the slave
2382
2600
  */
2383
2601
  bool write_base(IO_CACHE* file);
 
2602
#endif
2384
2603
 
2385
2604
private:
 
2605
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2386
2606
  virtual int do_apply_event(Relay_log_info const *rli);
 
2607
#endif
2387
2608
};
2388
2609
 
2389
2610
 
2396
2617
class Append_block_log_event: public Log_event
2397
2618
{
2398
2619
public:
2399
 
  unsigned char* block;
2400
 
  uint32_t block_len;
2401
 
  uint32_t file_id;
 
2620
  uchar* block;
 
2621
  uint block_len;
 
2622
  uint file_id;
2402
2623
  /*
2403
2624
    'db' is filled when the event is created in mysql_load() (the
2404
2625
    event needs to have a 'db' member to be well filtered by
2412
2633
  */
2413
2634
  const char* db;
2414
2635
 
2415
 
  Append_block_log_event(THD* thd, const char* db_arg, unsigned char* block_arg,
2416
 
                         uint32_t block_len_arg, bool using_trans);
 
2636
#ifndef MYSQL_CLIENT
 
2637
  Append_block_log_event(THD* thd, const char* db_arg, uchar* block_arg,
 
2638
                         uint block_len_arg, bool using_trans);
 
2639
#ifdef HAVE_REPLICATION
2417
2640
  void pack_info(Protocol* protocol);
2418
2641
  virtual int get_create_or_append() const;
 
2642
#endif /* HAVE_REPLICATION */
 
2643
#else
 
2644
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
2645
#endif
2419
2646
 
2420
 
  Append_block_log_event(const char* buf, uint32_t event_len,
 
2647
  Append_block_log_event(const char* buf, uint event_len,
2421
2648
                         const Format_description_log_event
2422
2649
                         *description_event);
2423
2650
  ~Append_block_log_event() {}
2424
2651
  Log_event_type get_type_code() { return APPEND_BLOCK_EVENT;}
2425
2652
  int get_data_size() { return  block_len + APPEND_BLOCK_HEADER_LEN ;}
2426
2653
  bool is_valid() const { return block != 0; }
 
2654
#ifndef MYSQL_CLIENT
2427
2655
  bool write(IO_CACHE* file);
2428
2656
  const char* get_db() { return db; }
 
2657
#endif
2429
2658
 
2430
2659
private:
 
2660
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2431
2661
  virtual int do_apply_event(Relay_log_info const *rli);
 
2662
#endif
2432
2663
};
2433
2664
 
2434
2665
 
2441
2672
class Delete_file_log_event: public Log_event
2442
2673
{
2443
2674
public:
2444
 
  uint32_t file_id;
 
2675
  uint file_id;
2445
2676
  const char* db; /* see comment in Append_block_log_event */
2446
2677
 
 
2678
#ifndef MYSQL_CLIENT
2447
2679
  Delete_file_log_event(THD* thd, const char* db_arg, bool using_trans);
 
2680
#ifdef HAVE_REPLICATION
2448
2681
  void pack_info(Protocol* protocol);
 
2682
#endif /* HAVE_REPLICATION */
 
2683
#else
 
2684
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
2685
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info,
 
2686
             bool enable_local);
 
2687
#endif
2449
2688
 
2450
 
  Delete_file_log_event(const char* buf, uint32_t event_len,
 
2689
  Delete_file_log_event(const char* buf, uint event_len,
2451
2690
                        const Format_description_log_event* description_event);
2452
2691
  ~Delete_file_log_event() {}
2453
2692
  Log_event_type get_type_code() { return DELETE_FILE_EVENT;}
2454
2693
  int get_data_size() { return DELETE_FILE_HEADER_LEN ;}
2455
2694
  bool is_valid() const { return file_id != 0; }
 
2695
#ifndef MYSQL_CLIENT
2456
2696
  bool write(IO_CACHE* file);
2457
2697
  const char* get_db() { return db; }
 
2698
#endif
2458
2699
 
2459
2700
private:
 
2701
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2460
2702
  virtual int do_apply_event(Relay_log_info const *rli);
 
2703
#endif
2461
2704
};
2462
2705
 
2463
2706
 
2470
2713
class Execute_load_log_event: public Log_event
2471
2714
{
2472
2715
public:
2473
 
  uint32_t file_id;
 
2716
  uint file_id;
2474
2717
  const char* db; /* see comment in Append_block_log_event */
2475
2718
 
 
2719
#ifndef MYSQL_CLIENT
2476
2720
  Execute_load_log_event(THD* thd, const char* db_arg, bool using_trans);
 
2721
#ifdef HAVE_REPLICATION
2477
2722
  void pack_info(Protocol* protocol);
 
2723
#endif /* HAVE_REPLICATION */
 
2724
#else
 
2725
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
2726
#endif
2478
2727
 
2479
 
  Execute_load_log_event(const char* buf, uint32_t event_len,
 
2728
  Execute_load_log_event(const char* buf, uint event_len,
2480
2729
                         const Format_description_log_event
2481
2730
                         *description_event);
2482
2731
  ~Execute_load_log_event() {}
2483
2732
  Log_event_type get_type_code() { return EXEC_LOAD_EVENT;}
2484
2733
  int get_data_size() { return  EXEC_LOAD_HEADER_LEN ;}
2485
2734
  bool is_valid() const { return file_id != 0; }
 
2735
#ifndef MYSQL_CLIENT
2486
2736
  bool write(IO_CACHE* file);
2487
2737
  const char* get_db() { return db; }
 
2738
#endif
2488
2739
 
2489
2740
private:
 
2741
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2490
2742
  virtual int do_apply_event(Relay_log_info const *rli);
 
2743
#endif
2491
2744
};
2492
2745
 
2493
2746
 
2503
2756
class Begin_load_query_log_event: public Append_block_log_event
2504
2757
{
2505
2758
public:
 
2759
#ifndef MYSQL_CLIENT
2506
2760
  Begin_load_query_log_event(THD* thd_arg, const char *db_arg,
2507
 
                             unsigned char* block_arg, uint32_t block_len_arg,
 
2761
                             uchar* block_arg, uint block_len_arg,
2508
2762
                             bool using_trans);
 
2763
#ifdef HAVE_REPLICATION
2509
2764
  Begin_load_query_log_event(THD* thd);
2510
2765
  int get_create_or_append() const;
2511
 
  Begin_load_query_log_event(const char* buf, uint32_t event_len,
 
2766
#endif /* HAVE_REPLICATION */
 
2767
#endif
 
2768
  Begin_load_query_log_event(const char* buf, uint event_len,
2512
2769
                             const Format_description_log_event
2513
2770
                             *description_event);
2514
2771
  ~Begin_load_query_log_event() {}
2515
2772
  Log_event_type get_type_code() { return BEGIN_LOAD_QUERY_EVENT; }
2516
2773
private:
 
2774
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2517
2775
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
 
2776
#endif
2518
2777
};
2519
2778
 
2520
2779
 
2536
2795
class Execute_load_query_log_event: public Query_log_event
2537
2796
{
2538
2797
public:
2539
 
  uint32_t file_id;       // file_id of temporary file
2540
 
  uint32_t fn_pos_start;  // pointer to the part of the query that should
 
2798
  uint file_id;       // file_id of temporary file
 
2799
  uint fn_pos_start;  // pointer to the part of the query that should
2541
2800
                      // be substituted
2542
 
  uint32_t fn_pos_end;    // pointer to the end of this part of query
 
2801
  uint fn_pos_end;    // pointer to the end of this part of query
2543
2802
  /*
2544
2803
    We have to store type of duplicate handling explicitly, because
2545
2804
    for LOAD DATA it also depends on LOCAL option. And this part
2548
2807
  */
2549
2808
  enum_load_dup_handling dup_handling;
2550
2809
 
 
2810
#ifndef MYSQL_CLIENT
2551
2811
  Execute_load_query_log_event(THD* thd, const char* query_arg,
2552
 
                               ulong query_length, uint32_t fn_pos_start_arg,
2553
 
                               uint32_t fn_pos_end_arg,
 
2812
                               ulong query_length, uint fn_pos_start_arg,
 
2813
                               uint fn_pos_end_arg,
2554
2814
                               enum_load_dup_handling dup_handling_arg,
2555
2815
                               bool using_trans, bool suppress_use,
2556
2816
                               THD::killed_state
2557
2817
                               killed_err_arg= THD::KILLED_NO_VALUE);
 
2818
#ifdef HAVE_REPLICATION
2558
2819
  void pack_info(Protocol* protocol);
2559
 
  Execute_load_query_log_event(const char* buf, uint32_t event_len,
 
2820
#endif /* HAVE_REPLICATION */
 
2821
#else
 
2822
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
2823
  /* Prints the query as LOAD DATA LOCAL and with rewritten filename */
 
2824
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info,
 
2825
             const char *local_fname);
 
2826
#endif
 
2827
  Execute_load_query_log_event(const char* buf, uint event_len,
2560
2828
                               const Format_description_log_event
2561
2829
                               *description_event);
2562
2830
  ~Execute_load_query_log_event() {}
2565
2833
  bool is_valid() const { return Query_log_event::is_valid() && file_id != 0; }
2566
2834
 
2567
2835
  ulong get_post_header_size_for_derived();
 
2836
#ifndef MYSQL_CLIENT
2568
2837
  bool write_post_header_for_derived(IO_CACHE* file);
 
2838
#endif
2569
2839
 
2570
2840
private:
 
2841
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2571
2842
  virtual int do_apply_event(Relay_log_info const *rli);
2572
 
};
2573
 
 
2574
 
 
2575
 
char *str_to_hex(char *to, const char *from, uint32_t len);
 
2843
#endif
 
2844
};
 
2845
 
 
2846
 
 
2847
#ifdef MYSQL_CLIENT
 
2848
/**
 
2849
  @class Unknown_log_event
 
2850
 
 
2851
  @section Unknown_log_event_binary_format Binary Format
 
2852
*/
 
2853
class Unknown_log_event: public Log_event
 
2854
{
 
2855
public:
 
2856
  /*
 
2857
    Even if this is an unknown event, we still pass description_event to
 
2858
    Log_event's ctor, this way we can extract maximum information from the
 
2859
    event's header (the unique ID for example).
 
2860
  */
 
2861
  Unknown_log_event(const char* buf,
 
2862
                    const Format_description_log_event *description_event):
 
2863
    Log_event(buf, description_event)
 
2864
  {}
 
2865
  ~Unknown_log_event() {}
 
2866
  void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 
2867
  Log_event_type get_type_code() { return UNKNOWN_EVENT;}
 
2868
  bool is_valid() const { return 1; }
 
2869
};
 
2870
#endif
 
2871
char *str_to_hex(char *to, const char *from, uint len);
2576
2872
 
2577
2873
/**
2578
2874
  @class Table_map_log_event
2701
2997
  </tr>
2702
2998
 
2703
2999
  <tr>
2704
 
    <td>DRIZZLE_TYPE_TINY</td><td>1</td>
2705
 
    <td>0</td>
2706
 
    <td>No column metadata.</td>
2707
 
  </tr>
2708
 
 
2709
 
  <tr>
2710
 
    <td>DRIZZLE_TYPE_SHORT</td><td>2</td>
2711
 
    <td>0</td>
2712
 
    <td>No column metadata.</td>
2713
 
  </tr>
2714
 
 
2715
 
  <tr>
2716
 
    <td>DRIZZLE_TYPE_LONG</td><td>3</td>
2717
 
    <td>0</td>
2718
 
    <td>No column metadata.</td>
2719
 
  </tr>
2720
 
 
2721
 
  <tr>
2722
 
    <td>DRIZZLE_TYPE_DOUBLE</td><td>5</td>
 
3000
    <td>MYSQL_TYPE_DECIMAL</td><td>0</td>
 
3001
    <td>0</td>
 
3002
    <td>No column metadata.</td>
 
3003
  </tr>
 
3004
 
 
3005
  <tr>
 
3006
    <td>MYSQL_TYPE_TINY</td><td>1</td>
 
3007
    <td>0</td>
 
3008
    <td>No column metadata.</td>
 
3009
  </tr>
 
3010
 
 
3011
  <tr>
 
3012
    <td>MYSQL_TYPE_SHORT</td><td>2</td>
 
3013
    <td>0</td>
 
3014
    <td>No column metadata.</td>
 
3015
  </tr>
 
3016
 
 
3017
  <tr>
 
3018
    <td>MYSQL_TYPE_LONG</td><td>3</td>
 
3019
    <td>0</td>
 
3020
    <td>No column metadata.</td>
 
3021
  </tr>
 
3022
 
 
3023
  <tr>
 
3024
    <td>MYSQL_TYPE_FLOAT</td><td>4</td>
 
3025
    <td>1 byte</td>
 
3026
    <td>1 byte unsigned integer, representing the "pack_length", which
 
3027
    is equal to sizeof(float) on the server from which the event
 
3028
    originates.</td>
 
3029
  </tr>
 
3030
 
 
3031
  <tr>
 
3032
    <td>MYSQL_TYPE_DOUBLE</td><td>5</td>
2723
3033
    <td>1 byte</td>
2724
3034
    <td>1 byte unsigned integer, representing the "pack_length", which
2725
3035
    is equal to sizeof(double) on the server from which the event
2727
3037
  </tr>
2728
3038
 
2729
3039
  <tr>
2730
 
    <td>DRIZZLE_TYPE_NULL</td><td>6</td>
2731
 
    <td>0</td>
2732
 
    <td>No column metadata.</td>
2733
 
  </tr>
2734
 
 
2735
 
  <tr>
2736
 
    <td>DRIZZLE_TYPE_TIMESTAMP</td><td>7</td>
2737
 
    <td>0</td>
2738
 
    <td>No column metadata.</td>
2739
 
  </tr>
2740
 
 
2741
 
  <tr>
2742
 
    <td>DRIZZLE_TYPE_LONGLONG</td><td>8</td>
2743
 
    <td>0</td>
2744
 
    <td>No column metadata.</td>
2745
 
  </tr>
2746
 
 
2747
 
  <tr>
2748
 
    <td>DRIZZLE_TYPE_DATE</td><td>10</td>
2749
 
    <td>0</td>
2750
 
    <td>No column metadata.</td>
2751
 
  </tr>
2752
 
 
2753
 
  <tr>
2754
 
    <td>DRIZZLE_TYPE_TIME</td><td>11</td>
2755
 
    <td>0</td>
2756
 
    <td>No column metadata.</td>
2757
 
  </tr>
2758
 
 
2759
 
  <tr>
2760
 
    <td>DRIZZLE_TYPE_DATETIME</td><td>12</td>
2761
 
    <td>0</td>
2762
 
    <td>No column metadata.</td>
2763
 
  </tr>
2764
 
 
2765
 
  <tr>
2766
 
    <td>DRIZZLE_TYPE_YEAR</td><td>13</td>
2767
 
    <td>0</td>
2768
 
    <td>No column metadata.</td>
2769
 
  </tr>
2770
 
 
2771
 
  <tr>
2772
 
    <td><i>DRIZZLE_TYPE_NEWDATE</i></td><td><i>14</i></td>
 
3040
    <td>MYSQL_TYPE_NULL</td><td>6</td>
 
3041
    <td>0</td>
 
3042
    <td>No column metadata.</td>
 
3043
  </tr>
 
3044
 
 
3045
  <tr>
 
3046
    <td>MYSQL_TYPE_TIMESTAMP</td><td>7</td>
 
3047
    <td>0</td>
 
3048
    <td>No column metadata.</td>
 
3049
  </tr>
 
3050
 
 
3051
  <tr>
 
3052
    <td>MYSQL_TYPE_LONGLONG</td><td>8</td>
 
3053
    <td>0</td>
 
3054
    <td>No column metadata.</td>
 
3055
  </tr>
 
3056
 
 
3057
  <tr>
 
3058
    <td>MYSQL_TYPE_INT24</td><td>9</td>
 
3059
    <td>0</td>
 
3060
    <td>No column metadata.</td>
 
3061
  </tr>
 
3062
 
 
3063
  <tr>
 
3064
    <td>MYSQL_TYPE_DATE</td><td>10</td>
 
3065
    <td>0</td>
 
3066
    <td>No column metadata.</td>
 
3067
  </tr>
 
3068
 
 
3069
  <tr>
 
3070
    <td>MYSQL_TYPE_TIME</td><td>11</td>
 
3071
    <td>0</td>
 
3072
    <td>No column metadata.</td>
 
3073
  </tr>
 
3074
 
 
3075
  <tr>
 
3076
    <td>MYSQL_TYPE_DATETIME</td><td>12</td>
 
3077
    <td>0</td>
 
3078
    <td>No column metadata.</td>
 
3079
  </tr>
 
3080
 
 
3081
  <tr>
 
3082
    <td>MYSQL_TYPE_YEAR</td><td>13</td>
 
3083
    <td>0</td>
 
3084
    <td>No column metadata.</td>
 
3085
  </tr>
 
3086
 
 
3087
  <tr>
 
3088
    <td><i>MYSQL_TYPE_NEWDATE</i></td><td><i>14</i></td>
2773
3089
    <td>&ndash;</td>
2774
3090
    <td><i>This enumeration value is only used internally and cannot
2775
3091
    exist in a binlog.</i></td>
2776
3092
  </tr>
2777
3093
 
2778
3094
  <tr>
2779
 
    <td>DRIZZLE_TYPE_VARCHAR</td><td>15</td>
 
3095
    <td>MYSQL_TYPE_VARCHAR</td><td>15</td>
2780
3096
    <td>2 bytes</td>
2781
3097
    <td>2 byte unsigned integer representing the maximum length of
2782
3098
    the string.</td>
2783
3099
  </tr>
2784
3100
 
2785
3101
  <tr>
2786
 
    <td>DRIZZLE_TYPE_NEWDECIMAL</td><td>246</td>
 
3102
    <td>MYSQL_TYPE_BIT</td><td>16</td>
 
3103
    <td>2 bytes</td>
 
3104
    <td>A 1 byte unsigned int representing the length in bits of the
 
3105
    bitfield (0 to 64), followed by a 1 byte unsigned int
 
3106
    representing the number of bytes occupied by the bitfield.  The
 
3107
    number of bytes is either int((length+7)/8) or int(length/8).</td>
 
3108
  </tr>
 
3109
 
 
3110
  <tr>
 
3111
    <td>MYSQL_TYPE_NEWDECIMAL</td><td>246</td>
2787
3112
    <td>2 bytes</td>
2788
3113
    <td>A 1 byte unsigned int representing the precision, followed
2789
3114
    by a 1 byte unsigned int representing the number of decimals.</td>
2790
3115
  </tr>
2791
3116
 
2792
3117
  <tr>
2793
 
    <td><i>DRIZZLE_TYPE_ENUM</i></td><td><i>247</i></td>
2794
 
    <td>&ndash;</td>
2795
 
    <td><i>This enumeration value is only used internally and cannot
2796
 
    exist in a binlog.</i></td>
2797
 
  </tr>
2798
 
 
2799
 
  <tr>
2800
 
    <td><i>DRIZZLE_TYPE_SET</i></td><td><i>248</i></td>
2801
 
    <td>&ndash;</td>
2802
 
    <td><i>This enumeration value is only used internally and cannot
2803
 
    exist in a binlog.</i></td>
2804
 
  </tr>
2805
 
 
2806
 
  <tr>
2807
 
    <td>DRIZZLE_TYPE_BLOB</td><td>252</td>
 
3118
    <td><i>MYSQL_TYPE_ENUM</i></td><td><i>247</i></td>
 
3119
    <td>&ndash;</td>
 
3120
    <td><i>This enumeration value is only used internally and cannot
 
3121
    exist in a binlog.</i></td>
 
3122
  </tr>
 
3123
 
 
3124
  <tr>
 
3125
    <td><i>MYSQL_TYPE_SET</i></td><td><i>248</i></td>
 
3126
    <td>&ndash;</td>
 
3127
    <td><i>This enumeration value is only used internally and cannot
 
3128
    exist in a binlog.</i></td>
 
3129
  </tr>
 
3130
 
 
3131
  <tr>
 
3132
    <td>MYSQL_TYPE_TINY_BLOB</td><td>249</td>
 
3133
    <td>&ndash;</td>
 
3134
    <td><i>This enumeration value is only used internally and cannot
 
3135
    exist in a binlog.</i></td>
 
3136
  </tr>
 
3137
 
 
3138
  <tr>
 
3139
    <td><i>MYSQL_TYPE_MEDIUM_BLOB</i></td><td><i>250</i></td>
 
3140
    <td>&ndash;</td>
 
3141
    <td><i>This enumeration value is only used internally and cannot
 
3142
    exist in a binlog.</i></td>
 
3143
  </tr>
 
3144
 
 
3145
  <tr>
 
3146
    <td><i>MYSQL_TYPE_LONG_BLOB</i></td><td><i>251</i></td>
 
3147
    <td>&ndash;</td>
 
3148
    <td><i>This enumeration value is only used internally and cannot
 
3149
    exist in a binlog.</i></td>
 
3150
  </tr>
 
3151
 
 
3152
  <tr>
 
3153
    <td>MYSQL_TYPE_BLOB</td><td>252</td>
2808
3154
    <td>1 byte</td>
2809
3155
    <td>The pack length, i.e., the number of bytes needed to represent
2810
3156
    the length of the blob: 1, 2, 3, or 4.</td>
2811
3157
  </tr>
2812
3158
 
2813
3159
  <tr>
2814
 
    <td>DRIZZLE_TYPE_STRING</td><td>254</td>
2815
 
    <td>2 bytes</td>
2816
 
    <td>The first byte is always DRIZZLE_TYPE_VAR_STRING (i.e., 253).
 
3160
    <td>MYSQL_TYPE_VAR_STRING</td><td>253</td>
 
3161
    <td>2 bytes</td>
 
3162
    <td>This is used to store both strings and enumeration values.
 
3163
    The first byte is a enumeration value storing the <i>real
 
3164
    type</i>, which may be either MYSQL_TYPE_VAR_STRING or
 
3165
    MYSQL_TYPE_ENUM.  The second byte is a 1 byte unsigned integer
 
3166
    representing the field size, i.e., the number of bytes needed to
 
3167
    store the length of the string.</td>
 
3168
  </tr>
 
3169
 
 
3170
  <tr>
 
3171
    <td>MYSQL_TYPE_STRING</td><td>254</td>
 
3172
    <td>2 bytes</td>
 
3173
    <td>The first byte is always MYSQL_TYPE_VAR_STRING (i.e., 253).
2817
3174
    The second byte is the field size, i.e., the number of bytes in
2818
3175
    the representation of size of the string: 3 or 4.</td>
2819
3176
  </tr>
2820
3177
 
 
3178
  <tr>
 
3179
    <td>MYSQL_TYPE_GEOMETRY</td><td>255</td>
 
3180
    <td>1 byte</td>
 
3181
    <td>The pack length, i.e., the number of bytes needed to represent
 
3182
    the length of the geometry: 1, 2, 3, or 4.</td>
 
3183
  </tr>
 
3184
 
2821
3185
  </table>
2822
3186
*/
2823
3187
class Table_map_log_event : public Log_event
2853
3217
    ENUM_FLAG_COUNT
2854
3218
  };
2855
3219
 
2856
 
  typedef uint16_t flag_set;
 
3220
  typedef uint16 flag_set;
2857
3221
 
2858
3222
  /* Special constants representing sets of flags */
2859
3223
  enum 
2865
3229
  void clear_flags(flag_set flag) { m_flags &= ~flag; }
2866
3230
  flag_set get_flags(flag_set flag) const { return m_flags & flag; }
2867
3231
 
2868
 
  Table_map_log_event(THD *thd, Table *tbl, ulong tid, 
2869
 
                      bool is_transactional, uint16_t flags);
2870
 
  Table_map_log_event(const char *buf, uint32_t event_len, 
 
3232
#ifndef MYSQL_CLIENT
 
3233
  Table_map_log_event(THD *thd, TABLE *tbl, ulong tid, 
 
3234
                      bool is_transactional, uint16 flags);
 
3235
#endif
 
3236
#ifdef HAVE_REPLICATION
 
3237
  Table_map_log_event(const char *buf, uint event_len, 
2871
3238
                      const Format_description_log_event *description_event);
 
3239
#endif
2872
3240
 
2873
3241
  ~Table_map_log_event();
2874
3242
 
2876
3244
  virtual bool is_valid() const { return m_memory != NULL; /* we check malloc */ }
2877
3245
 
2878
3246
  virtual int get_data_size() { return m_data_size; } 
 
3247
#ifndef MYSQL_CLIENT
2879
3248
  virtual int save_field_metadata();
2880
3249
  virtual bool write_data_header(IO_CACHE *file);
2881
3250
  virtual bool write_data_body(IO_CACHE *file);
2882
3251
  virtual const char *get_db() { return m_dbnam; }
 
3252
#endif
 
3253
 
 
3254
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2883
3255
  virtual void pack_info(Protocol *protocol);
 
3256
#endif
 
3257
 
 
3258
#ifdef MYSQL_CLIENT
 
3259
  virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 
3260
#endif
 
3261
 
2884
3262
 
2885
3263
private:
 
3264
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2886
3265
  virtual int do_apply_event(Relay_log_info const *rli);
2887
3266
  virtual int do_update_pos(Relay_log_info *rli);
2888
3267
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
 
3268
#endif
2889
3269
 
2890
 
  Table         *m_table;
 
3270
#ifndef MYSQL_CLIENT
 
3271
  TABLE         *m_table;
 
3272
#endif
2891
3273
  char const    *m_dbnam;
2892
3274
  size_t         m_dblen;
2893
3275
  char const    *m_tblnam;
2894
3276
  size_t         m_tbllen;
2895
3277
  ulong          m_colcnt;
2896
 
  unsigned char         *m_coltype;
 
3278
  uchar         *m_coltype;
2897
3279
 
2898
 
  unsigned char         *m_memory;
 
3280
  uchar         *m_memory;
2899
3281
  ulong          m_table_id;
2900
3282
  flag_set       m_flags;
2901
3283
 
2902
3284
  size_t         m_data_size;
2903
3285
 
2904
 
  unsigned char          *m_field_metadata;        // buffer for field metadata
 
3286
  uchar          *m_field_metadata;        // buffer for field metadata
2905
3287
  /*
2906
3288
    The size of field metadata buffer set by calling save_field_metadata()
2907
3289
  */
2908
3290
  ulong          m_field_metadata_size;   
2909
 
  unsigned char         *m_null_bits;
2910
 
  unsigned char         *m_meta_memory;
 
3291
  uchar         *m_null_bits;
 
3292
  uchar         *m_meta_memory;
2911
3293
};
2912
3294
 
2913
3295
 
2967
3349
    COMPLETE_ROWS_F = (1U << 3)
2968
3350
  };
2969
3351
 
2970
 
  typedef uint16_t flag_set;
 
3352
  typedef uint16 flag_set;
2971
3353
 
2972
3354
  /* Special constants representing sets of flags */
2973
3355
  enum 
2981
3363
  void clear_flags(flag_set flags_arg) { m_flags &= ~flags_arg; }
2982
3364
  flag_set get_flags(flag_set flags_arg) const { return m_flags & flags_arg; }
2983
3365
 
 
3366
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
2984
3367
  virtual void pack_info(Protocol *protocol);
2985
 
 
2986
 
  int add_row_data(unsigned char *data, size_t length)
 
3368
#endif
 
3369
 
 
3370
#ifdef MYSQL_CLIENT
 
3371
  /* not for direct call, each derived has its own ::print() */
 
3372
  virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info)= 0;
 
3373
#endif
 
3374
 
 
3375
#ifndef MYSQL_CLIENT
 
3376
  int add_row_data(uchar *data, size_t length)
2987
3377
  {
2988
3378
    return do_add_row_data(data,length); 
2989
3379
  }
 
3380
#endif
2990
3381
 
2991
3382
  /* Member functions to implement superclass interface */
2992
3383
  virtual int get_data_size();
2995
3386
  size_t get_width() const          { return m_width; }
2996
3387
  ulong get_table_id() const        { return m_table_id; }
2997
3388
 
 
3389
#ifndef MYSQL_CLIENT
2998
3390
  virtual bool write_data_header(IO_CACHE *file);
2999
3391
  virtual bool write_data_body(IO_CACHE *file);
3000
3392
  virtual const char *get_db() { return m_table->s->db.str; }
 
3393
#endif
3001
3394
  /*
3002
3395
    Check that malloc() succeeded in allocating memory for the rows
3003
3396
    buffer and the COLS vector. Checking that an Update_rows_log_event
3009
3402
    return m_rows_buf && m_cols.bitmap;
3010
3403
  }
3011
3404
 
3012
 
  uint32_t     m_row_count;         /* The number of rows added to the event */
 
3405
  uint     m_row_count;         /* The number of rows added to the event */
3013
3406
 
3014
3407
protected:
3015
3408
  /* 
3016
3409
     The constructors are protected since you're supposed to inherit
3017
3410
     this class, not create instances of this class.
3018
3411
  */
3019
 
  Rows_log_event(THD*, Table*, ulong table_id, 
 
3412
#ifndef MYSQL_CLIENT
 
3413
  Rows_log_event(THD*, TABLE*, ulong table_id, 
3020
3414
                 MY_BITMAP const *cols, bool is_transactional);
3021
 
  Rows_log_event(const char *row_data, uint32_t event_len, 
 
3415
#endif
 
3416
  Rows_log_event(const char *row_data, uint event_len, 
3022
3417
                 Log_event_type event_type,
3023
3418
                 const Format_description_log_event *description_event);
3024
3419
 
3025
 
  virtual int do_add_row_data(unsigned char *data, size_t length);
3026
 
 
3027
 
  Table *m_table;               /* The table the rows belong to */
 
3420
#ifdef MYSQL_CLIENT
 
3421
  void print_helper(FILE *, PRINT_EVENT_INFO *, char const *const name);
 
3422
#endif
 
3423
 
 
3424
#ifndef MYSQL_CLIENT
 
3425
  virtual int do_add_row_data(uchar *data, size_t length);
 
3426
#endif
 
3427
 
 
3428
#ifndef MYSQL_CLIENT
 
3429
  TABLE *m_table;               /* The table the rows belong to */
 
3430
#endif
3028
3431
  ulong       m_table_id;       /* Table ID */
3029
3432
  MY_BITMAP   m_cols;           /* Bitmap denoting columns available */
3030
3433
  ulong       m_width;          /* The width of the columns bitmap */
3040
3443
  ulong       m_master_reclength; /* Length of record on master side */
3041
3444
 
3042
3445
  /* Bit buffers in the same memory as the class */
3043
 
  uint32_t    m_bitbuf[128/(sizeof(uint32_t)*8)];
3044
 
  uint32_t    m_bitbuf_ai[128/(sizeof(uint32_t)*8)];
 
3446
  uint32    m_bitbuf[128/(sizeof(uint32)*8)];
 
3447
  uint32    m_bitbuf_ai[128/(sizeof(uint32)*8)];
3045
3448
 
3046
 
  unsigned char    *m_rows_buf;         /* The rows in packed format */
3047
 
  unsigned char    *m_rows_cur;         /* One-after the end of the data */
3048
 
  unsigned char    *m_rows_end;         /* One-after the end of the allocated space */
 
3449
  uchar    *m_rows_buf;         /* The rows in packed format */
 
3450
  uchar    *m_rows_cur;         /* One-after the end of the data */
 
3451
  uchar    *m_rows_end;         /* One-after the end of the allocated space */
3049
3452
 
3050
3453
  flag_set m_flags;             /* Flags for row-level events */
3051
3454
 
3052
3455
  /* helper functions */
3053
3456
 
3054
 
  const unsigned char *m_curr_row;     /* Start of the row being processed */
3055
 
  const unsigned char *m_curr_row_end; /* One-after the end of the current row */
3056
 
  unsigned char    *m_key;      /* Buffer to keep key value during searches */
 
3457
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
3458
  const uchar *m_curr_row;     /* Start of the row being processed */
 
3459
  const uchar *m_curr_row_end; /* One-after the end of the current row */
 
3460
  uchar    *m_key;      /* Buffer to keep key value during searches */
3057
3461
 
3058
3462
  int find_row(const Relay_log_info *const);
3059
3463
  int write_row(const Relay_log_info *const, const bool);
3062
3466
  int unpack_current_row(const Relay_log_info *const rli,
3063
3467
                         MY_BITMAP const *cols)
3064
3468
  { 
3065
 
    assert(m_table);
 
3469
    DBUG_ASSERT(m_table);
3066
3470
    ASSERT_OR_RETURN_ERROR(m_curr_row < m_rows_end, HA_ERR_CORRUPT_EVENT);
3067
3471
    int const result= ::unpack_row(rli, m_table, m_width, m_curr_row, cols,
3068
3472
                                   &m_curr_row_end, &m_master_reclength);
3071
3475
    ASSERT_OR_RETURN_ERROR(m_curr_row_end <= m_rows_end, HA_ERR_CORRUPT_EVENT);
3072
3476
    return result;
3073
3477
  }
 
3478
#endif
3074
3479
 
3075
3480
private:
3076
3481
 
 
3482
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
3077
3483
  virtual int do_apply_event(Relay_log_info const *rli);
3078
3484
  virtual int do_update_pos(Relay_log_info *rli);
3079
3485
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
3128
3534
      
3129
3535
  */
3130
3536
  virtual int do_exec_row(const Relay_log_info *const rli) = 0;
 
3537
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
3131
3538
 
3132
3539
  friend class Old_rows_log_event;
3133
3540
};
3150
3557
    TYPE_CODE = WRITE_ROWS_EVENT
3151
3558
  };
3152
3559
 
3153
 
  Write_rows_log_event(THD*, Table*, ulong table_id, 
 
3560
#if !defined(MYSQL_CLIENT)
 
3561
  Write_rows_log_event(THD*, TABLE*, ulong table_id, 
3154
3562
                       bool is_transactional);
3155
 
  Write_rows_log_event(const char *buf, uint32_t event_len, 
 
3563
#endif
 
3564
#ifdef HAVE_REPLICATION
 
3565
  Write_rows_log_event(const char *buf, uint event_len, 
3156
3566
                       const Format_description_log_event *description_event);
3157
 
  static bool binlog_row_logging_function(THD *thd, Table *table,
 
3567
#endif
 
3568
#if !defined(MYSQL_CLIENT) 
 
3569
  static bool binlog_row_logging_function(THD *thd, TABLE *table,
3158
3570
                                          bool is_transactional,
3159
 
                                          const unsigned char *before_record
 
3571
                                          const uchar *before_record
3160
3572
                                          __attribute__((unused)),
3161
 
                                          const unsigned char *after_record)
 
3573
                                          const uchar *after_record)
3162
3574
  {
3163
3575
    return thd->binlog_write_row(table, is_transactional, after_record);
3164
3576
  }
 
3577
#endif
3165
3578
 
3166
3579
private:
3167
3580
  virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }
3168
3581
 
 
3582
#ifdef MYSQL_CLIENT
 
3583
  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 
3584
#endif
 
3585
 
 
3586
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
3169
3587
  virtual int do_before_row_operations(const Slave_reporting_capability *const);
3170
3588
  virtual int do_after_row_operations(const Slave_reporting_capability *const,int);
3171
3589
  virtual int do_exec_row(const Relay_log_info *const);
 
3590
#endif
3172
3591
};
3173
3592
 
3174
3593
 
3193
3612
    TYPE_CODE = UPDATE_ROWS_EVENT
3194
3613
  };
3195
3614
 
3196
 
  Update_rows_log_event(THD*, Table*, ulong table_id,
 
3615
#ifndef MYSQL_CLIENT
 
3616
  Update_rows_log_event(THD*, TABLE*, ulong table_id,
3197
3617
                        bool is_transactional);
3198
3618
 
3199
3619
  void init(MY_BITMAP const *cols);
 
3620
#endif
3200
3621
 
3201
3622
  virtual ~Update_rows_log_event();
3202
3623
 
3203
 
  Update_rows_log_event(const char *buf, uint32_t event_len, 
 
3624
#ifdef HAVE_REPLICATION
 
3625
  Update_rows_log_event(const char *buf, uint event_len, 
3204
3626
                        const Format_description_log_event *description_event);
 
3627
#endif
3205
3628
 
3206
 
  static bool binlog_row_logging_function(THD *thd, Table *table,
 
3629
#if !defined(MYSQL_CLIENT) 
 
3630
  static bool binlog_row_logging_function(THD *thd, TABLE *table,
3207
3631
                                          bool is_transactional,
3208
 
                                          const unsigned char *before_record,
3209
 
                                          const unsigned char *after_record)
 
3632
                                          const uchar *before_record,
 
3633
                                          const uchar *after_record)
3210
3634
  {
3211
3635
    return thd->binlog_update_row(table, is_transactional,
3212
3636
                                  before_record, after_record);
3213
3637
  }
 
3638
#endif
3214
3639
 
3215
3640
  virtual bool is_valid() const
3216
3641
  {
3220
3645
protected:
3221
3646
  virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }
3222
3647
 
 
3648
#ifdef MYSQL_CLIENT
 
3649
  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 
3650
#endif
 
3651
 
 
3652
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
3223
3653
  virtual int do_before_row_operations(const Slave_reporting_capability *const);
3224
3654
  virtual int do_after_row_operations(const Slave_reporting_capability *const,int);
3225
3655
  virtual int do_exec_row(const Relay_log_info *const);
 
3656
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
3226
3657
};
3227
3658
 
3228
3659
/**
3254
3685
    TYPE_CODE = DELETE_ROWS_EVENT
3255
3686
  };
3256
3687
 
3257
 
  Delete_rows_log_event(THD*, Table*, ulong, 
 
3688
#ifndef MYSQL_CLIENT
 
3689
  Delete_rows_log_event(THD*, TABLE*, ulong, 
3258
3690
                        bool is_transactional);
3259
 
  Delete_rows_log_event(const char *buf, uint32_t event_len, 
 
3691
#endif
 
3692
#ifdef HAVE_REPLICATION
 
3693
  Delete_rows_log_event(const char *buf, uint event_len, 
3260
3694
                        const Format_description_log_event *description_event);
3261
 
  static bool binlog_row_logging_function(THD *thd, Table *table,
 
3695
#endif
 
3696
#if !defined(MYSQL_CLIENT) 
 
3697
  static bool binlog_row_logging_function(THD *thd, TABLE *table,
3262
3698
                                          bool is_transactional,
3263
 
                                          const unsigned char *before_record,
3264
 
                                          const unsigned char *after_record
 
3699
                                          const uchar *before_record,
 
3700
                                          const uchar *after_record
3265
3701
                                          __attribute__((unused)))
3266
3702
  {
3267
3703
    return thd->binlog_delete_row(table, is_transactional, before_record);
3268
3704
  }
 
3705
#endif
3269
3706
  
3270
3707
protected:
3271
3708
  virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }
3272
3709
 
 
3710
#ifdef MYSQL_CLIENT
 
3711
  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 
3712
#endif
 
3713
 
 
3714
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
3273
3715
  virtual int do_before_row_operations(const Slave_reporting_capability *const);
3274
3716
  virtual int do_after_row_operations(const Slave_reporting_capability *const,int);
3275
3717
  virtual int do_exec_row(const Relay_log_info *const);
 
3718
#endif
3276
3719
};
3277
3720
 
3278
3721
 
3314
3757
*/
3315
3758
class Incident_log_event : public Log_event {
3316
3759
public:
 
3760
#ifndef MYSQL_CLIENT
3317
3761
  Incident_log_event(THD *thd_arg, Incident incident)
3318
 
    : Log_event(thd_arg, 0, false), m_incident(incident)
 
3762
    : Log_event(thd_arg, 0, FALSE), m_incident(incident)
3319
3763
  {
 
3764
    DBUG_ENTER("Incident_log_event::Incident_log_event");
 
3765
    DBUG_PRINT("enter", ("m_incident: %d", m_incident));
3320
3766
    m_message.str= NULL;                    /* Just as a precaution */
3321
3767
    m_message.length= 0;
3322
 
    return;
 
3768
    DBUG_VOID_RETURN;
3323
3769
  }
3324
3770
 
3325
3771
  Incident_log_event(THD *thd_arg, Incident incident, LEX_STRING const msg)
3326
 
    : Log_event(thd_arg, 0, false), m_incident(incident)
 
3772
    : Log_event(thd_arg, 0, FALSE), m_incident(incident)
3327
3773
  {
 
3774
    DBUG_ENTER("Incident_log_event::Incident_log_event");
 
3775
    DBUG_PRINT("enter", ("m_incident: %d", m_incident));
3328
3776
    m_message= msg;
3329
 
    return;
 
3777
    DBUG_VOID_RETURN;
3330
3778
  }
 
3779
#endif
3331
3780
 
 
3781
#ifndef MYSQL_CLIENT
3332
3782
  void pack_info(Protocol*);
 
3783
#endif
3333
3784
 
3334
 
  Incident_log_event(const char *buf, uint32_t event_len,
 
3785
  Incident_log_event(const char *buf, uint event_len,
3335
3786
                     const Format_description_log_event *descr_event);
3336
3787
 
3337
3788
  virtual ~Incident_log_event();
3338
3789
 
 
3790
#ifdef MYSQL_CLIENT
 
3791
  virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
 
3792
#endif
 
3793
 
 
3794
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
3339
3795
  virtual int do_apply_event(Relay_log_info const *rli);
 
3796
#endif
3340
3797
 
3341
3798
  virtual bool write_data_header(IO_CACHE *file);
3342
3799
  virtual bool write_data_body(IO_CACHE *file);
3355
3812
  LEX_STRING m_message;
3356
3813
};
3357
3814
 
3358
 
int append_query_string(const CHARSET_INFO * const csinfo,
3359
 
                        String const *from, String *to);
3360
 
 
3361
3815
static inline bool copy_event_cache_to_file_and_reinit(IO_CACHE *cache,
3362
3816
                                                       FILE *file)
3363
3817
{
3364
3818
  return         
3365
3819
    my_b_copy_to_file(cache, file) ||
3366
 
    reinit_io_cache(cache, WRITE_CACHE, 0, false, true);
 
3820
    reinit_io_cache(cache, WRITE_CACHE, 0, FALSE, TRUE);
3367
3821
}
3368
3822
 
 
3823
#ifndef MYSQL_CLIENT
3369
3824
/*****************************************************************************
3370
3825
 
3371
3826
  Heartbeat Log Event class
3384
3839
class Heartbeat_log_event: public Log_event
3385
3840
{
3386
3841
public:
3387
 
  Heartbeat_log_event(const char* buf, uint32_t event_len,
 
3842
  Heartbeat_log_event(const char* buf, uint event_len,
3388
3843
                      const Format_description_log_event* description_event);
3389
3844
  Log_event_type get_type_code() { return HEARTBEAT_LOG_EVENT; }
3390
3845
  bool is_valid() const
3393
3848
              log_pos >= BIN_LOG_HEADER_SIZE);
3394
3849
    }
3395
3850
  const char * get_log_ident() { return log_ident; }
3396
 
  uint32_t get_ident_len() { return ident_len; }
 
3851
  uint get_ident_len() { return ident_len; }
3397
3852
  
3398
3853
private:
3399
3854
  const char* log_ident;
3400
 
  uint32_t ident_len;
 
3855
  uint ident_len;
3401
3856
};
 
3857
#endif
3402
3858
 
3403
3859
/**
3404
3860
  @} (end of group Replication)
3405
3861
*/
3406
3862
 
3407
 
#endif /* DRIZZLED_LOG_EVENT_H */
 
3863
#endif /* _log_event_h */