← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/log_event.h

  • Committer: Grant Limberg
  • Date: 2008-08-12 21:13:01 UTC
  • mto: (322.1.1 codestyle)
  • mto: This revision was merged to the branch mainline in revision 324.
  • Revision ID: grant@glsoftware.net-20080812211301-ym3wsowelkgp16s2
renamed all instances of MYSQL_ to DRIZZLE_

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/log_event.h
28
28
#ifndef _log_event_h
29
29
#define _log_event_h
30
30
 
31
 
#if defined(USE_PRAGMA_INTERFACE) && !defined(MYSQL_CLIENT)
 
31
#if defined(USE_PRAGMA_INTERFACE) && !defined(DRIZZLE_CLIENT)
32
32
#pragma interface                       /* gcc class implementation */
33
33
#endif
34
34
 
35
35
#include <mysys/my_bitmap.h>
36
36
#include "rpl_constants.h"
37
 
#ifndef MYSQL_CLIENT
 
37
#ifndef DRIZZLE_CLIENT
38
38
#include "rpl_record.h"
39
39
#include "rpl_reporting.h"
40
40
#else
547
547
};
548
548
 
549
549
 
550
 
#ifndef MYSQL_CLIENT
 
550
#ifndef DRIZZLE_CLIENT
551
551
class String;
552
 
class MYSQL_BIN_LOG;
 
552
class DRIZZLE_BIN_LOG;
553
553
class THD;
554
554
#endif
555
555
 
556
556
class Format_description_log_event;
557
557
class Relay_log_info;
558
558
 
559
 
#ifdef MYSQL_CLIENT
 
559
#ifdef DRIZZLE_CLIENT
560
560
enum enum_base64_output_mode {
561
561
  BASE64_OUTPUT_NEVER= 0,
562
562
  BASE64_OUTPUT_AUTO= 1,
867
867
  */
868
868
  ulong slave_exec_mode;
869
869
 
870
 
#ifndef MYSQL_CLIENT
 
870
#ifndef DRIZZLE_CLIENT
871
871
  THD* thd;
872
872
 
873
873
  Log_event();
940
940
  static void *operator new(size_t, void* ptr) { return ptr; }
941
941
  static void operator delete(void*, void*) { }
942
942
 
943
 
#ifndef MYSQL_CLIENT
 
943
#ifndef DRIZZLE_CLIENT
944
944
  bool write_header(IO_CACHE* file, ulong data_length);
945
945
  virtual bool write(IO_CACHE* file)
946
946
  {
1000
1000
 
1001
1001
  /* Return start of query time or current time */
1002
1002
 
1003
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
1003
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
1004
1004
public:
1005
1005
 
1006
1006
  /**
1554
1554
  uint lc_time_names_number; /* 0 means en_US */
1555
1555
  uint charset_database_number;
1556
1556
 
1557
 
#ifndef MYSQL_CLIENT
 
1557
#ifndef DRIZZLE_CLIENT
1558
1558
 
1559
1559
  Query_log_event(THD* thd_arg, const char* query_arg, ulong query_length,
1560
1560
                  bool using_trans, bool suppress_use,
1578
1578
      my_free((uchar*) data_buf, MYF(0));
1579
1579
  }
1580
1580
  Log_event_type get_type_code() { return QUERY_EVENT; }
1581
 
#ifndef MYSQL_CLIENT
 
1581
#ifndef DRIZZLE_CLIENT
1582
1582
  bool write(IO_CACHE* file);
1583
1583
  virtual bool write_post_header_for_derived(IO_CACHE* file __attribute__((unused)))
1584
1584
  { return false; }
1593
1593
  /* Writes derived event-specific part of post header. */
1594
1594
 
1595
1595
public:        /* !!! Public in this patch to allow old usage */
1596
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
1596
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
1597
1597
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
1598
1598
  virtual int do_apply_event(Relay_log_info const *rli);
1599
1599
  virtual int do_update_pos(Relay_log_info *rli);
1668
1668
  int master_log_len;
1669
1669
  uint16_t master_port;
1670
1670
 
1671
 
#ifndef MYSQL_CLIENT
 
1671
#ifndef DRIZZLE_CLIENT
1672
1672
  Slave_log_event(THD* thd_arg, Relay_log_info* rli);
1673
1673
  void pack_info(Protocol* protocol);
1674
1674
#else
1680
1680
  int get_data_size();
1681
1681
  bool is_valid() const { return master_host != 0; }
1682
1682
  Log_event_type get_type_code() { return SLAVE_EVENT; }
1683
 
#ifndef MYSQL_CLIENT
 
1683
#ifndef DRIZZLE_CLIENT
1684
1684
  bool write(IO_CACHE* file);
1685
1685
#endif
1686
1686
 
1687
1687
private:
1688
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
1688
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
1689
1689
  virtual int do_apply_event(Relay_log_info const* rli);
1690
1690
#endif
1691
1691
};
1939
1939
    return local_fname;
1940
1940
  }
