← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/session.h

  • Committer: Brian Aker
  • Date: 2011-02-21 17:37:00 UTC
  • mto: (2192.1.1 drizzle-staging)
  • mto: This revision was merged to the branch mainline in revision 2193.
  • Revision ID: brian@tangent.org-20110221173700-6wdfbxm60zq9q9se
Merge in change from REPLICATION to REPLICATE as keyword.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/session.h
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
 
4
 *  Copyright (C) 2008 Sun Microsystems, Inc.
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
 
21
20
#ifndef DRIZZLED_SESSION_H
22
21
#define DRIZZLED_SESSION_H
23
22
 
24
 
#include "drizzled/plugin.h"
25
 
#include "drizzled/sql_locale.h"
26
 
#include "drizzled/resource_context.h"
27
 
#include "drizzled/cursor.h"
28
 
#include "drizzled/current_session.h"
29
 
#include "drizzled/sql_error.h"
30
 
#include "drizzled/file_exchange.h"
31
 
#include "drizzled/select_result_interceptor.h"
32
 
#include "drizzled/statistics_variables.h"
33
 
#include "drizzled/xid.h"
34
 
#include "drizzled/query_id.h"
35
 
#include "drizzled/named_savepoint.h"
36
 
#include "drizzled/transaction_context.h"
37
 
#include "drizzled/util/storable.h"
38
 
#include "drizzled/my_hash.h"
39
 
#include "drizzled/pthread_globals.h"
 
23
#include <drizzled/cursor.h>
 
24
#include <drizzled/diagnostics_area.h>
 
25
#include <drizzled/file_exchange.h>
 
26
#include <drizzled/identifier.h>
 
27
#include <drizzled/lex_column.h>
 
28
#include <drizzled/my_hash.h>
 
29
#include <drizzled/named_savepoint.h>
 
30
#include <drizzled/open_tables_state.h>
 
31
#include <drizzled/plugin.h>
 
32
#include <drizzled/plugin/authorization.h>
 
33
#include <drizzled/pthread_globals.h>
 
34
#include <drizzled/query_id.h>
 
35
#include <drizzled/resource_context.h>
 
36
#include <drizzled/sql_error.h>
 
37
#include <drizzled/sql_lex.h>
 
38
#include <drizzled/sql_locale.h>
 
39
#include <drizzled/statistics_variables.h>
 
40
#include <drizzled/table_ident.h>
 
41
#include <drizzled/transaction_context.h>
 
42
#include <drizzled/util/storable.h>
 
43
#include <drizzled/var.h>
 
44
 
 
45
 
40
46
#include <netdb.h>
41
47
#include <sys/time.h>
42
48
#include <sys/resource.h>
43
49
 
44
50
#include <algorithm>
45
51
#include <bitset>
46
 
#include <deque>
47
52
#include <map>
48
53
#include <string>
49
54
 
50
 
#include "drizzled/security_context.h"
51
 
#include "drizzled/open_tables_state.h"
52
 
#include "drizzled/internal_error_handler.h"
53
 
#include "drizzled/diagnostics_area.h"
54
 
#include "drizzled/plugin/authorization.h"
 
55
#include <drizzled/catalog/instance.h>
 
56
#include <drizzled/catalog/local.h>
55
57
 
56
 
#include <boost/unordered_map.hpp>
 
58
#include <drizzled/copy_info.h>
 
59
#include <drizzled/ha_data.h>
 
60
#include <drizzled/session/property_map.h>
 
61
#include <drizzled/session/state.h>
 
62
#include <drizzled/session/table_messages.h>
 
63
#include <drizzled/session/transactions.h>
 
64
#include <drizzled/system_variables.h>
 
65
#include <drizzled/system_variables.h>
57
66
 
58
67
#include <boost/thread/thread.hpp>
59
68
#include <boost/thread/mutex.hpp>
61
70
#include <boost/thread/condition_variable.hpp>
62
71
#include <boost/make_shared.hpp>
63
72
 
 
73
#include <drizzled/visibility.h>
64
74
 
65
75
#define MIN_HANDSHAKE_SIZE      6
66
76
 
81
91
class Resultset;
82
92
}
83
93
 
84
 
namespace internal
85
 
{
86
 
struct st_my_thread_var;
87
 
}
88
 
 
89
 
namespace table
90
 
{
91
 
class Placeholder;
92
 
}
93
 
 
 
94
namespace internal { struct st_my_thread_var; }
 
95
namespace table { class Placeholder; }
 
96
 
 
97
class CopyField;
 
98
class DrizzleXid;
 
99
class Internal_error_handler;
94
100
class Lex_input_stream;
 
101
class TableShareInstance;
 
102
class Table_ident;
 
103
class Time_zone;
 
104
class select_result;
95
105
class user_var_entry;
96
 
class CopyField;
97
 
class Table_ident;
98
 
 
99
 
class TableShareInstance;
100
106
 
101
107
extern char internal_table_name[2];
102
108
extern char empty_c_string[1];
106
112
#define TC_HEURISTIC_RECOVER_ROLLBACK 2
107
113
extern uint32_t tc_heuristic_recover;
108
114
 
109
 
/**
110
 
  @brief
111
 
  Local storage for proto that are tmp table. This should be enlarged
112
 
  to hande the entire table-share for a local table. Once Hash is done,
113
 
  we should consider exchanging the map for it.
114
 
*/
115
 
typedef std::map <std::string, message::Table> ProtoCache;
116
 
 
117
 
/**
118
 
  The COPY_INFO structure is used by INSERT/REPLACE code.
119
 
  The schema of the row counting by the INSERT/INSERT ... ON DUPLICATE KEY
120
 
  UPDATE code:
121
 
    If a row is inserted then the copied variable is incremented.
122
 
    If a row is updated by the INSERT ... ON DUPLICATE KEY UPDATE and the
123
 
      new data differs from the old one then the copied and the updated
124
 
      variables are incremented.
125
 
    The touched variable is incremented if a row was touched by the update part
126
 
      of the INSERT ... ON DUPLICATE KEY UPDATE no matter whether the row
127
 
      was actually changed or not.
128
 
*/
129
 
