~drizzle-trunk/drizzle/development

/* Copyright (C) 2000-2006 MySQL AB

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/* Classes in mysql */

#include <drizzled/plugin_audit.h>

#include "log.h"

#include "rpl_tblmap.h"

class Relay_log_info;

class Query_log_event;

class Load_log_event;

class Slave_log_event;

class Lex_input_stream;

class Rows_log_event;

enum enum_enable_or_disable { LEAVE_AS_IS, ENABLE, DISABLE };

enum enum_ha_read_modes { RFIRST, RNEXT, RPREV, RLAST, RKEY, RNEXT_SAME };

enum enum_duplicates { DUP_ERROR, DUP_REPLACE, DUP_UPDATE };

enum enum_delay_key_write { DELAY_KEY_WRITE_NONE, DELAY_KEY_WRITE_ON,

			    DELAY_KEY_WRITE_ALL };

enum enum_slave_exec_mode { SLAVE_EXEC_MODE_STRICT,

                            SLAVE_EXEC_MODE_IDEMPOTENT,

                            SLAVE_EXEC_MODE_LAST_BIT};

enum enum_mark_columns

{ MARK_COLUMNS_NONE, MARK_COLUMNS_READ, MARK_COLUMNS_WRITE};

enum enum_filetype { FILETYPE_CSV, FILETYPE_XML };

extern char internal_table_name[2];

extern char empty_c_string[1];

extern const char **errmesg;

#define TC_LOG_PAGE_SIZE   8192

#define TC_LOG_MIN_SIZE    (3*TC_LOG_PAGE_SIZE)

#define TC_HEURISTIC_RECOVER_COMMIT   1

#define TC_HEURISTIC_RECOVER_ROLLBACK 2

extern uint tc_heuristic_recover;

typedef struct st_user_var_events

{

  user_var_entry *user_var_event;

  char *value;

  ulong length;

  Item_result type;

  uint charset_number;

} BINLOG_USER_VAR_EVENT;

#define RP_LOCK_LOG_IS_ALREADY_LOCKED 1

#define RP_FORCE_ROTATE               2

/*

  The COPY_INFO structure is used by INSERT/REPLACE code.

  The schema of the row counting by the INSERT/INSERT ... ON DUPLICATE KEY

  UPDATE code:

    If a row is inserted then the copied variable is incremented.

    If a row is updated by the INSERT ... ON DUPLICATE KEY UPDATE and the

      new data differs from the old one then the copied and the updated

      variables are incremented.

    The touched variable is incremented if a row was touched by the update part

      of the INSERT ... ON DUPLICATE KEY UPDATE no matter whether the row

      was actually changed or not.

*/

typedef struct st_copy_info {

  ha_rows records; /**< Number of processed records */

  ha_rows deleted; /**< Number of deleted records */

  ha_rows updated; /**< Number of updated records */

  ha_rows copied;  /**< Number of copied records */

  ha_rows error_count;

  ha_rows touched; /* Number of touched records */

  enum enum_duplicates handle_duplicates;

  int escape_char, last_errno;

  bool ignore;

  /* for INSERT ... UPDATE */

  List<Item> *update_fields;

  List<Item> *update_values;

  /* for VIEW ... WITH CHECK OPTION */

} COPY_INFO;

class Key_part_spec :public Sql_alloc {

public:

  LEX_STRING field_name;

  uint length;

  Key_part_spec(const LEX_STRING &name, uint len)

    : field_name(name), length(len)

  {}

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

    : length(len)

  { field_name.str= (char *)name; field_name.length= name_len; }

  bool operator==(const Key_part_spec& other) const;

  /**

    Construct a copy of this Key_part_spec. field_name is copied

    by-pointer as it is known to never change. At the same time

    'length' may be reset in mysql_prepare_create_table, and this

    is why we supply it with a copy.

    @return If out of memory, 0 is returned and an error is set in

    THD.

  */

  Key_part_spec *clone(MEM_ROOT *mem_root) const

  { return new (mem_root) Key_part_spec(*this); }

};

class Alter_drop :public Sql_alloc {

public:

