← 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: 2009-02-05 10:38:55 UTC
  • Revision ID: brian@tangent.org-20090205103855-wajzccrbu7zbvmh4
Reworked some classes out of session.h
Also updated ignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/session.h
18
18
 */
19
19
 
20
20
 
 
21
#ifndef DRIZZLED_SESSION_H
 
22
#define DRIZZLED_SESSION_H
 
23
 
21
24
/* Classes in mysql */
 
25
 
22
26
#include <drizzled/global.h>
23
 
#include "log.h"
24
 
#include "rpl_tblmap.h"
25
 
 
26
 
class Relay_log_info;
27
 
 
28
 
class Query_log_event;
29
 
class Load_log_event;
30
 
class Slave_log_event;
 
27
#include <drizzled/protocol.h>
 
28
#include <libdrizzleclient/password.h>     // rand_struct
 
29
#include <drizzled/sql_locale.h>
 
30
#include <drizzled/ha_trx_info.h>
 
31
#include <mysys/my_tree.h>
 
32
#include <drizzled/handler.h>
 
33
#include <drizzled/current_session.h>
 
34
#include <drizzled/sql_error.h>
 
35
#include <drizzled/query_arena.h>
 
36
#include <drizzled/file_exchange.h>
 
37
#include <drizzled/select_result_interceptor.h>
 
38
#include <string>
 
39
#include <bitset>
 
40
 
31
41
class Lex_input_stream;
32
 
class Rows_log_event;
 
42
class user_var_entry;
 
43
class Copy_field;
 
44
class Table_ident;
33
45
 
34
 
enum enum_enable_or_disable { LEAVE_AS_IS, ENABLE, DISABLE };
35
 
enum enum_ha_read_modes { RFIRST, RNEXT, RPREV, RLAST, RKEY, RNEXT_SAME };
36
 
enum enum_duplicates { DUP_ERROR, DUP_REPLACE, DUP_UPDATE };
37
 
enum enum_delay_key_write { DELAY_KEY_WRITE_NONE, DELAY_KEY_WRITE_ON,
38
 
                            DELAY_KEY_WRITE_ALL };
39
 
enum enum_slave_exec_mode { SLAVE_EXEC_MODE_STRICT,
40
 
                            SLAVE_EXEC_MODE_IDEMPOTENT,
41
 
                            SLAVE_EXEC_MODE_LAST_BIT};
42
 
enum enum_mark_columns
43
 
{ MARK_COLUMNS_NONE, MARK_COLUMNS_READ, MARK_COLUMNS_WRITE};
44
 
enum enum_filetype { FILETYPE_CSV, FILETYPE_XML };
45
46
 
46
47
extern char internal_table_name[2];
47
48
extern char empty_c_string[1];
48
49
extern const char **errmesg;
49
50
 
50
 
#define TC_LOG_PAGE_SIZE   8192
51
 
#define TC_LOG_MIN_SIZE    (3*TC_LOG_PAGE_SIZE)
52
 
 
53
51
#define TC_HEURISTIC_RECOVER_COMMIT   1
54
52
#define TC_HEURISTIC_RECOVER_ROLLBACK 2
55
53
extern uint32_t tc_heuristic_recover;
56
54
 
57
 
typedef struct st_user_var_events
58
 
{
59
 
  user_var_entry *user_var_event;
60
 
  char *value;
61
 
  ulong length;
62
 
  Item_result type;
63
 
  uint32_t charset_number;
64
 
} BINLOG_USER_VAR_EVENT;
65
 
 
66
 
#define RP_LOCK_LOG_IS_ALREADY_LOCKED 1
67
 
#define RP_FORCE_ROTATE               2
68
 
 
69
55
/*
70
56
  The COPY_INFO structure is used by INSERT/REPLACE code.
71
57
  The schema of the row counting by the INSERT/INSERT ... ON DUPLICATE KEY
95
81
} COPY_INFO;
96
82
 
97
83
 
98
 
class Key_part_spec :public Sql_alloc {
99
 
public:
100
 
  LEX_STRING field_name;
101
 
  uint32_t length;
102
 
  Key_part_spec(const LEX_STRING &name, uint32_t len)
103
 
    : field_name(name), length(len)
104
 
  {}
105
 
  Key_part_spec(const char *name, const size_t name_len, uint32_t len)
106
 
    : length(len)
107
 
  { field_name.str= (char *)name; field_name.length= name_len; }
108
 
  bool operator==(const Key_part_spec& other) const;
109
 
  /**
110
 
    Construct a copy of this Key_part_spec. field_name is copied
111
 
    by-pointer as it is known to never change. At the same time
112
 
    'length' may be reset in mysql_prepare_create_table, and this
113
 
    is why we supply it with a copy.
114
 
 
115
 
    @return If out of memory, 0 is returned and an error is set in
116
 
    THD.
117
 
  */
118
 
  Key_part_spec *clone(MEM_ROOT *mem_root) const
119
 
  { return new (mem_root) Key_part_spec(*this); }
120
 
};
121
 
 
122
 
 
123
 
class Alter_drop :public Sql_alloc {
124
 
public:
125
 
  enum drop_type {KEY, COLUMN };
126
 
  const char *name;
127
 
  enum drop_type type;
128
 
  Alter_drop(enum drop_type par_type,const char *par_name)
129
 
    :name(par_name), type(par_type) {}
130
 
  /**
131
 
    Used to make a clone of this object for ALTER/CREATE TABLE
132
 
    @sa comment for Key_part_spec::clone
133
 
  */
134
 
  Alter_drop *clone(MEM_ROOT *mem_root) const
135
 
    { return new (mem_root) Alter_drop(*this); }
136
 
};
137
 
 
138
 
 
139
 
class Alter_column :public Sql_alloc {
140
 
public:
141
 
  const char *name;
142
 
  Item *def;
143
 
  Alter_column(const char *par_name,Item *literal)
144
 
    :name(par_name), def(literal) {}
145
 
  /**
146
 
    Used to make a clone of this object for ALTER/CREATE TABLE
147
 
    @sa comment for Key_part_spec::clone
148
 
  */
149
 
  Alter_column *clone(MEM_ROOT *mem_root) const
150
 
    { return new (mem_root) Alter_column(*this); }
151
 
};
152
 
 
153
 
 
154
 
class Key :public Sql_alloc {
155
 
public:
156
 
  enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FOREIGN_KEY};
157
 
  enum Keytype type;
158
 
  KEY_CREATE_INFO key_create_info;
159
 
  List<Key_part_spec> columns;
160
 
  LEX_STRING name;
161
 
  bool generated;
162
 
 
163
 
  Key(enum Keytype type_par, const LEX_STRING &name_arg,
164
 
      KEY_CREATE_INFO *key_info_arg,
165
 
      bool generated_arg, List<Key_part_spec> &cols)
166
 
    :type(type_par), key_create_info(*key_info_arg), columns(cols),
167
 
    name(name_arg), generated(generated_arg)
168
 
  {}
169
 
  Key(enum Keytype type_par, const char *name_arg, size_t name_len_arg,
170
 
      KEY_CREATE_INFO *key_info_arg, bool generated_arg,
171
 
      List<Key_part_spec> &cols)
172
 
    :type(type_par), key_create_info(*key_info_arg), columns(cols),
173
 
    generated(generated_arg)
174
 
  {
175
 
    name.str= (char *)name_arg;
176
 
    name.length= name_len_arg;
177
 
  }
178
 
  Key(const Key &rhs, MEM_ROOT *mem_root);
179
 
  virtual ~Key() {}
180
 
  /* Equality comparison of keys (ignoring name) */
181
 
  friend bool foreign_key_prefix(Key *a, Key *b);
182
 
  /**
183
 
    Used to make a clone of this object for ALTER/CREATE TABLE
184
 
    @sa comment for Key_part_spec::clone
185
 
  */
186
 
  virtual Key *clone(MEM_ROOT *mem_root) const
187
 
    { return new (mem_root) Key(*this, mem_root); }
188
 
};
189
 
 
190
 
class Table_ident;
191
 
 
192
 
class Foreign_key: public Key {
193
 
public:
194
 
  enum fk_match_opt { FK_MATCH_UNDEF, FK_MATCH_FULL,
195
 
                      FK_MATCH_PARTIAL, FK_MATCH_SIMPLE};
196
 
  enum fk_option { FK_OPTION_UNDEF, FK_OPTION_RESTRICT, FK_OPTION_CASCADE,
197
 
                   FK_OPTION_SET_NULL, FK_OPTION_NO_ACTION, FK_OPTION_DEFAULT};
198
 
 
199
 
  Table_ident *ref_table;
200
 
  List<Key_part_spec> ref_columns;
201
 
  uint32_t delete_opt, update_opt, match_opt;
202
 
  Foreign_key(const LEX_STRING &name_arg, List<Key_part_spec> &cols,
203
 
              Table_ident *table,   List<Key_part_spec> &ref_cols,
204
 
              uint32_t delete_opt_arg, uint32_t update_opt_arg, uint32_t match_opt_arg)
205
 
    :Key(FOREIGN_KEY, name_arg, &default_key_create_info, 0, cols),
206
 