class CopyInfo 
130
 
{
131
 
public:
132
 
  ha_rows records; /**< Number of processed records */
133
 
  ha_rows deleted; /**< Number of deleted records */
134
 
  ha_rows updated; /**< Number of updated records */
135
 
  ha_rows copied;  /**< Number of copied records */
136
 
  ha_rows error_count;
137
 
  ha_rows touched; /* Number of touched records */
138
 
  enum enum_duplicates handle_duplicates;
139
 
  int escape_char, last_errno;
140
 
  bool ignore;
141
 
  /* for INSERT ... UPDATE */
142
 
  List<Item> *update_fields;
143
 
  List<Item> *update_values;
144
 
  /* for VIEW ... WITH CHECK OPTION */
145
 
 
146
 
  CopyInfo() :
147
 
    records(0),
148
 
    deleted(0),
149
 
    updated(0),
150
 
    copied(0),
151
 
    error_count(0),
152
 
    touched(0),
153
 
    escape_char(0),
154
 
    last_errno(0),
155
 
    ignore(0),
156
 
    update_fields(0),
157
 
    update_values(0)
158
 
  { }
159
 
 
160
 
};
161
 
 
162
 
} /* namespace drizzled */
163
 
 
164
 
/** @TODO why is this in the middle of the file */
165
 
#include <drizzled/lex_column.h>
166
 
 
167
 
namespace drizzled
168
 
{
169
 
 
170
 
class select_result;
171
 
class Time_zone;
172
 
 
173
115
#define Session_SENTRY_MAGIC 0xfeedd1ff
174
116
#define Session_SENTRY_GONE  0xdeadbeef
175
117
 
176
 
struct drizzle_system_variables
177
 
{
178
 
  drizzle_system_variables()
179
 
  {}
180
 
  /*
181
 
    How dynamically allocated system variables are handled:
182
 
 
183
 
    The global_system_variables and max_system_variables are "authoritative"
184
 
    They both should have the same 'version' and 'size'.
185
 
    When attempting to access a dynamic variable, if the session version
186
 
    is out of date, then the session version is updated and realloced if
187
 
    neccessary and bytes copied from global to make up for missing data.
188
 
  */
189
 
  ulong dynamic_variables_version;
190
 
  char * dynamic_variables_ptr;
191
 
  uint32_t dynamic_variables_head;  /* largest valid variable offset */
192
 
  uint32_t dynamic_variables_size;  /* how many bytes are in use */
193
 
 
194
 
  uint64_t myisam_max_extra_sort_file_size;
195
 
  uint64_t max_heap_table_size;
196
 
  uint64_t tmp_table_size;
197
 
  ha_rows select_limit;
198
 
  ha_rows max_join_size;
199
 
  uint64_t auto_increment_increment;
200
 
  uint64_t auto_increment_offset;
201
 
  uint64_t bulk_insert_buff_size;
202
 
  uint64_t join_buff_size;
203
 
  uint32_t max_allowed_packet;
204
 
  uint64_t max_error_count;
205
 
  uint64_t max_length_for_sort_data;
206
 
  size_t max_sort_length;
207
 
  uint64_t min_examined_row_limit;
208
 
  bool optimizer_prune_level;
209
 
  bool log_warnings;
210
 
 
211
 
  uint32_t optimizer_search_depth;
212
 
  uint32_t div_precincrement;
213
 
  uint64_t preload_buff_size;
214
 
  uint32_t read_buff_size;
215
 
  uint32_t read_rnd_buff_size;
216
 
  bool replicate_query;
217
 
  size_t sortbuff_size;
218
 
  uint32_t thread_handling;
219
 
  uint32_t tx_isolation;
220
 
  size_t transaction_message_threshold;
221
 
  uint32_t completion_type;
222
 
  /* Determines which non-standard SQL behaviour should be enabled */
223
 
  uint32_t sql_mode;
224
 
  uint64_t max_seeks_for_key;
225
 
  size_t range_alloc_block_size;
226
 
  uint32_t query_alloc_block_size;
227
 
  uint32_t query_prealloc_size;
228
 
  uint64_t group_concat_max_len;
229
 
  uint64_t pseudo_thread_id;
230
 
 
231
 
  plugin::StorageEngine *storage_engine;
232
 
 
233
 
  /* Only charset part of these variables is sensible */
234
 
  const CHARSET_INFO  *character_set_filesystem;
235
 
 
236
 
  /* Both charset and collation parts of these variables are important */
237
 
  const CHARSET_INFO    *collation_server;
238
 
 
239
 
  inline const CHARSET_INFO  *getCollation(void) 
240
 
  {
241
 
    return collation_server;
242
 
  }
243
 
 
244
 
  /* Locale Support */
245
 
  MY_LOCALE *lc_time_names;
246
 
 
247
 
  Time_zone *time_zone;
248
 
};
249
 
 
250
 
extern struct drizzle_system_variables global_system_variables;
251
 
 
252
 
} /* namespace drizzled */
253
 
 
254
 
#include "drizzled/sql_lex.h"
255
 
 
256
 
namespace drizzled
257
 