  enum drop_type {KEY, COLUMN };

  const char *name;

  enum drop_type type;

  Alter_drop(enum drop_type par_type,const char *par_name)

    :name(par_name), type(par_type) {}

  /**

    Used to make a clone of this object for ALTER/CREATE TABLE

    @sa comment for Key_part_spec::clone

  */

  Alter_drop *clone(MEM_ROOT *mem_root) const

    { return new (mem_root) Alter_drop(*this); }

};

class Alter_column :public Sql_alloc {

public:

  const char *name;

  Item *def;

  Alter_column(const char *par_name,Item *literal)

    :name(par_name), def(literal) {}

  /**

    Used to make a clone of this object for ALTER/CREATE TABLE

    @sa comment for Key_part_spec::clone

  */

  Alter_column *clone(MEM_ROOT *mem_root) const

    { return new (mem_root) Alter_column(*this); }

};

class Key :public Sql_alloc {

public:

  enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FOREIGN_KEY};

  enum Keytype type;

  KEY_CREATE_INFO key_create_info;

  List<Key_part_spec> columns;

  LEX_STRING name;

  bool generated;

  Key(enum Keytype type_par, const LEX_STRING &name_arg,

      KEY_CREATE_INFO *key_info_arg,

      bool generated_arg, List<Key_part_spec> &cols)

    :type(type_par), key_create_info(*key_info_arg), columns(cols),

    name(name_arg), generated(generated_arg)

  {}

  Key(enum Keytype type_par, const char *name_arg, size_t name_len_arg,

      KEY_CREATE_INFO *key_info_arg, bool generated_arg,

      List<Key_part_spec> &cols)

    :type(type_par), key_create_info(*key_info_arg), columns(cols),

    generated(generated_arg)

  {

    name.str= (char *)name_arg;

    name.length= name_len_arg;

  }

  Key(const Key &rhs, MEM_ROOT *mem_root);

  virtual ~Key() {}

  /* Equality comparison of keys (ignoring name) */

  friend bool foreign_key_prefix(Key *a, Key *b);

  /**

    Used to make a clone of this object for ALTER/CREATE TABLE

    @sa comment for Key_part_spec::clone

  */

  virtual Key *clone(MEM_ROOT *mem_root) const

    { return new (mem_root) Key(*this, mem_root); }

};

class Table_ident;

class Foreign_key: public Key {

public:

  enum fk_match_opt { FK_MATCH_UNDEF, FK_MATCH_FULL,

		      FK_MATCH_PARTIAL, FK_MATCH_SIMPLE};

  enum fk_option { FK_OPTION_UNDEF, FK_OPTION_RESTRICT, FK_OPTION_CASCADE,

		   FK_OPTION_SET_NULL, FK_OPTION_NO_ACTION, FK_OPTION_DEFAULT};

  Table_ident *ref_table;

  List<Key_part_spec> ref_columns;

  uint delete_opt, update_opt, match_opt;

  Foreign_key(const LEX_STRING &name_arg, List<Key_part_spec> &cols,

	      Table_ident *table,   List<Key_part_spec> &ref_cols,

	      uint delete_opt_arg, uint update_opt_arg, uint match_opt_arg)

    :Key(FOREIGN_KEY, name_arg, &default_key_create_info, 0, cols),

    ref_table(table), ref_columns(ref_cols),

    delete_opt(delete_opt_arg), update_opt(update_opt_arg),

    match_opt(match_opt_arg)

  {}

  Foreign_key(const Foreign_key &rhs, MEM_ROOT *mem_root);

  /**

    Used to make a clone of this object for ALTER/CREATE TABLE

    @sa comment for Key_part_spec::clone

  */

  virtual Key *clone(MEM_ROOT *mem_root) const

  { return new (mem_root) Foreign_key(*this, mem_root); }

};

typedef struct st_mysql_lock

{

  TABLE **table;

  uint table_count,lock_count;

  THR_LOCK_DATA **locks;

} MYSQL_LOCK;

class LEX_COLUMN : public Sql_alloc

{

public:

  String column;

  uint rights;

