← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/session.cc

  • Committer: Monty Taylor
  • Date: 2010-10-12 20:20:44 UTC
  • mto: (1842.1.3 build) (1843.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 1843.
  • Revision ID: mordred@inaugust.com-20101012202044-yfrmnmkznvkqfxe4
Added support for valgrind suppressions.
Run strip-valgrind as part of make valgrind.

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;
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
421
    boost_unique_lock_t scopedLock(mysys_var->mutex);
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)))
 
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 (unlikely(plugin::EventObserver::connectSession(*this)))
577
560
  {
578
561
    // We should do something about an error...
579
562
  }
580
563
 
581
 
  if (plugin::Scheduler::getScheduler()->addSession(arg))
 
564
  if (scheduler->addSession(this))
582
565
  {
583
 
    DRIZZLE_CONNECTION_START(arg->getSessionId());
 
566
    DRIZZLE_CONNECTION_START(thread_id);
584
567
    char error_message_buff[DRIZZLE_ERRMSG_SIZE];
585
568
 
586
 
    arg->setKilled(Session::KILL_CONNECTION);
 
569
    killed= Session::KILL_CONNECTION;
587
570
 
588
 
    arg->status_var.aborted_connects++;
 
571
    status_var.aborted_connects++;
589
572
 
590
573
    /* Can't use my_error() since store_globals has not been called. */
591
574
    /* TODO replace will better error message */
592
575
    snprintf(error_message_buff, sizeof(error_message_buff),
593
576
             ER(ER_CANT_CREATE_THREAD), 1);
594
 
    arg->client->sendError(ER_CANT_CREATE_THREAD, error_message_buff);
595
 
 
 
577
    client->sendError(ER_CANT_CREATE_THREAD, error_message_buff);
596
578
    return true;
597
579
  }
598
580
 
600
582
}
601
583
 
602
584
 
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
585
const char* Session::enter_cond(boost::condition_variable_any &cond, boost::mutex &mutex, const char* msg)
615
586
{
616
587
  const char* old_msg = get_proc_info();
638
609
 
639
610
bool Session::authenticate()
640
611
{
641
 
  lex->start(this);
 
612
  lex_start(this);
642
613
  if (client->authenticate())
643
614
    return false;
644
615
 
647
618
  return true;
648
619
}
649
620
 
650
 
bool Session::checkUser(const std::string &passwd_str,
651
 
                        const std::string &in_db)
 
621
bool Session::checkUser(const char *passwd, uint32_t passwd_len, const char *in_db)
652
622
{
 
623
  const string passwd_str(passwd, passwd_len);
653
624
  bool is_authenticated=
654
625
    plugin::Authentication::isAuthenticated(getSecurityContext(),
655
626
                                            passwd_str);
662
633
  }
663
634
 
664
635
  /* Change database if necessary */
665
 
  if (not in_db.empty())
 
636
  if (in_db && in_db[0])
666
637
  {
667
638
    SchemaIdentifier identifier(in_db);
668
639
    if (mysql_change_db(this, identifier))
672
643
    }
673
644
  }
674
645
  my_ok();
675
 
  password= not passwd_str.empty();
 
646
  password= test(passwd_len);          // remember for error messages
676
647
 
677
648
  /* Ready to handle queries */
678
649
  return true;
694
665
  main_da.reset_diagnostics_area();
695
666
 
696
667
  if (client->readCommand(&l_packet, &packet_length) == false)
697
 
  {
698
668
    return false;
699
 
  }
700
669
 
701
 
  if (getKilled() == KILL_CONNECTION)
 
670
  if (killed == KILL_CONNECTION)
702
671
    return false;
703
672
 
704
673
  if (packet_length == 0)
705
674
    return true;
706
675
 
707
 
  l_command= static_cast<enum_server_command>(l_packet[0]);
 
676
  l_command= (enum enum_server_command) (unsigned char) l_packet[0];
708
677
 
709
678
  if (command >= COM_END)