{
258
 
 
259
 
void mark_transaction_to_rollback(Session *session, bool all);
260
 
 
261
 
/**
262
 
  Storage engine specific thread local data.
263
 
*/
264
 
struct Ha_data
265
 
{
266
 
  /**
267
 
    Storage engine specific thread local data.
268
 
    Lifetime: one user connection.
269
 
  */
270
 
  void *ha_ptr;
271
 
  /**
272
 
   * Resource contexts for both the "statement" and "normal"
273
 
   * transactions.
274
 
   *
275
 
   * Resource context at index 0:
276
 
   *
277
 
   * Life time: one statement within a transaction. If @@autocommit is
278
 
   * on, also represents the entire transaction.
279
 
   *
280
 
   * Resource context at index 1:
281
 
   *
282
 
   * Life time: one transaction within a connection. 
283
 
   *
284
 
   * @note
285
 
   *
286
 
   * If the storage engine does not participate in a transaction, 
287
 
   * there will not be a resource context.
288
 
   */
289
 
  drizzled::ResourceContext resource_context[2];
290
 
 
291
 
  Ha_data() :ha_ptr(NULL) {}
292
 
};
 
118
extern DRIZZLED_API struct drizzle_system_variables global_system_variables;
293
119
 
294
120
/**
295
121
 * Represents a client connection to the database server.
310
136
 * all member variables that are not critical to non-internal operations of the
311
137
 * session object.
312
138
 */
313
 
typedef int64_t session_id_t;
314
139
 
315
 
class Session : public Open_tables_state
 
140
class DRIZZLED_API Session : public Open_tables_state
316
141
{
317
142
public:
318
143
  // Plugin storage in Session.
319
 
  typedef boost::unordered_map<std::string, util::Storable *, util::insensitive_hash, util::insensitive_equal_to> PropertyMap;
320
 
  typedef Session* Ptr;
321
144
  typedef boost::shared_ptr<Session> shared_ptr;
 
145
  typedef Session& reference;
 
146
  typedef const Session& const_reference;
 
147
  typedef const Session* const_pointer;
 
148
  typedef Session* pointer;
 
149
 
 
150
  static shared_ptr make_shared(plugin::Client *client, catalog::Instance::shared_ptr instance_arg)
 
151
  {
 
152
    assert(instance_arg);
 
153
    return boost::make_shared<Session>(client, instance_arg);
 
154
  }
322
155
 
323
156
  /*
324
157
    MARK_COLUMNS_NONE:  Means mark_used_colums is not set and no indicator to
332
165
                        and update_row.
333
166
  */
334
167
  enum enum_mark_columns mark_used_columns;
335
 
  inline void* alloc(size_t size)
336
 
  {
337
 
    return mem_root->alloc_root(size);
338
 
  }
339
168
  inline void* calloc(size_t size)
340
169
  {
341
170
    void *ptr;
343
172
      memset(ptr, 0, size);
344
173
    return ptr;
345
174
  }
346
 
  inline char *strdup(const char *str)
347
 
  {
348
 
    return mem_root->strdup_root(str);
349
 
  }
350
175
  inline char *strmake(const char *str, size_t size)
351
176
  {
352
177
    return mem_root->strmake_root(str,size);
353
178
  }
354
 
  inline void *memdup(const void *str, size_t size)
355
 
  {
356
 
    return mem_root->memdup_root(str, size);
357
 
  }
 
179
 
358
180
  inline void *memdup_w_gap(const void *str, size_t size, uint32_t gap)
359
181
  {
360
182
    void *ptr;
364
186
  }
365
187
  /** Frees all items attached to this Statement */
366
188
  void free_items();
 
189
 
367
190
  /**
368
191
   * List of items created in the parser for this query. Every item puts
369
192
   * itself to the list on creation (see Item::Item() for details))
402
225
  {
403
226
    return lex;
404
227
  }
 
228
 
 
229
  enum_sql_command getSqlCommand() const
 
230
  {
 
231
    return lex->sql_command;
 
232
  }
 
233
 
405
234
  /** query associated with this statement */
406
235
  typedef boost::shared_ptr<const std::string> QueryString;
 
236
 
407
237
private:
408
238
  boost::shared_ptr<std::string> query;
409
239
 
431
261
  {
432
262
    QueryString tmp_string(getQueryString());
433
263
 
434
 
    assert(tmp_string);
435
264
    if (not tmp_string)
436
265
    {
437
266
      length= 0;
438
 
      return 0;
 
267
      return NULL;
439
268
    }
440
269
 
441
270
    length= tmp_string->length();
443
272
    return to_return;
444
273
  }
445
274
 
446
 
  class State {
447
 
    std::vector <char> _query;
448
 
 
449
 
  public:
450
 
    typedef boost::shared_ptr<State> const_shared_ptr;
451
 
 
452
 
    State(const char *in_packet, size_t in_packet_length)
453
 
    {
454
 
      if (in_packet_length)
455
 
      {
456
 
        size_t minimum= std::min(in_packet_length, static_cast<size_t>(PROCESS_LIST_WIDTH));
457
 
        _query.resize(minimum + 1);
458
 
        memcpy(&_query[0], in_packet, minimum);
459
 
      }
460
 
      else
461
 
      {
462
 
        _query.resize(0);
463
 
      }
464
 
    }
465
 
 
466
 
    const char *query() const
467
 
    {
468
 
      if (_query.size())
469
 
        return &_query[0];
470
 
 
471
 
      return "";
472
 
    }
473
 
 
474
 
    const char *query(size_t &size) const
475
 
    {
476
 
      if (_query.size())
477
 
      {
478
 
        size= _query.size() -1;
479
 
        return &_query[0];
480
 
      }
481
 
 
482
 
      size= 0;
483
 
      return "";
484
 
    }
485
 
  protected:
486
 
    friend class Session;
487
 
    typedef boost::shared_ptr<State> shared_ptr;
488
 
  };
489
275
private:
490
 
  State::shared_ptr  _state; 
 
276
  session::State::shared_ptr  _state; 
 
277
 
491
278
public:
492
279
 
493
 
  State::const_shared_ptr state()
 
280
  session::State::const_shared_ptr state()
494
281
  {
495
282
    return _state;
496
283
  }
509
296
  */
510
297
private:
511
298
  util::string::shared_ptr _schema;
 
299
 
512
300
public:
513
301
 
514
302
  util::string::const_shared_ptr schema() const
518
306
 
519
307
    return util::string::const_shared_ptr(new std::string(""));
520
308
  }
521
 
  std::string catalog;
 
309
 
522
310
  /* current cache key */
523
311
  std::string query_cache_key;
524
312
  /**
530
318
  static const char * const DEFAULT_WHERE;
531
319
 
532
320
  memory::Root warn_root; /**< Allocation area for warnings and errors */
 
321
private:
533
322
  plugin::Client *client; /**< Pointer to client object */
534
323
 
 
324
public:
 
325
 
535
326
  void setClient(plugin::Client *client_arg);
536
327
 
537
328
  plugin::Client *getClient()
539
330
    return client;
540
331
  }
