~drizzle-trunk/drizzle/development

/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-

 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:

 *

 *  Copyright (C) 2008 Sun Microsystems

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; version 2 of the License.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#include <drizzled/global.h>

extern uint32_t tc_heuristic_recover;

  uint32_t charset_number;

  uint32_t length;

  Key_part_spec(const LEX_STRING &name, uint32_t len)

  Key_part_spec(const char *name, const size_t name_len, uint32_t len)

  uint32_t delete_opt, update_opt, match_opt;

              uint32_t delete_opt_arg, uint32_t update_opt_arg, uint32_t match_opt_arg)

  Table **table;

  uint32_t table_count,lock_count;

} DRIZZLE_LOCK;

  uint32_t rights;

  uint32_t dynamic_variables_head;  /* largest valid variable offset */

  uint32_t dynamic_variables_size;  /* how many bytes are in use */

  uint64_t myisam_max_extra_sort_file_size;

  uint64_t myisam_max_sort_file_size;

  uint64_t max_heap_table_size;

  uint64_t tmp_table_size;

  uint64_t long_query_time;

  bool low_priority_updates;

  bool new_mode;

  bool old_mode;

  bool engine_condition_pushdown;

  bool keep_files_on_create;

  bool old_alter_table;

  const CHARSET_INFO  *character_set_filesystem;

  const CHARSET_INFO  *character_set_client;

  const CHARSET_INFO  *character_set_results;

  const CHARSET_INFO    *collation_server;

  const CHARSET_INFO    *collation_database;

  const CHARSET_INFO  *collation_connection;

  /* DATE, DATETIME and DRIZZLE_TIME formats */

  bool sysdate_is_now;

#include "sql_lex.h"  /* only for SQLCOM_END */

  uint64_t bytes_received;

  uint64_t bytes_sent;

#ifdef DRIZZLE_SERVER

 

  Query_arena(MEM_ROOT *mem_root_arg) :

    free_list(0), mem_root(mem_root_arg)

  { }

  Query_arena() { }

      memset(ptr, 0, size);

  inline void *memdup_w_gap(const void *str, size_t size, uint32_t gap)

  uint32_t query_length;                          // current query length

  uint32_t db_length;

  Statement(LEX *lex_arg, MEM_ROOT *mem_root_arg, ulong id_arg);

  uint32_t                 length;

  char *user; 

  char *ip;

    return (ip ? ip : (char *)"%");

  Table *open_tables;

  Table *temporary_tables;

  Table *handler_tables;

  Table *derived_tables;

  DRIZZLE_LOCK *lock;

  DRIZZLE_LOCK *locked_tables;

  DRIZZLE_LOCK *extra_lock;

  uint32_t current_tablenr;

  uint32_t state_flags;

  NON_SYSTEM_THREAD,

  SYSTEM_THREAD_SLAVE_IO,

  SYSTEM_THREAD_SLAVE_SQL

  virtual bool handle_error(uint32_t sql_errno,

                            DRIZZLE_ERROR::enum_warning_level level,

                     uint64_t last_insert_id_arg,

  void set_error_status(THD *thd, uint32_t sql_errno_arg, const char *message_arg);

  uint32_t sql_errno() const

  uint32_t server_status() const

  uint64_t last_insert_id() const

  uint32_t total_warn_count() const

  char m_message[DRIZZLE_ERRMSG_SIZE];

  uint32_t m_sql_errno;

  uint32_t m_server_status;

  uint64_t   m_last_insert_id;

  void        set_proc_info(const char *info) { proc_info= info; }

  const char* get_proc_info() const { return proc_info; }

  uint32_t dbug_sentry; // watch out for memory corruption

  uint32_t     server_id;

  uint32_t     file_id;                 // for LOAD DATA INFILE

  uint16_t peer_port;

  uint64_t  connect_utime, thr_create_utime; // track down slow pthread_create

  uint64_t  start_utime, utime_after_lock;

  uint32_t in_sub_stmt;

  int binlog_write_table_map(Table *table, bool is_transactional);

  int binlog_write_row(Table* table, bool is_transactional,

                       const unsigned char *new_data);

  int binlog_delete_row(Table* table, bool is_transactional,

                        const unsigned char *old_data);

  int binlog_update_row(Table* table, bool is_transactional,

                        const unsigned char *old_data, const unsigned char *new_data);

  void set_server_id(uint32_t sid) { server_id = sid; }

    binlog_prepare_pending_rows_event(Table* table, uint32_t serv_id,

  uint32_t binlog_table_maps; // Number of table maps currently in the binlog

  uint32_t binlog_flags;

  uint32_t get_binlog_table_maps() const {

    CHANGED_TableList* changed_tables;

      memset(this, 0, sizeof(*this));