710
679
    command= COM_END;                           // Wrong command
711
680
 
712
681
  assert(packet_length);
713
 
  return not dispatch_command(l_command, this, l_packet+1, (uint32_t) (packet_length-1));
 
682
  return ! dispatch_command(l_command, this, l_packet+1, (uint32_t) (packet_length-1));
714
683
}
715
684
 
716
685
bool Session::readAndStoreQuery(const char *in_packet, uint32_t in_packet_length)
722
691
    in_packet_length--;
723
692
  }
724
693
  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])))
 
694
  while (in_packet_length > 0 &&
 
695
         (pos[-1] == ';' || my_isspace(charset() ,pos[-1])))
726
696
  {
727
697
    pos--;
728
698
    in_packet_length--;
729
699
  }
730
700
 
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));
 
701
  query.assign(in_packet, in_packet + in_packet_length);
739
702
 
740
703
  return true;
741
704
}
790
753
  }
791
754
 
792
755
  if (result == false)
793
 
  {
794
756
    my_error(killed_errno(), MYF(0));
795
 
  }
796
757
  else if ((result == true) && do_release)
797
 
  {
798
 
    setKilled(Session::KILL_CONNECTION);
799
 
  }
 
758
    killed= Session::KILL_CONNECTION;
800
759
 
801
760
  return result;
802
761
}
867
826
  where= Session::DEFAULT_WHERE;
868
827
 
869
828
  /* Reset the temporary shares we built */
870
 
  for_each(temporary_shares.begin(),
871
 
           temporary_shares.end(),
872
 
           DeletePtr());
 
829
  for (std::vector<TableShareInstance *>::iterator iter= temporary_shares.begin();
 
830
       iter != temporary_shares.end(); iter++)
 
831
  {
 
832
    delete *iter;
 
833
  }
873
834
  temporary_shares.clear();
874
835
}
875
836
 
955
916
  my_message(errcode, err, MYF(0));
956
917
  if (file > 0)