  LEX_COLUMN (const String& x,const  uint& y ): column (x),rights (y) {}

};

#include "sql_lex.h"				/* Must be here */

class select_result;

class Time_zone;

#define THD_SENTRY_MAGIC 0xfeedd1ff

#define THD_SENTRY_GONE  0xdeadbeef

#define THD_CHECK_SENTRY(thd) assert(thd->dbug_sentry == THD_SENTRY_MAGIC)

struct system_variables

{

  /*

    How dynamically allocated system variables are handled:

    The global_system_variables and max_system_variables are "authoritative"

    They both should have the same 'version' and 'size'.

    When attempting to access a dynamic variable, if the session version

    is out of date, then the session version is updated and realloced if

    neccessary and bytes copied from global to make up for missing data.

  */ 

  ulong dynamic_variables_version;

  char* dynamic_variables_ptr;

  uint dynamic_variables_head;  /* largest valid variable offset */

  uint 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;

  ha_rows select_limit;

  ha_rows max_join_size;

  ulong auto_increment_increment, auto_increment_offset;

  ulong bulk_insert_buff_size;

  ulong join_buff_size;

  ulong max_allowed_packet;

  ulong max_error_count;

  ulong max_length_for_sort_data;

  ulong max_sort_length;

  ulong max_tmp_tables;

  ulong min_examined_row_limit;

  ulong myisam_repair_threads;

  ulong myisam_sort_buff_size;

  ulong myisam_stats_method;

  ulong net_buffer_length;

  ulong net_interactive_timeout;

  ulong net_read_timeout;

  ulong net_retry_count;

  ulong net_wait_timeout;

  ulong net_write_timeout;

  ulong optimizer_prune_level;

  ulong optimizer_search_depth;

  /*

    Controls use of Engine-MRR:

      0 - auto, based on cost

      1 - force MRR when the storage engine is capable of doing it

      2 - disable MRR.

  */

  ulong optimizer_use_mrr; 

  /* A bitmap for switching optimizations on/off */

  ulong optimizer_switch;

  ulong preload_buff_size;

  ulong profiling_history_size;

  ulong query_cache_type;

  ulong read_buff_size;

  ulong read_rnd_buff_size;

  ulong div_precincrement;

  ulong sortbuff_size;

  ulong thread_handling;

  ulong tx_isolation;

  ulong completion_type;

  /* Determines which non-standard SQL behaviour should be enabled */

  ulong sql_mode;

  ulong default_week_format;

  ulong max_seeks_for_key;

  ulong range_alloc_block_size;

  ulong query_alloc_block_size;

  ulong query_prealloc_size;

  ulong trans_alloc_block_size;

  ulong trans_prealloc_size;

  ulong log_warnings;

  ulong group_concat_max_len;

  ulong binlog_format; // binlog format for this thd (see enum_binlog_format)

  /*

    In slave thread we need to know in behalf of which

    thread the query is being run to replicate temp tables properly

  */

  my_thread_id pseudo_thread_id;

  bool low_priority_updates;

  bool new_mode;

  /* 

    compatibility option:

      - index usage hints (USE INDEX without a FOR clause) behave as in 5.0 

  */

  bool old_mode;

  bool engine_condition_pushdown;

  bool keep_files_on_create;

  bool old_alter_table;

  plugin_ref table_plugin;

  /* Only charset part of these variables is sensible */

  CHARSET_INFO  *character_set_filesystem;

  CHARSET_INFO  *character_set_client;

  CHARSET_INFO  *character_set_results;

  /* Both charset and collation parts of these variables are important */

  CHARSET_INFO	*collation_server;

  CHARSET_INFO	*collation_database;

  CHARSET_INFO  *collation_connection;

  /* Locale Support */

  MY_LOCALE *lc_time_names;

  Time_zone *time_zone;

  /* DATE, DATETIME and DRIZZLE_TIME formats */

  DATE_TIME_FORMAT *date_format;

  DATE_TIME_FORMAT *datetime_format;

  DATE_TIME_FORMAT *time_format;

  bool sysdate_is_now;

};

/* per thread status variables */

