← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/session.cc

  • Committer: lbieber
  • Date: 2010-10-05 21:14:30 UTC
  • mfrom: (1775.5.2 bug621331)
  • mto: This revision was merged to the branch mainline in revision 1814.
  • Revision ID: lbieber@orisndriz08-20101005211430-xmy19fcls25swctl
Merge Billy - fix bug 621331 - Replace use of stringstream with boost::lexical_cast

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/session.cc
22
22
 */
23
23
 
24
24
#include "config.h"
25
 
#include "drizzled/session.h"
26
 
#include "drizzled/session/cache.h"
 
25
#include <drizzled/session.h>
 
26
#include "drizzled/session_list.h"
27
27
#include <sys/stat.h>
28
 
#include "drizzled/error.h"
29
 
#include "drizzled/gettext.h"
30
 
#include "drizzled/query_id.h"
31
 
#include "drizzled/data_home.h"
32
 
#include "drizzled/sql_base.h"
33
 
#include "drizzled/lock.h"
34
 
#include "drizzled/item/cache.h"
35
 
#include "drizzled/item/float.h"
36
 
#include "drizzled/item/return_int.h"
37
 
#include "drizzled/item/empty_string.h"
38
 
#include "drizzled/show.h"
39
 
#include "drizzled/plugin/client.h"
 
28
#include <drizzled/error.h>
 
29
#include <drizzled/gettext.h>
 
30
#include <drizzled/query_id.h>
 
31
#include <drizzled/data_home.h>
 
32
#include <drizzled/sql_base.h>
 
33
#include <drizzled/lock.h>
 
34
#include <drizzled/item/cache.h>
 
35
#include <drizzled/item/float.h>
 
36
#include <drizzled/item/return_int.h>
 
37
#include <drizzled/item/empty_string.h>
 
38
#include <drizzled/show.h>
 
39
#include <drizzled/plugin/client.h>
40
40
#include "drizzled/plugin/scheduler.h"
41
41
#include "drizzled/plugin/authentication.h"
42
42
#include "drizzled/plugin/logging.h"
43
43
#include "drizzled/plugin/transactional_storage_engine.h"
44
 
#include "drizzled/plugin/query_rewrite.h"
45
44
#include "drizzled/probes.h"
46
45
#include "drizzled/table_proto.h"
47
46
#include "drizzled/db.h"
49
48
#include "drizzled/transaction_services.h"
50
49
#include "drizzled/drizzled.h"
51
50
 
52
 
#include "drizzled/table/instance.h"
 
51
#include "drizzled/table_share_instance.h"
53
52
 
54
53
#include "plugin/myisam/myisam.h"
55
54
#include "drizzled/internal/iocache.h"
56
55
#include "drizzled/internal/thread_var.h"
57
56
#include "drizzled/plugin/event_observer.h"
58
57
 
59
 
#include "drizzled/util/functors.h"
60
 
 
61
 
#include "drizzled/display.h"
62
 
 
63
58
#include <fcntl.h>
64
59
#include <algorithm>
65
60
#include <climits>
66
 
#include <boost/filesystem.hpp>
67
 
 
68
 
#include "drizzled/util/backtrace.h"
 
61
#include "boost/filesystem.hpp" 
69
62
 
70
63
using namespace std;
71
64
 
86
79
{
87
80
  return length == other.length &&
88
81
         field_name.length == other.field_name.length &&
89
 
    !my_strcasecmp(system_charset_info, field_name.str, other.field_name.str);
 
82
         !strcmp(field_name.str, other.field_name.str);
90
83
}
91
84
 
92
85
Open_tables_state::Open_tables_state(uint64_t version_arg) :
162
155
Session::Session(plugin::Client *client_arg) :
163
156
  Open_tables_state(refresh_version),
164
157
  mem_root(&main_mem_root),
165
 
  xa_id(0),
166
158
  lex(&main_lex),
167
 
  query(new std::string),
168
 
  _schema(new std::string("")),
169
 
  catalog("LOCAL"),
 
159
  query(),
170
160
  client(client_arg),
171
161
  scheduler(NULL),
172
162
  scheduler_arg(NULL),
173
163
  lock_id(&main_lock_id),
174
164
  user_time(0),
175
165
  ha_data(plugin::num_trx_monitored_objects),
176
 
  concurrent_execute_allowed(true),
177
166
  arg_of_last_insert_id_function(false),
178
167
  first_successful_insert_id_in_prev_stmt(0),
179
168
  first_successful_insert_id_in_cur_stmt(0),
180
169
  limit_found_rows(0),
181
 
  _global_read_lock(NONE),
182
 
  _killed(NOT_KILLED),
 
170
  global_read_lock(0),
183
171
  some_tables_deleted(false),
184
172
  no_errors(false),
185
173
  password(false),
195
183
  session_event_observers(NULL),
196
184
  use_usage(false)
197
185
{
 
186
  memset(process_list_info, 0, PROCESS_LIST_WIDTH);
198
187
  client->setSession(this);
199
188
 
200
189
  /*
205
194
  memory::init_sql_alloc(&main_mem_root, memory::ROOT_MIN_BLOCK_SIZE, 0);
206
195
  thread_stack= NULL;
207
196
  count_cuted_fields= CHECK_FIELD_ERROR_FOR_NULL;
 
197
  killed= NOT_KILLED;
208
198
  col_access= 0;
209
199
  tmp_table= 0;
210
200
  used_tables= 0;
313
303
    return;
314
304
 
315
305
  setAbort(true);
316
 
  boost_unique_lock_t scopedLock(mysys_var->mutex);
 
306
  boost::mutex::scoped_lock scopedLock(mysys_var->mutex);
317
307
  if (mysys_var->current_cond)
318
308
  {
319
309
    mysys_var->current_mutex->lock();
339
329
{
340
330
  assert(cleanup_done == false);
341
331
 
342
 
  setKilled(KILL_CONNECTION);
 
332
  killed= KILL_CONNECTION;
343
333
#ifdef ENABLE_WHEN_BINLOG_WILL_BE_ABLE_TO_PREPARE
344
334
  if (transaction.xid_state.xa_state == XA_PREPARED)
345
335
  {
365
355
  close_temporary_tables();
366
356
 
367
357
  if (global_read_lock)
368
 
  {
369
 
    unlockGlobalReadLock();
370
 
  }
 
358
    unlock_global_read_lock(this);
371
359
 
372
360
  cleanup_done= true;
373
361
}
412
400
    delete (*iter).second;
413
401
  }
414
402
  life_properties.clear();
415
 
}
416
 
 
417
 
void Session::setClient(plugin::Client *client_arg)
418
 
{
419
 
  client= client_arg;
420
 
  client->setSession(this);
421
 
}
422
 
 
423
 
void Session::awake(Session::killed_state_t state_to_set)
424
 
{
425
 
  if ((state_to_set == Session::KILL_QUERY) and (command == COM_SLEEP))
426
 
    return;
427
 
 
 
403
 
 
404
  /* Ensure that no one is using Session */
 
405
  LOCK_delete.unlock();
 
406
}
 