1941
1941
 
1942
 
#ifndef MYSQL_CLIENT
 
1942
#ifndef DRIZZLE_CLIENT
1943
1943
  String field_lens_buf;
1944
1944
  String fields_buf;
1945
1945
 
1972
1972
  {
1973
1973
    return sql_ex.new_format() ? NEW_LOAD_EVENT: LOAD_EVENT;
1974
1974
  }
1975
 
#ifndef MYSQL_CLIENT
 
1975
#ifndef DRIZZLE_CLIENT
1976
1976
  bool write_data_header(IO_CACHE* file);
1977
1977
  bool write_data_body(IO_CACHE* file);
1978
1978
#endif
1985
1985
  }
1986
1986
 
1987
1987
public:        /* !!! Public in this patch to allow old usage */
1988
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
1988
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
1989
1989
  virtual int do_apply_event(Relay_log_info const* rli)
1990
1990
  {
1991
1991
    return do_apply_event(thd->slave_net,rli,0);
2053
2053
  */
2054
2054
  bool dont_set_created;
2055
2055
 
2056
 
#ifndef MYSQL_CLIENT
 
2056
#ifndef DRIZZLE_CLIENT
2057
2057
  Start_log_event_v3();
2058
2058
#ifdef HAVE_REPLICATION
2059
2059
  void pack_info(Protocol* protocol);
2067
2067
                     const Format_description_log_event* description_event);
2068
2068
  ~Start_log_event_v3() {}
2069
2069
  Log_event_type get_type_code() { return START_EVENT_V3;}
2070
 
#ifndef MYSQL_CLIENT
 
2070
#ifndef DRIZZLE_CLIENT
2071
2071
  bool write(IO_CACHE* file);
2072
2072
#endif
2073
2073
  bool is_valid() const { return 1; }
2078
2078
  virtual bool is_artificial_event() { return artificial_event; }
2079
2079
 
2080
2080
protected:
2081
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
2081
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
2082
2082
  virtual int do_apply_event(Relay_log_info const *rli);
2083
2083
  virtual enum_skip_reason do_shall_skip(Relay_log_info*)
2084
2084
  {
2130
2130
    my_free((uchar*)post_header_len, MYF(MY_ALLOW_ZERO_PTR));
2131
2131
  }
2132
2132
  Log_event_type get_type_code() { return FORMAT_DESCRIPTION_EVENT;}
2133
 
#ifndef MYSQL_CLIENT
 
2133
#ifndef DRIZZLE_CLIENT
2134
2134
  bool write(IO_CACHE* file);
2135
2135
#endif
2136
2136
  bool is_valid() const
2152
2152
  void calc_server_version_split();
2153
2153
 
2154
2154
protected:
2155
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
2155
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
2156
2156
  virtual int do_apply_event(Relay_log_info const *rli);
2157
2157
  virtual int do_update_pos(Relay_log_info *rli);
2158
2158
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
2203
2203
  uint64_t val;
2204
2204
  uchar type;
2205
2205
 
2206
 
#ifndef MYSQL_CLIENT
 
