~drizzle-trunk/drizzle/development

 

#include "config.h"

#include "drizzled/session.h"

#include <sys/stat.h>

#include "drizzled/error.h"

#include "drizzled/gettext.h"

#include "drizzled/plugin/authentication.h"

#include "drizzled/plugin/logging.h"

#include "drizzled/plugin/transactional_storage_engine.h"

#include "drizzled/probes.h"

#include "drizzled/table_proto.h"

#include "drizzled/db.h"

 

#include "drizzled/util/functors.h"

 

#include <fcntl.h>

#include <algorithm>

#include <climits>

#include <boost/filesystem.hpp>

 

using namespace std;

 

namespace fs=boost::filesystem;

{

  return length == other.length &&

         field_name.length == other.field_name.length &&

}

 

Open_tables_state::Open_tables_state(uint64_t version_arg) :

  mem_root(&main_mem_root),

  xa_id(0),

  lex(&main_lex),

  catalog("LOCAL"),

  client(client_arg),

  scheduler(NULL),

  lock_id(&main_lock_id),

  user_time(0),

  ha_data(plugin::num_trx_monitored_objects),

  arg_of_last_insert_id_function(false),

  first_successful_insert_id_in_prev_stmt(0),

  first_successful_insert_id_in_cur_stmt(0),

  limit_found_rows(0),

  some_tables_deleted(false),

  no_errors(false),

  password(false),

  session_event_observers(NULL),

  use_usage(false)

{

  client->setSession(this);

 

  /*

  memory::init_sql_alloc(&main_mem_root, memory::ROOT_MIN_BLOCK_SIZE, 0);

  thread_stack= NULL;

  count_cuted_fields= CHECK_FIELD_ERROR_FOR_NULL;

  col_access= 0;

  tmp_table= 0;

  used_tables= 0;

{

  assert(cleanup_done == false);

 

#ifdef ENABLE_WHEN_BINLOG_WILL_BE_ABLE_TO_PREPARE

  if (transaction.xid_state.xa_state == XA_PREPARED)

  {

  close_temporary_tables();

 

  if (global_read_lock)

 

  cleanup_done= true;

}

    delete (*iter).second;

  }

  life_properties.clear();

  this->checkSentry();

  if (state_to_set != Session::KILL_QUERY)

  {

    DRIZZLE_CONNECTION_DONE(thread_id);

  }

  if (mysys_var)

  {

    boost_unique_lock_t scopedLock(mysys_var->mutex);

 

  prepareForQueries();

 

  {

      break;

  }

 

  disconnect(0, true);

}

 

{

 

  connection_count.increment();

 

  }

 

  current_global_counters.connections++;

    char error_message_buff[DRIZZLE_ERRMSG_SIZE];

 

 

 

    /* Can't use my_error() since store_globals has not been called. */

    /* TODO replace will better error message */

    snprintf(error_message_buff, sizeof(error_message_buff),

             ER(ER_CANT_CREATE_THREAD), 1);

    return true;

  }

 

}

 

 

const char* Session::enter_cond(boost::condition_variable_any &cond, boost::mutex &mutex, const char* msg)

