← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/session.h

edit

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/session.h
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
 
20
 
20
21
#ifndef DRIZZLED_SESSION_H
21
22
#define DRIZZLED_SESSION_H
22
23
 
 
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"
 
40
#include <netdb.h>
 
41
#include <sys/time.h>
 
42
#include <sys/resource.h>
 
43
 
23
44
#include <algorithm>
24
45
#include <bitset>
25
 
#include <boost/make_shared.hpp>
26
 
#include <boost/thread/condition_variable.hpp>
 
46
#include <deque>
 
47
#include <map>
 
48
#include <string>
 
49
 
 
50
#include "drizzled/identifier.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
 
 
56
#include "drizzled/catalog/instance.h"
 
57
#include "drizzled/catalog/local.h"
 
58
 
 
59
#include <boost/unordered_map.hpp>
 
60
 
 
61
#include <boost/thread/thread.hpp>
27
62
#include <boost/thread/mutex.hpp>
28
63
#include <boost/thread/shared_mutex.hpp>
29
 
#include <boost/thread/thread.hpp>
30
 
#include <map>
31
 
#include <netdb.h>
32
 
#include <string>
33
 
#include <sys/resource.h>
34
 
#include <sys/time.h>
 
64
#include <boost/thread/condition_variable.hpp>
 
65
#include <boost/make_shared.hpp>
35
66
 
36
 
#include <drizzled/catalog/instance.h>
37
 
#include <drizzled/catalog/local.h>
38
 
#include <drizzled/copy_info.h>
39
 
#include <drizzled/cursor.h>
40
 
#include <drizzled/diagnostics_area.h>
41
 
#include <drizzled/file_exchange.h>
42
 
#include <drizzled/ha_data.h>
43
 
#include <drizzled/identifier.h>
44
 
#include <drizzled/lex_column.h>
45
 
#include <drizzled/my_hash.h>
46
 
#include <drizzled/named_savepoint.h>
47
 
#include <drizzled/open_tables_state.h>
48
 
#include <drizzled/plugin.h>
49
 
#include <drizzled/plugin/authorization.h>
50
 
#include <drizzled/pthread_globals.h>
51
 
#include <drizzled/query_id.h>
52
 
#include <drizzled/resource_context.h>
53
 
#include <drizzled/session/property_map.h>
54
 
#include <drizzled/session/state.h>
55
 
#include <drizzled/session/table_messages.h>
56
 
#include <drizzled/session/transactions.h>
57
 
#include <drizzled/sql_error.h>
58
 
#include <drizzled/sql_lex.h>
59
 
#include <drizzled/sql_locale.h>
60
 
#include <drizzled/statistics_variables.h>
61
 
#include <drizzled/system_variables.h>
62
 
#include <drizzled/system_variables.h>
63
 
#include <drizzled/table_ident.h>
64
 
#include <drizzled/transaction_context.h>
65
 
#include <drizzled/util/storable.h>
66
 
#include <drizzled/var.h>
67
 
#include <drizzled/visibility.h>
68
67
 
69
68
#define MIN_HANDSHAKE_SIZE      6
70
69
 
85
84
class Resultset;
86
85
}
87
86
 
88
 
namespace internal { struct st_my_thread_var; }
89
 
namespace table { class Placeholder; }
90
 
 
 
87
namespace internal
 
88
{
 
89
struct st_my_thread_var;
 
90
}
 
91
 
 
92
namespace table
 
93
{
 
94
class Placeholder;
 
95
}
 
96
 
 
97
class Lex_input_stream;
 
98
class user_var_entry;
91
99
class CopyField;
92
 
class DrizzleXid;
93
 
class Internal_error_handler;
94
 
class Lex_input_stream;
 
100
class Table_ident;
 
101
 
95
102
class TableShareInstance;
96
 
class Table_ident;
97
 
class Time_zone;
98
 
class select_result;
99
 
class user_var_entry;
100
103
 
