← 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: 2011-04-11 05:54:41 UTC
  • mfrom: (2263.3.12 ot0)
  • Revision ID: brian@gir-3.local-20110411055441-z9w6zvybq019zyms
Merge in xtf

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/session.cc
43
43
#include <drizzled/item/return_int.h>
44
44
#include <drizzled/item/subselect.h>
45
45
#include <drizzled/lock.h>
 
46
#include <drizzled/open_tables_state.h>
46
47
#include <drizzled/plugin/authentication.h>
47
48
#include <drizzled/plugin/authorization.h>
48
49
#include <drizzled/plugin/client.h>
54
55
#include <drizzled/probes.h>
55
56
#include <drizzled/pthread_globals.h>
56
57
#include <drizzled/query_id.h>
57
 
#include <drizzled/refresh_version.h>
58
58
#include <drizzled/schema.h>
59
59
#include <drizzled/select_dump.h>
60
60
#include <drizzled/select_exists_subselect.h>
105
105
 
106
106
const char * const Session::DEFAULT_WHERE= "field list";
107
107
 
 
108
uint64_t g_refresh_version = 1;
 
109
 
108
110
bool Key_part_spec::operator==(const Key_part_spec& other) const
109
111
{
110
112
  return length == other.length &&
112
114
    !my_strcasecmp(system_charset_info, field_name.str, other.field_name.str);
113
115
}
114
116
 
115
 
Open_tables_state::Open_tables_state(uint64_t version_arg) :
116
 
  version(version_arg)
 
117
Open_tables_state::Open_tables_state(Session& session, uint64_t version_arg) :
 
118
  version(version_arg),
 
119
  session_(session)
117
120
{
118
121
  open_tables_= temporary_tables= derived_tables= NULL;
119
122
  extra_lock= lock= NULL;
152
155
  typedef session::PropertyMap properties_t;
153
156
  typedef std::map<std::string, plugin::EventObserverList*> schema_event_observers_t;
154
157
 
 
158
  impl_c(Session& session) :
 
159
    open_tables(session, g_refresh_version)
 
160
  {
 
161
  }
 
162
 
155
163
  Diagnostics_area diagnostics;
156
164
  /**
157
165
    The lex to hold the parsed tree of conventional (non-prepared) queries.
160
168
    the same lex. (@see mysql_parse for details).
161
169
  */
162
170
  LEX lex;
 
171
  Open_tables_state open_tables;
163
172
  properties_t properties;
164
173
  schema_event_observers_t schema_event_observers;
165
174
  system_status_var status_var;
170
179
};
171
180
 
172
181
Session::Session(plugin::Client *client_arg, catalog::Instance::shared_ptr catalog_arg) :
173
 
  Open_tables_state(refresh_version),
174
 
  impl_(new impl_c),
 
182
  impl_(new impl_c(*this)),
175
183
  mem_root(&main_mem_root),
176
184
  query(new std::string),
177
185
  scheduler(NULL),
191
199
  query_id(0),
192
200
  warn_query_id(0),
193
201
        transaction(impl_->transaction),
194
 
  open_tables(*this),
 
202
  open_tables(impl_->open_tables),
195
203
  first_successful_insert_id_in_prev_stmt(0),
196
204
  first_successful_insert_id_in_cur_stmt(0),
197
205
  limit_found_rows(0),
427
435
  user_vars.clear();
428
436
 
429
437
 
430
 
  close_temporary_tables();
 
438
  open_tables.close_temporary_tables();
431
439
 
432
440
  if (global_read_lock)
433
441
  {
578
586
  if (variables.max_join_size == HA_POS_ERROR)
579
587
    options |= OPTION_BIG_SELECTS;
580
588
 
581
 
  version= refresh_version;
 
589
  open_tables.version= g_refresh_version;
582
590
  set_proc_info(NULL);
583
591
  command= COM_SLEEP;
584
592
  set_time();
1860
1868
{
1861
1869
  for (Table *table= temporary_tables ; table ; table= table->getNext())
1862
1870
  {
1863
 
    if (table->query_id == getQueryId())
 
1871
    if (table->query_id == session_.getQueryId())
1864
1872
    {
1865
1873
      table->query_id= 0;
1866
1874
      table->cursor->ha_reset();
1891
1899
*/
1892
1900
void Session::close_thread_tables()
1893
1901
{
1894
 
  clearDerivedTables();
 
1902
  open_tables.clearDerivedTables();
1895
1903
 
1896
1904
  /*
1897
1905
    Mark all temporary tables used by this statement as free for reuse.
1898
1906
  */
1899
 
  mark_temp_tables_as_free_for_reuse();
 
1907
  open_tables.mark_temp_tables_as_free_for_reuse();
1900
1908
  /*
1901
1909
    Let us commit transaction for statement. Since in 5.0 we only have
1902
1910
    one statement transaction and don't allow several nested statement
1913
1921
    transaction.stmt.reset();
1914
1922
  }
1915
1923
 
1916
 
  if (lock)
 
1924
  if (open_tables.lock)
1917
1925
  {
1918
1926
    /*
1919
1927
      For RBR we flush the pending event just before we unlock all the
1924
1932
      handled either before writing a query log event (inside
1925
1933
      binlog_query()) or when preparing a pending event.
1926
1934
     */
1927
 
    unlockTables(lock);
1928
 
    lock= 0;
 
1935
    unlockTables(open_tables.lock);
 
1936
    open_tables.lock= 0;
1929
1937
  }
1930
1938
  /*
1931
1939
    Note that we need to hold table::Cache::singleton().mutex() while changing the
1934
1942
    Closing a MERGE child before the parent would be fatal if the
1935
1943
    other thread tries to abort the MERGE lock in between.
1936
1944
  */
1937
 
  if (open_tables_)
 
1945
  if (open_tables.open_tables_)
1938
1946
    close_open_tables();
1939
1947
}
1940
1948
 
1982
1990
 
1983
1991
bool Open_tables_state::rm_temporary_table(const identifier::Table &identifier, bool best_effort)
1984
1992
{
1985
 
  if (plugin::StorageEngine::dropTable(*static_cast<Session *>(this), identifier))
 
1993
  if (plugin::StorageEngine::dropTable(session_, identifier))
1986
1994
                return false;
1987
1995
  if (not best_effort)
1988
1996
    errmsg_printf(error::WARN, _("Could not remove temporary table: '%s', error: %d"), identifier.getSQLPath().c_str(), errno);
1992
2000
bool Open_tables_state::rm_temporary_table(plugin::StorageEngine& base, const identifier::Table &identifier)
1993
2001
{
1994
2002
  drizzled::error_t error;
1995
 
  if (plugin::StorageEngine::dropTable(*static_cast<Session *>(this), base, identifier, error))
 
2003
  if (plugin::StorageEngine::dropTable(session_, base, identifier, error))
1996
2004
                return false;
1997
2005
  errmsg_printf(error::WARN, _("Could not remove temporary table: '%s', error: %d"), identifier.getSQLPath().c_str(), error);
1998
2006
  return true;