407
 
 
408
void Session::awake(Session::killed_state state_to_set)
 
409
{
428
410
  this->checkSentry();
429
 
 
430
 
  setKilled(state_to_set);
431
 
  scheduler->killSession(this);
432
 
 
 
411
  safe_mutex_assert_owner(&LOCK_delete);
 
412
 
 
413
  killed= state_to_set;
433
414
  if (state_to_set != Session::KILL_QUERY)
434
415
  {
 
416
    scheduler->killSession(this);
435
417
    DRIZZLE_CONNECTION_DONE(thread_id);
436
418
  }
437
 
 
438
419
  if (mysys_var)
439
420
  {
440
 
    boost_unique_lock_t scopedLock(mysys_var->mutex);
 
421
    boost::mutex::scoped_lock scopedLock(mysys_var->mutex);
441
422
    /*
442
423
      "
443
424
      This broadcast could be up in the air if the victim thread
547
528
 
548
529
  prepareForQueries();
549
530
 
550
 
  while (not client->haveError() && getKilled() != KILL_CONNECTION)
 
531
  while (! client->haveError() && killed != KILL_CONNECTION)
551
532
  {
552
 
    if (not executeStatement())
 
533
    if (! executeStatement())
553
534
      break;
554
535
  }
555
536
 
556
537
  disconnect(0, true);
557
538
}
558
539
 
559
 
bool Session::schedule(Session::shared_ptr &arg)
 
540
bool Session::schedule()
560
541
{
561
 
  arg->scheduler= plugin::Scheduler::getScheduler();
562
 
  assert(arg->scheduler);
 
542
  scheduler= plugin::Scheduler::getScheduler();
 
543
  assert(scheduler);
563
544
 
564
545
  connection_count.increment();
565
546
 
569
550
  }
570
551
 
571
552
  current_global_counters.connections++;
572
 
  arg->thread_id= arg->variables.pseudo_thread_id= global_thread_id++;
573
 
 
574
 
  session::Cache::singleton().insert(arg);
575
 
 
576
 
  if (unlikely(plugin::EventObserver::connectSession(*arg)))
577
 
  {
578
 
    // We should do something about an error...
579
 
  }
580
 
 
581
 
  if (plugin::Scheduler::getScheduler()->addSession(arg))
582
 
  {
583
 
    DRIZZLE_CONNECTION_START(arg->getSessionId());
 
553
  thread_id= variables.pseudo_thread_id= global_thread_id++;
 
554
 
 
555
  LOCK_thread_count.lock();
 
556
  getSessionList().push_back(this);
 
557
  LOCK_thread_count.unlock();
 
558
 
 
559
  if (scheduler->addSession(this))
 
560
  {
 
561
    DRIZZLE_CONNECTION_START(thread_id);
584
562
    char error_message_buff[DRIZZLE_ERRMSG_SIZE];
585
563
 
586
 
    arg->setKilled(Session::KILL_CONNECTION);
 
564
    killed= Session::KILL_CONNECTION;
587
565
 
588
 
    arg->status_var.aborted_connects++;
 
566
    status_var.aborted_connects++;
589
567
 
590
568
    /* Can't use my_error() since store_globals has not been called. */
591
569
    /* TODO replace will better error message */
592
570
    snprintf(error_message_buff, sizeof(error_message_buff),
593
571
             ER(ER_CANT_CREATE_THREAD), 1);
594
 
    arg->client->sendError(ER_CANT_CREATE_THREAD, error_message_buff);
595
 
 
 
572
    client->sendError(ER_CANT_CREATE_THREAD, error_message_buff);
596
573
    return true;
597
574
  }
598
575
 
600
577
}
601
578
 
602
579
 
603
 
/*
604
 
  Is this session viewable by the current user?
605
 
*/
606
 
bool Session::isViewable() const
607
 
{
608
 
  return plugin::Authorization::isAuthorized(current_session->getSecurityContext(),
609
 
                                             this,
610
 
                                             false);
611
 
}
612
 
 
613
 
 
614
 
const char* Session::enter_cond(boost::condition_variable_any &cond, boost::mutex &mutex, const char* msg)
 
580
const char* Session::enter_cond(boost::condition_variable &cond, boost::mutex &mutex, const char* msg)
615
581
{
616
582
  const char* old_msg = get_proc_info();
617
583
  safe_mutex_assert_owner(mutex);
630
596
    does a Session::awake() on you).
631
597
  */
632
598
  mysys_var->current_mutex->unlock();
633
 
  boost_unique_lock_t scopedLock(mysys_var->mutex);
 
599
  boost::mutex::scoped_lock scopedLock(mysys_var->mutex);
634
600
  mysys_var->current_mutex = 0;
635
601
  mysys_var->current_cond = 0;
636
602
  this->set_proc_info(old_msg);
638
604
 
639
605
bool Session::authenticate()
640
606
{
641
 
  lex->start(this);
 
607
  lex_start(this);
642
608
  if (client->authenticate())
643
609
    return false;
644
610
 
647
613
  return true;
648
614
}
649
615
 
650
 
bool Session::checkUser(const std::string &passwd_str,
651
 
                        const std::string &in_db)
 
