~drizzle-trunk/drizzle/development

#ifndef DRIZZLED_SESSION_H

#define DRIZZLED_SESSION_H

 

#include "drizzled/plugin.h"

#include "drizzled/resource_context.h"

#include "drizzled/query_id.h"

#include "drizzled/named_savepoint.h"

#include "drizzled/transaction_context.h"

#include "drizzled/util/storable.h"

#include "drizzled/my_hash.h"

#include <netdb.h>

#include <bitset>

#include <deque>

 

#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

 

class Statement;

class Resultset;

}

namespace internal

{

struct st_my_thread_var;

}

 

class Lex_input_stream;

class user_var_entry;

class CopyField;

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

 

};

 

} /* namespace drizzled */

 

/** @TODO why is this in the middle of the file */

#define Session_SENTRY_MAGIC 0xfeedd1ff

#define Session_SENTRY_GONE  0xdeadbeef

 

{

  /*

    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;

  Time_zone *time_zone;

};

 

 

} /* namespace drizzled */

 

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.

  */

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

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

  ResourceContext *getResourceContext(const plugin::MonitoredInTransaction *monitored,

                                      size_t index= 0);

 

  struct st_transactions {

    std::deque<NamedSavepoint> savepoints;

    XID_STATE xid_state;

 

    void cleanup()

  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;