    ref_table(table), ref_columns(ref_cols),
207
 
    delete_opt(delete_opt_arg), update_opt(update_opt_arg),
208
 
    match_opt(match_opt_arg)
209
 
  {}
210
 
  Foreign_key(const Foreign_key &rhs, MEM_ROOT *mem_root);
211
 
  /**
212
 
    Used to make a clone of this object for ALTER/CREATE TABLE
213
 
    @sa comment for Key_part_spec::clone
214
 
  */
215
 
  virtual Key *clone(MEM_ROOT *mem_root) const
216
 
  { return new (mem_root) Foreign_key(*this, mem_root); }
217
 
};
 
84
 
 
85
 
218
86
 
219
87
typedef struct st_mysql_lock
220
88
{
235
103
class select_result;
236
104
class Time_zone;
237
105
 
238
 
#define THD_SENTRY_MAGIC 0xfeedd1ff
239
 
#define THD_SENTRY_GONE  0xdeadbeef
 
106
#define Session_SENTRY_MAGIC 0xfeedd1ff
 
107
#define Session_SENTRY_GONE  0xdeadbeef
240
108
 
241
 
#define THD_CHECK_SENTRY(thd) assert(thd->dbug_sentry == THD_SENTRY_MAGIC)
 
109
#define Session_CHECK_SENTRY(session) assert(session->dbug_sentry == Session_SENTRY_MAGIC)
242
110
 
243
111
struct system_variables
244
112
{
245
113
  /*
246
114
    How dynamically allocated system variables are handled:
247
 
    
 
115
 
248
116
    The global_system_variables and max_system_variables are "authoritative"
249
117
    They both should have the same 'version' and 'size'.
250
118
    When attempting to access a dynamic variable, if the session version
251
119
    is out of date, then the session version is updated and realloced if
252
120
    neccessary and bytes copied from global to make up for missing data.
253
 
  */ 
 
121
  */
254
122
  ulong dynamic_variables_version;
255
123
  char* dynamic_variables_ptr;
256
124
  uint32_t dynamic_variables_head;  /* largest valid variable offset */
257
125
  uint32_t dynamic_variables_size;  /* how many bytes are in use */
258
 
  
 
126
 
259
127
  uint64_t myisam_max_extra_sort_file_size;
260
 
  uint64_t myisam_max_sort_file_size;
261
128
  uint64_t max_heap_table_size;
262
129
  uint64_t tmp_table_size;
263
 
  uint64_t long_query_time;
264
130
  ha_rows select_limit;
265
131
  ha_rows max_join_size;
266
 
  ulong auto_increment_increment, auto_increment_offset;
267
 
  ulong bulk_insert_buff_size;
268
 
  ulong join_buff_size;
269
 
  ulong max_allowed_packet;
270
 
  ulong max_error_count;
271
 
  ulong max_length_for_sort_data;
272
 
  ulong max_sort_length;
273
 
  ulong max_tmp_tables;
274
 
  ulong min_examined_row_limit;
275
 
  ulong myisam_repair_threads;
276
 
  ulong myisam_sort_buff_size;
277
 
  ulong myisam_stats_method;
278
 
  ulong net_buffer_length;
279
 
  ulong net_interactive_timeout;
280
 
  ulong net_read_timeout;
281
 
  ulong net_retry_count;
282
 
  ulong net_wait_timeout;
283
 
  ulong net_write_timeout;
284
 
  ulong optimizer_prune_level;
285
 
  ulong optimizer_search_depth;
 
132
  uint64_t auto_increment_increment;
 
133
  uint64_t auto_increment_offset;
 
134
  uint64_t bulk_insert_buff_size;
 
135
  uint64_t join_buff_size;
 
136
  uint32_t max_allowed_packet;
 
137
  uint64_t max_error_count;
 
138
  uint64_t max_length_for_sort_data;
 
139
  uint64_t max_sort_length;
 
140
  uint64_t max_tmp_tables;
 
141
  uint64_t min_examined_row_limit;
 
142
  uint32_t myisam_stats_method;
 
143
  uint32_t net_buffer_length;
 
144
  uint32_t net_interactive_timeout;
 
145
  uint32_t net_read_timeout;
 
146
  uint32_t net_retry_count;
 
147
  uint32_t net_wait_timeout;
 
148
  uint32_t net_write_timeout;
 
149
  bool optimizer_prune_level;
 
150
  uint32_t optimizer_search_depth;
286
151
  /*
287
152
    Controls use of Engine-MRR:
288
153
      0 - auto, based on cost
289
154
      1 - force MRR when the storage engine is capable of doing it
290
155
      2 - disable MRR.
291
156
  */
292
 
  ulong optimizer_use_mrr; 
 
157
  uint32_t optimizer_use_mrr;
293
158
  /* A bitmap for switching optimizations on/off */
294
 
  ulong optimizer_switch;
295
 
  ulong preload_buff_size;
296
 
  ulong profiling_history_size;
297
 
  ulong query_cache_type;
298
 
  ulong read_buff_size;
299
 
  ulong read_rnd_buff_size;
300
 
  ulong div_precincrement;
301
 
  ulong sortbuff_size;
302
 
  ulong thread_handling;
303
 
  ulong tx_isolation;
304
 
  ulong completion_type;
 
159
  uint32_t optimizer_switch;
 
160
  uint64_t preload_buff_size;
 
161
  uint32_t read_buff_size;
 
162
  uint32_t read_rnd_buff_size;
 
163
  uint32_t div_precincrement;
 
164
  size_t sortbuff_size;
 
165
  uint32_t thread_handling;
 
166
  uint32_t tx_isolation;
 
167
  uint32_t completion_type;
305
168
  /* Determines which non-standard SQL behaviour should be enabled */
306
 
  ulong sql_mode;
307
 
  ulong default_week_format;
308
 
  ulong max_seeks_for_key;
309
 
  ulong range_alloc_block_size;
310
 
  ulong query_alloc_block_size;
311
 
  ulong query_prealloc_size;
312
 
  ulong trans_alloc_block_size;
313
 
  ulong trans_prealloc_size;
314
 
  ulong log_warnings;
315
 
  ulong group_concat_max_len;
316
 
  ulong binlog_format; // binlog format for this thd (see enum_binlog_format)
317
 
  /*
318
 
    In slave thread we need to know in behalf of which
319
 
    thread the query is being run to replicate temp tables properly
320
 
  */
321
 
  my_thread_id pseudo_thread_id;
 
169
  uint32_t sql_mode;
 
170
  uint64_t max_seeks_for_key;
 
171
  size_t range_alloc_block_size;
 
172
  uint32_t query_alloc_block_size;
 
173
  uint32_t query_prealloc_size;
 
174
  uint32_t trans_alloc_block_size;
 
175
  uint32_t trans_prealloc_size;
 
176
  bool log_warnings;
 
177
  uint64_t group_concat_max_len;
 
178
  /* TODO: change this to my_thread_id - but have to fix set_var first */
 
179
  uint64_t pseudo_thread_id;
322
180
 
323
181
  bool low_priority_updates;
324
182
  bool new_mode;
325
 
  /* 
 
183
  /*
326
184
    compatibility option:
327
 
      - index usage hints (USE INDEX without a FOR clause) behave as in 5.0 
 
185
      - index usage hints (USE INDEX without a FOR clause) behave as in 5.0
328
186
  */
329
187
  bool old_mode;
330
188
  bool engine_condition_pushdown;
336
194
 
337
195
  /* Only charset part of these variables is sensible */
338
196
  const CHARSET_INFO  *character_set_filesystem;
339
 
  const CHARSET_INFO  *character_set_client;
340
 
  const CHARSET_INFO  *character_set_results;
341
197
 
342
198
  /* Both charset and collation parts of these variables are important */
343
199
  const CHARSET_INFO    *collation_server;
344
200
  const CHARSET_INFO    *collation_database;
345
 
  const CHARSET_INFO  *collation_connection;
 
201
 
 
202
  inline const CHARSET_INFO  *getCollation(void) 
 
203
  {
 
204
    return collation_database ? collation_database : collation_server;
 
205
  }
346
206
 
347
207
  /* Locale Support */
348
208
  MY_LOCALE *lc_time_names;
357
217
 
358
218
};
359
219
 
 
220
extern struct system_variables global_system_variables;
 
221
 
360
222
#include "sql_lex.h"  /* only for SQLCOM_END */
361
223
 
362
224
/* per thread status variables */
382
244
  ulong ha_update_count;
383
245
  ulong ha_write_count;
384
246
  ulong ha_prepare_count;
385
 
  ulong ha_discover_count;
386
247
  ulong ha_savepoint_count;
387
248
  ulong ha_savepoint_rollback_count;
388
249
 
408
269
  ulong filesort_range_count;
409
270
  ulong filesort_rows;
410
271
  ulong filesort_scan_count;
411
 
  /* Prepared statements and binary protocol */
412
 
  ulong com_stmt_prepare;
413
 
  ulong com_stmt_execute;
414
 
  ulong com_stmt_send_long_data;
415
 
  ulong com_stmt_fetch;
416
 
  ulong com_stmt_reset;
417
 
  ulong com_stmt_close;
418
272
  /*
419
273
    Number of statements sent from the client
420
274
  */
440
294
 
441
295
#define last_system_status_var questions
442
296
 
443
 
void mark_transaction_to_rollback(THD *thd, bool all);
444
 
 
445
 
#ifdef DRIZZLE_SERVER
446
 
 
447
 
class Query_arena
448
 
{
449
 
public:
450
 
  /*
451
 
    List of items created in the parser for this query. Every item puts
452
 
    itself to the list on creation (see Item::Item() for details))
453
 
  */
454
 
  Item *free_list;
455
 
  MEM_ROOT *mem_root;                   // Pointer to current memroot
456
 
 
457
 
  Query_arena(MEM_ROOT *mem_root_arg) :
458
 
    free_list(0), mem_root(mem_root_arg)
459
 
  { }
460
 
  /*
461
 
    This constructor is used only when Query_arena is created as
462
 
    backup storage for another instance of Query_arena.
463
 
  */
464
 
  Query_arena() { }
465
 
 
466
 
  virtual ~Query_arena() {};
467
 
 
468
 
  inline void* alloc(size_t size) { return alloc_root(mem_root,size); }
469
 
  inline void* calloc(size_t size)
470
 
  {
471
 
    void *ptr;
472
 
    if ((ptr=alloc_root(mem_root,size)))
473
 
      memset(ptr, 0, size);
474
 
    return ptr;
475
 
  }
476
 
  inline char *strdup(const char *str)
477
 
  { return strdup_root(mem_root,str); }
478
 
  inline char *strmake(const char *str, size_t size)
479
 
  { return strmake_root(mem_root,str,size); }
480
 
  inline void *memdup(const void *str, size_t size)
481
 
  { return memdup_root(mem_root,str,size); }
482
 
  inline void *memdup_w_gap(const void *str, size_t size, uint32_t gap)
483
 
  {
484
 
    void *ptr;
485
 
    if ((ptr= alloc_root(mem_root,size+gap)))
486
 
      memcpy(ptr,str,size);
487
 
    return ptr;
488
 
  }
489
 
 
490
 
  void free_items();
491
 
};
492
 
 
 
297
void mark_transaction_to_rollback(Session *session, bool all);
493
298
 
494
299
/**
495
300
  @class Statement
498
303
  One connection can contain a lot of simultaneously running statements,
499
304
  some of which could be:
500
305
   - prepared, that is, contain placeholders,
501
 
  To perform some action with statement we reset THD part to the state  of
502
 
  that statement, do the action, and then save back modified state from THD
 
306
  To perform some action with statement we reset Session part to the state  of
 
307
  that statement, do the action, and then save back modified state from Session
503
308
  to the statement. It will be changed in near future, and Statement will
504
309
  be used explicitly.
505
310
*/
520
325
                        handler of fields used is set
521
326
    MARK_COLUMNS_READ:  Means a bit in read set is set to inform handler
522
327
                        that the field is to be read. If field list contains
523
 
                        duplicates, then thd->dup_field is set to point
 
328
                        duplicates, then session->dup_field is set to point
524
329
                        to the last found duplicate.
525
330
    MARK_COLUMNS_WRITE: Means a bit is set in write set to inform handler
526
331
                        that it needs to update this field in write_row
539
344
    LOCK_thread_count mutex. And (B) we are ONLY allowed to set query to a
540
345
    non-NULL value if its previous value is NULL. We do not need to protect
541
346
    operation (B) with any mutex. To avoid crashes in races, if we do not
542
 
    know that thd->query cannot change at the moment, one should print
543
 
    thd->query like this:
 
347
    know that session->query cannot change at the moment, one should print
 
348
    session->query like this:
544
349
      (1) reserve the LOCK_thread_count mutex;
545
 
      (2) check if thd->query is NULL;
546
 
      (3) if not NULL, then print at most thd->query_length characters from
 
350
      (2) check if session->query is NULL;
 
351
      (3) if not NULL, then print at most session->query_length characters from
547
352
      it. We will see the query_length field as either 0, or the right value
548
353
      for it.
549
354
    Assuming that the write and read of an n-bit memory field in an n-bit
550
 
    computer is atomic, we can avoid races in the above way. 
 
355
    computer is atomic, we can avoid races in the above way.
551
356
    This printing is needed at least in SHOW PROCESSLIST and SHOW INNODB
552
357
    STATUS.
553
358
  */
563
368
    valid database name.
564
369
 
565
370
    @note this attribute is set and alloced by the slave SQL thread (for
566
 
    the THD of that thread); that thread is (and must remain, for now) the
 
371
    the Session of that thread); that thread is (and must remain, for now) the