616
bool Session::checkUser(const char *passwd, uint32_t passwd_len, const char *in_db)
652
617
{
 
618
  const string passwd_str(passwd, passwd_len);
653
619
  bool is_authenticated=
654
620
    plugin::Authentication::isAuthenticated(getSecurityContext(),
655
621
                                            passwd_str);
662
628
  }
663
629
 
664
630
  /* Change database if necessary */
665
 
  if (not in_db.empty())
 
631
  if (in_db && in_db[0])
666
632
  {
667
633
    SchemaIdentifier identifier(in_db);
668
634
    if (mysql_change_db(this, identifier))
672
638
    }
673
639
  }
674
640
  my_ok();
675
 
  password= not passwd_str.empty();
 
641
  password= test(passwd_len);          // remember for error messages
676
642
 
677
643
  /* Ready to handle queries */
678
644
  return true;
694
660
  main_da.reset_diagnostics_area();
695
661
 
696
662
  if (client->readCommand(&l_packet, &packet_length) == false)
697
 
  {
698
663
    return false;
699
 
  }
700
664
 
701
 
  if (getKilled() == KILL_CONNECTION)
 
665
  if (killed == KILL_CONNECTION)
702
666
    return false;
703
667
 
704
668
  if (packet_length == 0)
705
669
    return true;
706
670
 
707
 
  l_command= static_cast<enum_server_command>(l_packet[0]);
 
671
  l_command= (enum enum_server_command) (unsigned char) l_packet[0];
708
672
 
709
673
  if (command >= COM_END)
710
674
    command= COM_END;                           // Wrong command
711
675
 
712
676
  assert(packet_length);
713
 
  return not dispatch_command(l_command, this, l_packet+1, (uint32_t) (packet_length-1));
 
677
  return ! dispatch_command(l_command, this, l_packet+1, (uint32_t) (packet_length-1));
714
678
}
715
679
 
716
680
bool Session::readAndStoreQuery(const char *in_packet, uint32_t in_packet_length)
722
686
    in_packet_length--;
723
687
  }
724
688
  const char *pos= in_packet + in_packet_length; /* Point at end null */
725
 
  while (in_packet_length > 0 && (pos[-1] == ';' || my_isspace(charset() ,pos[-1])))
 
689
  while (in_packet_length > 0 &&
 
690
         (pos[-1] == ';' || my_isspace(charset() ,pos[-1])))
726
691
  {
727
692
    pos--;
728
693
    in_packet_length--;
729
694
  }
730
695
 
731
 
  std::string *new_query= new std::string(in_packet, in_packet + in_packet_length);
732
 
  // We can not be entirely sure _schema has a value
733
 
  if (_schema)
734
 
  {
735
 
    plugin::QueryRewriter::rewriteQuery(*_schema, *new_query);
736
 
  }
737
 
  query.reset(new_query);
738
 
  _state.reset(new State(in_packet, in_packet_length));
 
696
  query.assign(in_packet, in_packet + in_packet_length);
739
697
 
740
698
  return true;
741
699
}
790
748
  }
791
749
 
792
750
  if (result == false)
793
 
  {
794
751
    my_error(killed_errno(), MYF(0));
795
 
  }
796
752
  else if ((result == true) && do_release)
797
 
  {
798
 
    setKilled(Session::KILL_CONNECTION);
799
 
  }
 
753
    killed= Session::KILL_CONNECTION;
800
754
 
801
755
  return result;
802
756
}
867
821
  where= Session::DEFAULT_WHERE;
868
822
 
869
823
  /* Reset the temporary shares we built */
870
 
  for_each(temporary_shares.begin(),
871
 
           temporary_shares.end(),
872
 
           DeletePtr());
 
824
  for (std::vector<TableShareInstance *>::iterator iter= temporary_shares.begin();
 
825
       iter != temporary_shares.end(); iter++)
 
826
  {
 
827
    delete *iter;
 
828
  }
873
829
  temporary_shares.clear();
874
830
}
875
831
 
955
911
  my_message(errcode, err, MYF(0));
956
912
  if (file > 0)
957
913
  {
958
 
    (void) cache->end_io_cache();
 
914
    (void) end_io_cache(cache);
959
915
    (void) internal::my_close(file, MYF(0));
960
 
    (void) internal::my_delete(path.file_string().c_str(), MYF(0));             // Delete file on error
 
916
    (void) internal::my_delete(path, MYF(0));           // Delete file on error
961
917
    file= -1;
962
918
  }
963
919
}
965
921
 
966
922
bool select_to_file::send_eof()
967
923
{
968
 
  int error= test(cache->end_io_cache());
 
924
  int error= test(end_io_cache(cache));
969
925
  if (internal::my_close(file, MYF(MY_WME)))
970
926
    error= 1;
971
927
  if (!error)
987
943
  /* In case of error send_eof() may be not called: close the file here. */
988
944
  if (file >= 0)
989
945
  {
990
 
    (void) cache->end_io_cache();
 
946
    (void) end_io_cache(cache);
991
947
    (void) internal::my_close(file, MYF(0));
992
948
    file= -1;
993
949
  }
994
 
  path= "";
 
950
  path[0]= '\0';
995
951
  row_count= 0;
996
952
}
997
953
 
1001
957
    cache(static_cast<internal::IO_CACHE *>(memory::sql_calloc(sizeof(internal::IO_CACHE)))),
1002
958
    row_count(0L)
1003
959
{
1004
 
  path= "";
 
960
  path[0]=0;
1005
961
}
1006
962
 
1007
963
select_to_file::~select_to_file()
1035
991
*/
1036
992
 
1037
993
 
1038
 
static int create_file(Session *session,
1039
 
                       fs::path &target_path,
1040
 
                       file_exchange *exchange,
1041
 
                       internal::IO_CACHE *cache)
 