957
918
  {
958
 
    (void) cache->end_io_cache();
 
919
    (void) end_io_cache(cache);
959
920
    (void) internal::my_close(file, MYF(0));
960
921
    (void) internal::my_delete(path.file_string().c_str(), MYF(0));             // Delete file on error
961
922
    file= -1;
965
926
 
966
927
bool select_to_file::send_eof()
967
928
{
968
 
  int error= test(cache->end_io_cache());
 
929
  int error= test(end_io_cache(cache));
969
930
  if (internal::my_close(file, MYF(MY_WME)))
970
931
    error= 1;
971
932
  if (!error)
987
948
  /* In case of error send_eof() may be not called: close the file here. */
988
949
  if (file >= 0)
989
950
  {
990
 
    (void) cache->end_io_cache();
 
951
    (void) end_io_cache(cache);
991
952
    (void) internal::my_close(file, MYF(0));
992
953
    file= -1;
993
954
  }
1046
1007
  if (not to_file.has_root_directory())
1047
1008
  {
1048
1009
    target_path= fs::system_complete(getDataHomeCatalog());
1049
 
    util::string::const_shared_ptr schema(session->schema());
1050
 
    if (schema and not schema->empty())
 
1010
    if (not session->db.empty())
1051
1011
    {
1052
1012
      int count_elements= 0;
1053
1013
      for (fs::path::iterator iter= to_file.begin();
1057
1017
 
1058
1018
      if (count_elements == 1)
1059
1019
      {
1060
 
        target_path /= *schema;
 
1020
        target_path /= session->db;
1061
1021
      }
1062
1022
    }
1063
1023
    target_path /= to_file;
1086
1046
  if ((file= internal::my_create(target_path.file_string().c_str(), 0666, O_WRONLY|O_EXCL, MYF(MY_WME))) < 0)
1087
1047
    return file;
1088
1048
  (void) fchmod(file, 0666);                    // Because of umask()
1089
 
  if (cache->init_io_cache(file, 0L, internal::WRITE_CACHE, 0L, 1, MYF(MY_WME)))
 
1049
  if (init_io_cache(cache, file, 0L, internal::WRITE_CACHE, 0L, 1, MYF(MY_WME)))
1090
1050
  {
1091
1051
    internal::my_close(file, MYF(0));
1092
1052
    internal::my_delete(target_path.file_string().c_str(), MYF(0));  // Delete file on error, it was just created
1115
1075
    {
1116
1076
      if (item->max_length >= MAX_BLOB_WIDTH)
1117
1077
      {
1118
 
        blob_flag=1;
1119
 
        break;
 
1078
        blob_flag=1;
 
1079
        break;
1120
1080
      }
1121
 
 
1122
1081
      if (item->result_type() == STRING_RESULT)
1123
1082
        string_results= true;
1124
1083
      else
1169
1128
  if (unit->offset_limit_cnt)
1170
1129
  {                                             // using limit offset,count
1171
1130
    unit->offset_limit_cnt--;
1172
 
    return false;
 
1131
    return(0);
1173
1132
  }
1174
1133
  row_count++;
1175
1134
  Item *item;
1178
1137
 
1179
1138
  if (my_b_write(cache,(unsigned char*) exchange->line_start->ptr(),
1180
1139
                 exchange->line_start->length()))
1181
 
    return true;
1182
 
 
 
1140
    goto err;
1183
1141
  while ((item=li++))
1184
1142
  {
1185
1143
    Item_result result_type=item->result_type();
1190
1148
    {
1191
1149
      if (my_b_write(cache,(unsigned char*) exchange->enclosed->ptr(),
1192
1150
                     exchange->enclosed->length()))
1193
 
        return true;
 
1151
        goto err;
1194
1152
    }
1195
1153
    if (!res)
1196
1154
    {                                           // NULL
1201
1159
          null_buff[0]=escape_char;
1202
1160
          null_buff[1]='N';
1203
1161
          if (my_b_write(cache,(unsigned char*) null_buff,2))
1204
 
            return true;
 
1162
            goto err;
1205
1163
        }
1206
1164
        else if (my_b_write(cache,(unsigned char*) "NULL",4))
1207
 
          return true;
 
1165
          goto err;
1208
1166
      }
1209
1167
      else
1210
1168
      {
1295
1253
            tmp_buff[1]= *pos ? *pos : '0';
1296
1254
            if (my_b_write(cache,(unsigned char*) start,(uint32_t) (pos-start)) ||
1297
1255
                my_b_write(cache,(unsigned char*) tmp_buff,2))
1298
 
              return true;
 
1256
              goto err;
1299
1257
            start=pos+1;
1300
1258
          }
1301
1259
        }
1302
1260
        if (my_b_write(cache,(unsigned char*) start,(uint32_t) (pos-start)))
1303
 
          return true;
 
1261
          goto err;
1304
1262
      }
1305
1263
      else if (my_b_write(cache,(unsigned char*) res->ptr(),used_length))
1306
 
        return true;
 
1264
        goto err;
1307
1265
    }
1308
1266
    if (fixed_row_size)
1309
1267
    {                                           // Fill with space
1319
1277
        for (; length > sizeof(space) ; length-=sizeof(space))
1320
1278
        {
1321
1279
          if (my_b_write(cache,(unsigned char*) space,sizeof(space)))
1322
 
            return true;
 
1280
            goto err;
1323
1281
        }
1324
1282
        if (my_b_write(cache,(unsigned char*) space,length))
1325
 
          return true;
 
1283
          goto err;
1326
1284
      }
1327
1285
    }
1328
1286
    if (res && enclosed)
1329
1287
    {
1330
1288
      if (my_b_write(cache, (unsigned char*) exchange->enclosed->ptr(),
1331
1289
                     exchange->enclosed->length()))
1332
 
        return true;
 
1290
        goto err;
1333
1291
    }
1334
1292
    if (--items_left)
1335
1293
    {
1336
1294
      if (my_b_write(cache, (unsigned char*) exchange->field_term->ptr(),
1337
1295
                     field_term_length))
1338
 
        return true;
 
1296
        goto err;
1339
1297
    }
1340
1298
  }
1341
1299
  if (my_b_write(cache,(unsigned char*) exchange->line_term->ptr(),
1342
1300
                 exchange->line_term->length()))
1343
 
  {
1344
 
    return true;
1345
 
  }
1346
 
 
1347
 
  return false;
 
1301
    goto err;
 
1302
  return(0);
 
1303
err:
 
1304
  return(1);
1348
1305
}
1349
1306
 