567
372
    only responsible for freeing this member.
568
373
  */
569
374
 
593
398
  /* For now, this is only used to catch duplicated external xids */
594
399
  XID  xid;                           // transaction identifier
595
400
  enum xa_states xa_state;            // used by external XA only
596
 
  bool in_thd;
 
401
  bool in_session;
597
402
} XID_STATE;
598
403
 
599
404
extern pthread_mutex_t LOCK_xid_cache;
607
412
 
608
413
/**
609
414
  @class Security_context
610
 
  @brief A set of THD members describing the current authenticated user.
 
415
  @brief A set of Session members describing the current authenticated user.
611
416
*/
612
417
 
613
418
class Security_context {
614
419
public:
615
 
  Security_context() {}                       /* Remove gcc warning */
 
420
  Security_context() {}
616
421
  /*
617
422
    host - host of the client
618
423
    user - user of the client, set to NULL until the user has been read from
620
425
    priv_user - The user privilege we are using. May be "" for anonymous user.
621
426
    ip - client IP
622
427
  */
623
 
  char *user; 
624
 
  char *ip;
 
428
  std::string user;
 
429
  std::string ip;
625
430
 
626
 
  void init();
627
 
  void destroy();
628
431
  void skip_grants();
629
 
  inline char *priv_host_name()
 
432
  inline const char *priv_host_name()
630
433
  {
631
 
    return (ip ? ip : (char *)"%");
 
434
    return (ip.c_str() ? ip.c_str() : (char *)"%");
632
435
  }
633
436
};
634
437
 
690
493
    Tables that were locked with explicit or implicit LOCK TABLES.
691
494
    (Implicit LOCK TABLES happens when we are prelocking tables for
692
495
     execution of statement which uses stored routines. See description
693
 
     THD::prelocked_mode for more info.)
 
496
     Session::prelocked_mode for more info.)
694
497
  */
695
498
  DRIZZLE_LOCK *locked_tables;
696
499
 
735
538
};
736
539
 
737
540
 
738
 
/* Flags for the THD::system_thread variable */
 
541
/* Flags for the Session::system_thread variable */
739
542
enum enum_thread_type
740
543
{
741
544
  NON_SYSTEM_THREAD,
769
572
    from the anticipated conditions trapped during runtime.
770
573
 
771
574
    This mechanism is similar to C++ try/throw/catch:
772
 
    - 'try' correspond to <code>THD::push_internal_handler()</code>,
 
575
    - 'try' correspond to <code>Session::push_internal_handler()</code>,
773
576
    - 'throw' correspond to <code>my_error()</code>,
774
577
    which invokes <code>my_message_sql()</code>,
775
578
    - 'catch' correspond to checking how/if an internal handler was invoked,
776
579
    before removing it from the exception stack with
777
 
    <code>THD::pop_internal_handler()</code>.
 
580
    <code>Session::pop_internal_handler()</code>.
778
581
 
779
582
    @param sql_errno the error number
780
583
    @param level the error level
781
 
    @param thd the calling thread
 
584
    @param session the calling thread
782
585
    @return true if the error is handled
783
586
  */
784
587
  virtual bool handle_error(uint32_t sql_errno,
785
588
                            const char *message,
786
589
                            DRIZZLE_ERROR::enum_warning_level level,
787
 
                            THD *thd) = 0;
 
590
                            Session *session) = 0;
788
591
};
789
592
 
790
593
 
816
619
  /** Set to make set_error_status after set_{ok,eof}_status possible. */
817
620
  bool can_overwrite_status;
818
621
 