994
static int create_file(Session *session, char *path, file_exchange *exchange, internal::IO_CACHE *cache)
1042
995
{
1043
 
  fs::path to_file(exchange->file_name);
1044
996
  int file;
1045
 
 
1046
 
  if (not to_file.has_root_directory())
 
997
  uint32_t option= MY_UNPACK_FILENAME | MY_RELATIVE_PATH;
 
998
 
 
999
#ifdef DONT_ALLOW_FULL_LOAD_DATA_PATHS
 
1000
  option|= MY_REPLACE_DIR;                      // Force use of db directory
 
1001
#endif
 
1002
 
 
1003
  if (!internal::dirname_length(exchange->file_name))
1047
1004
  {
1048
 
    target_path= fs::system_complete(getDataHomeCatalog());
1049
 
    util::string::const_shared_ptr schema(session->schema());
1050
 
    if (schema and not schema->empty())
1051
 
    {
1052
 
      int count_elements= 0;
1053
 
      for (fs::path::iterator iter= to_file.begin();
1054
 
           iter != to_file.end();
1055
 
           ++iter, ++count_elements)
1056
 
      { }
1057
 
 
1058
 
      if (count_elements == 1)
1059
 
      {
1060
 
        target_path /= *schema;
1061
 
      }
1062
 
    }
1063
 
    target_path /= to_file;
 
1005
    strcpy(path, getDataHomeCatalog().c_str());
 
1006
    strncat(path, "/", 1);
 
1007
    if (! session->db.empty())
 
1008
      strncat(path, session->db.c_str(), FN_REFLEN-getDataHomeCatalog().size());
 
1009
    (void) internal::fn_format(path, exchange->file_name, path, "", option);
1064
1010
  }
1065
1011
  else
1066
 
  {
1067
 
    target_path = exchange->file_name;
1068
 
  }
 
1012
    (void) internal::fn_format(path, exchange->file_name, getDataHomeCatalog().c_str(), "", option);
1069
1013
 
1070
 
  if (not secure_file_priv.string().empty())
 
1014
  if (opt_secure_file_priv)
1071
1015
  {
1072
 
    if (target_path.file_string().substr(0, secure_file_priv.file_string().size()) != secure_file_priv.file_string())
 
1016
    fs::path secure_file_path(fs::system_complete(fs::path(opt_secure_file_priv)));
 
1017
    fs::path target_path(fs::system_complete(fs::path(path)));
 
1018
    if (target_path.file_string().substr(0, secure_file_path.file_string().size()) != secure_file_path.file_string())
1073
1019
    {
1074
1020
      /* Write only allowed to dir or subdir specified by secure_file_priv */
1075
1021
      my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--secure-file-priv");
1077
1023
    }
1078
1024
  }
1079
1025
 
1080
 
  if (!access(target_path.file_string().c_str(), F_OK))
 
1026
  if (!access(path, F_OK))
1081
1027
  {
1082
1028
    my_error(ER_FILE_EXISTS_ERROR, MYF(0), exchange->file_name);
1083
1029
    return -1;
1084
1030
  }
1085
1031
  /* Create the file world readable */
1086
 
  if ((file= internal::my_create(target_path.file_string().c_str(), 0666, O_WRONLY|O_EXCL, MYF(MY_WME))) < 0)
 
1032
  if ((file= internal::my_create(path, 0666, O_WRONLY|O_EXCL, MYF(MY_WME))) < 0)
1087
1033
    return file;
1088
1034
  (void) fchmod(file, 0666);                    // Because of umask()
1089
 
  if (cache->init_io_cache(file, 0L, internal::WRITE_CACHE, 0L, 1, MYF(MY_WME)))
 
1035
  if (init_io_cache(cache, file, 0L, internal::WRITE_CACHE, 0L, 1, MYF(MY_WME)))
1090
1036
  {
1091
1037
    internal::my_close(file, MYF(0));
1092
 
    internal::my_delete(target_path.file_string().c_str(), MYF(0));  // Delete file on error, it was just created
 
1038
    internal::my_delete(path, MYF(0));  // Delete file on error, it was just created
1093
1039
    return -1;
1094
1040
  }
1095
1041
  return file;
1103
1049
  bool string_results= false, non_string_results= false;
1104
1050
  unit= u;
1105
1051
  if ((uint32_t) strlen(exchange->file_name) + NAME_LEN >= FN_REFLEN)
1106
 
  {
1107
 
    path= exchange->file_name;
1108
 
  }
 
1052
    strncpy(path,exchange->file_name,FN_REFLEN-1);
1109
1053
 
1110
1054
  /* Check if there is any blobs in data */
1111
1055
  {
1115
1059
    {
1116
1060
      if (item->max_length >= MAX_BLOB_WIDTH)
1117
1061
      {
1118
 
        blob_flag=1;
1119
 
        break;
 
1062
        blob_flag=1;
 
1063
        break;
1120
1064
      }
1121
 
 
1122
1065
      if (item->result_type() == STRING_RESULT)
1123
1066
        string_results= true;
1124
1067
      else
1169
1112
  if (unit->offset_limit_cnt)
1170
1113
  {                                             // using limit offset,count
1171
1114
    unit->offset_limit_cnt--;
1172
 
    return false;
 
1115
    return(0);
1173
1116
  }
1174
1117
  row_count++;
1175
1118
  Item *item;
1178
1121
 
1179
1122
  if (my_b_write(cache,(unsigned char*) exchange->line_start->ptr(),
1180
1123
                 exchange->line_start->length()))
1181
 
    return true;
1182
 
 
 
1124
    goto err;
1183
1125
  while ((item=li++))
1184
1126
  {
1185
1127
    Item_result result_type=item->result_type();
1190
1132
    {
1191
1133
      if (my_b_write(cache,(unsigned char*) exchange->enclosed->ptr(),
1192
1134
                     exchange->enclosed->length()))
1193
 
        return true;
 
1135
        goto err;
1194
1136
    }
1195
1137
    if (!res)
1196
1138
    {                                           // NULL
1201
1143
          null_buff[0]=escape_char;
1202
1144
          null_buff[1]='N';
1203
1145
          if (my_b_write(cache,(unsigned char*) null_buff,2))
1204
 
            return true;
 
1146
            goto err;
1205
1147
        }
1206
1148
        else if (my_b_write(cache,(unsigned char*) "NULL",4))
1207
 
          return true;
 
1149
          goto err;
1208
1150
      }
1209
1151
      else
1210
1152
      {
1214
1156
    else
1215
1157
    {
1216
1158
      if (fixed_row_size)
1217
 
        used_length= min(res->length(), static_cast<size_t>(item->max_length));
 
1159
        used_length= min(res->length(),item->max_length);
1218
1160
      else
1219
1161
        used_length= res->length();
1220
1162
 
1295
1237
            tmp_buff[1]= *pos ? *pos : '0';
1296
1238
            if (my_b_write(cache,(unsigned char*) start,(uint32_t) (pos-start)) ||
1297
1239
                my_b_write(cache,(unsigned char*) tmp_buff,2))
1298
 
              return true;
 
1240
              goto err;
1299
1241
            start=pos+1;
1300
1242
          }
1301
1243
        }
1302
1244
        if (my_b_write(cache,(unsigned char*) start,(uint32_t) (pos-start)))
1303
 
          return true;
 
1245
          goto err;
1304
1246
      }
1305
1247
      else if (my_b_write(cache,(unsigned char*) res->ptr(),used_length))
1306
 
        return true;
 
1248
        goto err;
1307
1249
    }
1308
1250
    if (fixed_row_size)
1309
1251
    {                                           // Fill with space
1319
1261
        for (; length > sizeof(space) ; length-=sizeof(space))
1320
1262
        {
1321
1263
          if (my_b_write(cache,(unsigned char*) space,sizeof(space)))
1322
 
            return true;
 
1264
            goto err;
1323
1265
        }
1324
1266
        if (my_b_write(cache,(unsigned char*) space,length))
1325
 
          return true;
 
1267
          goto err;
1326
1268
      }
1327
1269
    }