2206
#ifndef DRIZZLE_CLIENT
2207
2207
  Intvar_log_event(THD* thd_arg,uchar type_arg, uint64_t val_arg)
2208
2208
    :Log_event(thd_arg,0,0),val(val_arg),type(type_arg)
2209
2209
  {}
2220
2220
  Log_event_type get_type_code() { return INTVAR_EVENT;}
2221
2221
  const char* get_var_type_name();
2222
2222
  int get_data_size() { return  9; /* sizeof(type) + sizeof(val) */;}
2223
 
#ifndef MYSQL_CLIENT
 
2223
#ifndef DRIZZLE_CLIENT
2224
2224
  bool write(IO_CACHE* file);
2225
2225
#endif
2226
2226
  bool is_valid() const { return 1; }
2227
2227
 
2228
2228
private:
2229
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
2229
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
2230
2230
  virtual int do_apply_event(Relay_log_info const *rli);
2231
2231
  virtual int do_update_pos(Relay_log_info *rli);
2232
2232
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
2278
2278
  uint64_t seed1;
2279
2279
  uint64_t seed2;
2280
2280
 
2281
 
#ifndef MYSQL_CLIENT
 
2281
#ifndef DRIZZLE_CLIENT
2282
2282
  Rand_log_event(THD* thd_arg, uint64_t seed1_arg, uint64_t seed2_arg)
2283
2283
    :Log_event(thd_arg,0,0),seed1(seed1_arg),seed2(seed2_arg)
2284
2284
  {}
2294
2294
  ~Rand_log_event() {}
2295
2295
  Log_event_type get_type_code() { return RAND_EVENT;}
2296
2296
  int get_data_size() { return 16; /* sizeof(uint64_t) * 2*/ }
2297
 
#ifndef MYSQL_CLIENT
 
2297
#ifndef DRIZZLE_CLIENT
2298
2298
  bool write(IO_CACHE* file);
2299
2299
#endif
2300
2300
  bool is_valid() const { return 1; }
2301
2301
 
2302
2302
private:
2303
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
2303
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
2304
2304
  virtual int do_apply_event(Relay_log_info const *rli);
2305
2305
  virtual int do_update_pos(Relay_log_info *rli);
2306
2306
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
2315
2315
 
2316
2316
  @section Xid_log_event_binary_format Binary Format  
2317
2317
*/
2318
 
#ifdef MYSQL_CLIENT
 
2318
#ifdef DRIZZLE_CLIENT
2319
2319
typedef uint64_t my_xid; // this line is the same as in handler.h
2320
2320
#endif
2321
2321
 
2324
2324
 public:
2325
2325
   my_xid xid;
2326
2326
 
2327
 
#ifndef MYSQL_CLIENT
 
2327
#ifndef DRIZZLE_CLIENT
2328
2328
  Xid_log_event(THD* thd_arg, my_xid x): Log_event(thd_arg,0,0), xid(x) {}
2329
2329
#ifdef HAVE_REPLICATION
2330
2330
  void pack_info(Protocol* protocol);
2338
2338
  ~Xid_log_event() {}
2339
2339
  Log_event_type get_type_code() { return XID_EVENT;}
2340
2340
  int get_data_size() { return sizeof(xid); }
2341
 
#ifndef MYSQL_CLIENT
 
2341
#ifndef DRIZZLE_CLIENT
2342
2342
  bool write(IO_CACHE* file);
2343
2343
#endif
2344
2344
  bool is_valid() const { return 1; }
2345
2345
 
2346
2346
private:
2347
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
2347
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
2348
2348
  virtual int do_apply_event(Relay_log_info const *rli);
2349
2349
  enum_skip_reason do_shall_skip(Relay_log_info *rli);
2350
2350
#endif
2369
2369
  Item_result type;
2370
2370
  uint charset_number;
2371
2371
  bool is_null;
2372
 
#ifndef MYSQL_CLIENT
 
2372
#ifndef DRIZZLE_CLIENT
2373
2373
  User_var_log_event(THD* thd_arg __attribute__((unused)),
2374
2374
                     char *name_arg, uint name_len_arg,
2375
2375
                     char *val_arg, ulong val_len_arg, Item_result type_arg,
2386
2386
                     const Format_description_log_event *description_event);