819
 
  void set_ok_status(THD *thd, ha_rows affected_rows_arg,
 
622
  void set_ok_status(Session *session, ha_rows affected_rows_arg,
820
623
                     uint64_t last_insert_id_arg,
821
624
                     const char *message);
822
 
  void set_eof_status(THD *thd);
823
 
  void set_error_status(THD *thd, uint32_t sql_errno_arg, const char *message_arg);
 
625
  void set_eof_status(Session *session);
 
626
  void set_error_status(Session *session, uint32_t sql_errno_arg, const char *message_arg);
824
627
 
825
628
  void disable_status();
826
629
 
869
672
  uint32_t m_sql_errno;
870
673
 
871
674
  /**
872
 
    Copied from thd->server_status when the diagnostics area is assigned.
 
675
    Copied from session->server_status when the diagnostics area is assigned.
873
676
    We need this member as some places in the code use the following pattern:
874
 
    thd->server_status|= ...
875
 
    my_eof(thd);
876
 
    thd->server_status&= ~...
 
677
    session->server_status|= ...
 
678
    my_eof(session);
 
679
    session->server_status&= ~...
877
680
    Assigned by OK, EOF or ERROR.
878
681
  */
879
682
  uint32_t m_server_status;
880
683
  /**
881
684
    The number of rows affected by the last statement. This is
882
 
    semantically close to thd->row_count_func, but has a different
883
 
    life cycle. thd->row_count_func stores the value returned by
 
685
    semantically close to session->row_count_func, but has a different
 
686
    life cycle. session->row_count_func stores the value returned by
884
687
    function ROW_COUNT() and is cleared only by statements that
885
688
    update its value, such as INSERT, UPDATE, DELETE and few others.
886
689
    This member is cleared at the beginning of the next statement.
887
690
 
888
 
    We could possibly merge the two, but life cycle of thd->row_count_func
 
691
    We could possibly merge the two, but life cycle of session->row_count_func
889
692
    can not be changed.
890
693
  */
891
694
  ha_rows    m_affected_rows;
892
695
  /**
893
696
    Similarly to the previous member, this is a replacement of
894
 
    thd->first_successful_insert_id_in_prev_stmt, which is used
 
697
    session->first_successful_insert_id_in_prev_stmt, which is used
895
698
    to implement LAST_INSERT_ID().
896
699
  */
897
700
  uint64_t   m_last_insert_id;
899
702
  uint       m_total_warn_count;
900
703
  enum_diagnostics_status m_status;
901
704
  /**
902
 
    @todo: the following THD members belong here:
 
705
    @todo: the following Session members belong here:
903
706
    - warn_list, warn_count,
904
707
  */
905
708
};
933
736
 
934
737
 
935
738
/**
936
 
  @class THD
937
 
  For each client connection we create a separate thread with THD serving as
 
739
  @class Session
 
740
  For each client connection we create a separate thread with Session serving as
938
741
  a thread/connection descriptor
939
742
*/
940
743
 
941
 
class THD :public Statement,
 
744
class Session :public Statement,
942
745
           public Open_tables_state
943
746
{
944
747
public:
945
 
  /* Used to execute base64 coded binlog events in MySQL server */
946
 
  Relay_log_info* rli_fake;
947
 
 
948
748
  /*
949
 
    Constant for THD::where initialization in the beginning of every query.
 
749
    Constant for Session::where initialization in the beginning of every query.
950
750
 
951
 
    It's needed because we do not save/restore THD::where normally during
 
751
    It's needed because we do not save/restore Session::where normally during
952
752
    primary (non subselect) query execution.
953
753
  */
954
754
  static const char * const DEFAULT_WHERE;
968
768
  THR_LOCK_OWNER main_lock_id;          // To use for conventional queries
969
769
  THR_LOCK_OWNER *lock_id;              // If not main_lock_id, points to
970
770
                                        // the lock_id of a cursor.
971
 
  pthread_mutex_t LOCK_delete;          // Locked before thd is deleted
 
771
  pthread_mutex_t LOCK_delete;          // Locked before session is deleted
972
772
  /*
973
773
    A pointer to the stack frame of handle_one_connection(),
974
774
    which is called first in the thread for handling a client
982
782
 
983
783
  /**
984
784
    @note
985
 
    Some members of THD (currently 'Statement::db',
 
785
    Some members of Session (currently 'Statement::db',
986
786
    'catalog' and 'query')  are set and alloced by the slave SQL thread
987
 
    (for the THD of that thread); that thread is (and must remain, for now)
 
787
    (for the Session of that thread); that thread is (and must remain, for now)
988
788
    the only responsible for freeing these 3 members. If you add members
989
789
    here, and you add code to set them in replication, don't forget to
990
790
    free_them_and_set_them_to_0 in replication properly. For details see
993
793
    @see handle_slave_sql
994
794
  */
995
795
 
996
 
  Security_context main_security_ctx;
997
 
  Security_context *security_ctx;
 
796
  Security_context security_ctx;
998
797
 
999
798
  /*
1000
799
    Points to info-string that we show in SHOW PROCESSLIST
1001
 
    You are supposed to call THD_SET_PROC_INFO only if you have coded
 
800
    You are supposed to call Session_SET_PROC_INFO only if you have coded
1002
801
    a time-consuming piece that MySQL can get stuck in for a long time.
1003
802
 
1004
 
    Set it using the  thd_proc_info(THD *thread, const char *message)
 
803
    Set it using the  session_proc_info(Session *thread, const char *message)
1005
804
    macro/function.
1006
805
  */
1007
806
  void        set_proc_info(const char *info) { proc_info= info; }
1022
821
  /*
1023
822
    One thread can hold up to one named user-level lock. This variable
1024
823
    points to a lock object if the lock is present. See item_func.cc and
1025
 
    chapter 'Miscellaneous functions', for functions GET_LOCK, RELEASE_LOCK. 
 
824
    chapter 'Miscellaneous functions', for functions GET_LOCK, RELEASE_LOCK.
1026
825
  */
1027
826
  uint32_t dbug_sentry; // watch out for memory corruption
1028
827
  struct st_my_thread_var *mysys_var;
1038
837
  time_t     start_time, user_time;
1039
838
  uint64_t  connect_utime, thr_create_utime; // track down slow pthread_create
1040
839
  uint64_t  start_utime, utime_after_lock;
1041
 
  
 
840
 
1042
841
  thr_lock_type update_lock_default;
1043
842
 
1044
 
  /* <> 0 if we are inside of trigger or stored function. */
1045
 
  uint32_t in_sub_stmt;
 
843
  /*
 
844
    Both of the following container points in session will be converted to an API.
 
845
  */
1046
846
 
1047
847
  /* container for handler's private per-connection data */
1048
848
  Ha_data ha_data[MAX_HA];
1049
849
 
 
850
  /* container for replication data */
 
851
  void *replication_data;
 
852
  inline void setReplicationData (void *data) { replication_data= data; }
 
853
  inline void *getReplicationData () { return replication_data; }
 
854
 
1050
855
  /* Place to store various things */
1051
 
  void *thd_marker;
1052
 
  int binlog_setup_trx_data();
1053
 
 
1054
 
  /*
1055
 
    Public interface to write RBR events to the binlog
1056
 
  */
1057
 
  void binlog_start_trans_and_stmt();
1058
 
  void binlog_set_stmt_begin();
1059
 
  int binlog_write_table_map(Table *table, bool is_transactional);
1060
 
  int binlog_write_row(Table* table, bool is_transactional,
1061
 
                       const unsigned char *new_data);
1062
 
  int binlog_delete_row(Table* table, bool is_transactional,
1063
 
                        const unsigned char *old_data);
1064
 
  int binlog_update_row(Table* table, bool is_transactional,
1065
 
                        const unsigned char *old_data, const unsigned char *new_data);
 
856
  void *session_marker;
1066
857
 
1067
858
  void set_server_id(uint32_t sid) { server_id = sid; }
1068
859
 
1069
 
  /*
1070
 
    Member functions to handle pending event for row-level logging.
1071
 
  */
1072
 
  template <class RowsEventT> Rows_log_event*
1073
 
    binlog_prepare_pending_rows_event(Table* table, uint32_t serv_id,
1074
 
                                      size_t needed,
1075
 
                                      bool is_transactional,
1076
 
                                      RowsEventT* hint);
1077
 
  Rows_log_event* binlog_get_pending_rows_event() const;
1078
 
  void            binlog_set_pending_rows_event(Rows_log_event* ev);
1079
 
  int binlog_flush_pending_rows_event(bool stmt_end);
1080
 
 
1081
 
private:
1082
 
  uint32_t binlog_table_maps; // Number of table maps currently in the binlog
1083
 
 
1084
 
  enum enum_binlog_flag {
1085
 
    BINLOG_FLAG_UNSAFE_STMT_PRINTED,
1086
 
    BINLOG_FLAG_COUNT
1087
 
  };
1088
 
 
1089
 
  /**
1090
 
     Flags with per-thread information regarding the status of the
1091
 
     binary log.
1092
 
   */
1093
 
  uint32_t binlog_flags;
1094
 
public:
1095
 
  uint32_t get_binlog_table_maps() const {
1096
 
    return binlog_table_maps;
1097
 
  }
1098
 
  void clear_binlog_table_maps() {
1099
 
    binlog_table_maps= 0;
1100
 
  }
1101
 
 
1102
860
public:
1103
861
 
1104
862
  struct st_transactions {
1105
863
    SAVEPOINT *savepoints;
1106
 
    THD_TRANS all;                      // Trans since BEGIN WORK
1107
 
    THD_TRANS stmt;                     // Trans for current statement
 
864
    Session_TRANS all;                  // Trans since BEGIN WORK
 
865
    Session_TRANS stmt;                 // Trans for current statement
1108
866
    bool on;                            // see ha_enable_transaction()
1109
867
    XID_STATE xid_state;
1110
 
    Rows_log_event *m_pending_rows_event;
1111
868
 
1112
869
    /*
1113
870
       Tables changed in transaction (that must be invalidated in query cache).
1134
891
  /*
1135
892
    This is to track items changed during execution of a prepared
1136
893
    statement/stored procedure. It's created by
1137
 
    register_item_tree_change() in memory root of THD, and freed in
 
894
    register_item_tree_change() in memory root of Session, and freed in
1138
895
    rollback_item_tree_changes(). For conventional execution it's always
1139
896
    empty.
1140
897
  */
1156
913
  */
1157
914
  uint64_t  first_successful_insert_id_in_prev_stmt;
1158
915
  /*
1159
 
    Variant of the above, used for storing in statement-based binlog. The
1160
 
    difference is that the one above can change as the execution of a stored
1161
 
    function progresses, while the one below is set once and then does not
1162
 
    change (which is the value which statement-based binlog needs).
1163
 
  */
1164
 
  uint64_t  first_successful_insert_id_in_prev_stmt_for_binlog;
1165
 
  /*
1166
916
    This is the first autogenerated insert id which was *successfully*
1167
917
    inserted by the current statement. It is maintained only to set
1168
918
    first_successful_insert_id_in_prev_stmt when statement ends.
1186
936
    first_successful_insert_id_in_cur_stmt.
1187
937
  */
1188
938
  /*
1189
 
    stmt_depends_on_first_successful_insert_id_in_prev_stmt is set when
1190
 
    LAST_INSERT_ID() is used by a statement.
1191
 
    If it is set, first_successful_insert_id_in_prev_stmt_for_binlog will be
1192
 
    stored in the statement-based binlog.
1193
 
    This variable is CUMULATIVE along the execution of a stored function or
1194
 
    trigger: if one substatement sets it to 1 it will stay 1 until the
1195
 
    function/trigger ends, thus making sure that
1196
 
    first_successful_insert_id_in_prev_stmt_for_binlog does not change anymore
1197
 
    and is propagated to the caller for binlogging.
1198
 
  */
1199
 
  bool       stmt_depends_on_first_successful_insert_id_in_prev_stmt;
1200
 
  /*
1201
939
    List of auto_increment intervals reserved by the thread so far, for
1202
940
    storage in the statement-based binlog.
1203
941
    Note that its minimum is not first_successful_insert_id_in_cur_stmt:
1254
992
  }
1255
993
  inline uint64_t read_first_successful_insert_id_in_prev_stmt(void)
1256
994
  {
1257
 
    if (!stmt_depends_on_first_successful_insert_id_in_prev_stmt)
1258
 
    {
1259
 
      /* It's the first time we read it */
1260
 
      first_successful_insert_id_in_prev_stmt_for_binlog=
1261
 
        first_successful_insert_id_in_prev_stmt;
1262
 
      stmt_depends_on_first_successful_insert_id_in_prev_stmt= 1;
1263
 
    }
1264
995
    return first_successful_insert_id_in_prev_stmt;
1265
996
  }