typedef struct system_status_var

{

  uint64_t bytes_received;

  uint64_t bytes_sent;

  ulong com_other;

  ulong com_stat[(uint) SQLCOM_END];

  ulong created_tmp_disk_tables;

  ulong created_tmp_tables;

  ulong ha_commit_count;

  ulong ha_delete_count;

  ulong ha_read_first_count;

  ulong ha_read_last_count;

  ulong ha_read_key_count;

  ulong ha_read_next_count;

  ulong ha_read_prev_count;

  ulong ha_read_rnd_count;

  ulong ha_read_rnd_next_count;

  ulong ha_rollback_count;

  ulong ha_update_count;

  ulong ha_write_count;

  ulong ha_prepare_count;

  ulong ha_discover_count;

  ulong ha_savepoint_count;

  ulong ha_savepoint_rollback_count;

  /* KEY_CACHE parts. These are copies of the original */

  ulong key_blocks_changed;

  ulong key_blocks_used;

  ulong key_cache_r_requests;

  ulong key_cache_read;

  ulong key_cache_w_requests;

  ulong key_cache_write;

  /* END OF KEY_CACHE parts */

  ulong net_big_packet_count;

  ulong opened_tables;

  ulong opened_shares;

  ulong select_full_join_count;

  ulong select_full_range_join_count;

  ulong select_range_count;

  ulong select_range_check_count;

  ulong select_scan_count;

  ulong long_query_count;

  ulong filesort_merge_passes;

  ulong filesort_range_count;

  ulong filesort_rows;

  ulong filesort_scan_count;

  /* Prepared statements and binary protocol */

  ulong com_stmt_prepare;

  ulong com_stmt_execute;

  ulong com_stmt_send_long_data;

  ulong com_stmt_fetch;

  ulong com_stmt_reset;

  ulong com_stmt_close;

  /*

    Number of statements sent from the client

  */

  ulong questions;

  /*

    IMPORTANT!

    SEE last_system_status_var DEFINITION BELOW.

    Below 'last_system_status_var' are all variables which doesn't make any

    sense to add to the /global/ status variable counter.

  */

  double last_query_cost;

} STATUS_VAR;

/*

  This is used for 'SHOW STATUS'. It must be updated to the last ulong

  variable in system_status_var which is makes sens to add to the global

  counter

*/

#define last_system_status_var questions

void mark_transaction_to_rollback(THD *thd, bool all);

#ifdef MYSQL_SERVER

#define INIT_ARENA_DBUG_INFO is_backup_arena= 0

class Query_arena

{

public:

  /*

    List of items created in the parser for this query. Every item puts

    itself to the list on creation (see Item::Item() for details))

  */

  Item *free_list;

  MEM_ROOT *mem_root;                   // Pointer to current memroot

  bool is_backup_arena; /* True if this arena is used for backup. */

  /*

    The states relfects three diffrent life cycles for three

    different types of statements:

    Prepared statement: INITIALIZED -> PREPARED -> EXECUTED.

    Stored procedure:   INITIALIZED_FOR_SP -> EXECUTED.

    Other statements:   CONVENTIONAL_EXECUTION never changes.

  */

  enum enum_state

  {

    INITIALIZED= 0,

    CONVENTIONAL_EXECUTION= 3, EXECUTED= 4, ERROR= -1

  };

  enum_state state;

  Query_arena(MEM_ROOT *mem_root_arg, enum enum_state state_arg) :

    free_list(0), mem_root(mem_root_arg), state(state_arg)

  { INIT_ARENA_DBUG_INFO; }

  /*

    This constructor is used only when Query_arena is created as

    backup storage for another instance of Query_arena.

  */

  Query_arena() { INIT_ARENA_DBUG_INFO; }

  virtual ~Query_arena() {};

  inline bool is_conventional() const

  { assert(state == CONVENTIONAL_EXECUTION); return state == CONVENTIONAL_EXECUTION; }

  inline void* alloc(size_t size) { return alloc_root(mem_root,size); }

  inline void* calloc(size_t size)

