~drizzle-trunk/drizzle/development

 */

 

#include "config.h"

#include <sys/stat.h>

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

 

using namespace std;

 

{

  return length == other.length &&

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

}

 

Open_tables_state::Open_tables_state(uint64_t version_arg) :

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

  Open_tables_state(refresh_version),

  mem_root(&main_mem_root),

  lex(&main_lex),

  client(client_arg),

  scheduler(NULL),

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

  if (unit->offset_limit_cnt)

  {                                             // using limit offset,count

    unit->offset_limit_cnt--;

  }

  row_count++;

  Item *item;

 

  if (my_b_write(cache,(unsigned char*) exchange->line_start->ptr(),

                 exchange->line_start->length()))

  while ((item=li++))

  {

    Item_result result_type=item->result_type();

    {

      if (my_b_write(cache,(unsigned char*) exchange->enclosed->ptr(),

                     exchange->enclosed->length()))

    }

    if (!res)

    {                                           // NULL

          null_buff[0]=escape_char;

          null_buff[1]='N';

          if (my_b_write(cache,(unsigned char*) null_buff,2))

        }

        else if (my_b_write(cache,(unsigned char*) "NULL",4))

      }

      else

      {

            tmp_buff[1]= *pos ? *pos : '0';

            if (my_b_write(cache,(unsigned char*) start,(uint32_t) (pos-start)) ||

                my_b_write(cache,(unsigned char*) tmp_buff,2))

            start=pos+1;

          }

        }

        if (my_b_write(cache,(unsigned char*) start,(uint32_t) (pos-start)))

      }

      else if (my_b_write(cache,(unsigned char*) res->ptr(),used_length))

    }

    if (fixed_row_size)

    {                                           // Fill with space

        for (; length > sizeof(space) ; length-=sizeof(space))

        {

          if (my_b_write(cache,(unsigned char*) space,sizeof(space)))

        }

        if (my_b_write(cache,(unsigned char*) space,length))

      }

    }

    if (res && enclosed)

    {

      if (my_b_write(cache, (unsigned char*) exchange->enclosed->ptr(),

                     exchange->enclosed->length()))

    }

    if (--items_left)

    {

      if (my_b_write(cache, (unsigned char*) exchange->field_term->ptr(),

                     field_term_length))

    }

  }

  if (my_b_write(cache,(unsigned char*) exchange->line_term->ptr(),

                 exchange->line_term->length()))

}

 

 

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