1266
997
  /*
1293
1024
  /*
1294
1025
    The set of those tables whose fields are referenced in all subqueries
1295
1026
    of the query.
1296
 
    TODO: possibly this it is incorrect to have used tables in THD because
 
1027
    TODO: possibly this it is incorrect to have used tables in Session because
1297
1028
    with more than one subquery, it is not clear what does the field mean.
1298
1029
  */
1299
1030
  table_map  used_tables;
1342
1073
  enum_tx_isolation session_tx_isolation;
1343
1074
  enum_check_fields count_cuted_fields;
1344
1075
 
1345
 
  DYNAMIC_ARRAY user_var_events;        /* For user variables replication */
1346
 
  MEM_ROOT      *user_var_events_alloc; /* Allocate above array elements here */
1347
 
 
1348
1076
  enum killed_state
1349
1077
  {
1350
 
    NOT_KILLED=0,
1351
 
    KILL_BAD_DATA=1,
1352
 
    KILL_CONNECTION=ER_SERVER_SHUTDOWN,
1353
 
    KILL_QUERY=ER_QUERY_INTERRUPTED,
 
1078
    NOT_KILLED,
 
1079
    KILL_BAD_DATA,
 
1080
    KILL_CONNECTION,
 
1081
    KILL_QUERY,
1354
1082
    KILLED_NO_VALUE      /* means neither of the states */
1355
1083
  };
1356
1084
  killed_state volatile killed;
1358
1086
  /* scramble - random string sent to client on handshake */
1359
1087
  char       scramble[SCRAMBLE_LENGTH+1];
1360
1088
 
1361
 
  bool       slave_thread, one_shot_set;
1362
 
  /* tells if current statement should binlog row-based(1) or stmt-based(0) */
1363
 
  bool       current_stmt_binlog_row_based;
1364
1089
  bool       some_tables_deleted;
1365
1090
  bool       last_cuted_field;
1366
1091
  bool       no_errors, password;
1369
1094
    can not continue. In particular, disables activation of
1370
1095
    CONTINUE or EXIT handlers of stored routines.
1371
1096
    Reset in the end of processing of the current user request, in
1372
 
    @see mysql_reset_thd_for_next_command().
 
1097
    @see mysql_reset_session_for_next_command().
1373
1098
  */
1374
1099
  bool is_fatal_error;
1375
1100
  /**
1390
1115
    Reset to false when we leave the sub-statement mode.
1391
1116
  */
1392
1117
  bool       is_fatal_sub_stmt_error;
1393
 
  bool       query_start_used, rand_used, time_zone_used;
1394
1118
  /* for IS NULL => = last_insert_id() fix in remove_eq_conds() */
1395
1119
  bool       substitute_null_with_insert_id;
1396
1120
  bool       in_lock_tables;
1397
 
  /**
1398
 
    True if a slave error. Causes the slave to stop. Not the same
1399
 
    as the statement execution error (is_error()), since
1400
 
    a statement may be expected to return an error, e.g. because
1401
 
    it returned an error on master, and this is OK on the slave.
1402
 
  */
1403
 
  bool       is_slave_error;
1404
 
  bool       bootstrap, cleanup_done;
1405
 
  
 
1121
  bool       cleanup_done;
 
1122
 
1406
1123
  /**  is set if some thread specific value(s) used in a statement. */
1407
1124
  bool       thread_specific_used;
1408
1125
  bool       charset_is_system_charset, charset_is_collation_connection;
1409
1126
  bool       charset_is_character_set_filesystem;
1410
 
  bool       enable_slow_log;   /* enable slow log for current statement */
1411
1127
  bool       abort_on_warning;
1412
1128
  bool       got_warning;       /* Set on call to push_warning() */
1413
1129
  bool       no_warnings_for_error; /* no warnings on call to my_error() */
1415
1131
  bool       derived_tables_processing;
1416
1132
  bool    tablespace_op;        /* This is true in DISCARD/IMPORT TABLESPACE */
1417
1133
 
1418
 
  /*
1419
 
    If we do a purge of binary logs, log index info of the threads
1420
 
    that are currently reading it needs to be adjusted. To do that
1421
 
    each thread that is using LOG_INFO needs to adjust the pointer to it
1422
 
  */
1423
 
  LOG_INFO*  current_linfo;
1424
 
  NET*       slave_net;                 // network connection from slave -> m.
1425
1134
  /* Used by the sys_var class to store temporary values */
1426
1135
  union
1427
1136
  {
1430
1139
    ulong     ulong_value;
1431
1140
    uint64_t uint64_t_value;
1432
1141
  } sys_var_tmp;
1433
 
  
1434
 
  struct {
1435
 
    /* 
1436
 
      If true, mysql_bin_log::write(Log_event) call will not write events to 
1437
 
      binlog, and maintain 2 below variables instead (use
1438
 
      mysql_bin_log.start_union_events to turn this on)
1439
 
    */
1440
 
    bool do_union;
1441
 
    /*
1442
 
      If true, at least one mysql_bin_log::write(Log_event) call has been
1443
 
      made after last mysql_bin_log.start_union_events() call.
1444
 
    */
1445
 
    bool unioned_events;
1446
 
    /*
1447
 
      If true, at least one mysql_bin_log::write(Log_event e), where 
1448
 
      e.cache_stmt == true call has been made after last 
1449
 
      mysql_bin_log.start_union_events() call.
1450
 
    */
1451
 
    bool unioned_events_trans;
1452
 
    
1453
 
    /* 
1454
 
      'queries' (actually SP statements) that run under inside this binlog
1455
 
      union have thd->query_id >= first_query_id.
1456
 
    */
1457
 
    query_id_t first_query_id;
1458
 
  } binlog_evt_union;
1459
1142
 
1460
1143
  /**
1461
1144
    Character input stream consumed by the lexical analyser,
1466
1149
  */
1467
1150
  Lex_input_stream *m_lip;
1468
1151
 
1469
 
  THD();
1470
 
  ~THD();
 
1152
  Session();
 
1153
  ~Session();
1471
1154
 
1472
1155
  void init(void);