101
104
extern char internal_table_name[2];
102
105
extern char empty_c_string[1];
106
109
#define TC_HEURISTIC_RECOVER_ROLLBACK 2
107
110
extern uint32_t tc_heuristic_recover;
108
111
 
 
112
/**
 
113
  @brief
 
114
  Local storage for proto that are tmp table. This should be enlarged
 
115
  to hande the entire table-share for a local table. Once Hash is done,
 
116
  we should consider exchanging the map for it.
 
117
*/
 
118
typedef std::map <std::string, message::Table> ProtoCache;
 
119
 
 
120
/**
 
121
  The COPY_INFO structure is used by INSERT/REPLACE code.
 
122
  The schema of the row counting by the INSERT/INSERT ... ON DUPLICATE KEY
 
123
  UPDATE code:
 
124
    If a row is inserted then the copied variable is incremented.
 
125
    If a row is updated by the INSERT ... ON DUPLICATE KEY UPDATE and the
 
126
      new data differs from the old one then the copied and the updated
 
127
      variables are incremented.
 
128
    The touched variable is incremented if a row was touched by the update part
 
129
      of the INSERT ... ON DUPLICATE KEY UPDATE no matter whether the row
 
130
      was actually changed or not.
 
131
*/
 
132
class CopyInfo 
 
133
{
 
134
public:
 
135
  ha_rows records; /**< Number of processed records */
 
136
  ha_rows deleted; /**< Number of deleted records */
 
137
  ha_rows updated; /**< Number of updated records */
 
138
  ha_rows copied;  /**< Number of copied records */
 
139
  ha_rows error_count;
 
140
  ha_rows touched; /* Number of touched records */
 
141
  enum enum_duplicates handle_duplicates;
 
142
  int escape_char, last_errno;
 
143
  bool ignore;
 
144
  /* for INSERT ... UPDATE */
 
145
  List<Item> *update_fields;
 
146
  List<Item> *update_values;
 
147
  /* for VIEW ... WITH CHECK OPTION */
 
148
 
 
149
  CopyInfo() :
 
150
    records(0),
 
151
    deleted(0),
 
152
    updated(0),
 
153
    copied(0),
 
154
    error_count(0),
 
155
    touched(0),
 
156
    escape_char(0),
 
157
    last_errno(0),
 
158
    ignore(0),
 
159
    update_fields(0),
 
160
    update_values(0)
 
161
  { }
 
162
 
 
163
};
 
164
 
 
165
} /* namespace drizzled */
 
166
 
 
167
/** @TODO why is this in the middle of the file */
 
168
#include <drizzled/lex_column.h>
 
169
 
 
170
namespace drizzled
 