2387
2387
  ~User_var_log_event() {}
2388
2388
  Log_event_type get_type_code() { return USER_VAR_EVENT;}
2389
 
#ifndef MYSQL_CLIENT
 
2389
#ifndef DRIZZLE_CLIENT
2390
2390
  bool write(IO_CACHE* file);
2391
2391
#endif
2392
2392
  bool is_valid() const { return 1; }
2393
2393
 
2394
2394
private:
2395
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
2395
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
2396
2396
  virtual int do_apply_event(Relay_log_info const *rli);
2397
2397
  virtual int do_update_pos(Relay_log_info *rli);
2398
2398
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
2411
2411
class Stop_log_event: public Log_event
2412
2412
{
2413
2413
public:
2414
 
#ifndef MYSQL_CLIENT
 
2414
#ifndef DRIZZLE_CLIENT
2415
2415
  Stop_log_event() :Log_event()
2416
2416
  {}
2417
2417
#else
2427
2427
  bool is_valid() const { return 1; }
2428
2428
 
2429
2429
private:
2430
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
2430
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
2431
2431
  virtual int do_update_pos(Relay_log_info *rli);
2432
2432
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli __attribute__((unused)))
2433
2433
  {
2502
2502
  uint64_t pos;
2503
2503
  uint ident_len;
2504
2504
  uint flags;
2505
 
#ifndef MYSQL_CLIENT
 
2505
#ifndef DRIZZLE_CLIENT
2506
2506
  Rotate_log_event(const char* new_log_ident_arg,
2507
2507
                   uint ident_len_arg,
2508
2508
                   uint64_t pos_arg, uint flags);
2523
2523
  Log_event_type get_type_code() { return ROTATE_EVENT;}
2524
2524
  int get_data_size() { return  ident_len + ROTATE_HEADER_LEN;}
2525
2525
  bool is_valid() const { return new_log_ident != 0; }
2526
 
#ifndef MYSQL_CLIENT
 
2526
#ifndef DRIZZLE_CLIENT
2527
2527
  bool write(IO_CACHE* file);
2528
2528
#endif
2529
2529
 
2530
2530
private:
2531
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
2531
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
2532
2532
  virtual int do_update_pos(Relay_log_info *rli);
2533
2533
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
2534
2534
#endif
2559
2559
  uint file_id;
2560
2560
  bool inited_from_old;
2561
2561
 
2562
 
#ifndef MYSQL_CLIENT
 
2562
#ifndef DRIZZLE_CLIENT
2563
2563
  Create_file_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
2564
2564
                        const char* table_name_arg,
2565
2565
                        List<Item>& fields_arg,
2593
2593
            4 + 1 + block_len);
2594
2594
  }
2595
2595
  bool is_valid() const { return inited_from_old || block != 0; }
2596
 
#ifndef MYSQL_CLIENT
 
2596
#ifndef DRIZZLE_CLIENT
2597
2597
  bool write_data_header(IO_CACHE* file);
2598
2598
  bool write_data_body(IO_CACHE* file);
2599
2599
  /*
2604
2604
#endif
2605
2605
 
2606
2606
private:
2607
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
2607
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
2608
2608
  virtual int do_apply_event(Relay_log_info const *rli);
2609
2609
#endif
2610
2610
};
2635
2635
  */
2636
2636
  const char* db;
2637
2637
 
2638
 
#ifndef MYSQL_CLIENT
 
2638
#ifndef DRIZZLE_CLIENT
2639
2639
  Append_block_log_event(THD* thd, const char* db_arg, uchar* block_arg,
2640
2640
                         uint block_len_arg, bool using_trans);
2641
2641
#ifdef HAVE_REPLICATION
2653
2653
  Log_event_type get_type_code() { return APPEND_BLOCK_EVENT;}
2654
2654
  int get_data_size() { return  block_len + APPEND_BLOCK_HEADER_LEN ;}
2655
2655
  bool is_valid() const { return block != 0; }
