← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_class.h

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_class.h
20
20
#pragma interface                       /* gcc class implementation */
21
21
#endif
22
22
 
23
 
#include <mysql/plugin_audit.h>
 
23
#include <drizzled/plugin_audit.h>
24
24
#include "log.h"
25
25
#include "rpl_tblmap.h"
26
26
 
499
499
  {
500
500
    void *ptr;
501
501
    if ((ptr=alloc_root(mem_root,size)))
502
 
      bzero(ptr, size);
 
502
      memset(ptr, 0, size);
503
503
    return ptr;
504
504
  }
505
505
  inline char *strdup(const char *str)
586
586
    STATUS.
587
587
  */
588
588
  char *query;
589
 
  uint32 query_length;                          // current query length
 
589
  uint32_t query_length;                          // current query length
590
590
 
591
591
  /**
592
592
    Name of the current (default) database.
1108
1108
    first byte of the packet in do_command()
1109
1109
  */
1110
1110
  enum enum_server_command command;
1111
 
  uint32     server_id;
1112
 
  uint32     file_id;                   // for LOAD DATA INFILE
 
1111
  uint32_t     server_id;
 
1112
  uint32_t     file_id;                 // for LOAD DATA INFILE
1113
1113
  /* remote (peer) port */
1114
 
  uint16 peer_port;
 
1114
  uint16_t peer_port;
1115
1115
  time_t     start_time, user_time;
1116
1116
  uint64_t  connect_utime, thr_create_utime; // track down slow pthread_create
1117
1117
  uint64_t  start_utime, utime_after_lock;
1142
1142
  int binlog_update_row(TABLE* table, bool is_transactional,
1143
1143
                        const uchar *old_data, const uchar *new_data);
1144
1144
 
1145
 
  void set_server_id(uint32 sid) { server_id = sid; }
 
1145
  void set_server_id(uint32_t sid) { server_id = sid; }
1146
1146
 
1147
1147
  /*
1148
1148
    Member functions to handle pending event for row-level logging.
1149
1149
  */
1150
1150
  template <class RowsEventT> Rows_log_event*
1151
 
    binlog_prepare_pending_rows_event(TABLE* table, uint32 serv_id,
 
1151
    binlog_prepare_pending_rows_event(TABLE* table, uint32_t serv_id,
1152
1152
                                      size_t needed,
1153
1153
                                      bool is_transactional,
1154
1154
                                      RowsEventT* hint);
1168
1168
     Flags with per-thread information regarding the status of the
1169
1169
     binary log.
1170
1170
   */
1171
 
  uint32 binlog_flags;
 
1171
  uint32_t binlog_flags;
1172
1172
public:
1173
1173
  uint get_binlog_table_maps() const {
1174
1174
    return binlog_table_maps;
1203
1203
    }
1204
1204
    st_transactions()
1205
1205
    {
1206
 
      bzero((char*)this, sizeof(*this));
 
1206
      memset((char*)this, 0, sizeof(*this));
1207
1207
      xid_state.xid.null();
1208
1208
      init_sql_alloc(&mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
1209
1209
    }
2009
2009
public:
2010
2010
  select_result();
2011
2011
  virtual ~select_result() {};
2012
 
  virtual int prepare(List<Item> &list __attribute__((__unused__)),
 
2012
  virtual int prepare(List<Item> &list __attribute__((unused)),
2013
2013
                      SELECT_LEX_UNIT *u)
2014
2014
  {
2015
2015
    unit= u;
2025
2025
  { return fields.elements; }
2026
2026
  virtual bool send_fields(List<Item> &list, uint flags)=0;
2027
2027
  virtual bool send_data(List<Item> &items)=0;
2028
 
  virtual bool initialize_tables (JOIN  __attribute__((__unused__)) *join=0)
 
2028
  virtual bool initialize_tables (JOIN  __attribute__((unused)) *join=0)
2029
2029
  { return 0; }
2030
2030
  virtual void send_error(uint errcode,const char *err);
2031
2031
  virtual bool send_eof()=0;
2058
2058
{
2059
2059
public:
2060
2060
  select_result_interceptor() {}              /* Remove gcc warning */
2061
 
  uint field_count(List<Item> &fields __attribute__((__unused__))) const
 
2061
  uint field_count(List<Item> &fields __attribute__((unused))) const
2062
2062
  { return 0; }
2063
 
  bool send_fields(List<Item> &fields __attribute__((__unused__)),
2064
 
                   uint flag __attribute__((__unused__))) { return false; }
 
2063
  bool send_fields(List<Item> &fields __attribute__((unused)),
 
2064
                   uint flag __attribute__((unused))) { return false; }
2065
2065
};
2066
2066
 
2067
2067
 
2214
2214
  int prepare2(void) { return 0; }
2215
2215
};
2216
2216
 
2217
 
#include <myisam.h>
 
2217
#include <storage/myisam/myisam.h>
2218
2218
 
2219
2219
/* 
2220
2220
  Param to create temporary tables when doing SELECT:s