171
{
 
172
 
 
173
class select_result;
 
174
class Time_zone;
 
175
 
109
176
#define Session_SENTRY_MAGIC 0xfeedd1ff
110
177
#define Session_SENTRY_GONE  0xdeadbeef
111
178
 
112
 
extern DRIZZLED_API struct drizzle_system_variables global_system_variables;
 
179
struct drizzle_system_variables
 
180
{
 
181
  drizzle_system_variables()
 
182
  {}
 
183
  /*
 
184
    How dynamically allocated system variables are handled:
 
185
 
 
186
    The global_system_variables and max_system_variables are "authoritative"
 
187
    They both should have the same 'version' and 'size'.
 
188
    When attempting to access a dynamic variable, if the session version
 
189
    is out of date, then the session version is updated and realloced if
 
190
    neccessary and bytes copied from global to make up for missing data.
 
191
  */
 
192
  ulong dynamic_variables_version;
 
193
  char * dynamic_variables_ptr;
 
194
  uint32_t dynamic_variables_head;  /* largest valid variable offset */
 
195
  uint32_t dynamic_variables_size;  /* how many bytes are in use */
 
196
 
 
197
  uint64_t myisam_max_extra_sort_file_size;
 
198
  uint64_t max_heap_table_size;
 
199
  uint64_t tmp_table_size;
 
200
  ha_rows select_limit;
 
201
  ha_rows max_join_size;
 
202
  uint64_t auto_increment_increment;
 
203
  uint64_t auto_increment_offset;
 
204
  uint64_t bulk_insert_buff_size;
 
205
  uint64_t join_buff_size;
 
206
  uint32_t max_allowed_packet;
 
207
  uint64_t max_error_count;
 
208
  uint64_t max_length_for_sort_data;
 
209
  size_t max_sort_length;
 
210
  uint64_t min_examined_row_limit;
 
211
  bool optimizer_prune_level;
 
212
  bool log_warnings;
 
213
 
 
214
  uint32_t optimizer_search_depth;
 
215
  uint32_t div_precincrement;
 
216
  uint64_t preload_buff_size;
 
217
  uint32_t read_buff_size;
 
218
  uint32_t read_rnd_buff_size;
 
219
  bool replicate_query;
 
220
  size_t sortbuff_size;
 
221
  uint32_t thread_handling;
 
222
  uint32_t tx_isolation;
 
223
  size_t transaction_message_threshold;
 
224
  uint32_t completion_type;
 
225
  /* Determines which non-standard SQL behaviour should be enabled */
 
226
  uint32_t sql_mode;
 
227
  uint64_t max_seeks_for_key;
 
228
  size_t range_alloc_block_size;
 
229
  uint32_t query_alloc_block_size;
 
230
  uint32_t query_prealloc_size;
 
231
  uint64_t group_concat_max_len;
 
232
  uint64_t pseudo_thread_id;
 
233
 
 
234
  plugin::StorageEngine *storage_engine;
 
235
 
 
236
  /* Only charset part of these variables is sensible */
 
237
  const CHARSET_INFO  *character_set_filesystem;
 
238
 
 
239
  /* Both charset and collation parts of these variables are important */
 
240
  const CHARSET_INFO    *collation_server;
 
241
 
 
242
  inline const CHARSET_INFO  *getCollation(void) 
 
243
  {
 
244
    return collation_server;
 
245
  }
 
246
 
 
247
  /* Locale Support */
 
248
  MY_LOCALE *lc_time_names;
 
249
 
 
250
  Time_zone *time_zone;
 
251
};
 
252
 
 
253
extern struct drizzle_system_variables global_system_variables;
 
254
 
 
255
} /* namespace drizzled */
 
256
 
 
257
#include "drizzled/sql_lex.h"
 
258
 
 
259
namespace drizzled
 
