~drizzle-trunk/drizzle/development

#include "drizzled/transaction_context.h"

#include "drizzled/util/storable.h"

#include "drizzled/my_hash.h"

#include <netdb.h>

#include <bitset>

#include <deque>

 

#include "drizzled/open_tables_state.h"

#include "drizzled/internal_error_handler.h"

#include "drizzled/diagnostics_area.h"

#include "drizzled/plugin/authorization.h"

 

#include <boost/unordered_map.hpp>

#include <boost/thread/mutex.hpp>

#include <boost/thread/shared_mutex.hpp>

#include <boost/thread/condition_variable.hpp>

 

#define MIN_HANDSHAKE_SIZE      6

 

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

      was actually changed or not.

*/

{

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

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

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

struct drizzle_system_variables

{

  drizzle_system_variables()

  /*

    How dynamically allocated system variables are handled:

 

  uint64_t preload_buff_size;

  uint32_t read_buff_size;

  uint32_t read_rnd_buff_size;

  size_t sortbuff_size;

  uint32_t thread_handling;

  uint32_t tx_isolation;

public:

  // Plugin storage in Session.

  typedef boost::unordered_map<std::string, util::Storable *, util::insensitive_hash, util::insensitive_equal_to> PropertyMap;

 

  /*

    MARK_COLUMNS_NONE:  Means mark_used_colums is not set and no indicator to

  {

    return mem_root;

  }

  /**

   * Uniquely identifies each statement object in thread scope; change during

   * statement lifetime.

    return lex;

  }

  /** query associated with this statement */

 

  /**

    Name of the current (default) database.

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

    only responsible for freeing this member.

  */

  std::string catalog;

  /* current cache key */

  std::string query_cache_key;

 

  memory::Root warn_root; /**< Allocation area for warnings and errors */

  plugin::Client *client; /**< Pointer to client object */

  plugin::Scheduler *scheduler; /**< Pointer to scheduler object */

  void *scheduler_arg; /**< Pointer to the optional scheduler argument */

  typedef boost::unordered_map< std::string, user_var_entry *, util::insensitive_hash, util::insensitive_equal_to> UserVars;

  typedef std::pair< UserVars::iterator, UserVars::iterator > UserVarsRange;

  UserVars user_vars; /**< Hash of user variables defined during the session's lifetime */

 

public:

  drizzle_system_variables variables; /**< Mutable local variables local to the session */

  struct system_status_var status_var; /**< Session-local status counters */

  THR_LOCK_INFO lock_info; /**< Locking information for this session */

  THR_LOCK_OWNER main_lock_id; /**< To use for conventional queries */

  THR_LOCK_OWNER *lock_id; /**< If not main_lock_id, points to the lock_id of a cursor. */

 

  /**

   * A pointer to the stack frame of the scheduler thread

  char *thread_stack;

 

private:

 

  int32_t scoreboard_index;

 

    assert(this->dbug_sentry == Session_SENTRY_MAGIC);

  }

public:

  {

  }

 

  {

  }

 

  int32_t getScoreboardIndex()

  /**

   * Is this session viewable by the current user?

   */

 

  /**

    Used in error messages to tell user in what part of MySQL we found an

  */

  uint32_t dbug_sentry; /**< watch for memory corruption */

private:

  internal::st_my_thread_var *mysys_var;

public:

 

  internal::st_my_thread_var *getThreadVar()

  {

    return mysys_var;

  }

 

  /**

   * Type of current query: COM_STMT_PREPARE, COM_QUERY, etc. Set from

   * first byte of the packet in executeStatement()

  Field *dup_field;

  sigset_t signals;

 

  /* Tells if LAST_INSERT_ID(#) was called for the current statement */

  bool arg_of_last_insert_id_function;

  /*

    ALL OVER THIS FILE, "insert_id" means "*automatically generated* value for

    insertion into an auto_increment column".

  uint32_t row_count;

  session_id_t thread_id;

  uint32_t tmp_table;

  uint32_t server_status;

  uint32_t open_options;

  uint32_t select_number; /**< number of select (used for EXPLAIN) */

  enum_tx_isolation session_tx_isolation;

  enum_check_fields count_cuted_fields;

 

  {

    NOT_KILLED,

    KILL_BAD_DATA,

    KILL_QUERY,

    KILLED_NO_VALUE /* means none of the above states apply */

  };

  bool some_tables_deleted;

  bool no_errors;

  bool password;

  }

 

  /** Returns the current query ID */

  {

    return query_id;

  }

    return warn_query_id;

  }

 

  /** Accessor method returning the session's ID. */

  inline session_id_t getSessionId()  const

  {

   */

  void cleanup_after_query();

  bool storeGlobals();

  /**

   * Pulls thread-specific variables into Session state.

   *

  /**

   * Schedule a session to be run on the default scheduler.

   */

 

  /*

    For enter_cond() / exit_cond() to work the mutex must be got before

  inline time_t query_start() { return start_time; }

  inline void set_time()

  {

    if (user_time)

    {

      start_time= user_time;

    }

  }

  inline void   set_current_time()    { start_time= time(NULL); }

  inline void   set_time(time_t t)

  {

    start_time= user_time= t;

  /**

   * Returns the current micro-timestamp

   */

  inline uint64_t getCurrentTimestamp()  

  { 

  }

  inline uint64_t found_rows(void)

  {

    @todo: To silence an error, one should use Internal_error_handler

    mechanism. In future this function will be removed.

  */

  {

    if (main_da.is_error())

      main_da.reset_diagnostics_area();

  }

 

  /**

  void end_statement();

  inline int killed_errno() const

  {

  }

  void send_kill_message() const;

  /* return true if we will abort query if we make a warning now */

    database usually involves other actions, like switching other database

    attributes including security context. In the future, this operation

    will be made private and more convenient interface will be provided.

  */

 

  /*

    Copy the current database to the argument. Use the current arena to

   * set to query_id of original query.

   */

  void mark_used_tables_as_free_for_reuse(Table *table);

 

public:

 

  void close_old_data_files(bool morph_locks= false,

                            bool send_refresh= false);

  void close_open_tables();

 

private:

  bool free_cached_table();

  Table *openTable(TableList *table_list, bool *refresh, uint32_t flags= 0);

 

  void unlink_open_table(Table *find);

  void close_cached_table(Table *table);

 

  /* Create a lock in the cache */

  table::Placeholder *table_cache_insert_placeholder(const TableIdentifier &identifier);

 

  typedef boost::unordered_map<std::string, message::Table, util::insensitive_hash, util::insensitive_equal_to> TableMessageCache;

private:

public:

 

  /* Reopen operations */

  bool reopen_tables(bool get_locks, bool mark_share_as_old);

  int setup_conds(TableList *leaves, COND **conds);

  int lock_tables(TableList *tables, uint32_t count, bool *need_reopen);

 

  drizzled::util::Storable *getProperty(const std::string &arg)

  {

    return life_properties[arg];

    if (variables.storage_engine)

      return variables.storage_engine;

    return global_system_variables.storage_engine;

 

  void get_xid(DRIZZLE_XID *xid); // Innodb only

 

 * A structure used to describe sort information

 * for a field or item used in ORDER BY.

 */

{

  Field *field; /**< Field to sort */

  Item  *item; /**< Item if not sorting fields */

  size_t length; /**< Length of sort field */

static const std::bitset<CF_BIT_SIZE> CF_SHOW_TABLE_COMMAND(1 << CF_BIT_SHOW_TABLE_COMMAND);

static const std::bitset<CF_BIT_SIZE> CF_WRITE_LOGS_COMMAND(1 << CF_BIT_WRITE_LOGS_COMMAND);