1350
1307
 
1451
1408
      switch (val_item->result_type())
1452
1409
      {
1453
1410
      case REAL_RESULT:
1454
 
        op= &select_max_min_finder_subselect::cmp_real;
1455
 
        break;
 
1411
        op= &select_max_min_finder_subselect::cmp_real;
 
1412
        break;
1456
1413
      case INT_RESULT:
1457
 
        op= &select_max_min_finder_subselect::cmp_int;
1458
 
        break;
 
1414
        op= &select_max_min_finder_subselect::cmp_int;
 
1415
        break;
1459
1416
      case STRING_RESULT:
1460
 
        op= &select_max_min_finder_subselect::cmp_str;
1461
 
        break;
 
1417
        op= &select_max_min_finder_subselect::cmp_str;
 
1418
        break;
1462
1419
      case DECIMAL_RESULT:
1463
1420
        op= &select_max_min_finder_subselect::cmp_decimal;
1464
1421
        break;
1465
1422
      case ROW_RESULT:
1466
1423
        // This case should never be choosen
1467
 
        assert(0);
1468
 
        op= 0;
 
1424
        assert(0);
 
1425
        op= 0;
1469
1426
      }
1470
1427
    }
1471
1428
    cache->store(val_item);
1554
1511
void Session::end_statement()
1555
1512
{
1556
1513
  /* Cleanup SQL processing state to reuse this statement in next query. */
1557
 
  lex->end();
 
1514
  lex_end(lex);
1558
1515
  query_cache_key= ""; // reset the cache key
1559
1516
  resetResultsetMessage();
1560
1517
}
1561
1518
 
1562
1519
bool Session::copy_db_to(char **p_db, size_t *p_db_length)
1563
1520
{
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
 
 
 
1521
  if (db.empty())
 
1522
  {
 
1523
    my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
 
1524
    return true;
 
1525
  }
 
1526
  *p_db= strmake(db.c_str(), db.length());
 
1527
  *p_db_length= db.length();
1580
1528
  return false;
1581
1529
}
1582
1530
 
1616
1564
}
1617
1565
 
1618
1566
 
1619
 
void Session::set_db(const std::string &new_db)
 
1567
bool Session::set_db(const std::string &new_db)
1620
1568
{
1621
1569
  /* Do not reallocate memory if current chunk is big enough. */
1622
1570
  if (new_db.length())
1623
 
  {
1624
 
    _schema.reset(new std::string(new_db));
1625
 
  }
 
1571
    db= new_db;
1626
1572
  else
1627
 
  {
1628
 
    _schema.reset(new std::string(""));
1629
 
  }
1630
 
}
1631
 
 
 
1573
    db.clear();
 
1574
 
 
1575
  return false;
 
1576
}
 
1577
 
 
1578
 
 
1579
 
 
1580
 
 
1581
/**
 
1582
  Check the killed state of a user thread
 
1583
  @param session  user thread
 
1584
  @retval 0 the user thread is active
 
1585
  @retval 1 the user thread has been killed
 
1586
*/
 
1587
int session_killed(const Session *session)
 
1588
{
 
1589
  return(session->killed);
 
1590
}
 
1591
 
 
1592
 
 
1593
const struct charset_info_st *session_charset(Session *session)
 
1594
{
 
1595
  return(session->charset());
 
1596
}
1632
1597
 