1328
1270
    if (res && enclosed)
1329
1271
    {
1330
1272
      if (my_b_write(cache, (unsigned char*) exchange->enclosed->ptr(),
1331
1273
                     exchange->enclosed->length()))
1332
 
        return true;
 
1274
        goto err;
1333
1275
    }
1334
1276
    if (--items_left)
1335
1277
    {
1336
1278
      if (my_b_write(cache, (unsigned char*) exchange->field_term->ptr(),
1337
1279
                     field_term_length))
1338
 
        return true;
 
1280
        goto err;
1339
1281
    }
1340
1282
  }
1341
1283
  if (my_b_write(cache,(unsigned char*) exchange->line_term->ptr(),
1342
1284
                 exchange->line_term->length()))
1343
 
  {
1344
 
    return true;
1345
 
  }
1346
 
 
1347
 
  return false;
 
1285
    goto err;
 
1286
  return(0);
 
1287
err:
 
1288
  return(1);
1348
1289
}
1349
1290
 
1350
1291
 
1377
1318
  if (row_count++ > 1)
1378
1319
  {
1379
1320
    my_message(ER_TOO_MANY_ROWS, ER(ER_TOO_MANY_ROWS), MYF(0));
1380
 
    return 1;
 
1321
    goto err;
1381
1322
  }
1382
1323
  while ((item=li++))
1383
1324
  {
1385
1326
    if (!res)                                   // If NULL
1386
1327
    {
1387
1328
      if (my_b_write(cache,(unsigned char*) "",1))
1388
 
        return 1;
 
1329
        goto err;
1389
1330
    }
1390
1331
    else if (my_b_write(cache,(unsigned char*) res->ptr(),res->length()))
1391
1332
    {
1392
 
      my_error(ER_ERROR_ON_WRITE, MYF(0), path.file_string().c_str(), errno);
1393
 
      return 1;
 
1333
      my_error(ER_ERROR_ON_WRITE, MYF(0), path, errno);
 
1334
      goto err;
1394
1335
    }
1395
1336
  }
1396
1337
  return(0);
 
1338
err:
 
1339
  return(1);
1397
1340
}
1398
1341
 
1399
1342
 
1451
1394
      switch (val_item->result_type())
1452
1395
      {
1453
1396
      case REAL_RESULT:
1454
 
        op= &select_max_min_finder_subselect::cmp_real;
1455
 
        break;
 
1397
        op= &select_max_min_finder_subselect::cmp_real;
 
1398
        break;
1456
1399
      case INT_RESULT:
1457
 
        op= &select_max_min_finder_subselect::cmp_int;
1458
 
        break;
 
1400
        op= &select_max_min_finder_subselect::cmp_int;
 
1401
        break;
1459
1402
      case STRING_RESULT:
1460
 
        op= &select_max_min_finder_subselect::cmp_str;
1461
 
        break;
 
1403
        op= &select_max_min_finder_subselect::cmp_str;
 
1404
        break;
1462
1405
      case DECIMAL_RESULT:
1463
1406
        op= &select_max_min_finder_subselect::cmp_decimal;
1464
1407
        break;
1465
1408
      case ROW_RESULT:
1466
1409
        // This case should never be choosen
1467
 
        assert(0);
1468
 
        op= 0;
 
1410
        assert(0);
 
1411
        op= 0;
1469
1412
      }
1470
1413
    }
1471
1414
    cache->store(val_item);
1554
1497
void Session::end_statement()
1555
1498
{
1556
1499
  /* Cleanup SQL processing state to reuse this statement in next query. */
1557
 
  lex->end();
 
1500
  lex_end(lex);
1558
1501
  query_cache_key= ""; // reset the cache key
1559
1502
  resetResultsetMessage();
1560
1503
}
1561
1504
 
1562
1505
bool Session::copy_db_to(char **p_db, size_t *p_db_length)
1563
1506
{
1564
 
  assert(_schema);
1565
 
  if (_schema and _schema->empty())
1566
 
  {
1567
 
    my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
1568
 
    return true;
1569
 
  }
1570
 
  else if (not _schema)
1571
 
  {
1572
 
    my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
1573
 
    return true;
1574
 
  }
1575
 
  assert(_schema);
1576
 
 
1577
 
  *p_db= strmake(_schema->c_str(), _schema->size());
1578
 
  *p_db_length= _schema->size();
1579
 
 
 
1507
  if (db.empty())
 
1508
  {
 
1509
    my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
 
1510
    return true;
 
1511
  }
 
1512
  *p_db= strmake(db.c_str(), db.length());
 
1513
  *p_db_length= db.length();
1580
1514
  return false;
1581
1515
}
1582
1516
 
1616
1550
}
1617
1551
 