2656
 
#ifndef MYSQL_CLIENT
 
2656
#ifndef DRIZZLE_CLIENT
2657
2657
  bool write(IO_CACHE* file);
2658
2658
  const char* get_db() { return db; }
2659
2659
#endif
2660
2660
 
2661
2661
private:
2662
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
2662
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
2663
2663
  virtual int do_apply_event(Relay_log_info const *rli);
2664
2664
#endif
2665
2665
};
2677
2677
  uint file_id;
2678
2678
  const char* db; /* see comment in Append_block_log_event */
2679
2679
 
2680
 
#ifndef MYSQL_CLIENT
 
2680
#ifndef DRIZZLE_CLIENT
2681
2681
  Delete_file_log_event(THD* thd, const char* db_arg, bool using_trans);
2682
2682
#ifdef HAVE_REPLICATION
2683
2683
  void pack_info(Protocol* protocol);
2694
2694
  Log_event_type get_type_code() { return DELETE_FILE_EVENT;}
2695
2695
  int get_data_size() { return DELETE_FILE_HEADER_LEN ;}
2696
2696
  bool is_valid() const { return file_id != 0; }
2697
 
#ifndef MYSQL_CLIENT
 
2697
#ifndef DRIZZLE_CLIENT
2698
2698
  bool write(IO_CACHE* file);
2699
2699
  const char* get_db() { return db; }
2700
2700
#endif
2701
2701
 
2702
2702
private:
2703
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
2703
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
2704
2704
  virtual int do_apply_event(Relay_log_info const *rli);
2705
2705
#endif
2706
2706
};
2718
2718
  uint file_id;
2719
2719
  const char* db; /* see comment in Append_block_log_event */
2720
2720
 
2721
 
#ifndef MYSQL_CLIENT
 
2721
#ifndef DRIZZLE_CLIENT
2722
2722
  Execute_load_log_event(THD* thd, const char* db_arg, bool using_trans);
2723
2723
#ifdef HAVE_REPLICATION
2724
2724
  void pack_info(Protocol* protocol);
2734
2734
  Log_event_type get_type_code() { return EXEC_LOAD_EVENT;}
2735
2735
  int get_data_size() { return  EXEC_LOAD_HEADER_LEN ;}
2736
2736
  bool is_valid() const { return file_id != 0; }
2737
 
#ifndef MYSQL_CLIENT
 
2737
#ifndef DRIZZLE_CLIENT
2738
2738
  bool write(IO_CACHE* file);
2739
2739
  const char* get_db() { return db; }
2740
2740
#endif
2741
2741
 
2742
2742
private:
2743
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
2743
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
2744
2744
  virtual int do_apply_event(Relay_log_info const *rli);
2745
2745
#endif
2746
2746
};
2758
2758
class Begin_load_query_log_event: public Append_block_log_event
2759
2759
{
2760
2760
public:
2761
 
#ifndef MYSQL_CLIENT
 
2761
#ifndef DRIZZLE_CLIENT
2762
2762
  Begin_load_query_log_event(THD* thd_arg, const char *db_arg,
2763
2763
                             uchar* block_arg, uint block_len_arg,
2764
2764
                             bool using_trans);
2773
2773
  ~Begin_load_query_log_event() {}
2774
2774
  Log_event_type get_type_code() { return BEGIN_LOAD_QUERY_EVENT; }
2775
2775
private:
2776
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
2776
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
2777
2777
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
2778
2778
#endif
2779
2779
};
2809
2809
  */
2810
2810
  enum_load_dup_handling dup_handling;
2811
2811
 
2812
 
#ifndef MYSQL_CLIENT
 