541
332
 
 
333
  plugin::Client *getClient() const
 
334
  {
 
335
    return client;
 
336
  }
 
337
 
542
338
  plugin::Scheduler *scheduler; /**< Pointer to scheduler object */
543
339
  void *scheduler_arg; /**< Pointer to the optional scheduler argument */
544
340
 
545
341
  typedef boost::unordered_map< std::string, user_var_entry *, util::insensitive_hash, util::insensitive_equal_to> UserVars;
 
342
 
546
343
private:
547
344
  typedef std::pair< UserVars::iterator, UserVars::iterator > UserVarsRange;
548
345
  UserVars user_vars; /**< Hash of user variables defined during the session's lifetime */
549
346
 
550
347
public:
551
 
 
552
348
  const UserVars &getUserVariables() const
553
349
  {
554
350
    return user_vars;
555
351
  }
556
352
 
557
353
  drizzle_system_variables variables; /**< Mutable local variables local to the session */
 
354
 
 
355
  enum_tx_isolation getTxIsolation()
 
356
  {
 
357
    return (enum_tx_isolation)variables.tx_isolation;
 
358
  }
 
359
 
558
360
  struct system_status_var status_var; /**< Session-local status counters */
559
361
  THR_LOCK_INFO lock_info; /**< Locking information for this session */
560
362
  THR_LOCK_OWNER main_lock_id; /**< To use for conventional queries */
567
369
  char *thread_stack;
568
370
 
569
371
private:
570
 
  SecurityContext security_ctx;
 
372
  identifier::User::shared_ptr security_ctx;
571
373
 
572
374
  int32_t scoreboard_index;
573
375
 
575
377
  {
576
378
    assert(this->dbug_sentry == Session_SENTRY_MAGIC);
577
379
  }
 
380
 
578
381
public:
579
 
  const SecurityContext& getSecurityContext() const
 
382
  identifier::User::const_shared_ptr user() const
580
383
  {
581
 
    return security_ctx;
 
384
    if (security_ctx)
 
385
      return security_ctx;
 
386
 
 
387
    return identifier::User::const_shared_ptr();
582
388
  }
583
389
 
584
 
  SecurityContext& getSecurityContext()
 
390
  void setUser(identifier::User::shared_ptr arg)
585
391
  {
586
 
    return security_ctx;
 
392
    security_ctx= arg;
587
393
  }
588
394
 
589
395
  int32_t getScoreboardIndex()
599
405
  /**
600
406
   * Is this session viewable by the current user?
601
407
   */
602
 
  bool isViewable() const;
 
408
  bool isViewable(identifier::User::const_reference) const;
603
409
 
 
410
private:
604
411
  /**
605
412
    Used in error messages to tell user in what part of MySQL we found an
606
413
    error. E. g. when where= "having clause", if fix_fields() fails, user
607
414
    will know that the error was in having clause.
608
415
  */
609
 
  const char *where;
 
416
  const char *_where;
 
417
 
 
418
public:
 
419
  const char *where()
 
420
  {
 
421
    return _where;
 
422
  }
 
423
 
 
424
  void setWhere(const char *arg)
 
425
  {
 
426
    _where= arg;
 
427
  }
610
428
 
611
429
  /*
612
430
    One thread can hold up to one named user-level lock. This variable
614
432
    chapter 'Miscellaneous functions', for functions GET_LOCK, RELEASE_LOCK.
615
433
  */
616
434
  uint32_t dbug_sentry; /**< watch for memory corruption */
 
435
 
617
436
private:
618
437
  boost::thread::id boost_thread_id;
619
438
  boost_thread_shared_ptr _thread;
620
439
  boost::this_thread::disable_interruption *interrupt;
621
440
 
622
441
  internal::st_my_thread_var *mysys_var;
 
442
 
623
443
public:
624
 
 
625
444
  boost_thread_shared_ptr &getThread()