1618
1552
 
1619
 
void Session::set_db(const std::string &new_db)
 
1553
bool Session::set_db(const std::string &new_db)
1620
1554
{
1621
1555
  /* Do not reallocate memory if current chunk is big enough. */
1622
1556
  if (new_db.length())
1623
 
  {
1624
 
    _schema.reset(new std::string(new_db));
1625
 
  }
 
1557
    db= new_db;
1626
1558
  else
1627
 
  {
1628
 
    _schema.reset(new std::string(""));
1629
 
  }
1630
 
}
1631
 
 
 
1559
    db.clear();
 
1560
 
 
1561
  return false;
 
1562
}
 
1563
 
 
1564
 
 
1565
 
 
1566
 
 
1567
/**
 
1568
  Check the killed state of a user thread
 
1569
  @param session  user thread
 
1570
  @retval 0 the user thread is active
 
1571
  @retval 1 the user thread has been killed
 
1572
*/
 
1573
int session_killed(const Session *session)
 
1574
{
 
1575
  return(session->killed);
 
1576
}
 
1577
 
 
1578
 
 
1579
const struct charset_info_st *session_charset(Session *session)
 
1580
{
 
1581
  return(session->charset());
 
1582
}
1632
1583
 
1633
1584
/**
1634
1585
  Mark transaction to rollback and mark error as fatal to a sub-statement.
1651
1602
  plugin_sessionvar_cleanup(this);
1652
1603
 
1653
1604
  /* If necessary, log any aborted or unauthorized connections */
1654
 
  if (getKilled() || client->wasAborted())
 
1605
  if (killed || client->wasAborted())
1655
1606
  {
1656
1607
    status_var.aborted_threads++;
1657
1608
  }
1658
1609
 
1659
1610
  if (client->wasAborted())
1660
1611
  {
1661
 
    if (not getKilled() && variables.log_warnings > 1)
 
1612
    if (! killed && variables.log_warnings > 1)
1662
1613
    {
1663
1614
      SecurityContext *sctx= &security_ctx;
1664
1615
 
1665
1616
      errmsg_printf(ERRMSG_LVL_WARN, ER(ER_NEW_ABORTING_CONNECTION)
1666
1617
                  , thread_id
1667
 
                  , (_schema->empty() ? "unconnected" : _schema->c_str())
 
1618
                  , (db.empty() ? "unconnected" : db.c_str())
1668
1619
                  , sctx->getUser().empty() == false ? sctx->getUser().c_str() : "unauthenticated"
1669
1620
                  , sctx->getIp().c_str()
1670
1621
                  , (main_da.is_error() ? main_da.message() : ER(ER_UNKNOWN_ERROR)));
1673
1624
 
1674
1625
  /* Close out our connection to the client */
1675
1626
  if (should_lock)
1676
 
    session::Cache::singleton().mutex().lock();
1677
 
 
1678
 
  setKilled(Session::KILL_CONNECTION);
1679
 
 
 
1627
    LOCK_thread_count.lock();
 
1628
  killed= Session::KILL_CONNECTION;
1680
1629
  if (client->isConnected())
1681
1630
  {
1682
1631
    if (errcode)
1686
1635
    }
1687
1636
    client->close();
1688
1637
  }
1689
 
 
1690
1638
  if (should_lock)
1691
 
  {
1692
 
    session::Cache::singleton().mutex().unlock();
1693
 
  }
 
1639
    (void) LOCK_thread_count.unlock();
1694
1640
}
1695
1641
 
1696
1642
void Session::reset_for_next_command()
1718
1664
  Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
1719
1665
*/
1720
1666
 
1721
 
void Open_tables_state::close_temporary_tables()
 