  {

    void *ptr;

    if ((ptr=alloc_root(mem_root,size)))

      memset(ptr, 0, size);

    return ptr;

  }

  inline char *strdup(const char *str)

  { return strdup_root(mem_root,str); }

  inline char *strmake(const char *str, size_t size)

  { return strmake_root(mem_root,str,size); }

  inline void *memdup(const void *str, size_t size)

  { return memdup_root(mem_root,str,size); }

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

  {

    void *ptr;

    if ((ptr= alloc_root(mem_root,size+gap)))

      memcpy(ptr,str,size);

    return ptr;

  }

  void set_query_arena(Query_arena *set);

  void free_items();

  /* Close the active state associated with execution of this statement */

  virtual void cleanup_stmt();

};

/**

  @class Statement

  @brief State of a single command executed against this connection.

  One connection can contain a lot of simultaneously running statements,

  some of which could be:

   - prepared, that is, contain placeholders,

  To perform some action with statement we reset THD part to the state  of

  that statement, do the action, and then save back modified state from THD

  to the statement. It will be changed in near future, and Statement will

  be used explicitly.

*/

class Statement: public ilink, public Query_arena

{

  Statement(const Statement &rhs);              /* not implemented: */

  Statement &operator=(const Statement &rhs);   /* non-copyable */

public:

  /*

    Uniquely identifies each statement object in thread scope; change during

    statement lifetime. FIXME: must be const

  */

   ulong id;

  /*

    MARK_COLUMNS_NONE:  Means mark_used_colums is not set and no indicator to

                        handler of fields used is set

    MARK_COLUMNS_READ:  Means a bit in read set is set to inform handler

	                that the field is to be read. If field list contains

                        duplicates, then thd->dup_field is set to point

                        to the last found duplicate.

    MARK_COLUMNS_WRITE: Means a bit is set in write set to inform handler

			that it needs to update this field in write_row

                        and update_row.

  */

  enum enum_mark_columns mark_used_columns;

  LEX_STRING name; /* name for named prepared statements */

  LEX *lex;                                     // parse tree descriptor

  /*

    Points to the query associated with this statement. It's const, but

    we need to declare it char * because all table handlers are written

    in C and need to point to it.

    Note that (A) if we set query = NULL, we must at the same time set

    query_length = 0, and protect the whole operation with the

    LOCK_thread_count mutex. And (B) we are ONLY allowed to set query to a

    non-NULL value if its previous value is NULL. We do not need to protect

    operation (B) with any mutex. To avoid crashes in races, if we do not

    know that thd->query cannot change at the moment, one should print

    thd->query like this:

      (1) reserve the LOCK_thread_count mutex;

      (2) check if thd->query is NULL;

      (3) if not NULL, then print at most thd->query_length characters from

      it. We will see the query_length field as either 0, or the right value

      for it.

    Assuming that the write and read of an n-bit memory field in an n-bit

    computer is atomic, we can avoid races in the above way. 

    This printing is needed at least in SHOW PROCESSLIST and SHOW INNODB

    STATUS.

  */

  char *query;

  uint32_t query_length;                          // current query length

  /**

    Name of the current (default) database.

    If there is the current (default) database, "db" contains its name. If

    there is no current (default) database, "db" is NULL and "db_length" is

    0. In other words, "db", "db_length" must either be NULL, or contain a

    valid database name.

    @note this attribute is set and alloced by the slave SQL thread (for

    the THD of that thread); that thread is (and must remain, for now) the

    only responsible for freeing this member.

  */

  char *db;

  uint db_length;

public:

  /* This constructor is called for backup statements */

  Statement() {}

  Statement(LEX *lex_arg, MEM_ROOT *mem_root_arg,

            enum enum_state state_arg, ulong id_arg);

  ~Statement() {}

  /* Assign execution context (note: not all members) of given stmt to self */

  void set_statement(Statement *stmt);

  void set_n_backup_statement(Statement *stmt, Statement *backup);

  void restore_backup_statement(Statement *stmt, Statement *backup);

};

struct st_savepoint {

  struct st_savepoint *prev;

  char                *name;

  uint                 length;