626
445
  {
627
446
    return _thread;
651
470
  uint32_t file_id;     /**< File ID for LOAD DATA INFILE */
652
471
  /* @note the following three members should likely move to Client */
653
472
  uint32_t max_client_packet_length; /**< Maximum number of bytes a client can send in a single packet */
654
 
  time_t start_time;
655
 
  time_t user_time;
656
 
  uint64_t thr_create_utime; /**< track down slow pthread_create */
657
 
  uint64_t start_utime;
658
 
  uint64_t utime_after_lock;
 
473
 
 
474
private:
 
475
  boost::posix_time::ptime _epoch;
 
476
  boost::posix_time::ptime _connect_time;
 
477
  boost::posix_time::ptime _start_timer;
 
478
  boost::posix_time::ptime _end_timer;
 
479
 
 
480
  boost::posix_time::ptime _user_time;
 
481
public:
 
482
  uint64_t utime_after_lock; // This used by Innodb.
 
483
 
 
484
  void resetUserTime()
 
485
  {
 
486
    _user_time= boost::posix_time::not_a_date_time;
 
487
  }
 
488
 
 
489
  const boost::posix_time::ptime &start_timer() const
 
490
  {
 
491
    return _start_timer;
 
492
  }
 
493
 
 
494
  void getTimeDifference(boost::posix_time::time_duration &result_arg, const boost::posix_time::ptime &arg) const
 
495
  {
 
496
    result_arg=  arg - _start_timer;
 
497
  }
659
498
 
660
499
  thr_lock_type update_lock_default;
661
500
 
676
515
  */
677
516
  query_id_t query_id;
678
517
  query_id_t warn_query_id;
 
518
 
679
519
public:
680
520
  void **getEngineData(const plugin::MonitoredInTransaction *monitored);
681
521
  ResourceContext *getResourceContext(const plugin::MonitoredInTransaction *monitored,
682
522
                                      size_t index= 0);
683
523
 
684
 
  /**
685
 
   * Structure used to manage "statement transactions" and
686
 
   * "normal transactions". In autocommit mode, the normal transaction is
687
 
   * equivalent to the statement transaction.
688
 
   *
689
 
   * Storage engines will be registered here when they participate in
690
 
   * a transaction. No engine is registered more than once.
691
 
   */
692
 
  struct st_transactions {
693
 
    std::deque<NamedSavepoint> savepoints;
694
 
 
695
 
    /**
696
 
     * The normal transaction (since BEGIN WORK).
697
 
     *
698
 
     * Contains a list of all engines that have participated in any of the
699
 
     * statement transactions started within the context of the normal
700
 
     * transaction.
701
 
     *
702
 
     * @note In autocommit mode, this is empty.
703
 
     */
704
 
    TransactionContext all;
705
 
 
706
 
    /**
707
 
     * The statment transaction.
708
 
     *
709
 
     * Contains a list of all engines participating in the given statement.
710
 
     *
711
 
     * @note In autocommit mode, this will be used to commit/rollback the
712
 
     * normal transaction.
713
 
     */
714
 
    TransactionContext stmt;
715
 
 
716
 
    XID_STATE xid_state;
717
 
 
718
 
    void cleanup()
719
 
    {
720
 
      savepoints.clear();
721
 
    }
722
 
    st_transactions() :
723
 
      savepoints(),
724
 
      all(),
725
 
      stmt(),
726
 
      xid_state()
727
 
    { }
728
 
  } transaction;
 
524
  session::Transactions transaction;
729
525
 
730
526
  Field *dup_field;
731
527
  sigset_t signals;
733
529
  // As of right now we do not allow a concurrent execute to launch itself
734
530
private:
735
531
  bool concurrent_execute_allowed;
 
532
 
736
533
public:
737
534
 
738
535
  void setConcurrentExecute(bool arg)
801
598
  uint64_t limit_found_rows;
802
599
  uint64_t options; /**< Bitmap of options */
803
600
  int64_t row_count_func; /**< For the ROW_COUNT() function */
 
601
 
 
602
  int64_t rowCount() const
 
603
  {
 
604
    return row_count_func;
 
605
  }
 
606
 
804
607
  ha_rows cuted_fields; /**< Count of "cut" or truncated fields. @todo Kill this friggin thing. */
805
608
 
806
609
  /** 
849
652
    create_sort_index(); may differ from examined_row_count.
850
653
  */
851
654
  uint32_t row_count;
 
655
 
 
656
  uint32_t getRowCount() const
 
657
  {
 
658
    return row_count;
 
659
  }
 
660
 
852
661
  session_id_t thread_id;
853
662
  uint32_t tmp_table;
854
663
  enum global_read_lock_t
872
681
    _global_read_lock= arg;
873
682
  }
874
683
 
875
 
  DrizzleLock *lockTables(Table **tables, uint32_t count, uint32_t flags, bool *need_reopen);
 
684
  DrizzleLock *lockTables(Table **tables, uint32_t count, uint32_t flags);
876
685
  bool lockGlobalReadLock();
877
686
  bool lock_table_names(TableList *table_list);
878
687
  bool lock_table_names_exclusively(TableList *table_list);
940
749
    can not continue. In particular, disables activation of
941
750
    CONTINUE or EXIT handlers of stored routines.
942
751
    Reset in the end of processing of the current user request, in
943
 
    @see mysql_reset_session_for_next_command().
 
752
    @see reset_session_for_next_command().
944
753
  */
945
754
  bool is_fatal_error;
946
755
  /**
965
774
  bool substitute_null_with_insert_id;
966
775
  bool cleanup_done;
967
776
 
 
777
private:
968
778
  bool abort_on_warning;
 
779
  bool tablespace_op; /**< This is true in DISCARD/IMPORT TABLESPACE */
 
780
 
 
781
public:
969
782
  bool got_warning; /**< Set on call to push_warning() */
970
783
  bool no_warnings_for_error; /**< no warnings on call to my_error() */
971
784
  /** set during loop of derived table processing */
972
785
  bool derived_tables_processing;
973
 
  bool tablespace_op; /**< This is true in DISCARD/IMPORT TABLESPACE */
 
786
 
 
787
  bool doing_tablespace_operation(void)
 
788
  {
 
789
    return tablespace_op;
 
790
  }
 
791
 
 
792
  void setDoingTablespaceOperation(bool doing)
 
793
  {
 
794
    tablespace_op= doing;
 
795
  }
 
796
 
974
797
 
975
798
  /** Used by the sys_var class to store temporary values */
976
799
  union
1112
935
    auto_inc_intervals_forced.append(next_id, UINT64_MAX, 0);
1113
936
  }
1114
937
 
1115
 
  Session(plugin::Client *client_arg);
 
938
  Session(plugin::Client *client_arg, catalog::Instance::shared_ptr catalog);
1116
939
  virtual ~Session();
1117
940
 
1118
941
  void cleanup(void);
1195
1018
  bool endTransaction(enum enum_mysql_completiontype completion);
1196
1019
  bool endActiveTransaction();
1197
1020
  bool startTransaction(start_transaction_option_t opt= START_TRANS_NO_OPTIONS);
 
1021
  void markTransactionForRollback(bool all);
1198
1022
 