{

  const char* old_msg = get_proc_info();

 

bool Session::authenticate()

{

  if (client->authenticate())

    return false;

 

  main_da.reset_diagnostics_area();

 

  if (client->readCommand(&l_packet, &packet_length) == false)

    return false;

 

    return false;

 

  if (packet_length == 0)

    return true;

 

 

  if (command >= COM_END)

    command= COM_END;                           // Wrong command

 

  assert(packet_length);

}

 

bool Session::readAndStoreQuery(const char *in_packet, uint32_t in_packet_length)

    in_packet_length--;

  }

  const char *pos= in_packet + in_packet_length; /* Point at end null */

  {

    pos--;

    in_packet_length--;

  }

 

 

  return true;

}

  }

 

  if (result == false)

    my_error(killed_errno(), MYF(0));

  else if ((result == true) && do_release)

 

  return result;

}

  my_message(errcode, err, MYF(0));

  if (file > 0)

  {

    (void) internal::my_close(file, MYF(0));

    (void) internal::my_delete(path.file_string().c_str(), MYF(0));             // Delete file on error

    file= -1;

 

bool select_to_file::send_eof()

{

  if (internal::my_close(file, MYF(MY_WME)))

    error= 1;

  if (!error)

  /* In case of error send_eof() may be not called: close the file here. */

  if (file >= 0)

  {

    (void) internal::my_close(file, MYF(0));

    file= -1;

  }

  if (not to_file.has_root_directory())

  {

    target_path= fs::system_complete(getDataHomeCatalog());

    {

      int count_elements= 0;

      for (fs::path::iterator iter= to_file.begin();

 

      if (count_elements == 1)

      {

      }

    }

    target_path /= to_file;

  if ((file= internal::my_create(target_path.file_string().c_str(), 0666, O_WRONLY|O_EXCL, MYF(MY_WME))) < 0)

    return file;

  (void) fchmod(file, 0666);                    // Because of umask()

  {

    internal::my_close(file, MYF(0));

    internal::my_delete(target_path.file_string().c_str(), MYF(0));  // Delete file on error, it was just created

    {

      if (item->max_length >= MAX_BLOB_WIDTH)

      {

      }

      if (item->result_type() == STRING_RESULT)

        string_results= true;

      else

void Session::end_statement()

{

  /* Cleanup SQL processing state to reuse this statement in next query. */

  query_cache_key= ""; // reset the cache key

  resetResultsetMessage();

}

 

bool Session::copy_db_to(char **p_db, size_t *p_db_length)

{

  return false;

}

 

}

 

 

{

  /* Do not reallocate memory if current chunk is big enough. */

  if (new_db.length())

  else

 

/**

  Mark transaction to rollback and mark error as fatal to a sub-statement.

  plugin_sessionvar_cleanup(this);

 

  /* If necessary, log any aborted or unauthorized connections */

  {

    status_var.aborted_threads++;

  }

 

  if (client->wasAborted())

  {

    {

      SecurityContext *sctx= &security_ctx;

 

      errmsg_printf(ERRMSG_LVL_WARN, ER(ER_NEW_ABORTING_CONNECTION)

                  , thread_id

                  , sctx->getUser().empty() == false ? sctx->getUser().c_str() : "unauthenticated"

                  , sctx->getIp().c_str()

                  , (main_da.is_error() ? main_da.message() : ER(ER_UNKNOWN_ERROR)));

 

  /* Close out our connection to the client */

  if (should_lock)

  if (client->isConnected())

  {

    if (errcode)

    }

    client->close();

  }

  if (should_lock)

}

 

void Session::reset_for_next_command()

  Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread

*/

 

{

  Table *table;

  Table *tmp_next;

  unlink from session->temporary tables and close temporary table

*/

 

{

  if (table->getPrev())

  {

  If this is needed, use close_temporary_table()

*/

 

{

  plugin::StorageEngine *table_type= table->getShare()->db_type();

 

                              DERIVATION_IMPLICIT, false);

}

 

{

  for (Table *table= temporary_tables ; table ; table= table->getNext())

  {

    {

      table->query_id= 0;

      table->cursor->ha_reset();

{

  for (; table ; table= table->getNext())

  {

    {

      table->query_id= 0;

      table->cursor->ha_reset();

*/

void Session::close_thread_tables()

{

 

  /*

    Mark all temporary tables used by this statement as free for reuse.

      handled either before writing a query log event (inside

      binlog_query()) or when preparing a pending event.

     */

    lock= 0;

  }

  /*

    open_tables list. Another thread may work on it.

    (See: table::Cache::singleton().removeTable(), mysql_wait_completed_table())

    Closing a MERGE child before the parent would be fatal if the

  might be an issue (lame engines).

*/

 

{

  {

    if (not best_effort)

    {

      errmsg_printf(ERRMSG_LVL_WARN, _("Could not remove temporary table: '%s', error: %d"),

    }

 

    return true;

  return false;

}

 

{

  assert(base);

 

  {

    errmsg_printf(ERRMSG_LVL_WARN, _("Could not remove temporary table: '%s', error: %d"),

 

    return true;

  }

  @note this will be removed, I am looking through Hudson to see if it is finding

  any tables that are missed during cleanup.

*/

{

  Table *table;

 

      cerr << "\t\t Proto " << proto->schema() << " " << proto->name() << "\n";

    }

    else

      cerr << "\tTabl;e Name " << table->getShare()->getSchemaName() << "." << table->getShare()->getTableName() << " : " << answer << "\n";

  }

}

 

{

  table_message_cache.insert(make_pair(identifier.getPath(), table_message));

 

  return true;

}

 

{

  TableMessageCache::iterator iter;

 

  return true;

}

 

{

  TableMessageCache::iterator iter;

 

  return true;

}

 

{

  TableMessageCache::iterator iter;

 

  return true;

}

 

{

  TableMessageCache::iterator iter;

 

  return tmp_share;

}

 

} /* namespace drizzled */