← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/session.cc

  • Committer: Brian Aker
  • Date: 2010-10-15 03:36:56 UTC
  • mfrom: (1843.7.6 refactor)
  • Revision ID: brian@tangent.org-20101015033656-9u3aptcc6ipoc1vj
This removes two of our dead plugins (the bad schedulers).
Also this fixes help messages to say "schema" instead of "database"
everywhere..

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