2812
#ifndef DRIZZLE_CLIENT
2813
2813
  Execute_load_query_log_event(THD* thd, const char* query_arg,
2814
2814
                               ulong query_length, uint fn_pos_start_arg,
2815
2815
                               uint fn_pos_end_arg,
2835
2835
  bool is_valid() const { return Query_log_event::is_valid() && file_id != 0; }
2836
2836
 
2837
2837
  ulong get_post_header_size_for_derived();
2838
 
#ifndef MYSQL_CLIENT
 
2838
#ifndef DRIZZLE_CLIENT
2839
2839
  bool write_post_header_for_derived(IO_CACHE* file);
2840
2840
#endif
2841
2841
 
2842
2842
private:
2843
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
2843
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
2844
2844
  virtual int do_apply_event(Relay_log_info const *rli);
2845
2845
#endif
2846
2846
};
2847
2847
 
2848
2848
 
2849
 
#ifdef MYSQL_CLIENT
 
2849
#ifdef DRIZZLE_CLIENT
2850
2850
/**
2851
2851
  @class Unknown_log_event
2852
2852
 
3163
3163
  void clear_flags(flag_set flag) { m_flags &= ~flag; }
3164
3164
  flag_set get_flags(flag_set flag) const { return m_flags & flag; }
3165
3165
 
3166
 
#ifndef MYSQL_CLIENT
 
3166
#ifndef DRIZZLE_CLIENT
3167
3167
  Table_map_log_event(THD *thd, TABLE *tbl, ulong tid, 
3168
3168
                      bool is_transactional, uint16_t flags);
3169
3169
#endif
3178
3178
  virtual bool is_valid() const { return m_memory != NULL; /* we check malloc */ }
3179
3179
 
3180
3180
  virtual int get_data_size() { return m_data_size; } 
3181
 
#ifndef MYSQL_CLIENT
 
3181
#ifndef DRIZZLE_CLIENT
3182
3182
  virtual int save_field_metadata();
3183
3183
  virtual bool write_data_header(IO_CACHE *file);
3184
3184
  virtual bool write_data_body(IO_CACHE *file);
3185
3185
  virtual const char *get_db() { return m_dbnam; }
3186
3186
#endif
3187
3187
 
3188
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
3188
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
3189
3189
  virtual void pack_info(Protocol *protocol);
3190
3190
#endif
3191
3191
 
3192
 
#ifdef MYSQL_CLIENT
 
3192
#ifdef DRIZZLE_CLIENT
3193
3193
  virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
3194
3194
#endif
3195
3195
 
3196
3196
 
3197
3197
private:
3198
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
3198
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
3199
3199
  virtual int do_apply_event(Relay_log_info const *rli);
3200
3200
  virtual int do_update_pos(Relay_log_info *rli);
3201
3201
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
3202
3202
#endif
3203
3203
 
3204
 
#ifndef MYSQL_CLIENT
 
3204
#ifndef DRIZZLE_CLIENT
3205
3205
  TABLE         *m_table;
3206
3206
#endif
3207
3207
  char const    *m_dbnam;
3297
3297
  void clear_flags(flag_set flags_arg) { m_flags &= ~flags_arg; }
3298
3298
  flag_set get_flags(flag_set flags_arg) const { return m_flags & flags_arg; }
3299
3299
 
3300
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
3300
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
3301
3301
  virtual void pack_info(Protocol *protocol);
3302
3302
#endif
3303
3303
 
3304
 
#ifdef MYSQL_CLIENT
 
3304
#ifdef DRIZZLE_CLIENT
3305
3305
  /* not for direct call, each derived has its own ::print() */
3306
3306
  virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info)= 0;
3307
3307
#endif
3308
3308
 
3309
 
#ifndef MYSQL_CLIENT
 
3309
#ifndef DRIZZLE_CLIENT
3310
3310
  int add_row_data(uchar *data, size_t length)
3311
3311
  {
3312
3312
    return do_add_row_data(data,length); 
3320
3320
  size_t get_width() const          { return m_width; }
3321
3321
  ulong get_table_id() const        { return m_table_id; }
3322
3322
 
3323
 
#ifndef MYSQL_CLIENT
 
3323
#ifndef DRIZZLE_CLIENT
3324
3324
  virtual bool write_data_header(IO_CACHE *file);
3325
3325
  virtual bool write_data_body(IO_CACHE *file);
3326
3326
  virtual const char *get_db() { return m_table->s->db.str; }
3343
3343
     The constructors are protected since you're supposed to inherit
3344
3344
     this class, not create instances of this class.
3345
3345
  */
3346
 
#ifndef MYSQL_CLIENT
 
3346
#ifndef DRIZZLE_CLIENT
3347
3347
  Rows_log_event(THD*, TABLE*, ulong table_id, 
3348
3348
                 MY_BITMAP const *cols, bool is_transactional);
3349
3349
#endif
3351
3351
                 Log_event_type event_type,
3352
3352
                 const Format_description_log_event *description_event);
