~drizzle-trunk/drizzle/development

  void resetQueryString()

  {

    query.reset();

    _state.reset();

  }

 

  /*

    We need to copy the lock on the string in order to make sure we have a stable string.

    Once this is done we can use it to build a const char* which can be handed off for

    a method to use (Innodb is currently the only engine using this).

  */

  const char *getQueryStringCopy(size_t &length)

 

 

    char *to_return= strmake(tmp_string->c_str(), tmp_string->length());

    return to_return;

  }

 

private:

  boost::shared_ptr<session::State> _state;

 

public:

 

  const boost::shared_ptr<session::State>& state()

  {

    return _state;

  }

 

  /**

    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 Session of that thread); that thread is (and must remain, for now) the

    only responsible for freeing this member.

  */

public:

 

  util::string::const_shared_ptr schema() const

  {

    return _schema ? _schema : util::string::const_shared_ptr(new std::string);

  }

  enum enum_server_command command;

  uint32_t file_id;     /**< File ID for LOAD DATA INFILE */

  /* @note the following three members should likely move to Client */

  uint32_t max_client_packet_length; /**< Maximum number of bytes a client can send in a single packet */

 

private:

  boost::posix_time::ptime _epoch;

  boost::posix_time::ptime _connect_time;

  boost::posix_time::ptime _start_timer;

  boost::posix_time::ptime _end_timer;

 

  boost::posix_time::ptime _user_time;

public:

  uint64_t utime_after_lock; // This used by Innodb.

 

  void resetUserTime()

  {

    _user_time= boost::posix_time::not_a_date_time;

  }

 

  const boost::posix_time::ptime &start_timer() const

  {

    return _start_timer;

  }

 

  void getTimeDifference(boost::posix_time::time_duration &result_arg, const boost::posix_time::ptime &arg) const

  {

    result_arg=  arg - _start_timer;

  }

  bool storeGlobals();

  /**

   * Pulls thread-specific variables into Session state.

   *

   * Returns true most times, or false if there was a problem

   * allocating resources for thread-specific storage.

   *

   * @TODO Kill this.  It's not necessary once my_thr_init() is bye bye.

   *

   */

  bool initGlobals();

 

  /**

   * Run a session.

   *

   * This will initialize the session and begin the command loop.

   */

 

  /**

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

   */

 

  static void unlink(session_id_t &session_id);

  type::Time::epoch_t query_start()

  {

    return getCurrentTimestampEpoch();

  }

 

  void set_time()

  {

    _end_timer= _start_timer= boost::posix_time::microsec_clock::universal_time();

    utime_after_lock= (_start_timer - _epoch).total_microseconds();

  }

 

  void set_time(time_t t) // This is done by a sys_var, as long as user_time is set, we will use that for all references to time

  {

    _user_time= boost::posix_time::from_time_t(t);

  }

 

  void set_time_after_lock()

  {

    utime_after_lock= (boost::posix_time::microsec_clock::universal_time() - _epoch).total_microseconds();

  }

 

  void set_end_timer();

 

  uint64_t getElapsedTime() const

  {

    return (_end_timer - _start_timer).total_microseconds();

  }

 

  /**

   * Returns the current micro-timestamp

   */

  type::Time::epoch_t getCurrentTimestamp(bool actual= true) const

  {

    return ((actual ? boost::posix_time::microsec_clock::universal_time() : _end_timer) - _epoch).total_microseconds();

  }

 

  // We may need to set user on this

  type::Time::epoch_t getCurrentTimestampEpoch() const

  {

                return ((_user_time.is_not_a_date_time() ? _start_timer : _user_time) - _epoch).total_seconds();

  }

 

  type::Time::epoch_t getCurrentTimestampEpoch(type::Time::usec_t &fraction_arg) const

  {

    if (not _user_time.is_not_a_date_time())

    {

      fraction_arg= 0;

      return (_user_time - _epoch).total_seconds();

    }

 

    fraction_arg= _start_timer.time_of_day().fractional_seconds() % 1000000;

    return (_start_timer - _epoch).total_seconds();

  }

 

  inline const charset_info_st *charset() { return default_charset_info; }

   * Returns the timestamp (in microseconds) of when the Session

   * connected to the server.

   */

  uint64_t getConnectMicroseconds() const

  {

    return (_connect_time - _epoch).total_microseconds();

  }

 

  uint64_t getConnectSeconds() const

  {

    return (_connect_time - _epoch).total_seconds();

  }

 

  /**

  util::string::shared_ptr _schema;