1199
1023
  /**
1200
1024
   * Authenticates users, with error reporting.
1215
1039
   */
1216
1040
  static bool schedule(Session::shared_ptr&);
1217
1041
 
 
1042
  static void unlink(session_id_t &session_id);
1218
1043
  static void unlink(Session::shared_ptr&);
1219
1044
 
1220
1045
  /*
1225
1050
  const char* enter_cond(boost::condition_variable_any &cond, boost::mutex &mutex, const char* msg);
1226
1051
  void exit_cond(const char* old_msg);
1227
1052
 
1228
 
  inline time_t query_start() { return start_time; }
1229
 
  inline void set_time()
1230
 
  {
1231
 
    boost::posix_time::ptime mytime(boost::posix_time::microsec_clock::local_time());
1232
 
    boost::posix_time::ptime epoch(boost::gregorian::date(1970,1,1));
1233
 
    start_utime= utime_after_lock= (mytime-epoch).total_microseconds();
1234
 
 
1235
 
    if (user_time)
1236
 
    {
1237
 
      start_time= user_time;
1238
 
      connect_microseconds= start_utime;
1239
 
    }
1240
 
    else 
1241
 
      start_time= (mytime-epoch).total_seconds();
1242
 
  }
1243
 
  inline void   set_current_time()    { start_time= time(NULL); }
1244
 
  inline void   set_time(time_t t)
1245
 
  {
1246
 
    start_time= user_time= t;
1247
 
    boost::posix_time::ptime mytime(boost::posix_time::microsec_clock::local_time());
1248
 
    boost::posix_time::ptime epoch(boost::gregorian::date(1970,1,1));
1249
 
    uint64_t t_mark= (mytime-epoch).total_microseconds();
1250
 
 
1251
 
    start_utime= utime_after_lock= t_mark;
1252
 
  }
1253
 
  void set_time_after_lock()  { 
1254
 
     boost::posix_time::ptime mytime(boost::posix_time::microsec_clock::local_time());
1255
 
     boost::posix_time::ptime epoch(boost::gregorian::date(1970,1,1));
1256
 
     utime_after_lock= (mytime-epoch).total_microseconds();
1257
 
  }
 
1053
  type::Time::epoch_t query_start()
 
1054
  {
 
1055
    return getCurrentTimestampEpoch();
 
1056
  }
 
1057
 
 
1058
  void set_time()
 
1059
  {
 
1060
    _end_timer= _start_timer= boost::posix_time::microsec_clock::universal_time();
 
1061
    utime_after_lock= (_start_timer - _epoch).total_microseconds();
 
1062
  }
 
1063
 
 
1064
  void set_time(time_t t) // This is done by a sys_var, as long as user_time is set, we will use that for all references to time
 
1065
  {
 
1066
    _user_time= boost::posix_time::from_time_t(t);
 
1067
  }
 
1068
 
 
1069
  void set_time_after_lock()
 
1070
  { 
 
1071
    boost::posix_time::ptime mytime(boost::posix_time::microsec_clock::universal_time());
 
1072
    utime_after_lock= (mytime - _epoch).total_microseconds();
 
1073
  }
 
1074
 
 
1075
  void set_end_timer()
 
1076
  {
 
1077
    _end_timer= boost::posix_time::microsec_clock::universal_time();
 
1078
    status_var.execution_time_nsec+=(_end_timer - _start_timer).total_microseconds();
 
1079
  }
 
1080
 
 
1081
  uint64_t getElapsedTime() const
 
1082
  {
 
1083
    return (_end_timer - _start_timer).total_microseconds();
 
1084
  }
 
1085
 
1258
1086
  /**
1259
1087
   * Returns the current micro-timestamp
1260
1088
   */
1261
 
  inline uint64_t getCurrentTimestamp()  
 
1089
  type::Time::epoch_t getCurrentTimestamp(bool actual= true) const
1262
1090
  { 
1263
 
    boost::posix_time::ptime mytime(boost::posix_time::microsec_clock::local_time());
1264
 
    boost::posix_time::ptime epoch(boost::gregorian::date(1970,1,1));
1265
 
    uint64_t t_mark= (mytime-epoch).total_microseconds();
 
1091
    type::Time::epoch_t t_mark;
 
1092
 
 
1093
    if (actual)
 
1094
    {
 
1095
      boost::posix_time::ptime mytime(boost::posix_time::microsec_clock::universal_time());
 
1096
      t_mark= (mytime - _epoch).total_microseconds();
 
1097
    }
 
1098
    else
 
1099
    {
 
1100
      t_mark= (_end_timer - _epoch).total_microseconds();
 
1101
    }
1266
1102
 
1267
1103
    return t_mark; 
1268
1104
  }
1269
 
  inline uint64_t found_rows(void)
 
1105
 
 
1106
  // We may need to set user on this
 
1107
  type::Time::epoch_t getCurrentTimestampEpoch() const
 
1108
  { 
 
1109
    if (not _user_time.is_not_a_date_time())
 
1110
      return (_user_time - _epoch).total_seconds();
 
1111
 
 
1112
    return (_start_timer - _epoch).total_seconds();
 
1113
  }
 
1114
 
 
1115
  type::Time::epoch_t getCurrentTimestampEpoch(type::Time::usec_t &fraction_arg) const
 
1116
  { 
 
1117
    if (not _user_time.is_not_a_date_time())
 
1118
    {
 
1119
      fraction_arg= 0;
 
1120
      return (_user_time - _epoch).total_seconds();
 
1121
    }
 
1122
 
 
1123
    fraction_arg= _start_timer.time_of_day().fractional_seconds() % 1000000;
 
1124
    return (_start_timer - _epoch).total_seconds();
 
1125
  }
 
1126
 
 
1127
  uint64_t found_rows(void) const
1270
1128
  {
1271
1129
    return limit_found_rows;
1272
1130
  }
 
1131
 
