~drizzle-trunk/drizzle/development

#include "drizzled/transaction_context.h"

#include "drizzled/util/storable.h"

#include "drizzled/my_hash.h"

 

#include <netdb.h>

#include <map>

#include <string>

#include <bitset>

#include <deque>

 

#include "drizzled/security_context.h"

#include "drizzled/open_tables_state.h"

#include "drizzled/internal_error_handler.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>

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

  }

  /** query associated with this statement */

 

  /**

    Name of the current (default) database.

    only responsible for freeing this member.

  */

  std::string db;

  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 */

 

  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

  /**

   * 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".

    return warn_query_id;

  }

 

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

  inline session_id_t getSessionId()  const

  {

  /**

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

 

    return global_system_variables.storage_engine;

  }

 

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

 

  table::Instance *getInstanceTable();

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

 

} /* namespace drizzled */

 

#endif /* DRIZZLED_SESSION_H */