~drizzle-trunk/drizzle/development

#include "drizzled/session.h"

#include "drizzled/session/cache.h"

#include "drizzled/error.h"

#include "drizzled/gettext.h"

#include "drizzled/query_id.h"

#include "drizzled/data_home.h"

#include "drizzled/sql_base.h"

#include "drizzled/lock.h"

#include "drizzled/item/cache.h"

#include "drizzled/item/float.h"

#include "drizzled/item/return_int.h"

#include "drizzled/item/empty_string.h"

#include "drizzled/show.h"

#include "drizzled/plugin/client.h"

#include "drizzled/plugin/query_rewrite.h"

#include "drizzled/identifier.h"

 

#include "drizzled/display.h"

 

#include <boost/filesystem.hpp>

 

#include "drizzled/util/backtrace.h"

    !my_strcasecmp(system_charset_info, field_name.str, other.field_name.str);

  xa_id(0),

  query(new std::string),

  _schema(new std::string("")),

  thread_stack(NULL),

  security_ctx(identifier::User::make_shared()),

  concurrent_execute_allowed(true),

  _global_read_lock(NONE),

  _killed(NOT_KILLED),

  setKilled(KILL_CONNECTION);

  {

    unlockGlobalReadLock();

  }

    assert(security_ctx);

    {

      errmsg_printf(ERRMSG_LVL_WARN, ER(ER_FORCING_CLOSE),

                    internal::my_progname,

                    thread_id,

                    security_ctx->username().c_str());

    }

 

}

 

void Session::setClient(plugin::Client *client_arg)

{

  client= client_arg;

  client->setSession(this);

}

 

void Session::awake(Session::killed_state_t state_to_set)

{

  if ((state_to_set == Session::KILL_QUERY) and (command == COM_SLEEP))

    return;

 

 

  setKilled(state_to_set);

  scheduler->killSession(this);

 

 

  while (not client->haveError() && getKilled() != KILL_CONNECTION)

    if (not executeStatement())

bool Session::schedule(Session::shared_ptr &arg)

  arg->scheduler= plugin::Scheduler::getScheduler();

  assert(arg->scheduler);

  arg->thread_id= arg->variables.pseudo_thread_id= global_thread_id++;

 

  session::Cache::singleton().insert(arg);

 

  if (unlikely(plugin::EventObserver::connectSession(*arg)))

  {

    // We should do something about an error...

  }

 

  if (plugin::Scheduler::getScheduler()->addSession(arg))

  {

    DRIZZLE_CONNECTION_START(arg->getSessionId());

    arg->setKilled(Session::KILL_CONNECTION);

    arg->status_var.aborted_connects++;

    arg->client->sendError(ER_CANT_CREATE_THREAD, error_message_buff);

 

/*

  Is this session viewable by the current user?

*/

bool Session::isViewable() const

{

  return plugin::Authorization::isAuthorized(current_session->user(),

                                             this,

                                             false);

}

 

 

  lex->start(this);

    plugin::Authentication::isAuthenticated(user(), passwd_str);

  {

  }

  if (getKilled() == KILL_CONNECTION)

  l_command= static_cast<enum_server_command>(l_packet[0]);

  return not dispatch_command(l_command, this, l_packet+1, (uint32_t) (packet_length-1));

  while (in_packet_length > 0 && (pos[-1] == ';' || my_isspace(charset() ,pos[-1])))

  std::string *new_query= new std::string(in_packet, in_packet + in_packet_length);

  // We can not be entirely sure _schema has a value

  if (_schema)

  {

    plugin::QueryRewriter::rewriteQuery(*_schema, *new_query);

  }

  query.reset(new_query);

  _state.reset(new State(in_packet, in_packet_length));

  {

  }

  {

    setKilled(Session::KILL_CONNECTION);

  }

    (void) cache->end_io_cache();

  int error= test(cache->end_io_cache());

    (void) cache->end_io_cache();

    util::string::const_shared_ptr schema(session->schema());

    if (schema and not schema->empty())

        target_path /= *schema;

  if (cache->init_io_cache(file, 0L, internal::WRITE_CACHE, 0L, 1, MYF(MY_WME)))

        blob_flag=1;

        break;

 

  lex->end();

  assert(_schema);

  if (_schema and _schema->empty())

  {

    my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));

    return true;

  }

  else if (not _schema)

  {

    my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));

    return true;

  }

  assert(_schema);

 

  *p_db= strmake(_schema->c_str(), _schema->size());

  *p_db_length= _schema->size();

 

void Session::set_db(const std::string &new_db)

  {

    _schema.reset(new std::string(new_db));

  }

  {

    _schema.reset(new std::string(""));

  }

}

 

  if (getKilled() || client->wasAborted())

    if (not getKilled() && variables.log_warnings > 1)

                  , (_schema->empty() ? "unconnected" : _schema->c_str())

                  , security_ctx->username().empty() == false ? security_ctx->username().c_str() : "unauthenticated"

                  , security_ctx->address().c_str()

    session::Cache::singleton().mutex().lock();

 

  setKilled(Session::KILL_CONNECTION);

 

 

  {

    session::Cache::singleton().mutex().unlock();

  }

void Open_tables_state::close_temporary_tables()

void Open_tables_state::close_temporary_table(Table *table)

void Open_tables_state::nukeTable(Table *table)

void Open_tables_state::mark_temp_tables_as_free_for_reuse()

    if (table->query_id == getQueryId())

    if (table->query_id == getQueryId())