260
{
 
261
 
 
262
void mark_transaction_to_rollback(Session *session, bool all);
 
263
 
 
264
/**
 
265
  Storage engine specific thread local data.
 
266
*/
 
267
struct Ha_data
 
268
{
 
269
  /**
 
270
    Storage engine specific thread local data.
 
271
    Lifetime: one user connection.
 
272
  */
 
273
  void *ha_ptr;
 
274
  /**
 
275
   * Resource contexts for both the "statement" and "normal"
 
276
   * transactions.
 
277
   *
 
278
   * Resource context at index 0:
 
279
   *
 
280
   * Life time: one statement within a transaction. If @@autocommit is
 
281
   * on, also represents the entire transaction.
 
282
   *
 
283
   * Resource context at index 1:
 
284
   *
 
285
   * Life time: one transaction within a connection. 
 
286
   *
 
287
   * @note
 
288
   *
 
289
   * If the storage engine does not participate in a transaction, 
 
290
   * there will not be a resource context.
 
291
   */
 
292
  drizzled::ResourceContext resource_context[2];
 
293
 
 
294
  Ha_data() :ha_ptr(NULL) {}
 
295
};
113
296
 
114
297
/**
115
298
 * Represents a client connection to the database server.
131
314
 * session object.
132
315
 */
133
316
 
134
 
class DRIZZLED_API Session : public Open_tables_state
 
317
class Session : public Open_tables_state
135
318
{
136
319
public:
137
320
  // Plugin storage in Session.
 
321
  typedef boost::unordered_map<std::string, util::Storable *, util::insensitive_hash, util::insensitive_equal_to> PropertyMap;
 
322
  typedef Session* Ptr;
138
323
  typedef boost::shared_ptr<Session> shared_ptr;
139
324
  typedef Session& reference;
140
325
  typedef const Session& const_reference;
159
344
                        and update_row.
160
345
  */
161
346
  enum enum_mark_columns mark_used_columns;
 
347
  inline void* alloc(size_t size)
 
348
  {
 
349
    return mem_root->alloc_root(size);
 
350
  }
162
351
  inline void* calloc(size_t size)
163
352
  {
164
353
    void *ptr;
166
355
      memset(ptr, 0, size);
167
356
    return ptr;
168
357
  }
 
358
  inline char *strdup(const char *str)
 
359
  {
 
360
    return mem_root->strdup_root(str);
 
361
  }
169
362
  inline char *strmake(const char *str, size_t size)
170
363
  {
171
364
    return mem_root->strmake_root(str,size);
172
365
  }
173
 
 
 
366
  inline void *memdup(const void *str, size_t size)
 
367
  {
 
368
    return mem_root->memdup_root(str, size);
 
369
  }
174
370
  inline void *memdup_w_gap(const void *str, size_t size, uint32_t gap)
175
371
  {
176
372
    void *ptr;
180
376
  }
181
377
  /** Frees all items attached to this Statement */
182
378
  void free_items();
183
 
 
184
379
  /**
185
380
   * List of items created in the parser for this query. Every item puts
186
381
   * itself to the list on creation (see Item::Item() for details))
213
408
   * @todo should be const
214
409
   */
215
410
  uint32_t id;
216
 
private:
217
411
  LEX *lex; /**< parse tree descriptor */
218
412
 
219
 
public:
220
413
  LEX *getLex() 
221
414
  {
222
415
    return lex;
223
416
  }
224
 
 
225
 
  enum_sql_command getSqlCommand() const
226
 
  {
227
 
    return lex->sql_command;
228
 
  }
229
 
 
230
417
  /** query associated with this statement */
231
418
  typedef boost::shared_ptr<const std::string> QueryString;
232
 
 
233
419
private:
234
420
  boost::shared_ptr<std::string> query;
235
421
 
268
454
    return to_return;
269
455
  }
270
456
 
 
457
  class State {
 
458
    std::vector <char> _query;
 
459
 
 
460
  public:
 
461
    typedef boost::shared_ptr<State> const_shared_ptr;
 
462
 
 
463
    State(const char *in_packet, size_t in_packet_length)
 
464
    {
 
465
      if (in_packet_length)
 
466
      {
 
467
        size_t minimum= std::min(in_packet_length, static_cast<size_t>(PROCESS_LIST_WIDTH));
 
468
        _query.resize(minimum + 1);
 
469
        memcpy(&_query[0], in_packet, minimum);
 
470
      }
 
471
      else
 
472
      {
 
473
        _query.resize(0);
 
474
      }
 
475
    }
 
476
 
 
477
    const char *query() const
 
478
    {
 
479
      if (_query.size())
 
480
        return &_query[0];
 
481
 
 
482
      return "";
 
483
    }
 
484
 
 
485
    const char *query(size_t &size) const
 
486
    {
 
487
      if (_query.size())
 
488
      {
 
489
        size= _query.size() -1;
 
490
        return &_query[0];
 
491
      }
 
492
 
 
493
      size= 0;
 
494
      return "";
 
495
    }
 
496
  protected:
 
497
    friend class Session;
 
498
    typedef boost::shared_ptr<State> shared_ptr;
 
499
  };
271
500
private:
272
 
  session::State::shared_ptr  _state; 
273
 
 
 
501
  State::shared_ptr  _state; 
274
502
public:
275
503
 
276
 
  session::State::const_shared_ptr state()
 
504
  State::const_shared_ptr state()
277
505
  {
278
506
    return _state;
279
507
  }
292
520
  */
293
521
private:
294
522
  util::string::shared_ptr _schema;
295
 
 
296
523
public:
297
524
 
298
525
  util::string::const_shared_ptr schema() const
326
553
    return client;
327
554
  }