1473
1156
  /*
1474
1157
    Initialize memory roots necessary for query processing and (!)
1475
 
    pre-allocate memory for it. We can't do that in THD constructor because
 
1158
    pre-allocate memory for it. We can't do that in Session constructor because
1476
1159
    there are use cases (acl_init, watcher threads,
1477
1160
    killing mysqld) where it's vital to not allocate excessive and not used
1478
1161
    memory. Note, that we still don't return error from init_for_queries():
1479
1162
    if preallocation fails, we should notice that at the first call to
1480
 
    alloc_root. 
 
1163
    alloc_root.
1481
1164
  */
1482
1165
  void init_for_queries();
1483
 
  void change_user(void);
1484
1166
  void cleanup(void);
1485
1167
  void cleanup_after_query();
1486
1168
  bool store_globals();
1487
 
  void awake(THD::killed_state state_to_set);
1488
 
 
1489
 
  enum enum_binlog_query_type {
1490
 
    /*
1491
 
      The query can be logged row-based or statement-based
1492
 
    */
1493
 
    ROW_QUERY_TYPE,
1494
 
    
1495
 
    /*
1496
 
      The query has to be logged statement-based
1497
 
    */
1498
 
    STMT_QUERY_TYPE,
1499
 
    
1500
 
    /*
1501
 
      The query represents a change to a table in the "mysql"
1502
 
      database and is currently mapped to ROW_QUERY_TYPE.
1503
 
    */
1504
 
    DRIZZLE_QUERY_TYPE,
1505
 
    QUERY_TYPE_COUNT
1506
 
  };
1507
 
  
1508
 
  int binlog_query(enum_binlog_query_type qtype,
1509
 
                   char const *query, ulong query_len,
1510
 
                   bool is_trans, bool suppress_use,
1511
 
                   THD::killed_state killed_err_arg= THD::KILLED_NO_VALUE);
 
1169
  void awake(Session::killed_state state_to_set);
1512
1170
 
1513
1171
  /*
1514
1172
    For enter_cond() / exit_cond() to work the mutex must be got before
1515
1173
    enter_cond(); this mutex is then released by exit_cond().
1516
1174
    Usage must be: lock mutex; enter_cond(); your code; exit_cond().
1517
1175
  */
1518
 
  inline const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex,
1519
 
                          const char* msg)
 
1176
  inline const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex, const char* msg)
1520
1177
  {
1521
1178
    const char* old_msg = get_proc_info();
1522
1179
    safe_mutex_assert_owner(mutex);
1523
1180
    mysys_var->current_mutex = mutex;
1524
1181
    mysys_var->current_cond = cond;
1525
 
    thd_proc_info(this, msg);
 
1182
    this->set_proc_info(msg);
1526
1183
    return old_msg;
1527
1184
  }
1528
1185
  inline void exit_cond(const char* old_msg)
1531
1188
      Putting the mutex unlock in exit_cond() ensures that
1532
1189
      mysys_var->current_mutex is always unlocked _before_ mysys_var->mutex is
1533
1190
      locked (if that would not be the case, you'll get a deadlock if someone
1534
 
      does a THD::awake() on you).
 
1191
      does a Session::awake() on you).
1535
1192
    */
1536
1193
    pthread_mutex_unlock(mysys_var->current_mutex);
1537
1194
    pthread_mutex_lock(&mysys_var->mutex);
1538
1195
    mysys_var->current_mutex = 0;
1539
1196
    mysys_var->current_cond = 0;
1540
 
    thd_proc_info(this, old_msg);
 
1197
    this->set_proc_info(old_msg);
1541
1198
    pthread_mutex_unlock(&mysys_var->mutex);
1542
1199
  }
1543
 
  inline time_t query_start() { query_start_used=1; return start_time; }
 
1200
  inline time_t query_start() { return start_time; }
1544
1201
  inline void set_time()
1545
1202
  {
1546
1203
    if (user_time)
1551
1208
    else
1552
1209
      start_utime= utime_after_lock= my_micro_time_and_time(&start_time);
1553
1210
  }
1554
 
  inline void   set_current_time()    { start_time= my_time(MY_WME); }
 
1211
  inline void   set_current_time()    { start_time= time(NULL); }
1555
1212
  inline void   set_time(time_t t)
1556
1213
  {
1557
1214
    start_time= user_time= t;
1601
1258
  {
1602
1259
    if (main_da.is_error())
1603
1260
      main_da.reset_diagnostics_area();
1604
 
    is_slave_error= 0;
1605
1261
    return;
1606
1262
  }
1607
1263
  inline bool vio_ok() const { return net.vio != 0; }
1630
1286
    To raise this flag, use my_error().
1631
1287
  */
1632
1288
  inline bool is_error() const { return main_da.is_error(); }
1633
 
  inline const CHARSET_INFO *charset() { return variables.character_set_client; }
 
1289
  inline const CHARSET_INFO *charset() { return default_charset_info; }
1634
1290
  void update_charset();
1635
1291
 
1636
1292
  void change_item_tree(Item **place, Item *new_value)
1661
1317
  void reset_n_backup_open_tables_state(Open_tables_state *backup);
1662
1318
  void restore_backup_open_tables_state(Open_tables_state *backup);
1663
1319
 
1664
 
  inline void set_current_stmt_binlog_row_based_if_mixed()
1665
 
  {
1666
 
    /*
1667
 
      If in a stored/function trigger, the caller should already have done the
1668
 
      change. We test in_sub_stmt to prevent introducing bugs where people
1669
 
      wouldn't ensure that, and would switch to row-based mode in the middle
1670
 
      of executing a stored function/trigger (which is too late, see also
1671
 
      reset_current_stmt_binlog_row_based()); this condition will make their
1672
 
      tests fail and so force them to propagate the
1673
 
      lex->binlog_row_based_if_mixed upwards to the caller.
1674
 
    */
1675
 
    if ((variables.binlog_format == BINLOG_FORMAT_MIXED) &&
1676
 
        (in_sub_stmt == 0))
1677
 
      current_stmt_binlog_row_based= true;
1678
 
  }
1679
 
  inline void set_current_stmt_binlog_row_based()
1680
 
  {
1681
 
    current_stmt_binlog_row_based= true;
1682
 
  }
1683
 
  inline void clear_current_stmt_binlog_row_based()
1684
 
  {
1685
 
    current_stmt_binlog_row_based= false;
1686
 
  }
1687
 
  inline void reset_current_stmt_binlog_row_based()
1688
 
  {
1689
 
    /*
1690
 
      If there are temporary tables, don't reset back to
1691
 
      statement-based. Indeed it could be that:
1692
 
      CREATE TEMPORARY TABLE t SELECT UUID(); # row-based
1693
 
      # and row-based does not store updates to temp tables
1694
 
      # in the binlog.
1695
 
      INSERT INTO u SELECT * FROM t; # stmt-based
1696
 
      and then the INSERT will fail as data inserted into t was not logged.
1697
 
      So we continue with row-based until the temp table is dropped.
1698
 
      If we are in a stored function or trigger, we mustn't reset in the
1699
 
      middle of its execution (as the binary logging way of a stored function
1700
 
      or trigger is decided when it starts executing, depending for example on
1701
 
      the caller (for a stored function: if caller is SELECT or
1702
 
      INSERT/UPDATE/DELETE...).
1703
 
 
1704
 
      Don't reset binlog format for NDB binlog injector thread.
1705
 
    */
1706
 
    if ((temporary_tables == NULL) && (in_sub_stmt == 0))
1707
 
    {
1708
 
      current_stmt_binlog_row_based= 
1709
 
        test(variables.binlog_format == BINLOG_FORMAT_ROW);
1710
 
    }
1711
 
  }
1712
 
 
1713
1320
  /**
1714
1321
    Set the current database; use deep copy of C-string.
1715
1322
 
1731
1338
      @retval false Success
1732
1339
      @retval true  Out-of-memory error
1733
1340
  */
1734
 
  bool set_db(const char *new_db, size_t new_db_len)
1735
 
  {
1736
 
    /* Do not reallocate memory if current chunk is big enough. */
1737
 
    if (db && new_db && db_length >= new_db_len)
1738
 
      memcpy(db, new_db, new_db_len+1);
1739
 
    else
1740
 
    {
1741
 
      if (db)
1742
 
        free(db);
1743
 
      if (new_db)
1744
 
        db= my_strndup(new_db, new_db_len, MYF(MY_WME | ME_FATALERROR));
1745
 
      else
1746
 
        db= NULL;
1747
 
    }
1748
 
    db_length= db ? new_db_len : 0;
1749
 
    return new_db && !db;
1750
 
  }
 
1341
  bool set_db(const char *new_db, size_t new_db_len);
1751
1342
 
1752
1343
  /**
1753
1344
    Set the current database; use shallow copy of C-string.
1771
1362
    a statement is parsed but before it's executed.
1772
1363
  */
1773
1364
  bool copy_db_to(char **p_db, size_t *p_db_length);
1774
 
  thd_scheduler scheduler;
 
1365
  /* session_scheduler for events */
 
1366
  void *scheduler;
1775
1367
 
1776
1368
public:
1777
1369
  /**
1794
1386
  */
1795
1387
  void pop_internal_handler();
1796
1388
 
 
1389
  /**
 
1390
    Reset object after executing commands.
 
1391
  */
 
1392
  void reset_for_next_command();
 
1393
 
 
1394
  /**
 
1395
    Close the current connection.
 
1396
  */
 
1397
  void close_connection(uint32_t errcode, bool lock);
 
1398
  void close_temporary_tables();
 
1399
 
1797
1400
private:
1798
1401
  const char *proc_info;
1799
1402
 
1815
1418
    tree itself is reused between executions and thus is stored elsewhere.
1816
1419
  */
1817
1420
  MEM_ROOT main_mem_root;
1818
 
};
1819
 
 
1820
 
 
1821
 