  Ha_trx_info         *ha_list;

};

enum xa_states {XA_NOTR=0, XA_ACTIVE, XA_IDLE, XA_PREPARED};

extern const char *xa_state_names[];

typedef struct st_xid_state {

  /* For now, this is only used to catch duplicated external xids */

  XID  xid;                           // transaction identifier

  enum xa_states xa_state;            // used by external XA only

  bool in_thd;

} XID_STATE;

extern pthread_mutex_t LOCK_xid_cache;

extern HASH xid_cache;

bool xid_cache_init(void);

void xid_cache_free(void);

XID_STATE *xid_cache_search(XID *xid);

bool xid_cache_insert(XID *xid, enum xa_states xa_state);

bool xid_cache_insert(XID_STATE *xid_state);

void xid_cache_delete(XID_STATE *xid_state);

/**

  @class Security_context

  @brief A set of THD members describing the current authenticated user.

*/

class Security_context {

public:

  Security_context() {}                       /* Remove gcc warning */

  /*

    host - host of the client

    user - user of the client, set to NULL until the user has been read from

    the connection

    priv_user - The user privilege we are using. May be "" for anonymous user.

    ip - client IP

  */

  char   *host, *user, *priv_user, *ip;

  /* The host privilege we are using */

  char   priv_host[MAX_HOSTNAME];

  /* points to host if host is available, otherwise points to ip */

  const char *host_or_ip;

  ulong db_access;                     /* Privileges for current db */

  void init();

  void destroy();

  void skip_grants();

  inline char *priv_host_name()

  {

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

  }

};

/**

  A registry for item tree transformations performed during

  query optimization. We register only those changes which require

  a rollback to re-execute a prepared statement or stored procedure

  yet another time.

*/

struct Item_change_record;

typedef I_List<Item_change_record> Item_change_list;

/**

  Class that holds information about tables which were opened and locked

  by the thread. It is also used to save/restore this information in

  push_open_tables_state()/pop_open_tables_state().

*/

class Open_tables_state

{

public:

  /**

    List of regular tables in use by this thread. Contains temporary and

    base tables that were opened with @see open_tables().

  */

  TABLE *open_tables;

  /**

    List of temporary tables used by this thread. Contains user-level

    temporary tables, created with CREATE TEMPORARY TABLE, and

    internal temporary tables, created, e.g., to resolve a SELECT,

    or for an intermediate table used in ALTER.

    XXX Why are internal temporary tables added to this list?

  */

  TABLE *temporary_tables;

  /**

    List of tables that were opened with HANDLER OPEN and are

    still in use by this thread.

  */

  TABLE *handler_tables;

  TABLE *derived_tables;

  /*

    During a MySQL session, one can lock tables in two modes: automatic

    or manual. In automatic mode all necessary tables are locked just before

    statement execution, and all acquired locks are stored in 'lock'

    member. Unlocking takes place automatically as well, when the

    statement ends.

    Manual mode comes into play when a user issues a 'LOCK TABLES'

    statement. In this mode the user can only use the locked tables.

    Trying to use any other tables will give an error. The locked tables are

    stored in 'locked_tables' member.  Manual locking is described in

    the 'LOCK_TABLES' chapter of the MySQL manual.

    See also lock_tables() for details.

  */

  MYSQL_LOCK *lock;

  /*

    Tables that were locked with explicit or implicit LOCK TABLES.

    (Implicit LOCK TABLES happens when we are prelocking tables for

     execution of statement which uses stored routines. See description

     THD::prelocked_mode for more info.)

  */

  MYSQL_LOCK *locked_tables;

  /*

    CREATE-SELECT keeps an extra lock for the table being

    created. This field is used to keep the extra lock available for

    lower level routines, which would otherwise miss that lock.

   */

  MYSQL_LOCK *extra_lock;

  ulong	version;

  uint current_tablenr;

  enum enum_flags {

    BACKUPS_AVAIL = (1U << 0)     /* There are backups available */

  };

  /*

    Flags with information about the open tables state.

  */

  uint state_flags;