1273
1132
  /** Returns whether the session is currently inside a transaction */
1274
 
  inline bool inTransaction()
 
1133
  bool inTransaction() const
1275
1134
  {
1276
1135
    return server_status & SERVER_STATUS_IN_TRANS;
1277
1136
  }
 
1137
 
1278
1138
  LEX_STRING *make_lex_string(LEX_STRING *lex_str,
1279
1139
                              const char* str, uint32_t length,
1280
1140
                              bool allocate_lex_string);
 
1141
 
1281
1142
  LEX_STRING *make_lex_string(LEX_STRING *lex_str,
1282
1143
                              const std::string &str,
1283
1144
                              bool allocate_lex_string);
1284
1145
 
1285
1146
  int send_explain_fields(select_result *result);
 
1147
 
1286
1148
  /**
1287
1149
    Clear the current error, if any.
1288
1150
    We do not clear is_fatal_error or is_fatal_sub_stmt_error since we
1352
1214
  }
1353
1215
  void send_kill_message() const;
1354
1216
  /* return true if we will abort query if we make a warning now */
1355
 
  inline bool really_abort_on_warning()
1356
 
  {
1357
 
    return (abort_on_warning);
 
1217
  inline bool abortOnWarning()
 
1218
  {
 
1219
    return abort_on_warning;
 
1220
  }
 
1221
 
 
1222
  inline void setAbortOnWarning(bool arg)
 
1223
  {
 
1224
    abort_on_warning= arg;
1358
1225
  }
1359
1226
 
1360
1227
  void setAbort(bool arg);
1400
1267
    @param level the error level
1401
1268
    @return true if the error is handled
1402
1269
  */
1403
 
  virtual bool handle_error(uint32_t sql_errno, const char *message,
 
1270
  virtual bool handle_error(drizzled::error_t sql_errno, const char *message,
1404
1271
                            DRIZZLE_ERROR::enum_warning_level level);
1405
1272
 
1406
1273
  /**
1428
1295
   * updates any status variables necessary.
1429
1296
   *
1430
1297
   * @param errcode     Error code to print to console
1431
 
   * @param should_lock 1 if we have have to lock LOCK_thread_count
1432
1298
   *
1433
1299
   * @note  For the connection that is doing shutdown, this is called twice
1434
1300
   */
1435
 
  void disconnect(uint32_t errcode, bool lock);
 
1301
  void disconnect(enum error_t errcode= EE_OK);
1436
1302
 
1437
1303
  /**
1438
1304
   * Check if user exists and the password supplied is correct.
1452
1318
   * Returns the timestamp (in microseconds) of when the Session 
1453
1319
   * connected to the server.
1454
1320
   */
1455
 
  inline uint64_t getConnectMicroseconds() const
1456
 
  {
1457
 
    return connect_microseconds;
 
1321
  uint64_t getConnectMicroseconds() const
 
1322
  {
 
1323
    return (_connect_time - _epoch).total_microseconds();
 
1324
  }
 
1325
 
 
1326
  uint64_t getConnectSeconds() const
 
1327
  {
 
1328
    return (_connect_time - _epoch).total_seconds();
1458
1329
  }
1459
1330
 
1460
1331
  /**
1575
1446
  
1576
1447
  
1577
1448
 private:
1578
 
 /** Microsecond timestamp of when Session connected */
1579
 
  uint64_t connect_microseconds;
1580
1449
  const char *proc_info;
1581
1450
 
1582
1451
  /** The current internal error handler for this thread, or NULL. */
1669
1538
  void close_old_data_files(bool morph_locks= false,
1670
1539
                            bool send_refresh= false);
1671
1540
  void close_open_tables();
1672
 
  void close_data_files_and_morph_locks(const TableIdentifier &identifier);
 
1541
  void close_data_files_and_morph_locks(const identifier::Table &identifier);
1673
1542
 
1674
1543
private:
1675
 
  bool free_cached_table();
 
1544
  bool free_cached_table(boost::mutex::scoped_lock &scopedLock);
 
1545
 
1676
1546
public:
1677
1547
 
1678
1548
  /**
1706
1576
  Table *openTable(TableList *table_list, bool *refresh, uint32_t flags= 0);
1707
1577
 
1708
1578
  void unlink_open_table(Table *find);
1709
 
  void drop_open_table(Table *table, const TableIdentifier &identifier);
 
1579
  void drop_open_table(Table *table, const identifier::Table &identifier);
1710
1580
  void close_cached_table(Table *table);
1711
1581
 
1712
1582
  /* Create a lock in the cache */
1713
 
  table::Placeholder *table_cache_insert_placeholder(const TableIdentifier &identifier);
1714
 
  bool lock_table_name_if_not_cached(const TableIdentifier &identifier, Table **table);
1715
 
 
1716
 
  typedef boost::unordered_map<std::string, message::Table, util::insensitive_hash, util::insensitive_equal_to> TableMessageCache;
1717
 
 
1718
 
  class TableMessages
1719
 
  {
1720
 
    TableMessageCache table_message_cache;
1721
 
 
1722
 
  public:
1723
 
    bool storeTableMessage(const TableIdentifier &identifier, message::Table &table_message);
1724
 
    bool removeTableMessage(const TableIdentifier &identifier);
1725
 
    bool getTableMessage(const TableIdentifier &identifier, message::Table &table_message);
1726
 
    bool doesTableMessageExist(const TableIdentifier &identifier);
1727
 
    bool renameTableMessage(const TableIdentifier &from, const TableIdentifier &to);
1728
 
 
1729
 
  };
 
1583
  table::Placeholder *table_cache_insert_placeholder(const identifier::Table &identifier);
 
1584
  bool lock_table_name_if_not_cached(const identifier::Table &identifier, Table **table);
 
1585
 
1730
1586
private:
1731
 
  TableMessages _table_message_cache;
 
1587
  session::TableMessages _table_message_cache;
1732
1588
 
1733
1589
public:
1734
 
  TableMessages &getMessageCache()
 
1590
  session::TableMessages &getMessageCache()
1735
1591
  {
1736
1592
    return _table_message_cache;
1737
1593
  }
1738
1594
 
1739
1595
  /* Reopen operations */
1740
 
  bool reopen_tables(bool get_locks, bool mark_share_as_old);
 
1596
  bool reopen_tables();
1741
1597
  bool close_cached_tables(TableList *tables, bool wait_for_refresh, bool wait_for_placeholders);
1742
1598
 
1743
1599
  void wait_for_condition(boost::mutex &mutex, boost::condition_variable_any &cond);
1746
1602
 
1747
1603
  drizzled::util::Storable *getProperty(const std::string &arg)
1748
1604
  {
1749
 
    return life_properties[arg];
 
1605
    return life_properties.getProperty(arg);
1750
1606
  }
1751
1607
 
1752
1608
  template<class T>
1753
1609
  bool setProperty(const std::string &arg, T *value)
1754
1610
  {
1755
 
    life_properties[arg]= value;
 
1611
    life_properties.setProperty(arg, value);
1756
1612
 
1757
1613
    return true;
1758
1614
  }
1772
1628
    return global_system_variables.storage_engine;
1773
1629
  }
1774
1630
 
1775
 
  void get_xid(DRIZZLE_XID *xid); // Innodb only
 
1631
  void get_xid(DrizzleXid *xid); // Innodb only
1776
1632
 
1777
 
  table::Instance *getInstanceTable();
1778
 
  table::Instance *getInstanceTable(List<CreateField> &field_list);
 
1633
  table::Singular *getInstanceTable();
 
1634
  table::Singular *getInstanceTable(List<CreateField> &field_list);
1779
1635
 
1780
1636
private:
1781
1637
  bool resetUsage()
1787
1643
 
1788
1644
    return true;
1789
1645
  }
 
1646
 
1790
1647
public:
1791
1648
 
1792
1649
  void setUsage(bool arg)
1799
1656
    return usage;
1800
1657
  }