3353
3353
 
3354
 
#ifdef MYSQL_CLIENT
 
3354
#ifdef DRIZZLE_CLIENT
3355
3355
  void print_helper(FILE *, PRINT_EVENT_INFO *, char const *const name);
3356
3356
#endif
3357
3357
 
3358
 
#ifndef MYSQL_CLIENT
 
3358
#ifndef DRIZZLE_CLIENT
3359
3359
  virtual int do_add_row_data(uchar *data, size_t length);
3360
3360
#endif
3361
3361
 
3362
 
#ifndef MYSQL_CLIENT
 
3362
#ifndef DRIZZLE_CLIENT
3363
3363
  TABLE *m_table;               /* The table the rows belong to */
3364
3364
#endif
3365
3365
  ulong       m_table_id;       /* Table ID */
3388
3388
 
3389
3389
  /* helper functions */
3390
3390
 
3391
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
3391
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
3392
3392
  const uchar *m_curr_row;     /* Start of the row being processed */
3393
3393
  const uchar *m_curr_row_end; /* One-after the end of the current row */
3394
3394
  uchar    *m_key;      /* Buffer to keep key value during searches */
3413
3413
 
3414
3414
private:
3415
3415
 
3416
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
3416
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
3417
3417
  virtual int do_apply_event(Relay_log_info const *rli);
3418
3418
  virtual int do_update_pos(Relay_log_info *rli);
3419
3419
  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
3468
3468
      
3469
3469
  */
3470
3470
  virtual int do_exec_row(const Relay_log_info *const rli) = 0;
3471
 
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
 
3471
#endif /* !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION) */
3472
3472
 
3473
3473
  friend class Old_rows_log_event;
3474
3474
};
3491
3491
    TYPE_CODE = WRITE_ROWS_EVENT
3492
3492
  };
3493
3493
 
3494
 
#if !defined(MYSQL_CLIENT)
 
3494
#if !defined(DRIZZLE_CLIENT)
3495
3495
  Write_rows_log_event(THD*, TABLE*, ulong table_id, 
3496
3496
                       bool is_transactional);
3497
3497
#endif
3499
3499
  Write_rows_log_event(const char *buf, uint event_len, 
3500
3500
                       const Format_description_log_event *description_event);
3501
3501
#endif
3502
 
#if !defined(MYSQL_CLIENT) 
 
3502
#if !defined(DRIZZLE_CLIENT) 
3503
3503
  static bool binlog_row_logging_function(THD *thd, TABLE *table,
3504
3504
                                          bool is_transactional,
3505
3505
                                          const uchar *before_record
3513
3513
private:
3514
3514
  virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }
3515
3515
 
3516
 
#ifdef MYSQL_CLIENT
 
3516
#ifdef DRIZZLE_CLIENT
3517
3517
  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
3518
3518
#endif
3519
3519
 
3520
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
3520
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
3521
3521
  virtual int do_before_row_operations(const Slave_reporting_capability *const);
3522
3522
  virtual int do_after_row_operations(const Slave_reporting_capability *const,int);
3523
3523
  virtual int do_exec_row(const Relay_log_info *const);
3546
3546
    TYPE_CODE = UPDATE_ROWS_EVENT
3547
3547
  };
3548
3548
 
3549
 
#ifndef MYSQL_CLIENT
 
3549
#ifndef DRIZZLE_CLIENT
3550
3550
  Update_rows_log_event(THD*, TABLE*, ulong table_id,
3551
3551
                        bool is_transactional);
3552
3552
 