328
555
 
329
 
  plugin::Client *getClient() const
330
 
  {
331
 
    return client;
332
 
  }
333
 
 
334
556
  plugin::Scheduler *scheduler; /**< Pointer to scheduler object */
335
557
  void *scheduler_arg; /**< Pointer to the optional scheduler argument */
336
558
 
337
559
  typedef boost::unordered_map< std::string, user_var_entry *, util::insensitive_hash, util::insensitive_equal_to> UserVars;
338
 
 
339
560
private:
340
561
  typedef std::pair< UserVars::iterator, UserVars::iterator > UserVarsRange;
341
562
  UserVars user_vars; /**< Hash of user variables defined during the session's lifetime */
342
563
 
343
564
public:
 
565
 
344
566
  const UserVars &getUserVariables() const
345
567
  {
346
568
    return user_vars;
347
569
  }
348
570
 
349
571
  drizzle_system_variables variables; /**< Mutable local variables local to the session */
350
 
 
351
 
  enum_tx_isolation getTxIsolation()
352
 
  {
353
 
    return (enum_tx_isolation)variables.tx_isolation;
354
 
  }
355
 
 
356
572
  struct system_status_var status_var; /**< Session-local status counters */
357
573
  THR_LOCK_INFO lock_info; /**< Locking information for this session */
358
574
  THR_LOCK_OWNER main_lock_id; /**< To use for conventional queries */
373
589
  {
374
590
    assert(this->dbug_sentry == Session_SENTRY_MAGIC);
375
591
  }
376
 
 
377
592
public:
378
593
  identifier::User::const_shared_ptr user() const