1633
1598
/**
1634
1599
  Mark transaction to rollback and mark error as fatal to a sub-statement.
1651
1616
  plugin_sessionvar_cleanup(this);
1652
1617
 
1653
1618
  /* If necessary, log any aborted or unauthorized connections */
1654
 
  if (getKilled() || client->wasAborted())
 
1619
  if (killed || client->wasAborted())
1655
1620
  {
1656
1621
    status_var.aborted_threads++;
1657
1622
  }
1658
1623
 
1659
1624
  if (client->wasAborted())
1660
1625
  {
1661
 
    if (not getKilled() && variables.log_warnings > 1)
 
1626
    if (! killed && variables.log_warnings > 1)
1662
1627
    {
1663
1628
      SecurityContext *sctx= &security_ctx;
1664
1629
 
1665
1630
      errmsg_printf(ERRMSG_LVL_WARN, ER(ER_NEW_ABORTING_CONNECTION)
1666
1631
                  , thread_id
1667
 
                  , (_schema->empty() ? "unconnected" : _schema->c_str())
 
1632
                  , (db.empty() ? "unconnected" : db.c_str())
1668
1633
                  , sctx->getUser().empty() == false ? sctx->getUser().c_str() : "unauthenticated"
1669
1634
                  , sctx->getIp().c_str()
1670
1635
                  , (main_da.is_error() ? main_da.message() : ER(ER_UNKNOWN_ERROR)));
1673
1638
 
1674
1639
  /* Close out our connection to the client */
1675
1640
  if (should_lock)
1676
 
    session::Cache::singleton().mutex().lock();
1677
 
 
1678
 
  setKilled(Session::KILL_CONNECTION);
1679
 
 
 
1641
    LOCK_thread_count.lock();
 
1642
  killed= Session::KILL_CONNECTION;
1680
1643
  if (client->isConnected())
1681
1644
  {
1682
1645
    if (errcode)
1686
1649
    }
1687
1650
    client->close();
1688
1651
  }
1689
 
 
1690
1652
  if (should_lock)
1691
 
  {
1692
 
    session::Cache::singleton().mutex().unlock();
1693
 
  }
 
1653
    (void) LOCK_thread_count.unlock();
1694
1654
}
1695
1655
 
1696
1656
void Session::reset_for_next_command()
1718
1678
  Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
1719
1679
*/
1720
1680
 
1721
 
void Open_tables_state::close_temporary_tables()
 