1801
1658
 
 
1659
  catalog::Instance::const_reference catalog() const
 
1660
  {
 
1661
    return *(_catalog.get());
 
1662
  }
 
1663
 
 
1664
  catalog::Instance::reference catalog()
 
1665
  {
 
1666
    return *(_catalog.get());
 
1667
  }
 
1668
 
1802
1669
private:
 
1670
  catalog::Instance::shared_ptr _catalog;
 
1671
 
1803
1672
  // This lives throughout the life of Session
1804
1673
  bool use_usage;
1805
 
  PropertyMap life_properties;
1806
 
  std::vector<table::Instance *> temporary_shares;
 
1674
  session::PropertyMap life_properties;
 
1675
  std::vector<table::Singular *> temporary_shares;
1807
1676
  struct rusage usage;
1808
1677
};
1809
1678
 
1810
 
class Join;
1811
 
 
1812
1679
#define ESCAPE_CHARS "ntrb0ZN" // keep synchronous with READ_INFO::unescape
1813
1680
 
1814
 
} /* namespace drizzled */
1815
 
 
1816
 
/** @TODO why is this in the middle of the file */
1817
 
#include <drizzled/select_to_file.h>
1818
 
#include <drizzled/select_export.h>
1819
 
#include <drizzled/select_dump.h>
1820
 
#include <drizzled/select_insert.h>
1821
 
#include <drizzled/select_create.h>
1822
 
#include <drizzled/tmp_table_param.h>
1823
 
#include <drizzled/select_union.h>
1824
 
#include <drizzled/select_subselect.h>
1825
 
#include <drizzled/select_singlerow_subselect.h>
1826
 
#include <drizzled/select_max_min_finder_subselect.h>
1827
 
#include <drizzled/select_exists_subselect.h>
1828
 
 
1829
 
namespace drizzled
1830
 
{
1831
 
 
1832
 
/**
1833
 
 * A structure used to describe sort information
1834
 
 * for a field or item used in ORDER BY.
1835
 
 */
1836
 
class SortField 
1837
 
{
1838
 
public:
1839
 
  Field *field; /**< Field to sort */
1840
 
  Item  *item; /**< Item if not sorting fields */
1841
 
  size_t length; /**< Length of sort field */
1842
 
  uint32_t suffix_length; /**< Length suffix (0-4) */
1843
 
  Item_result result_type; /**< Type of item */
1844
 
  bool reverse; /**< if descending sort */
1845
 
  bool need_strxnfrm;   /**< If we have to use strxnfrm() */
1846
 
 
1847
 
  SortField() :
1848
 
    field(0),
1849
 
    item(0),
1850
 
    length(0),
1851
 
    suffix_length(0),
1852
 
    result_type(STRING_RESULT),
1853
 
    reverse(0),
1854
 
    need_strxnfrm(0)
1855
 
  { }
1856
 
 
1857
 
};
1858
 
 
1859
 
} /* namespace drizzled */
1860
 
 
1861
 
/** @TODO why is this in the middle of the file */
1862
 
 
1863
 
#include <drizzled/table_ident.h>
1864
 
#include <drizzled/user_var_entry.h>
1865
 
#include <drizzled/unique.h>
1866
 
#include <drizzled/var.h>
1867
 
#include <drizzled/select_dumpvar.h>
1868
 
 
1869
 
namespace drizzled
1870
 
{
1871
 
 
1872
1681
/* Bits in sql_command_flags */
1873
1682
 
1874
1683
enum sql_command_flag_bits 
1890
1699
namespace display  {
1891
1700
const std::string &type(drizzled::Session::global_read_lock_t type);
1892
1701
size_t max_string_length(drizzled::Session::global_read_lock_t type);
 
1702
 
1893
1703
} /* namespace display */
1894
1704
 
1895
1705
} /* namespace drizzled */