/** A short cut for thd->main_da.set_ok_status(). */
1822
 
 
1823
 
inline void
1824
 
my_ok(THD *thd, ha_rows affected_rows= 0, uint64_t id= 0,
1825
 
        const char *message= NULL)
1826
 
{
1827
 
  thd->main_da.set_ok_status(thd, affected_rows, id, message);
1828
 
}
1829
 
 
1830
 
 
1831
 
/** A short cut for thd->main_da.set_eof_status(). */
1832
 
 
1833
 
inline void
1834
 
my_eof(THD *thd)
1835
 
{
1836
 
  thd->main_da.set_eof_status(thd);
1837
 
}
1838
 
 
1839
 
#define tmp_disable_binlog(A)       \
1840
 
  {uint64_t tmp_disable_binlog__save_options= (A)->options; \
1841
 
  (A)->options&= ~OPTION_BIN_LOG
1842
 
 
1843
 
#define reenable_binlog(A)   (A)->options= tmp_disable_binlog__save_options;}
1844
 
 
1845
 
 
1846
 
/*
1847
 
  Used to hold information about file and file structure in exchange
1848
 
  via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
1849
 
  XXX: We never call destructor for objects of this class.
1850
 
*/
1851
 
 
1852
 
class sql_exchange :public Sql_alloc
1853
 
{
 
1421
 
1854
1422
public:
1855
 
  enum enum_filetype filetype; /* load XML, Added by Arnold & Erik */ 
1856
 
  char *file_name;
1857
 
  String *field_term,*enclosed,*line_term,*line_start,*escaped;
1858
 
  bool opt_enclosed;
1859
 
  bool dumpfile;
1860
 
  ulong skip_lines;
1861
 
  const CHARSET_INFO *cs;
1862
 
  sql_exchange(char *name, bool dumpfile_flag,
1863
 
               enum_filetype filetype_arg= FILETYPE_CSV);
 
1423
  /** A short cut for session->main_da.set_ok_status(). */
 
1424
  inline void my_ok(ha_rows affected_rows= 0, uint64_t passed_id= 0, const char *message= NULL)
 
1425
  {
 
1426
    main_da.set_ok_status(this, affected_rows, passed_id, message);
 
1427
  }
 
1428
 
 
1429
 
 
1430
  /** A short cut for session->main_da.set_eof_status(). */
 
1431
 
 
1432
  inline void my_eof()
 
1433
  {
 
1434
    main_da.set_eof_status(this);
 
1435
  }
1864
1436
};
1865
1437
 
1866
 
#include "log_event.h"
1867
 
 
1868
1438
/*
1869
1439
  This is used to get result from a select
1870
1440
*/
1871
1441
 
1872
1442
class JOIN;
1873
1443
 
1874
 
class select_result :public Sql_alloc {
1875
 
protected:
1876
 
  THD *thd;
1877
 
  SELECT_LEX_UNIT *unit;
1878
 
public:
1879
 
  select_result();
1880
 
  virtual ~select_result() {};
1881
 
  virtual int prepare(List<Item> &list __attribute__((unused)),
1882
 
                      SELECT_LEX_UNIT *u)
1883
 
  {
1884
 
    unit= u;
1885
 
    return 0;
1886
 
  }
1887
 
  virtual int prepare2(void) { return 0; }
1888
 
  /*
1889
 
    Because of peculiarities of prepared statements protocol
1890
 
    we need to know number of columns in the result set (if
1891
 
    there is a result set) apart from sending columns metadata.
1892
 
  */
1893
 
  virtual uint32_t field_count(List<Item> &fields) const
1894
 
  { return fields.elements; }
1895
 
  virtual bool send_fields(List<Item> &list, uint32_t flags)=0;
1896
 
  virtual bool send_data(List<Item> &items)=0;
1897
 
  virtual bool initialize_tables (JOIN  __attribute__((unused)) *join=0)
1898
 
  { return 0; }
1899
 
  virtual void send_error(uint32_t errcode,const char *err);
1900
 
  virtual bool send_eof()=0;
1901
 
  /**
1902
 
    Check if this query returns a result set and therefore is allowed in
1903
 
    cursors and set an error message if it is not the case.
1904
 
 
1905
 
    @retval false     success
1906
 
    @retval true      error, an error message is set
1907
 
  */
1908
 
  virtual bool check_simple_select() const;
1909
 
  virtual void abort() {}
1910
 
  /*
1911
 
    Cleanup instance of this class for next execution of a prepared
1912
 
    statement/stored procedure.
1913
 
  */
1914
 
  virtual void cleanup();
1915
 
  void set_thd(THD *thd_arg) { thd= thd_arg; }
1916
 
  void begin_dataset() {}
1917
 
};
1918
 
 
1919
 
 
1920
 
/*
1921
 
  Base class for select_result descendands which intercept and
1922
 
  transform result set rows. As the rows are not sent to the client,
1923
 
  sending of result set metadata should be suppressed as well.
1924
 
*/
1925
 
 
1926
 
class select_result_interceptor: public select_result
1927
 
{
1928
 
public:
1929
 
  select_result_interceptor() {}              /* Remove gcc warning */
1930
 
  uint32_t field_count(List<Item> &fields __attribute__((unused))) const
1931
 
  { return 0; }
1932
 
  bool send_fields(List<Item> &fields __attribute__((unused)),
1933
 
                   uint32_t flag __attribute__((unused))) { return false; }
1934
 
};
1935
 
 
1936
 
 
1937
 
class select_send :public select_result {
1938
 
  /**
1939
 
    True if we have sent result set metadata to the client.
1940
 
    In this case the client always expects us to end the result
1941
 
    set with an eof or error packet
1942
 
  */
1943
 
  bool is_result_set_started;
1944
 
public:
1945
 
  select_send() :is_result_set_started(false) {}
1946
 
  bool send_fields(List<Item> &list, uint32_t flags);
1947
 
  bool send_data(List<Item> &items);
1948
 
  bool send_eof();
1949
 
  virtual bool check_simple_select() const { return false; }
1950
 
  void abort();
1951
 
  virtual void cleanup();
1952
 
};
1953
 
 
1954
1444
 
1955
1445
class select_to_file :public select_result_interceptor {
1956
1446
protected:
1957
 
  sql_exchange *exchange;
 
1447
  file_exchange *exchange;
1958
1448
  File file;
1959
1449
  IO_CACHE cache;
1960
1450
  ha_rows row_count;
1961
1451
  char path[FN_REFLEN];
1962
1452
 
1963
1453
public:
1964
 
  select_to_file(sql_exchange *ex) :exchange(ex), file(-1),row_count(0L)
 
1454
  select_to_file(file_exchange *ex) :exchange(ex), file(-1),row_count(0L)
1965
1455
  { path[0]=0; }
1966
1456
  ~select_to_file();
1967
1457
  void send_error(uint32_t errcode,const char *err);
2003
1493
  bool is_unsafe_field_sep;
2004
1494
  bool fixed_row_size;
2005
1495
public:
2006
 
  select_export(sql_exchange *ex) :select_to_file(ex) {}
 
1496
  select_export(file_exchange *ex) :select_to_file(ex) {}
2007
1497
  ~select_export();
2008
1498
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2009
1499
  bool send_data(List<Item> &items);
2012
1502
 
2013
1503
class select_dump :public select_to_file {
2014
1504
public:
2015
 
  select_dump(sql_exchange *ex) :select_to_file(ex) {}
 
1505
  select_dump(file_exchange *ex) :select_to_file(ex) {}
2016
1506
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2017
1507
  bool send_data(List<Item> &items);
2018
1508
};
2053
1543
  Field **field;
2054
1544
  /* lock data for tmp table */
2055
1545
  DRIZZLE_LOCK *m_lock;
2056
 
  /* m_lock or thd->extra_lock */
 
1546
  /* m_lock or session->extra_lock */
2057
1547
  DRIZZLE_LOCK **m_plock;
2058
1548
public:
2059
1549
  select_create (TableList *table_arg,
2070
1560
    {}
2071
1561
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2072
1562
 
2073
 
  void binlog_show_create_table(Table **tables, uint32_t count);
2074
1563
  void store_values(List<Item> &values);
2075
1564
  void send_error(uint32_t errcode,const char *err);
2076
1565
  bool send_eof();
2077
1566
  void abort();
2078
1567
  virtual bool can_rollback_data() { return 1; }
2079
1568
 
2080
 
  // Needed for access from local class MY_HOOKS in prepare(), since thd is proteted.
2081
 
  const THD *get_thd(void) { return thd; }
 
1569
  // Needed for access from local class MY_HOOKS in prepare(), since session is proteted.
 
1570
  const Session *get_session(void) { return session; }
2082
1571
  const HA_CREATE_INFO *get_create_info() { return create_info; };
2083
1572
  int prepare2(void) { return 0; }
2084
1573
};
2085
1574
 
2086
1575
#include <storage/myisam/myisam.h>
2087
1576
 
2088
 
/* 
2089
 
  Param to create temporary tables when doing SELECT:s 
 
1577
/*
 
1578
  Param to create temporary tables when doing SELECT:s
2090
1579
  NOTE
2091
1580
    This structure is copied using memcpy as a part of JOIN.
2092
1581
*/
2114
1603
  uint  quick_group;
2115
1604
  bool  using_indirect_summary_function;
2116
1605
  /* If >0 convert all blob fields to varchar(convert_blob_length) */
2117
 
  uint32_t  convert_blob_length; 
2118
 
  const CHARSET_INFO *table_charset; 
 
1606
  uint32_t  convert_blob_length;
 
1607
  const CHARSET_INFO *table_charset;
2119
1608
  bool schema_table;
2120
1609
  /*
2121
1610
    True if GROUP BY and its aggregate functions are already computed
2143
1632
    cleanup();
2144
1633
  }
2145
1634
  void init(void);
2146
 
  inline void cleanup(void)
2147
 
  {
2148
 
    if (copy_field)                             /* Fix for Intel compiler */
2149
 
    {
2150
 
      delete [] copy_field;
2151
 
      save_copy_field= copy_field= 0;
2152
 
    }
2153
 
  }
 
1635
  void cleanup(void);
2154
1636
};
2155
1637
 