1681
void Session::close_temporary_tables()
1722
1682
{
1723
1683
  Table *table;
1724
1684
  Table *tmp_next;
1738
1698
  unlink from session->temporary tables and close temporary table
1739
1699
*/
1740
1700
 
1741
 
void Open_tables_state::close_temporary_table(Table *table)
 
1701
void Session::close_temporary_table(Table *table)
1742
1702
{
1743
1703
  if (table->getPrev())
1744
1704
  {
1774
1734
  If this is needed, use close_temporary_table()
1775
1735
*/
1776
1736
 
1777
 
void Open_tables_state::nukeTable(Table *table)
 
1737
void Session::nukeTable(Table *table)
1778
1738
{
1779
1739
  plugin::StorageEngine *table_type= table->getShare()->db_type();
1780
1740
 
1805
1765
 
1806
1766
user_var_entry *Session::getVariable(LEX_STRING &name, bool create_if_not_exists)
1807
1767
{
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);
 
1768
  user_var_entry *entry= NULL;
 
1769
  UserVarsRange ppp= user_vars.equal_range(std::string(name.str, name.length));
1814
1770
 
1815
1771
  for (UserVars::iterator iter= ppp.first;
1816
 
       iter != ppp.second; ++iter)
 
1772
         iter != ppp.second; ++iter)
1817
1773
  {
1818
 
    return (*iter).second;
 
1774
    entry= (*iter).second;
1819
1775
  }
1820
1776
 
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)
 
1777
  if ((entry == NULL) && create_if_not_exists)
1833
1778
  {
1834
 
    delete entry;
 
1779
    entry= new (nothrow) user_var_entry(name.str, query_id);
 
1780
 
 
1781
    if (entry == NULL)
 
1782
      return NULL;
 
1783
 
 
1784
    std::pair<UserVars::iterator, bool> returnable= user_vars.insert(make_pair(std::string(name.str, name.length), entry));
 
1785
 
 
1786
    if (not returnable.second)
 
1787
    {
 
1788
      delete entry;
 
1789
      return NULL;
 
1790
    }
1835
1791
  }
1836
1792
 
1837
1793
  return entry;
1838
1794
}
1839
1795
 
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()
 
1796
void Session::mark_temp_tables_as_free_for_reuse()
1852
1797
{
1853
1798
  for (Table *table= temporary_tables ; table ; table= table->getNext())
1854
1799
  {
1855
 
    if (table->query_id == getQueryId())
 
1800
    if (table->query_id == query_id)
1856
1801
    {
1857
1802
      table->query_id= 0;
1858
1803
      table->cursor->ha_reset();
1864
1809
{
1865
1810
  for (; table ; table= table->getNext())
1866
1811
  {
1867
 
    if (table->query_id == getQueryId())
 
1812
    if (table->query_id == query_id)
1868
1813
    {
1869
1814
      table->query_id= 0;
1870
1815
      table->cursor->ha_reset();
1883
1828
*/
1884
1829
void Session::close_thread_tables()
1885
1830
{
1886
 
  clearDerivedTables();
 
1831
  if (derived_tables)
 
1832
    derived_tables= NULL; // They should all be invalid by this point
1887
1833
 
1888
1834
  /*
1889
1835
    Mark all temporary tables used by this statement as free for reuse.
1916
1862
      handled either before writing a query log event (inside
1917
1863
      binlog_query()) or when preparing a pending event.
1918
1864
     */
1919
 
    unlockTables(lock);
 
1865
    mysql_unlock_tables(this, lock);
1920
1866
    lock= 0;
1921
1867
  }
1922
1868
  /*
1923
 
    Note that we need to hold table::Cache::singleton().mutex() while changing the
 
1869
    Note that we need to hold LOCK_open while changing the
1924
1870
    open_tables list. Another thread may work on it.
1925
 
    (See: table::Cache::singleton().removeTable(), mysql_wait_completed_table())
 
1871
    (See: remove_table_from_cache(), mysql_wait_completed_table())
1926
1872
    Closing a MERGE child before the parent would be fatal if the
1927
1873
    other thread tries to abort the MERGE lock in between.
1928
1874
  */
1974
1920
  might be an issue (lame engines).
1975
1921
*/
1976
1922
 
1977
 
bool Open_tables_state::rm_temporary_table(const TableIdentifier &identifier, bool best_effort)
 
1923
bool Session::rm_temporary_table(TableIdentifier &identifier, bool best_effort)
1978
1924
{
1979
 
  if (plugin::StorageEngine::dropTable(*static_cast<Session *>(this), identifier))
 
1925
  if (plugin::StorageEngine::dropTable(*this, identifier))
1980
1926
  {
1981
1927
    if (not best_effort)
1982
1928
    {
1983
 
      std::string path;
1984
 
      identifier.getSQLPath(path);
1985
1929
      errmsg_printf(ERRMSG_LVL_WARN, _("Could not remove temporary table: '%s', error: %d"),
1986
 
                    path.c_str(), errno);
 
1930
                    identifier.getSQLPath().c_str(), errno);
1987
1931
    }
1988
1932
 
1989
1933
    return true;
1992
1936
  return false;
1993
1937
}
1994
1938
 
1995
 
bool Open_tables_state::rm_temporary_table(plugin::StorageEngine *base, const TableIdentifier &identifier)
 
1939
bool Session::rm_temporary_table(plugin::StorageEngine *base, TableIdentifier &identifier)
1996
1940
{
1997
1941
  assert(base);
1998
1942
 
1999
 
  if (plugin::StorageEngine::dropTable(*static_cast<Session *>(this), *base, identifier))
 
1943
  if (plugin::StorageEngine::dropTable(*this, *base, identifier))
2000
1944
  {
2001
 
    std::string path;
2002
 
    identifier.getSQLPath(path);
2003
1945
    errmsg_printf(ERRMSG_LVL_WARN, _("Could not remove temporary table: '%s', error: %d"),
2004
 
                  path.c_str(), errno);
 
1946
                  identifier.getSQLPath().c_str(), errno);
2005
1947
 
2006
1948
    return true;
2007
1949
  }
2013
1955
  @note this will be removed, I am looking through Hudson to see if it is finding
2014
1956
  any tables that are missed during cleanup.
2015
1957
*/
2016
 
void Open_tables_state::dumpTemporaryTableNames(const char *foo)
 
1958
void Session::dumpTemporaryTableNames(const char *foo)
2017
1959
{
2018
1960
  Table *table;
2019
1961
 
2037
1979
      cerr << "\t\t Proto " << proto->schema() << " " << proto->name() << "\n";
2038
1980
    }
2039
1981
    else
2040
 
    {
2041
1982
      cerr << "\tTabl;e Name " << table->getShare()->getSchemaName() << "." << table->getShare()->getTableName() << " : " << answer << "\n";
2042
 
    }
2043
1983
  }
2044
1984
}
2045
1985
 
2046
 
bool Session::TableMessages::storeTableMessage(const TableIdentifier &identifier, message::Table &table_message)
 
1986
bool Session::storeTableMessage(const TableIdentifier &identifier, message::Table &table_message)
2047
1987
{
2048
1988
  table_message_cache.insert(make_pair(identifier.getPath(), table_message));
2049
1989
 
2050
1990
  return true;
2051
1991
}
2052
1992
 
2053
 
bool Session::TableMessages::removeTableMessage(const TableIdentifier &identifier)
 
1993
bool Session::removeTableMessage(const TableIdentifier &identifier)
2054
1994
{
2055
1995
  TableMessageCache::iterator iter;
2056
1996
 
2064
2004
  return true;
2065
2005
}
2066
2006
 
2067
 
bool Session::TableMessages::getTableMessage(const TableIdentifier &identifier, message::Table &table_message)
 
2007
bool Session::getTableMessage(const TableIdentifier &identifier, message::Table &table_message)
2068
2008
{
2069
2009
  TableMessageCache::iterator iter;
2070
2010
 
2078
2018
  return true;
2079
2019
}
2080
2020
 
2081
 
bool Session::TableMessages::doesTableMessageExist(const TableIdentifier &identifier)
 
2021
bool Session::doesTableMessageExist(const TableIdentifier &identifier)
2082
2022
{
2083
2023
  TableMessageCache::iterator iter;
2084
2024
 
2092
2032
  return true;
2093
2033
}
2094
2034
 
2095
 
bool Session::TableMessages::renameTableMessage(const TableIdentifier &from, const TableIdentifier &to)
 
2035
bool Session::renameTableMessage(const TableIdentifier &from, const TableIdentifier &to)
2096
2036
{
2097
2037
  TableMessageCache::iterator iter;
2098
2038
 
2111
2051
  return true;
2112
2052
}
2113
2053
 
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 */
 
2054
TableShareInstance *Session::getTemporaryShare(TableIdentifier::Type type_arg)
 
2055
{
 
2056
  temporary_shares.push_back(new TableShareInstance(type_arg)); // This will not go into the tableshare cache, so no key is used.
 
2057
 
 
2058
  TableShareInstance *tmp_share= temporary_shares.back();
 
2059
 
 
2060
  assert(tmp_share);
 
2061
 
 
2062
  return tmp_share;
 
2063
}
2180
2064
 
2181
2065
} /* namespace drizzled */