379
594
  {
403
618
   */
404
619
  bool isViewable(identifier::User::const_reference) const;
405
620
 
406
 
private:
407
621
  /**
408
622
    Used in error messages to tell user in what part of MySQL we found an
409
623
    error. E. g. when where= "having clause", if fix_fields() fails, user
410
624
    will know that the error was in having clause.
411
625
  */
412
 
  const char *_where;
413
 
 
414
 
public:
415
 
  const char *where()
416
 
  {
417
 
    return _where;
418
 
  }
419
 
 
420
 
  void setWhere(const char *arg)
421
 
  {
422
 
    _where= arg;
423
 
  }
 
626
  const char *where;
424
627
 
425
628
  /*
426
629
    One thread can hold up to one named user-level lock. This variable
428
631
    chapter 'Miscellaneous functions', for functions GET_LOCK, RELEASE_LOCK.
429
632
  */
430
633
  uint32_t dbug_sentry; /**< watch for memory corruption */
431
 
 
432
634
private:
433
635
  boost::thread::id boost_thread_id;
434
636
  boost_thread_shared_ptr _thread;
435
637
  boost::this_thread::disable_interruption *interrupt;
436
638
 
437
639
  internal::st_my_thread_var *mysys_var;
 
640
public:
438
641
 
439
 
public:
440
642
  boost_thread_shared_ptr &getThread()
441
643
  {
442
644
    return _thread;
517
719
  ResourceContext *getResourceContext(const plugin::MonitoredInTransaction *monitored,
518
720
                                      size_t index= 0);
519
721
 
520
 
  session::Transactions transaction;
 
722
  /**
 
723
   * Structure used to manage "statement transactions" and
 
724
   * "normal transactions". In autocommit mode, the normal transaction is
 
725
   * equivalent to the statement transaction.
 
726
   *
 
727
   * Storage engines will be registered here when they participate in
 
728
   * a transaction. No engine is registered more than once.
 
729
   */
 
730
  struct st_transactions {
 
731
    std::deque<NamedSavepoint> savepoints;
 
732
 
 
733
    /**
 
734
     * The normal transaction (since BEGIN WORK).
 
735
     *
 
736
     * Contains a list of all engines that have participated in any of the
 
737
     * statement transactions started within the context of the normal
 
738
     * transaction.
 
739
     *
 
740
     * @note In autocommit mode, this is empty.
 
741
     */
 
742
    TransactionContext all;
 
743
 
 
744
    /**
 
745
     * The statment transaction.
 
746
     *
 
747
     * Contains a list of all engines participating in the given statement.
 
748
     *
 
749
     * @note In autocommit mode, this will be used to commit/rollback the
 
750
     * normal transaction.
 
751
     */
 
752
    TransactionContext stmt;
 
753
 
 
754
    XID_STATE xid_state;
 
755
 
 
756
    void cleanup()
 
757
    {
 
758
      savepoints.clear();
 
759
    }
 
760
    st_transactions() :
 
761
      savepoints(),
 
762
      all(),
 
763
      stmt(),
 
764
      xid_state()
 
765
    { }
 
766
  } transaction;
521
767
 
522
768
  Field *dup_field;
523
769
  sigset_t signals;
525
771
  // As of right now we do not allow a concurrent execute to launch itself
526
772
private:
527
773
  bool concurrent_execute_allowed;
528
 
 
529
774
public:
530
775
 
531
776
  void setConcurrentExecute(bool arg)
594
839
  uint64_t limit_found_rows;
595
840
  uint64_t options; /**< Bitmap of options */
596
841
  int64_t row_count_func; /**< For the ROW_COUNT() function */
597
 
 
598
 
  int64_t rowCount() const
599
 
  {
600
 
    return row_count_func;
601
 
  }
602
 
 
603
842
  ha_rows cuted_fields; /**< Count of "cut" or truncated fields. @todo Kill this friggin thing. */
604
843
 
605
844
  /** 
770
1009
  bool substitute_null_with_insert_id;
771
1010
  bool cleanup_done;
772
1011
 
773
 
private:
774
1012
  bool abort_on_warning;
775
 
  bool tablespace_op; /**< This is true in DISCARD/IMPORT TABLESPACE */
776
 
 
777
 
public:
778
1013
  bool got_warning; /**< Set on call to push_warning() */
779
1014
  bool no_warnings_for_error; /**< no warnings on call to my_error() */
780
1015
  /** set during loop of derived table processing */
781
1016
  bool derived_tables_processing;
782
 
 
783
 
  bool doing_tablespace_operation(void)
784
 
  {
785
 
    return tablespace_op;
786
 
  }
787
 
 
788
 
  void setDoingTablespaceOperation(bool doing)
789
 
  {
790
 
    tablespace_op= doing;
791
 
  }
792
 
 
 
1017
  bool tablespace_op; /**< This is true in DISCARD/IMPORT TABLESPACE */
793
1018
 
794
1019
  /** Used by the sys_var class to store temporary values */
795
1020
  union
1014
1239
  bool endTransaction(enum enum_mysql_completiontype completion);
1015
1240
  bool endActiveTransaction();
1016
1241
  bool startTransaction(start_transaction_option_t opt= START_TRANS_NO_OPTIONS);
1017
 
  void markTransactionForRollback(bool all);
1018
1242
 
1019
1243
  /**
1020
1244
   * Authenticates users, with error reporting.
1046
1270
  const char* enter_cond(boost::condition_variable_any &cond, boost::mutex &mutex, const char* msg);
1047
1271
  void exit_cond(const char* old_msg);
1048
1272
 
1049
 
  type::Time::epoch_t query_start()
 
1273
  time_t query_start()
1050
1274
  {
1051
1275
    return getCurrentTimestampEpoch();
1052
1276
  }
1082
1306
  /**
1083
1307
   * Returns the current micro-timestamp
1084
1308
   */
1085
 
  type::Time::epoch_t getCurrentTimestamp(bool actual= true) const
 
1309
  uint64_t getCurrentTimestamp(bool actual= true) const
1086
1310
  { 
1087
 
    type::Time::epoch_t t_mark;
 
1311
    uint64_t t_mark;
1088
1312
 
1089
1313
    if (actual)
1090
1314
    {
1100
1324
  }
1101
1325
 
1102
1326
  // We may need to set user on this
1103
 
  type::Time::epoch_t getCurrentTimestampEpoch() const
 
1327
  time_t getCurrentTimestampEpoch() const
1104
1328
  { 
1105
1329
    if (not _user_time.is_not_a_date_time())
1106
1330
      return (_user_time - _epoch).total_seconds();
1108
1332
    return (_start_timer - _epoch).total_seconds();
1109
1333
  }
1110
1334
 
1111
 
  type::Time::epoch_t getCurrentTimestampEpoch(type::Time::usec_t &fraction_arg) const
 
1335
  time_t getCurrentTimestampEpoch(uint32_t &fraction_arg) const
1112
1336
  { 
1113
1337
    if (not _user_time.is_not_a_date_time())
1114
1338
    {
1210
1434
  }
1211
1435
  void send_kill_message() const;
1212
1436
  /* return true if we will abort query if we make a warning now */
1213
 
  inline bool abortOnWarning()
1214
 
  {
1215
 
    return abort_on_warning;
1216
 
  }
1217
 
 
1218
 
  inline void setAbortOnWarning(bool arg)
1219
 
  {
1220
 
    abort_on_warning= arg;
 
1437
  inline bool really_abort_on_warning()
 
1438
  {
 
1439
    return (abort_on_warning);
1221
1440
  }
1222
1441
 
1223
1442
  void setAbort(bool arg);
1579
1798
  table::Placeholder *table_cache_insert_placeholder(const identifier::Table &identifier);
1580
1799
  bool lock_table_name_if_not_cached(const identifier::Table &identifier, Table **table);
1581
1800
 
 
1801
  typedef boost::unordered_map<std::string, message::Table, util::insensitive_hash, util::insensitive_equal_to> TableMessageCache;
 
1802
 
 
1803
  class TableMessages
 
1804
  {
 
1805
    TableMessageCache table_message_cache;
 
1806
 
 
1807
  public:
 
1808
    bool storeTableMessage(const identifier::Table &identifier, message::Table &table_message);
 
1809
    bool removeTableMessage(const identifier::Table &identifier);
 
1810
    bool getTableMessage(const identifier::Table &identifier, message::Table &table_message);
 
1811
    bool doesTableMessageExist(const identifier::Table &identifier);
 
1812
    bool renameTableMessage(const identifier::Table &from, const identifier::Table &to);
 
1813
  };
 
1814
 
1582
1815
private:
1583
 
  session::TableMessages _table_message_cache;
 
1816
  TableMessages _table_message_cache;
1584
1817
 
1585
1818
public:
1586
 
  session::TableMessages &getMessageCache()
 
1819
  TableMessages &getMessageCache()
1587
1820
  {
1588
1821
    return _table_message_cache;
1589
1822
  }
1598
1831
 
1599
1832
  drizzled::util::Storable *getProperty(const std::string &arg)
1600
1833
  {
1601
 
    return life_properties.getProperty(arg);
 
1834
    return life_properties[arg];
1602
1835
  }
1603
1836
 
1604
1837
  template<class T>
1605
1838
  bool setProperty(const std::string &arg, T *value)
1606
1839
  {
1607
 
    life_properties.setProperty(arg, value);
 
1840
    life_properties[arg]= value;
1608
1841
 
1609
1842
    return true;
1610
1843
  }
1624
1857
    return global_system_variables.storage_engine;
1625
1858
  }
1626
1859
 
1627
 
  void get_xid(DrizzleXid *xid); // Innodb only
 
1860
  void get_xid(DRIZZLE_XID *xid); // Innodb only
1628
1861
 
1629
1862
  table::Singular *getInstanceTable();
1630
1863
  table::Singular *getInstanceTable(List<CreateField> &field_list);
1639
1872
 
1640
1873
    return true;
1641
1874
  }
1642
 
 
1643
1875
public:
1644
1876
 
1645
1877
  void setUsage(bool arg)
1667
1899
 
1668
1900
  // This lives throughout the life of Session
1669
1901
  bool use_usage;
1670
 
  session::PropertyMap life_properties;
 
1902
  PropertyMap life_properties;
1671
1903
  std::vector<table::Singular *> temporary_shares;
1672
1904
  struct rusage usage;
1673
1905
};
1674
1906
 
 
1907
class Join;
 
1908
 
1675
1909
#define ESCAPE_CHARS "ntrb0ZN" // keep synchronous with READ_INFO::unescape
1676
1910
 
 
1911
} /* namespace drizzled */
 
1912
 
 
1913
/** @TODO why is this in the middle of the file */
 
1914
#include <drizzled/select_to_file.h>
 
1915
#include <drizzled/select_export.h>
 
1916
#include <drizzled/select_dump.h>
 
1917
#include <drizzled/select_insert.h>
 
1918
#include <drizzled/select_create.h>
 
1919
#include <drizzled/tmp_table_param.h>
 
1920
#include <drizzled/select_union.h>
 
1921
#include <drizzled/select_subselect.h>
 
1922
#include <drizzled/select_singlerow_subselect.h>
 
1923
#include <drizzled/select_max_min_finder_subselect.h>
 
1924
#include <drizzled/select_exists_subselect.h>
 
1925
 
 
1926
namespace drizzled
 
1927
{
 
1928
 
 
1929
/**
 
1930
 * A structure used to describe sort information
 
1931
 * for a field or item used in ORDER BY.
 
1932
 */
 
1933
class SortField 
 
1934
{
 
1935
public:
 
1936
  Field *field; /**< Field to sort */
 
1937
  Item  *item; /**< Item if not sorting fields */
 
1938
  size_t length; /**< Length of sort field */
 
1939
  uint32_t suffix_length; /**< Length suffix (0-4) */
 
1940
  Item_result result_type; /**< Type of item */
 
1941
  bool reverse; /**< if descending sort */
 
1942
  bool need_strxnfrm;   /**< If we have to use strxnfrm() */
 
1943
 
 
1944
  SortField() :
 
1945
    field(0),
 
1946
    item(0),
 
1947
    length(0),
 
1948
    suffix_length(0),
 
1949
    result_type(STRING_RESULT),
 
1950
    reverse(0),
 
1951
    need_strxnfrm(0)
 
1952
  { }
 
1953
 
 
1954
};
 
1955
 
 
1956
} /* namespace drizzled */
 
1957
 
 
1958
/** @TODO why is this in the middle of the file */
 
1959
 
 
1960
#include <drizzled/table_ident.h>
 
1961
#include <drizzled/user_var_entry.h>
 
1962
#include <drizzled/unique.h>
 
1963
#include <drizzled/var.h>
 
1964
#include <drizzled/select_dumpvar.h>
 
1965
 
 
1966
namespace drizzled
 
1967
{
 
1968
 
1677
1969
/* Bits in sql_command_flags */
1678
1970
 
1679
1971
enum sql_command_flag_bits 
1695
1987
namespace display  {
1696
1988
const std::string &type(drizzled::Session::global_read_lock_t type);
1697
1989
size_t max_string_length(drizzled::Session::global_read_lock_t type);
1698
 
 
1699
1990
} /* namespace display */
1700
1991
 
1701
1992
} /* namespace drizzled */