2156
1638
class select_union :public select_result_interceptor
2165
1647
  bool send_eof();
2166
1648
  bool flush();
2167
1649
  void cleanup();
2168
 
  bool create_result_table(THD *thd, List<Item> *column_types,
 
1650
  bool create_result_table(Session *session, List<Item> *column_types,
2169
1651
                           bool is_distinct, uint64_t options,
2170
1652
                           const char *alias, bool bit_fields_as_long);
2171
1653
};
2247
1729
  LEX_STRING db;
2248
1730
  LEX_STRING table;
2249
1731
  SELECT_LEX_UNIT *sel;
2250
 
  inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
 
1732
  inline Table_ident(Session *session, LEX_STRING db_arg, LEX_STRING table_arg,
2251
1733
                     bool force)
2252
1734
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
2253
1735
  {
2254
 
    if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
 
1736
    if (!force && (session->client_capabilities & CLIENT_NO_SCHEMA))
2255
1737
      db.str=0;
2256
1738
    else
2257
1739
      db= db_arg;
2258
1740
  }
2259
 
  inline Table_ident(LEX_STRING table_arg) 
 
1741
  inline Table_ident(LEX_STRING table_arg)
2260
1742
    :table(table_arg), sel((SELECT_LEX_UNIT *)0)
2261
1743
  {
2262
1744
    db.str=0;
2302
1784
};
2303
1785
 
2304
1786
/*
2305
 
   Unique -- class for unique (removing of duplicates). 
 
1787
   Unique -- class for unique (removing of duplicates).
2306
1788
   Puts all values to the TREE. If the tree becomes too big,
2307
1789
   it's dumped to the file. User can request sorted values, or
2308
1790
   just iterate through them. In the last case tree merging is performed in
2313
1795
{
2314
1796
  DYNAMIC_ARRAY file_ptrs;
2315
1797
  ulong max_elements;
2316
 
  uint64_t max_in_memory_size;
 
1798
  size_t max_in_memory_size;
2317
1799
  IO_CACHE file;
2318
1800
  TREE tree;
2319
1801
  unsigned char *record_pointers;
2323
1805
public:
2324
1806
  ulong elements;
2325
1807
  Unique(qsort_cmp2 comp_func, void *comp_func_fixed_arg,
2326
 
         uint32_t size_arg, uint64_t max_in_memory_size_arg);
 
1808
         uint32_t size_arg, size_t max_in_memory_size_arg);
2327
1809
  ~Unique();
2328
1810
  ulong elements_in_tree() { return tree.elements_in_tree; }
2329
1811
  inline bool unique_add(void *ptr)
2334
1816
  }
2335
1817
 
2336
1818
  bool get(Table *table);
2337
 
  static double get_use_cost(uint32_t *buffer, uint32_t nkeys, uint32_t key_size, 
2338
 
                             uint64_t max_in_memory_size);
2339
 
  inline static int get_cost_calc_buff_size(ulong nkeys, uint32_t key_size, 
2340
 
                                            uint64_t max_in_memory_size)
 
1819
  static double get_use_cost(uint32_t *buffer, uint32_t nkeys, uint32_t key_size,
 
1820
                             size_t max_in_memory_size);
 
1821
  inline static int get_cost_calc_buff_size(ulong nkeys, uint32_t key_size,
 
1822
                                            size_t max_in_memory_size)
2341
1823
  {
2342
 
    register uint64_t max_elems_in_tree=
 
1824
    register size_t max_elems_in_tree=
2343
1825
      (1 + max_in_memory_size / ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size));
2344
1826
    return (int) (sizeof(uint)*(1 + nkeys/max_elems_in_tree));
2345
1827
  }
2397
1879
  uint32_t table_count;
2398
1880
  /*
2399
1881
   List of tables referenced in the CHECK OPTION condition of
2400
 
   the updated view excluding the updated table. 
 
1882
   the updated view excluding the updated table.
2401
1883
  */
2402
1884
  List <Table> unupdated_check_opt_tables;
2403
1885
  Copy_field *copy_field;
2406
1888
  /* True if the update operation has made a change in a transactional table */
2407
1889
  bool transactional_tables;
2408
1890
  bool ignore;
2409
 
  /* 
 
1891
  /*
2410
1892
     error handling (rollback and binlogging) can happen in send_eof()
2411
1893
     so that afterward send_error() needs to find out that.
2412
1894
  */
2447
1929
  int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2448
1930
  bool send_data(List<Item> &items);
2449
1931
  bool send_eof();
2450
 
  virtual bool check_simple_select() const;
2451
1932
  void cleanup();
2452
1933
};
2453
1934
 
2454
1935
/* Bits in sql_command_flags */
2455
1936
 
2456
 
#define CF_CHANGES_DATA         1
2457
 
#define CF_HAS_ROW_COUNT        2
2458
 
#define CF_STATUS_COMMAND       4
2459
 
#define CF_SHOW_TABLE_COMMAND   8
2460
 
#define CF_WRITE_LOGS_COMMAND  16
 
1937
enum sql_command_flag_bits {
 
1938
  CF_BIT_CHANGES_DATA,
 
1939
  CF_BIT_HAS_ROW_COUNT,
 
1940
  CF_BIT_STATUS_COMMAND,
 
1941
  CF_BIT_SHOW_TABLE_COMMAND,
 
1942
  CF_BIT_WRITE_LOGS_COMMAND,
 
1943
  CF_BIT_SIZE
 
1944
};
 
1945
 
 
1946
static const std::bitset<CF_BIT_SIZE> CF_CHANGES_DATA(1 << CF_BIT_CHANGES_DATA);
 
1947
static const std::bitset<CF_BIT_SIZE> CF_HAS_ROW_COUNT(1 << CF_BIT_HAS_ROW_COUNT);
 
1948
static const std::bitset<CF_BIT_SIZE> CF_STATUS_COMMAND(1 << CF_BIT_STATUS_COMMAND);
 
1949
static const std::bitset<CF_BIT_SIZE> CF_SHOW_TABLE_COMMAND(1 << CF_BIT_SHOW_TABLE_COMMAND);
 
1950
static const std::bitset<CF_BIT_SIZE> CF_WRITE_LOGS_COMMAND(1 << CF_BIT_WRITE_LOGS_COMMAND);
2461
1951
 
2462
1952
/* Functions in sql_class.cc */
2463
1953
 
2466
1956
void add_diff_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var,
2467
1957
                        STATUS_VAR *dec_var);
2468
1958
 
2469
 
#endif /* DRIZZLE_SERVER */
 
1959
/* Some inline functions for more speed */
 
1960
 
 
1961
inline bool add_item_to_list(Session *session, Item *item)
 
1962
{
 
1963
  return session->lex->current_select->add_item_to_list(session, item);
 
1964
}
 
1965
 
 
1966
inline bool add_value_to_list(Session *session, Item *value)
 
1967
{
 
1968
  return session->lex->value_list.push_back(value);
 
1969
}
 
1970
 
 
1971
inline bool add_order_to_list(Session *session, Item *item, bool asc)
 
1972
{
 
1973
  return session->lex->current_select->add_order_to_list(session, item, asc);
 
1974
}
 
1975
 
 
1976
inline bool add_group_to_list(Session *session, Item *item, bool asc)
 
1977
{
 
1978
  return session->lex->current_select->add_group_to_list(session, item, asc);
 
1979
}
 
1980
 
 
1981
#endif /* DRIZZLED_SQL_CLASS_H */