1667
void Session::close_temporary_tables()
1722
1668
{
1723
1669
  Table *table;
1724
1670
  Table *tmp_next;
1738
1684
  unlink from session->temporary tables and close temporary table
1739
1685
*/
1740
1686
 
1741
 
void Open_tables_state::close_temporary_table(Table *table)
 
1687
void Session::close_temporary_table(Table *table)
1742
1688
{
1743
1689
  if (table->getPrev())
1744
1690
  {
1774
1720
  If this is needed, use close_temporary_table()
1775
1721
*/
1776
1722
 
1777
 
void Open_tables_state::nukeTable(Table *table)
 
1723
void Session::nukeTable(Table *table)
1778
1724
{
1779
1725
  plugin::StorageEngine *table_type= table->getShare()->db_type();
1780
1726
 
1805
1751
 
1806
1752
user_var_entry *Session::getVariable(LEX_STRING &name, bool create_if_not_exists)
1807
1753
{
1808
 
  return getVariable(std::string(name.str, name.length), create_if_not_exists);
1809
 
}
1810
 
 
1811
 
user_var_entry *Session::getVariable(const std::string  &name, bool create_if_not_exists)
1812
 
{
1813
 
  UserVarsRange ppp= user_vars.equal_range(name);
 
1754
  user_var_entry *entry= NULL;
 
1755
  UserVarsRange ppp= user_vars.equal_range(std::string(name.str, name.length));
1814
1756
 
1815
1757
  for (UserVars::iterator iter= ppp.first;
1816
 
       iter != ppp.second; ++iter)
 
1758
         iter != ppp.second; ++iter)
1817
1759
  {
1818
 
    return (*iter).second;
 
1760
    entry= (*iter).second;
1819
1761
  }
1820
1762
 
1821
 
  if (not create_if_not_exists)
1822
 
    return NULL;
1823
 
 
1824
 
  user_var_entry *entry= NULL;
1825
 
  entry= new (nothrow) user_var_entry(name.c_str(), query_id);
1826
 
 
1827
 
  if (entry == NULL)
1828
 
    return NULL;
1829
 
 
1830
 
  std::pair<UserVars::iterator, bool> returnable= user_vars.insert(make_pair(name, entry));
1831
 
 
1832
 
  if (not returnable.second)
 
1763
  if ((entry == NULL) && create_if_not_exists)
1833
1764
  {
1834
 
    delete entry;
 
1765
    entry= new (nothrow) user_var_entry(name.str, query_id);
 
1766
 
 
1767
    if (entry == NULL)
 
1768
      return NULL;
 
1769
 
 
1770
    std::pair<UserVars::iterator, bool> returnable= user_vars.insert(make_pair(std::string(name.str, name.length), entry));
 
1771
 
 
1772
    if (not returnable.second)
 
1773
    {
 
1774
      delete entry;
 
1775
      return NULL;
 
1776
    }
1835
1777
  }
1836
1778
 
1837
1779
  return entry;
1838
1780
}
1839
1781
 
1840
 
void Session::setVariable(const std::string &name, const std::string &value)
1841
 
{
1842
 
  user_var_entry *updateable_var= getVariable(name.c_str(), true);
1843
 
 
1844
 
  updateable_var->update_hash(false,
1845
 
                              (void*)value.c_str(),
1846
 
                              static_cast<uint32_t>(value.length()), STRING_RESULT,
1847
 
                              &my_charset_bin,
1848
 
                              DERIVATION_IMPLICIT, false);
1849
 
}
1850
 
 
1851
 
void Open_tables_state::mark_temp_tables_as_free_for_reuse()
 
1782
void Session::mark_temp_tables_as_free_for_reuse()
1852
1783
{
1853
1784
  for (Table *table= temporary_tables ; table ; table= table->getNext())
1854
1785
  {
1855
 
    if (table->query_id == getQueryId())
 
1786
    if (table->query_id == query_id)
1856
1787
    {
1857
1788
      table->query_id= 0;
1858
1789
      table->cursor->ha_reset();
1864
1795
{
1865
1796
  for (; table ; table= table->getNext())
1866
1797
  {
1867
 
    if (table->query_id == getQueryId())
 
1798
    if (table->query_id == query_id)
1868
1799
    {
1869
1800
      table->query_id= 0;
1870
1801
      table->cursor->ha_reset();
1883
1814
*/
1884
1815
void Session::close_thread_tables()
1885
1816
{
1886
 
  clearDerivedTables();
 
1817
  if (derived_tables)
 
1818
    derived_tables= NULL; // They should all be invalid by this point
1887
1819
 
1888
1820
  /*
1889
1821
    Mark all temporary tables used by this statement as free for reuse.
1916
1848
      handled either before writing a query log event (inside
1917
1849
      binlog_query()) or when preparing a pending event.
1918
1850
     */
1919
 
    unlockTables(lock);
 
1851
    mysql_unlock_tables(this, lock);
1920
1852
    lock= 0;
1921
1853
  }
1922
1854
  /*
1923
 
    Note that we need to hold table::Cache::singleton().mutex() while changing the
 
1855
    Note that we need to hold LOCK_open while changing the
1924
1856
    open_tables list. Another thread may work on it.
1925
 
    (See: table::Cache::singleton().removeTable(), mysql_wait_completed_table())
 
1857
    (See: remove_table_from_cache(), mysql_wait_completed_table())
1926
1858
    Closing a MERGE child before the parent would be fatal if the
1927
1859
    other thread tries to abort the MERGE lock in between.
1928
1860
  */
1961
1893
    close_tables_for_reopen(&tables);
1962
1894
  }
1963
1895
  if ((mysql_handle_derived(lex, &mysql_derived_prepare) ||
1964
 
       (
 
1896
       (fill_derived_tables() &&
1965
1897
        mysql_handle_derived(lex, &mysql_derived_filling))))
1966
1898
    return true;
1967
1899
 
1968
1900
  return false;
1969
1901
}
1970
1902
 
 
1903
bool Session::openTables(TableList *tables, uint32_t flags)
 
1904
{
 
1905
  uint32_t counter;
 
1906
  bool ret= fill_derived_tables();
 
1907
  assert(ret == false);
 
1908
  if (open_tables_from_list(&tables, &counter, flags) ||
 
1909
      mysql_handle_derived(lex, &mysql_derived_prepare))
 
1910
  {
 
1911
    return true;
 
1912
  }
 
1913
  return false;
 
1914
}
 
1915
 
1971
1916
/*
1972
1917
  @note "best_effort" is used in cases were if a failure occurred on this
1973
1918
  operation it would not be surprising because we are only removing because there
1974
1919
  might be an issue (lame engines).
1975
1920
*/
1976
1921
 
1977
 
bool Open_tables_state::rm_temporary_table(const TableIdentifier &identifier, bool best_effort)
 
1922
bool Session::rm_temporary_table(TableIdentifier &identifier, bool best_effort)
1978
1923
{
1979
 
  if (plugin::StorageEngine::dropTable(*static_cast<Session *>(this), identifier))
 
1924
  if (plugin::StorageEngine::dropTable(*this, identifier))
1980
1925
  {
1981
1926
    if (not best_effort)
1982
1927
    {
1983
 
      std::string path;
1984
 
      identifier.getSQLPath(path);
1985
1928
      errmsg_printf(ERRMSG_LVL_WARN, _("Could not remove temporary table: '%s', error: %d"),
1986
 
                    path.c_str(), errno);
 
1929
                    identifier.getSQLPath().c_str(), errno);
1987
1930
    }
1988
1931
 
1989
1932
    return true;
1992
1935
  return false;
1993
1936
}
1994
1937
 
1995
 
bool Open_tables_state::rm_temporary_table(plugin::StorageEngine *base, const TableIdentifier &identifier)
 
1938
bool Session::rm_temporary_table(plugin::StorageEngine *base, TableIdentifier &identifier)
1996
1939
{
1997
1940
  assert(base);
1998
1941
 
1999
 
  if (plugin::StorageEngine::dropTable(*static_cast<Session *>(this), *base, identifier))
 
1942
  if (plugin::StorageEngine::dropTable(*this, *base, identifier))
2000
1943
  {
2001
 
    std::string path;
2002
 
    identifier.getSQLPath(path);
2003
1944
    errmsg_printf(ERRMSG_LVL_WARN, _("Could not remove temporary table: '%s', error: %d"),
2004
 
                  path.c_str(), errno);
 
1945
                  identifier.getSQLPath().c_str(), errno);
2005
1946
 
2006
1947
    return true;
2007
1948
  }
2013
1954
  @note this will be removed, I am looking through Hudson to see if it is finding
2014
1955
  any tables that are missed during cleanup.
2015
1956
*/
2016
 
void Open_tables_state::dumpTemporaryTableNames(const char *foo)
 
1957
void Session::dumpTemporaryTableNames(const char *foo)
2017
1958
{
2018
1959
  Table *table;
2019
1960
 
2037
1978
      cerr << "\t\t Proto " << proto->schema() << " " << proto->name() << "\n";
2038
1979
    }
2039
1980
    else
2040
 
    {
2041
1981
      cerr << "\tTabl;e Name " << table->getShare()->getSchemaName() << "." << table->getShare()->getTableName() << " : " << answer << "\n";
2042
 
    }
2043
1982
  }
2044
1983
}
2045
1984
 
2046
 
bool Session::TableMessages::storeTableMessage(const TableIdentifier &identifier, message::Table &table_message)
 
1985
bool Session::storeTableMessage(const TableIdentifier &identifier, message::Table &table_message)
2047
1986
{
2048
1987
  table_message_cache.insert(make_pair(identifier.getPath(), table_message));
2049
1988
 
2050
1989
  return true;
2051
1990
}
2052
1991
 
2053
 
bool Session::TableMessages::removeTableMessage(const TableIdentifier &identifier)
 
1992
bool Session::removeTableMessage(const TableIdentifier &identifier)
2054
1993
{
2055
1994
  TableMessageCache::iterator iter;
2056
1995
 
2064
2003
  return true;
2065
2004
}
2066
2005
 
2067
 
bool Session::TableMessages::getTableMessage(const TableIdentifier &identifier, message::Table &table_message)
 
2006
bool Session::getTableMessage(const TableIdentifier &identifier, message::Table &table_message)
2068
2007
{
2069
2008
  TableMessageCache::iterator iter;
2070
2009
 
2078
2017
  return true;
2079
2018
}
2080
2019
 
2081
 
bool Session::TableMessages::doesTableMessageExist(const TableIdentifier &identifier)
 
2020
bool Session::doesTableMessageExist(const TableIdentifier &identifier)
2082
2021
{
2083
2022
  TableMessageCache::iterator iter;
2084
2023
 
2092
2031
  return true;
2093
2032
}
2094
2033
 
2095
 
bool Session::TableMessages::renameTableMessage(const TableIdentifier &from, const TableIdentifier &to)
 
2034
bool Session::renameTableMessage(const TableIdentifier &from, const TableIdentifier &to)
2096
2035
{
2097
2036
  TableMessageCache::iterator iter;
2098
2037
 
2111
2050
  return true;
2112
2051
}
2113
2052
 
2114
 
table::Instance *Session::getInstanceTable()
2115
 
{
2116
 
  temporary_shares.push_back(new table::Instance()); // This will not go into the tableshare cache, so no key is used.
2117
 
 
2118
 
  table::Instance *tmp_share= temporary_shares.back();
2119
 
 
2120
 
  assert(tmp_share);
2121
 
 
2122
 
  return tmp_share;
2123
 
}
2124
 
 
2125
 
 
2126
 
/**
2127
 
  Create a reduced Table object with properly set up Field list from a
2128
 
  list of field definitions.
2129
 
 
2130
 
    The created table doesn't have a table Cursor associated with
2131
 
    it, has no keys, no group/distinct, no copy_funcs array.
2132
 
    The sole purpose of this Table object is to use the power of Field
2133
 
    class to read/write data to/from table->getInsertRecord(). Then one can store
2134
 
    the record in any container (RB tree, hash, etc).
2135
 
    The table is created in Session mem_root, so are the table's fields.
2136
 
    Consequently, if you don't BLOB fields, you don't need to free it.
2137
 
 
2138
 
  @param session         connection handle
2139
 
  @param field_list  list of column definitions
2140
 
 
2141
 
  @return
2142
 
    0 if out of memory, Table object in case of success
2143
 
*/
2144
 
table::Instance *Session::getInstanceTable(List<CreateField> &field_list)
2145
 
{
2146
 
  temporary_shares.push_back(new table::Instance(this, field_list)); // This will not go into the tableshare cache, so no key is used.
2147
 
 
2148
 
  table::Instance *tmp_share= temporary_shares.back();
2149
 
 
2150
 
  assert(tmp_share);
2151
 
 
2152
 
  return tmp_share;
2153
 
}
2154
 
 
2155
 
namespace display  {
2156
 
 
2157
 
static const std::string NONE= "NONE";
2158
 
static const std::string GOT_GLOBAL_READ_LOCK= "HAS GLOBAL READ LOCK";
2159
 
static const std::string MADE_GLOBAL_READ_LOCK_BLOCK_COMMIT= "HAS GLOBAL READ LOCK WITH BLOCKING COMMIT";
2160
 
 
2161
 
const std::string &type(drizzled::Session::global_read_lock_t type)
2162
 
{
2163
 
  switch (type) {
2164
 
    default:
2165
 
    case Session::NONE:
2166
 
      return NONE;
2167
 
    case Session::GOT_GLOBAL_READ_LOCK:
2168
 
      return GOT_GLOBAL_READ_LOCK;
2169
 
    case Session::MADE_GLOBAL_READ_LOCK_BLOCK_COMMIT:
2170
 
      return MADE_GLOBAL_READ_LOCK_BLOCK_COMMIT;
2171
 
  }
2172
 
}
2173
 
 
2174
 
size_t max_string_length(drizzled::Session::global_read_lock_t)
2175
 
{
2176
 
  return MADE_GLOBAL_READ_LOCK_BLOCK_COMMIT.size();
2177
 
}
2178
 
 
2179
 
} /* namespace display */
 
2053
TableShareInstance *Session::getTemporaryShare(TableIdentifier::Type type_arg)
 
2054
{
 
2055
  temporary_shares.push_back(new TableShareInstance(type_arg)); // This will not go into the tableshare cache, so no key is used.
 
2056
 
 
2057
  TableShareInstance *tmp_share= temporary_shares.back();
 
2058
 
 
2059
  assert(tmp_share);
 
2060
 
 
2061
  return tmp_share;
 
2062
}
2180
2063
 
2181
2064
} /* namespace drizzled */