  /*

    This constructor serves for creation of Open_tables_state instances

    which are used as backup storage.

  */

  Open_tables_state() : state_flags(0U) { }

  Open_tables_state(ulong version_arg);

  void set_open_tables_state(Open_tables_state *state)

  {

    *this= *state;

  }

  void reset_open_tables_state()

  {

    open_tables= temporary_tables= handler_tables= derived_tables= 0;

    extra_lock= lock= locked_tables= 0;

    state_flags= 0U;

  }

};

/**

  @class Sub_statement_state

  @brief Used to save context when executing a function or trigger

*/

/* Defines used for Sub_statement_state::in_sub_stmt */

#define SUB_STMT_TRIGGER 1

#define SUB_STMT_FUNCTION 2

class Sub_statement_state

{

public:

  uint64_t options;

  uint64_t first_successful_insert_id_in_prev_stmt;

  uint64_t first_successful_insert_id_in_cur_stmt, insert_id_for_cur_row;

  Discrete_interval auto_inc_interval_for_cur_row;

  Discrete_intervals_list auto_inc_intervals_forced;

  uint64_t limit_found_rows;

  ha_rows    cuted_fields, sent_row_count, examined_row_count;

  ulong client_capabilities;

  uint in_sub_stmt;

  bool enable_slow_log;

  bool last_insert_id_used;

  SAVEPOINT *savepoints;

};

/* Flags for the THD::system_thread variable */

enum enum_thread_type

{

  NON_SYSTEM_THREAD,

  SYSTEM_THREAD_SLAVE_IO,

  SYSTEM_THREAD_SLAVE_SQL

};

/**

  This class represents the interface for internal error handlers.

  Internal error handlers are exception handlers used by the server

  implementation.

*/

class Internal_error_handler

{

protected:

  Internal_error_handler() {}

  virtual ~Internal_error_handler() {}

public:

  /**

    Handle an error condition.

    This method can be implemented by a subclass to achieve any of the

    following:

    - mask an error internally, prevent exposing it to the user,

    - mask an error and throw another one instead.

    When this method returns true, the error condition is considered

    'handled', and will not be propagated to upper layers.

    It is the responsability of the code installing an internal handler

    to then check for trapped conditions, and implement logic to recover

    from the anticipated conditions trapped during runtime.

    This mechanism is similar to C++ try/throw/catch:

    - 'try' correspond to <code>THD::push_internal_handler()</code>,

    - 'throw' correspond to <code>my_error()</code>,

    which invokes <code>my_message_sql()</code>,

    - 'catch' correspond to checking how/if an internal handler was invoked,

    before removing it from the exception stack with

    <code>THD::pop_internal_handler()</code>.

    @param sql_errno the error number

    @param level the error level

    @param thd the calling thread

    @return true if the error is handled

  */

  virtual bool handle_error(uint sql_errno,

                            const char *message,

                            DRIZZLE_ERROR::enum_warning_level level,

                            THD *thd) = 0;

};

/**

  Stores status of the currently executed statement.

  Cleared at the beginning of the statement, and then

  can hold either OK, ERROR, or EOF status.

  Can not be assigned twice per statement.

*/

class Diagnostics_area

{

public:

  enum enum_diagnostics_status

  {

    /** The area is cleared at start of a statement. */

    DA_EMPTY= 0,

    /** Set whenever one calls my_ok(). */

    DA_OK,

    /** Set whenever one calls my_eof(). */

    DA_EOF,

    /** Set whenever one calls my_error() or my_message(). */

    DA_ERROR,

    /** Set in case of a custom response, such as one from COM_STMT_PREPARE. */

    DA_DISABLED

  };

  /** True if status information is sent to the client. */

  bool is_sent;

  /** Set to make set_error_status after set_{ok,eof}_status possible. */

  bool can_overwrite_status;

  void set_ok_status(THD *thd, ha_rows affected_rows_arg,

                     uint64_t last_insert_id_arg,

                     const char *message);

  void set_eof_status(THD *thd);

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

  void disable_status();

  void reset_diagnostics_area();

  bool is_set() const { return m_status != DA_EMPTY; }