3560
3560
                        const Format_description_log_event *description_event);
3561
3561
#endif
3562
3562
 
3563
 
#if !defined(MYSQL_CLIENT) 
 
3563
#if !defined(DRIZZLE_CLIENT) 
3564
3564
  static bool binlog_row_logging_function(THD *thd, TABLE *table,
3565
3565
                                          bool is_transactional,
3566
3566
                                          const uchar *before_record,
3579
3579
protected:
3580
3580
  virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }
3581
3581
 
3582
 
#ifdef MYSQL_CLIENT
 
3582
#ifdef DRIZZLE_CLIENT
3583
3583
  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
3584
3584
#endif
3585
3585
 
3586
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
3586
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
3587
3587
  virtual int do_before_row_operations(const Slave_reporting_capability *const);
3588
3588
  virtual int do_after_row_operations(const Slave_reporting_capability *const,int);
3589
3589
  virtual int do_exec_row(const Relay_log_info *const);
3590
 
#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
 
3590
#endif /* !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION) */
3591
3591
};
3592
3592
 
3593
3593
/**
3619
3619
    TYPE_CODE = DELETE_ROWS_EVENT
3620
3620
  };
3621
3621
 
3622
 
#ifndef MYSQL_CLIENT
 
3622
#ifndef DRIZZLE_CLIENT
3623
3623
  Delete_rows_log_event(THD*, TABLE*, ulong, 
3624
3624
                        bool is_transactional);
3625
3625
#endif
3627
3627
  Delete_rows_log_event(const char *buf, uint event_len, 
3628
3628
                        const Format_description_log_event *description_event);
3629
3629
#endif
3630
 
#if !defined(MYSQL_CLIENT) 
 
3630
#if !defined(DRIZZLE_CLIENT) 
3631
3631
  static bool binlog_row_logging_function(THD *thd, TABLE *table,
3632
3632
                                          bool is_transactional,
3633
3633
                                          const uchar *before_record,
3641
3641
protected:
3642
3642
  virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }
3643
3643
 
3644
 
#ifdef MYSQL_CLIENT
 
3644
#ifdef DRIZZLE_CLIENT
3645
3645
  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
3646
3646
#endif
3647
3647
 
3648
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
3648
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
3649
3649
  virtual int do_before_row_operations(const Slave_reporting_capability *const);
3650
3650
  virtual int do_after_row_operations(const Slave_reporting_capability *const,int);
3651
3651
  virtual int do_exec_row(const Relay_log_info *const);
3691
3691
*/
3692
3692
class Incident_log_event : public Log_event {
3693
3693
public:
3694
 
#ifndef MYSQL_CLIENT
 
3694
#ifndef DRIZZLE_CLIENT
3695
3695
  Incident_log_event(THD *thd_arg, Incident incident)
3696
3696
    : Log_event(thd_arg, 0, false), m_incident(incident)
3697
3697
  {
3708
3708
  }
3709
3709
#endif
3710
3710
 
3711
 
#ifndef MYSQL_CLIENT
 
3711
#ifndef DRIZZLE_CLIENT
3712
3712
  void pack_info(Protocol*);
3713
3713
#endif
3714
3714
 
3717
3717
 
3718
3718
  virtual ~Incident_log_event();
3719
3719
 
3720
 
#ifdef MYSQL_CLIENT
 
3720
#ifdef DRIZZLE_CLIENT
3721
3721
  virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
3722
3722
#endif
3723
3723
 
3724
 
#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
3724
#if !defined(DRIZZLE_CLIENT) && defined(HAVE_REPLICATION)
3725
3725
  virtual int do_apply_event(Relay_log_info const *rli);
3726
3726
#endif
3727
3727
 
3753
3753
    reinit_io_cache(cache, WRITE_CACHE, 0, false, true);
3754
3754
}
3755
3755
 
3756
 
#ifndef MYSQL_CLIENT
 
3756
#ifndef DRIZZLE_CLIENT
3757
3757
/*****************************************************************************
3758
3758
 
3759
3759
  Heartbeat Log Event class