1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
4
* Copyright (C) 2008 Sun Microsystems, Inc.
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; version 2 of the License.
10
* This program is distributed in the hope that it will be useful,
11
* but WITHOUT ANY WARRANTY; without even the implied warranty of
12
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
* GNU General Public License for more details.
15
* You should have received a copy of the GNU General Public License
16
* along with this program; if not, write to the Free Software
17
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20
#ifndef DRIZZLED_SESSION_H
21
#define DRIZZLED_SESSION_H
25
#include <boost/make_shared.hpp>
26
#include <boost/thread/condition_variable.hpp>
27
#include <boost/thread/mutex.hpp>
28
#include <boost/thread/shared_mutex.hpp>
29
#include <boost/thread/thread.hpp>
33
#include <sys/resource.h>
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>
69
#define MIN_HANDSHAKE_SIZE 6
78
class EventObserverList;
88
namespace internal { struct st_my_thread_var; }
89
namespace table { class Placeholder; }
93
class Internal_error_handler;
1
/* Copyright (C) 2000-2006 MySQL AB
3
This program is free software; you can redistribute it and/or modify
4
it under the terms of the GNU General Public License as published by
5
the Free Software Foundation; version 2 of the License.
7
This program is distributed in the hope that it will be useful,
8
but WITHOUT ANY WARRANTY; without even the implied warranty of
9
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10
GNU General Public License for more details.
12
You should have received a copy of the GNU General Public License
13
along with this program; if not, write to the Free Software
14
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
17
/* Classes in mysql */
19
#ifdef USE_PRAGMA_INTERFACE
20
#pragma interface /* gcc class implementation */
23
#include <mysql/plugin_audit.h>
25
#include "rpl_tblmap.h"
29
class Query_log_event;
31
class Slave_log_event;
94
32
class Lex_input_stream;
95
class TableShareInstance;
35
enum enum_enable_or_disable { LEAVE_AS_IS, ENABLE, DISABLE };
36
enum enum_ha_read_modes { RFIRST, RNEXT, RPREV, RLAST, RKEY, RNEXT_SAME };
37
enum enum_duplicates { DUP_ERROR, DUP_REPLACE, DUP_UPDATE };
38
enum enum_delay_key_write { DELAY_KEY_WRITE_NONE, DELAY_KEY_WRITE_ON,
39
DELAY_KEY_WRITE_ALL };
40
enum enum_slave_exec_mode { SLAVE_EXEC_MODE_STRICT,
41
SLAVE_EXEC_MODE_IDEMPOTENT,
42
SLAVE_EXEC_MODE_LAST_BIT};
43
enum enum_mark_columns
44
{ MARK_COLUMNS_NONE, MARK_COLUMNS_READ, MARK_COLUMNS_WRITE};
45
enum enum_filetype { FILETYPE_CSV, FILETYPE_XML };
101
47
extern char internal_table_name[2];
102
48
extern char empty_c_string[1];
103
49
extern const char **errmesg;
51
#define TC_LOG_PAGE_SIZE 8192
52
#define TC_LOG_MIN_SIZE (3*TC_LOG_PAGE_SIZE)
105
54
#define TC_HEURISTIC_RECOVER_COMMIT 1
106
55
#define TC_HEURISTIC_RECOVER_ROLLBACK 2
107
extern uint32_t tc_heuristic_recover;
109
#define Session_SENTRY_MAGIC 0xfeedd1ff
110
#define Session_SENTRY_GONE 0xdeadbeef
112
extern DRIZZLED_API struct drizzle_system_variables global_system_variables;
56
extern uint tc_heuristic_recover;
58
typedef struct st_user_var_events
60
user_var_entry *user_var_event;
65
} BINLOG_USER_VAR_EVENT;
67
#define RP_LOCK_LOG_IS_ALREADY_LOCKED 1
68
#define RP_FORCE_ROTATE 2
71
The COPY_INFO structure is used by INSERT/REPLACE code.
72
The schema of the row counting by the INSERT/INSERT ... ON DUPLICATE KEY
74
If a row is inserted then the copied variable is incremented.
75
If a row is updated by the INSERT ... ON DUPLICATE KEY UPDATE and the
76
new data differs from the old one then the copied and the updated
77
variables are incremented.
78
The touched variable is incremented if a row was touched by the update part
79
of the INSERT ... ON DUPLICATE KEY UPDATE no matter whether the row
80
was actually changed or not.
82
typedef struct st_copy_info {
83
ha_rows records; /**< Number of processed records */
84
ha_rows deleted; /**< Number of deleted records */
85
ha_rows updated; /**< Number of updated records */
86
ha_rows copied; /**< Number of copied records */
88
ha_rows touched; /* Number of touched records */
89
enum enum_duplicates handle_duplicates;
90
int escape_char, last_errno;
92
/* for INSERT ... UPDATE */
93
List<Item> *update_fields;
94
List<Item> *update_values;
95
/* for VIEW ... WITH CHECK OPTION */
99
class Key_part_spec :public Sql_alloc {
101
LEX_STRING field_name;
103
Key_part_spec(const LEX_STRING &name, uint len)
104
: field_name(name), length(len)
106
Key_part_spec(const char *name, const size_t name_len, uint len)
108
{ field_name.str= (char *)name; field_name.length= name_len; }
109
bool operator==(const Key_part_spec& other) const;
111
Construct a copy of this Key_part_spec. field_name is copied
112
by-pointer as it is known to never change. At the same time
113
'length' may be reset in mysql_prepare_create_table, and this
114
is why we supply it with a copy.
116
@return If out of memory, 0 is returned and an error is set in
119
Key_part_spec *clone(MEM_ROOT *mem_root) const
120
{ return new (mem_root) Key_part_spec(*this); }
124
class Alter_drop :public Sql_alloc {
126
enum drop_type {KEY, COLUMN };
129
Alter_drop(enum drop_type par_type,const char *par_name)
130
:name(par_name), type(par_type) {}
132
Used to make a clone of this object for ALTER/CREATE TABLE
133
@sa comment for Key_part_spec::clone
135
Alter_drop *clone(MEM_ROOT *mem_root) const
136
{ return new (mem_root) Alter_drop(*this); }
140
class Alter_column :public Sql_alloc {
144
Alter_column(const char *par_name,Item *literal)
145
:name(par_name), def(literal) {}
147
Used to make a clone of this object for ALTER/CREATE TABLE
148
@sa comment for Key_part_spec::clone
150
Alter_column *clone(MEM_ROOT *mem_root) const
151
{ return new (mem_root) Alter_column(*this); }
155
class Key :public Sql_alloc {
157
enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FOREIGN_KEY};
159
KEY_CREATE_INFO key_create_info;
160
List<Key_part_spec> columns;
164
Key(enum Keytype type_par, const LEX_STRING &name_arg,
165
KEY_CREATE_INFO *key_info_arg,
166
bool generated_arg, List<Key_part_spec> &cols)
167
:type(type_par), key_create_info(*key_info_arg), columns(cols),
168
name(name_arg), generated(generated_arg)
170
Key(enum Keytype type_par, const char *name_arg, size_t name_len_arg,
171
KEY_CREATE_INFO *key_info_arg, bool generated_arg,
172
List<Key_part_spec> &cols)
173
:type(type_par), key_create_info(*key_info_arg), columns(cols),
174
generated(generated_arg)
176
name.str= (char *)name_arg;
177
name.length= name_len_arg;
179
Key(const Key &rhs, MEM_ROOT *mem_root);
181
/* Equality comparison of keys (ignoring name) */
182
friend bool foreign_key_prefix(Key *a, Key *b);
184
Used to make a clone of this object for ALTER/CREATE TABLE
185
@sa comment for Key_part_spec::clone
187
virtual Key *clone(MEM_ROOT *mem_root) const
188
{ return new (mem_root) Key(*this, mem_root); }
193
class Foreign_key: public Key {
195
enum fk_match_opt { FK_MATCH_UNDEF, FK_MATCH_FULL,
196
FK_MATCH_PARTIAL, FK_MATCH_SIMPLE};
197
enum fk_option { FK_OPTION_UNDEF, FK_OPTION_RESTRICT, FK_OPTION_CASCADE,
198
FK_OPTION_SET_NULL, FK_OPTION_NO_ACTION, FK_OPTION_DEFAULT};
200
Table_ident *ref_table;
201
List<Key_part_spec> ref_columns;
202
uint delete_opt, update_opt, match_opt;
203
Foreign_key(const LEX_STRING &name_arg, List<Key_part_spec> &cols,
204
Table_ident *table, List<Key_part_spec> &ref_cols,
205
uint delete_opt_arg, uint update_opt_arg, uint match_opt_arg)
206
:Key(FOREIGN_KEY, name_arg, &default_key_create_info, 0, cols),
207
ref_table(table), ref_columns(ref_cols),
208
delete_opt(delete_opt_arg), update_opt(update_opt_arg),
209
match_opt(match_opt_arg)
211
Foreign_key(const Foreign_key &rhs, MEM_ROOT *mem_root);
213
Used to make a clone of this object for ALTER/CREATE TABLE
214
@sa comment for Key_part_spec::clone
216
virtual Key *clone(MEM_ROOT *mem_root) const
217
{ return new (mem_root) Foreign_key(*this, mem_root); }
220
typedef struct st_mysql_lock
223
uint table_count,lock_count;
224
THR_LOCK_DATA **locks;
228
class LEX_COLUMN : public Sql_alloc
233
LEX_COLUMN (const String& x,const uint& y ): column (x),rights (y) {}
236
#include "sql_lex.h" /* Must be here */
241
#define THD_SENTRY_MAGIC 0xfeedd1ff
242
#define THD_SENTRY_GONE 0xdeadbeef
244
#define THD_CHECK_SENTRY(thd) assert(thd->dbug_sentry == THD_SENTRY_MAGIC)
246
struct system_variables
249
How dynamically allocated system variables are handled:
251
The global_system_variables and max_system_variables are "authoritative"
252
They both should have the same 'version' and 'size'.
253
When attempting to access a dynamic variable, if the session version
254
is out of date, then the session version is updated and realloced if
255
neccessary and bytes copied from global to make up for missing data.
257
ulong dynamic_variables_version;
258
char* dynamic_variables_ptr;
259
uint dynamic_variables_head; /* largest valid variable offset */
260
uint dynamic_variables_size; /* how many bytes are in use */
262
uint64_t myisam_max_extra_sort_file_size;
263
uint64_t myisam_max_sort_file_size;
264
uint64_t max_heap_table_size;
265
uint64_t tmp_table_size;
266
uint64_t long_query_time;
267
ha_rows select_limit;
268
ha_rows max_join_size;
269
ulong auto_increment_increment, auto_increment_offset;
270
ulong bulk_insert_buff_size;
271
ulong join_buff_size;
272
ulong max_allowed_packet;
273
ulong max_error_count;
274
ulong max_length_for_sort_data;
275
ulong max_sort_length;
276
ulong max_tmp_tables;
277
ulong min_examined_row_limit;
278
ulong myisam_repair_threads;
279
ulong myisam_sort_buff_size;
280
ulong myisam_stats_method;
281
ulong net_buffer_length;
282
ulong net_interactive_timeout;
283
ulong net_read_timeout;
284
ulong net_retry_count;
285
ulong net_wait_timeout;
286
ulong net_write_timeout;
287
ulong optimizer_prune_level;
288
ulong optimizer_search_depth;
290
Controls use of Engine-MRR:
291
0 - auto, based on cost
292
1 - force MRR when the storage engine is capable of doing it
295
ulong optimizer_use_mrr;
296
/* A bitmap for switching optimizations on/off */
297
ulong optimizer_switch;
298
ulong preload_buff_size;
299
ulong profiling_history_size;
300
ulong query_cache_type;
301
ulong read_buff_size;
302
ulong read_rnd_buff_size;
303
ulong div_precincrement;
305
ulong thread_handling;
307
ulong completion_type;
308
/* Determines which non-standard SQL behaviour should be enabled */
310
ulong default_week_format;
311
ulong max_seeks_for_key;
312
ulong range_alloc_block_size;
313
ulong query_alloc_block_size;
314
ulong query_prealloc_size;
315
ulong trans_alloc_block_size;
316
ulong trans_prealloc_size;
318
ulong group_concat_max_len;
319
ulong binlog_format; // binlog format for this thd (see enum_binlog_format)
321
In slave thread we need to know in behalf of which
322
thread the query is being run to replicate temp tables properly
324
my_thread_id pseudo_thread_id;
326
my_bool low_priority_updates;
329
compatibility option:
330
- index usage hints (USE INDEX without a FOR clause) behave as in 5.0
333
my_bool engine_condition_pushdown;
334
my_bool keep_files_on_create;
336
my_bool old_alter_table;
338
plugin_ref table_plugin;
340
/* Only charset part of these variables is sensible */
341
CHARSET_INFO *character_set_filesystem;
342
CHARSET_INFO *character_set_client;
343
CHARSET_INFO *character_set_results;
345
/* Both charset and collation parts of these variables are important */
346
CHARSET_INFO *collation_server;
347
CHARSET_INFO *collation_database;
348
CHARSET_INFO *collation_connection;
351
MY_LOCALE *lc_time_names;
353
Time_zone *time_zone;
355
/* DATE, DATETIME and MYSQL_TIME formats */
356
DATE_TIME_FORMAT *date_format;
357
DATE_TIME_FORMAT *datetime_format;
358
DATE_TIME_FORMAT *time_format;
359
my_bool sysdate_is_now;
364
/* per thread status variables */
366
typedef struct system_status_var
368
uint64_t bytes_received;
371
ulong com_stat[(uint) SQLCOM_END];
372
ulong created_tmp_disk_tables;
373
ulong created_tmp_tables;
374
ulong ha_commit_count;
375
ulong ha_delete_count;
376
ulong ha_read_first_count;
377
ulong ha_read_last_count;
378
ulong ha_read_key_count;
379
ulong ha_read_next_count;
380
ulong ha_read_prev_count;
381
ulong ha_read_rnd_count;
382
ulong ha_read_rnd_next_count;
383
ulong ha_rollback_count;
384
ulong ha_update_count;
385
ulong ha_write_count;
386
ulong ha_prepare_count;
387
ulong ha_discover_count;
388
ulong ha_savepoint_count;
389
ulong ha_savepoint_rollback_count;
391
/* KEY_CACHE parts. These are copies of the original */
392
ulong key_blocks_changed;
393
ulong key_blocks_used;
394
ulong key_cache_r_requests;
395
ulong key_cache_read;
396
ulong key_cache_w_requests;
397
ulong key_cache_write;
398
/* END OF KEY_CACHE parts */
400
ulong net_big_packet_count;
403
ulong select_full_join_count;
404
ulong select_full_range_join_count;
405
ulong select_range_count;
406
ulong select_range_check_count;
407
ulong select_scan_count;
408
ulong long_query_count;
409
ulong filesort_merge_passes;
410
ulong filesort_range_count;
412
ulong filesort_scan_count;
413
/* Prepared statements and binary protocol */
414
ulong com_stmt_prepare;
415
ulong com_stmt_execute;
416
ulong com_stmt_send_long_data;
417
ulong com_stmt_fetch;
418
ulong com_stmt_reset;
419
ulong com_stmt_close;
421
Number of statements sent from the client
427
SEE last_system_status_var DEFINITION BELOW.
429
Below 'last_system_status_var' are all variables which doesn't make any
430
sense to add to the /global/ status variable counter.
432
double last_query_cost;
438
This is used for 'SHOW STATUS'. It must be updated to the last ulong
439
variable in system_status_var which is makes sens to add to the global
443
#define last_system_status_var questions
445
void mark_transaction_to_rollback(THD *thd, bool all);
449
#define INIT_ARENA_DBUG_INFO is_backup_arena= 0
455
List of items created in the parser for this query. Every item puts
456
itself to the list on creation (see Item::Item() for details))
459
MEM_ROOT *mem_root; // Pointer to current memroot
460
bool is_backup_arena; /* True if this arena is used for backup. */
463
The states relfects three diffrent life cycles for three
464
different types of statements:
465
Prepared statement: INITIALIZED -> PREPARED -> EXECUTED.
466
Stored procedure: INITIALIZED_FOR_SP -> EXECUTED.
467
Other statements: CONVENTIONAL_EXECUTION never changes.
471
INITIALIZED= 0, INITIALIZED_FOR_SP= 1, PREPARED= 2,
472
CONVENTIONAL_EXECUTION= 3, EXECUTED= 4, ERROR= -1
477
/* We build without RTTI, so dynamic_cast can't be used. */
480
STATEMENT, PREPARED_STATEMENT, STORED_PROCEDURE
483
Query_arena(MEM_ROOT *mem_root_arg, enum enum_state state_arg) :
484
free_list(0), mem_root(mem_root_arg), state(state_arg)
485
{ INIT_ARENA_DBUG_INFO; }
487
This constructor is used only when Query_arena is created as
488
backup storage for another instance of Query_arena.
490
Query_arena() { INIT_ARENA_DBUG_INFO; }
492
virtual ~Query_arena() {};
494
inline bool is_conventional() const
495
{ assert(state == CONVENTIONAL_EXECUTION); return state == CONVENTIONAL_EXECUTION; }
497
inline void* alloc(size_t size) { return alloc_root(mem_root,size); }
498
inline void* calloc(size_t size)
501
if ((ptr=alloc_root(mem_root,size)))
505
inline char *strdup(const char *str)
506
{ return strdup_root(mem_root,str); }
507
inline char *strmake(const char *str, size_t size)
508
{ return strmake_root(mem_root,str,size); }
509
inline void *memdup(const void *str, size_t size)
510
{ return memdup_root(mem_root,str,size); }
511
inline void *memdup_w_gap(const void *str, size_t size, uint gap)
514
if ((ptr= alloc_root(mem_root,size+gap)))
515
memcpy(ptr,str,size);
519
void set_query_arena(Query_arena *set);
522
/* Close the active state associated with execution of this statement */
523
virtual void cleanup_stmt();
115
* Represents a client connection to the database server.
117
* Contains the client/server protocol object, the current statement
118
* being executed, local-to-session variables and status counters, and
119
* a host of other information.
123
* The Session class should have a vector of Statement object pointers which
124
* comprise the statements executed on the Session. Until this architectural
125
* change is done, we can forget about parallel operations inside a session.
129
* Make member variables private and have inlined accessors and setters. Hide
130
* all member variables that are not critical to non-internal operations of the
134
class DRIZZLED_API Session : public Open_tables_state
529
@brief State of a single command executed against this connection.
531
One connection can contain a lot of simultaneously running statements,
532
some of which could be:
533
- prepared, that is, contain placeholders,
534
To perform some action with statement we reset THD part to the state of
535
that statement, do the action, and then save back modified state from THD
536
to the statement. It will be changed in near future, and Statement will
540
class Statement: public ilink, public Query_arena
542
Statement(const Statement &rhs); /* not implemented: */
543
Statement &operator=(const Statement &rhs); /* non-copyable */
137
// Plugin storage in Session.
138
typedef boost::shared_ptr<Session> shared_ptr;
139
typedef Session& reference;
140
typedef const Session& const_reference;
141
typedef const Session* const_pointer;
142
typedef Session* pointer;
144
static shared_ptr make_shared(plugin::Client *client, catalog::Instance::shared_ptr instance_arg)
146
assert(instance_arg);
147
return boost::make_shared<Session>(client, instance_arg);
546
Uniquely identifies each statement object in thread scope; change during
547
statement lifetime. FIXME: must be const
151
552
MARK_COLUMNS_NONE: Means mark_used_colums is not set and no indicator to
152
553
handler of fields used is set
153
554
MARK_COLUMNS_READ: Means a bit in read set is set to inform handler
154
555
that the field is to be read. If field list contains
155
duplicates, then session->dup_field is set to point
556
duplicates, then thd->dup_field is set to point
156
557
to the last found duplicate.
157
558
MARK_COLUMNS_WRITE: Means a bit is set in write set to inform handler
158
559
that it needs to update this field in write_row
161
562
enum enum_mark_columns mark_used_columns;
162
inline void* calloc(size_t size)
165
if ((ptr= mem_root->alloc_root(size)))
166
memset(ptr, 0, size);
169
inline char *strmake(const char *str, size_t size)
171
return mem_root->strmake_root(str,size);
174
inline void *memdup_w_gap(const void *str, size_t size, uint32_t gap)
177
if ((ptr= mem_root->alloc_root(size + gap)))
178
memcpy(ptr,str,size);
181
/** Frees all items attached to this Statement */
185
* List of items created in the parser for this query. Every item puts
186
* itself to the list on creation (see Item::Item() for details))
189
memory::Root *mem_root; /**< Pointer to current memroot */
192
memory::Root *getMemRoot()
204
void setXaId(uint64_t in_xa_id)
210
* Uniquely identifies each statement object in thread scope; change during
211
* statement lifetime.
213
* @todo should be const
217
LEX *lex; /**< parse tree descriptor */
225
enum_sql_command getSqlCommand() const
227
return lex->sql_command;
230
/** query associated with this statement */
231
typedef boost::shared_ptr<const std::string> QueryString;
234
boost::shared_ptr<std::string> query;
236
// Never allow for a modification of this outside of the class. c_str()
237
// requires under some setup non const, you must copy the QueryString in
240
QueryString getQueryString() const
245
void resetQueryString()
564
LEX_STRING name; /* name for named prepared statements */
565
LEX *lex; // parse tree descriptor
252
We need to copy the lock on the string in order to make sure we have a stable string.
253
Once this is done we can use it to build a const char* which can be handed off for
254
a method to use (Innodb is currently the only engine using this).
567
Points to the query associated with this statement. It's const, but
568
we need to declare it char * because all table handlers are written
569
in C and need to point to it.
571
Note that (A) if we set query = NULL, we must at the same time set
572
query_length = 0, and protect the whole operation with the
573
LOCK_thread_count mutex. And (B) we are ONLY allowed to set query to a
574
non-NULL value if its previous value is NULL. We do not need to protect
575
operation (B) with any mutex. To avoid crashes in races, if we do not
576
know that thd->query cannot change at the moment, one should print
577
thd->query like this:
578
(1) reserve the LOCK_thread_count mutex;
579
(2) check if thd->query is NULL;
580
(3) if not NULL, then print at most thd->query_length characters from
581
it. We will see the query_length field as either 0, or the right value
583
Assuming that the write and read of an n-bit memory field in an n-bit
584
computer is atomic, we can avoid races in the above way.
585
This printing is needed at least in SHOW PROCESSLIST and SHOW INNODB
256
const char *getQueryStringCopy(size_t &length)
258
QueryString tmp_string(getQueryString());
266
length= tmp_string->length();
267
char *to_return= strmake(tmp_string->c_str(), tmp_string->length());
272
session::State::shared_ptr _state;
276
session::State::const_shared_ptr state()
589
uint32 query_length; // current query length
282
592
Name of the current (default) database.
287
597
valid database name.
289
599
@note this attribute is set and alloced by the slave SQL thread (for
290
the Session of that thread); that thread is (and must remain, for now) the
600
the THD of that thread); that thread is (and must remain, for now) the
291
601
only responsible for freeing this member.
609
/* This constructor is called for backup statements */
612
Statement(LEX *lex_arg, MEM_ROOT *mem_root_arg,
613
enum enum_state state_arg, ulong id_arg);
616
/* Assign execution context (note: not all members) of given stmt to self */
617
void set_statement(Statement *stmt);
618
void set_n_backup_statement(Statement *stmt, Statement *backup);
619
void restore_backup_statement(Statement *stmt, Statement *backup);
622
struct st_savepoint {
623
struct st_savepoint *prev;
626
Ha_trx_info *ha_list;
629
enum xa_states {XA_NOTR=0, XA_ACTIVE, XA_IDLE, XA_PREPARED};
630
extern const char *xa_state_names[];
632
typedef struct st_xid_state {
633
/* For now, this is only used to catch duplicated external xids */
634
XID xid; // transaction identifier
635
enum xa_states xa_state; // used by external XA only
639
extern pthread_mutex_t LOCK_xid_cache;
640
extern HASH xid_cache;
641
bool xid_cache_init(void);
642
void xid_cache_free(void);
643
XID_STATE *xid_cache_search(XID *xid);
644
bool xid_cache_insert(XID *xid, enum xa_states xa_state);
645
bool xid_cache_insert(XID_STATE *xid_state);
646
void xid_cache_delete(XID_STATE *xid_state);
649
@class Security_context
650
@brief A set of THD members describing the current authenticated user.
653
class Security_context {
655
Security_context() {} /* Remove gcc warning */
657
host - host of the client
658
user - user of the client, set to NULL until the user has been read from
660
priv_user - The user privilege we are using. May be "" for anonymous user.
663
char *host, *user, *priv_user, *ip;
664
/* The host privilege we are using */
665
char priv_host[MAX_HOSTNAME];
666
/* points to host if host is available, otherwise points to ip */
667
const char *host_or_ip;
668
ulong db_access; /* Privileges for current db */
673
inline char *priv_host_name()
675
return (*priv_host ? priv_host : (char *)"%");
681
A registry for item tree transformations performed during
682
query optimization. We register only those changes which require
683
a rollback to re-execute a prepared statement or stored procedure
687
struct Item_change_record;
688
typedef I_List<Item_change_record> Item_change_list;
692
Class that holds information about tables which were opened and locked
693
by the thread. It is also used to save/restore this information in
694
push_open_tables_state()/pop_open_tables_state().
697
class Open_tables_state
701
List of regular tables in use by this thread. Contains temporary and
702
base tables that were opened with @see open_tables().
706
List of temporary tables used by this thread. Contains user-level
707
temporary tables, created with CREATE TEMPORARY TABLE, and
708
internal temporary tables, created, e.g., to resolve a SELECT,
709
or for an intermediate table used in ALTER.
710
XXX Why are internal temporary tables added to this list?
712
TABLE *temporary_tables;
714
List of tables that were opened with HANDLER OPEN and are
715
still in use by this thread.
717
TABLE *handler_tables;
718
TABLE *derived_tables;
720
During a MySQL session, one can lock tables in two modes: automatic
721
or manual. In automatic mode all necessary tables are locked just before
722
statement execution, and all acquired locks are stored in 'lock'
723
member. Unlocking takes place automatically as well, when the
725
Manual mode comes into play when a user issues a 'LOCK TABLES'
726
statement. In this mode the user can only use the locked tables.
727
Trying to use any other tables will give an error. The locked tables are
728
stored in 'locked_tables' member. Manual locking is described in
729
the 'LOCK_TABLES' chapter of the MySQL manual.
730
See also lock_tables() for details.
734
Tables that were locked with explicit or implicit LOCK TABLES.
735
(Implicit LOCK TABLES happens when we are prelocking tables for
736
execution of statement which uses stored routines. See description
737
THD::prelocked_mode for more info.)
739
MYSQL_LOCK *locked_tables;
742
CREATE-SELECT keeps an extra lock for the table being
743
created. This field is used to keep the extra lock available for
744
lower level routines, which would otherwise miss that lock.
746
MYSQL_LOCK *extra_lock;
749
uint current_tablenr;
752
BACKUPS_AVAIL = (1U << 0) /* There are backups available */
756
Flags with information about the open tables state.
761
This constructor serves for creation of Open_tables_state instances
762
which are used as backup storage.
764
Open_tables_state() : state_flags(0U) { }
766
Open_tables_state(ulong version_arg);
768
void set_open_tables_state(Open_tables_state *state)
773
void reset_open_tables_state()
775
open_tables= temporary_tables= handler_tables= derived_tables= 0;
776
extra_lock= lock= locked_tables= 0;
782
@class Sub_statement_state
783
@brief Used to save context when executing a function or trigger
786
/* Defines used for Sub_statement_state::in_sub_stmt */
788
#define SUB_STMT_TRIGGER 1
789
#define SUB_STMT_FUNCTION 2
792
class Sub_statement_state
796
uint64_t first_successful_insert_id_in_prev_stmt;
797
uint64_t first_successful_insert_id_in_cur_stmt, insert_id_for_cur_row;
798
Discrete_interval auto_inc_interval_for_cur_row;
799
Discrete_intervals_list auto_inc_intervals_forced;
800
uint64_t limit_found_rows;
801
ha_rows cuted_fields, sent_row_count, examined_row_count;
802
ulong client_capabilities;
804
bool enable_slow_log;
805
bool last_insert_id_used;
806
SAVEPOINT *savepoints;
810
/* Flags for the THD::system_thread variable */
811
enum enum_thread_type
814
SYSTEM_THREAD_SLAVE_IO,
815
SYSTEM_THREAD_SLAVE_SQL
820
This class represents the interface for internal error handlers.
821
Internal error handlers are exception handlers used by the server
824
class Internal_error_handler
827
Internal_error_handler() {}
828
virtual ~Internal_error_handler() {}
832
Handle an error condition.
833
This method can be implemented by a subclass to achieve any of the
835
- mask an error internally, prevent exposing it to the user,
836
- mask an error and throw another one instead.
837
When this method returns true, the error condition is considered
838
'handled', and will not be propagated to upper layers.
839
It is the responsability of the code installing an internal handler
840
to then check for trapped conditions, and implement logic to recover
841
from the anticipated conditions trapped during runtime.
843
This mechanism is similar to C++ try/throw/catch:
844
- 'try' correspond to <code>THD::push_internal_handler()</code>,
845
- 'throw' correspond to <code>my_error()</code>,
846
which invokes <code>my_message_sql()</code>,
847
- 'catch' correspond to checking how/if an internal handler was invoked,
848
before removing it from the exception stack with
849
<code>THD::pop_internal_handler()</code>.
851
@param sql_errno the error number
852
@param level the error level
853
@param thd the calling thread
854
@return true if the error is handled
856
virtual bool handle_error(uint sql_errno,
858
MYSQL_ERROR::enum_warning_level level,
864
Stores status of the currently executed statement.
865
Cleared at the beginning of the statement, and then
866
can hold either OK, ERROR, or EOF status.
867
Can not be assigned twice per statement.
870
class Diagnostics_area
873
enum enum_diagnostics_status
875
/** The area is cleared at start of a statement. */
877
/** Set whenever one calls my_ok(). */
879
/** Set whenever one calls my_eof(). */
881
/** Set whenever one calls my_error() or my_message(). */
883
/** Set in case of a custom response, such as one from COM_STMT_PREPARE. */
886
/** True if status information is sent to the client. */
888
/** Set to make set_error_status after set_{ok,eof}_status possible. */
889
bool can_overwrite_status;
891
void set_ok_status(THD *thd, ha_rows affected_rows_arg,
892
uint64_t last_insert_id_arg,
893
const char *message);
894
void set_eof_status(THD *thd);
895
void set_error_status(THD *thd, uint sql_errno_arg, const char *message_arg);
897
void disable_status();
899
void reset_diagnostics_area();
901
bool is_set() const { return m_status != DA_EMPTY; }
902
bool is_error() const { return m_status == DA_ERROR; }
903
bool is_eof() const { return m_status == DA_EOF; }
904
bool is_ok() const { return m_status == DA_OK; }
905
bool is_disabled() const { return m_status == DA_DISABLED; }
906
enum_diagnostics_status status() const { return m_status; }
908
const char *message() const
909
{ assert(m_status == DA_ERROR || m_status == DA_OK); return m_message; }
911
uint sql_errno() const
912
{ assert(m_status == DA_ERROR); return m_sql_errno; }
914
uint server_status() const
916
assert(m_status == DA_OK || m_status == DA_EOF);
917
return m_server_status;
920
ha_rows affected_rows() const
921
{ assert(m_status == DA_OK); return m_affected_rows; }
923
uint64_t last_insert_id() const
924
{ assert(m_status == DA_OK); return m_last_insert_id; }
926
uint total_warn_count() const
928
assert(m_status == DA_OK || m_status == DA_EOF);
929
return m_total_warn_count;
932
Diagnostics_area() { reset_diagnostics_area(); }
294
util::string::shared_ptr _schema;
935
/** Message buffer. Can be used by OK or ERROR status. */
936
char m_message[MYSQL_ERRMSG_SIZE];
938
SQL error number. One of ER_ codes from share/errmsg.txt.
939
Set by set_error_status.
944
Copied from thd->server_status when the diagnostics area is assigned.
945
We need this member as some places in the code use the following pattern:
946
thd->server_status|= ...
948
thd->server_status&= ~...
949
Assigned by OK, EOF or ERROR.
951
uint m_server_status;
953
The number of rows affected by the last statement. This is
954
semantically close to thd->row_count_func, but has a different
955
life cycle. thd->row_count_func stores the value returned by
956
function ROW_COUNT() and is cleared only by statements that
957
update its value, such as INSERT, UPDATE, DELETE and few others.
958
This member is cleared at the beginning of the next statement.
960
We could possibly merge the two, but life cycle of thd->row_count_func
963
ha_rows m_affected_rows;
965
Similarly to the previous member, this is a replacement of
966
thd->first_successful_insert_id_in_prev_stmt, which is used
967
to implement LAST_INSERT_ID().
969
uint64_t m_last_insert_id;
970
/** The total number of warnings. */
971
uint m_total_warn_count;
972
enum_diagnostics_status m_status;
974
@todo: the following THD members belong here:
975
- warn_list, warn_count,
981
Storage engine specific thread local data.
987
Storage engine specific thread local data.
988
Lifetime: one user connection.
992
0: Life time: one statement within a transaction. If @@autocommit is
993
on, also represents the entire transaction.
994
@sa trans_register_ha()
996
1: Life time: one transaction within a connection.
997
If the storage engine does not participate in a transaction,
998
this should not be used.
999
@sa trans_register_ha()
1001
Ha_trx_info ha_info[2];
1003
Ha_data() :ha_ptr(NULL) {}
1009
For each client connection we create a separate thread with THD serving as
1010
a thread/connection descriptor
1013
class THD :public Statement,
1014
public Open_tables_state
298
util::string::const_shared_ptr schema() const
303
return util::string::const_shared_ptr(new std::string(""));
306
/* current cache key */
307
std::string query_cache_key;
309
Constant for Session::where initialization in the beginning of every query.
311
It's needed because we do not save/restore Session::where normally during
1017
/* Used to execute base64 coded binlog events in MySQL server */
1018
Relay_log_info* rli_fake;
1021
Constant for THD::where initialization in the beginning of every query.
1023
It's needed because we do not save/restore THD::where normally during
312
1024
primary (non subselect) query execution.
314
1026
static const char * const DEFAULT_WHERE;
316
memory::Root warn_root; /**< Allocation area for warnings and errors */
318
plugin::Client *client; /**< Pointer to client object */
322
void setClient(plugin::Client *client_arg);
324
plugin::Client *getClient()
329
plugin::Client *getClient() const
334
plugin::Scheduler *scheduler; /**< Pointer to scheduler object */
335
void *scheduler_arg; /**< Pointer to the optional scheduler argument */
337
typedef boost::unordered_map< std::string, user_var_entry *, util::insensitive_hash, util::insensitive_equal_to> UserVars;
340
typedef std::pair< UserVars::iterator, UserVars::iterator > UserVarsRange;
341
UserVars user_vars; /**< Hash of user variables defined during the session's lifetime */
344
const UserVars &getUserVariables() const
349
drizzle_system_variables variables; /**< Mutable local variables local to the session */
351
enum_tx_isolation getTxIsolation()
353
return (enum_tx_isolation)variables.tx_isolation;
356
struct system_status_var status_var; /**< Session-local status counters */
357
THR_LOCK_INFO lock_info; /**< Locking information for this session */
358
THR_LOCK_OWNER main_lock_id; /**< To use for conventional queries */
359
THR_LOCK_OWNER *lock_id; /**< If not main_lock_id, points to the lock_id of a cursor. */
362
* A pointer to the stack frame of the scheduler thread
363
* which is called first in the thread for handling a client
368
identifier::User::shared_ptr security_ctx;
370
int32_t scoreboard_index;
372
inline void checkSentry() const
374
assert(this->dbug_sentry == Session_SENTRY_MAGIC);
378
identifier::User::const_shared_ptr user() const
383
return identifier::User::const_shared_ptr();
386
void setUser(identifier::User::shared_ptr arg)
391
int32_t getScoreboardIndex()
393
return scoreboard_index;
396
void setScoreboardIndex(int32_t in_scoreboard_index)
398
scoreboard_index= in_scoreboard_index;
402
* Is this session viewable by the current user?
404
bool isViewable(identifier::User::const_reference) const;
1028
NET net; // client connection descriptor
1029
MEM_ROOT warn_root; // For warnings and errors
1030
Protocol *protocol; // Current protocol
1031
Protocol_text protocol_text; // Normal protocol
1032
HASH user_vars; // hash for user variables
1033
String packet; // dynamic buffer for network I/O
1034
String convert_buffer; // buffer for charset conversions
1035
struct rand_struct rand; // used for authentication
1036
struct system_variables variables; // Changeable local variables
1037
struct system_status_var status_var; // Per thread statistic vars
1038
struct system_status_var *initial_status_var; /* used by show status */
1039
THR_LOCK_INFO lock_info; // Locking info of this thread
1040
THR_LOCK_OWNER main_lock_id; // To use for conventional queries
1041
THR_LOCK_OWNER *lock_id; // If not main_lock_id, points to
1042
// the lock_id of a cursor.
1043
pthread_mutex_t LOCK_delete; // Locked before thd is deleted
1045
A pointer to the stack frame of handle_one_connection(),
1046
which is called first in the thread for handling a client
1051
Currently selected catalog.
1057
Some members of THD (currently 'Statement::db',
1058
'catalog' and 'query') are set and alloced by the slave SQL thread
1059
(for the THD of that thread); that thread is (and must remain, for now)
1060
the only responsible for freeing these 3 members. If you add members
1061
here, and you add code to set them in replication, don't forget to
1062
free_them_and_set_them_to_0 in replication properly. For details see
1063
the 'err:' label of the handle_slave_sql() in sql/slave.cc.
1065
@see handle_slave_sql
1068
Security_context main_security_ctx;
1069
Security_context *security_ctx;
1072
Points to info-string that we show in SHOW PROCESSLIST
1073
You are supposed to call THD_SET_PROC_INFO only if you have coded
1074
a time-consuming piece that MySQL can get stuck in for a long time.
1076
Set it using the thd_proc_info(THD *thread, const char *message)
1079
#define THD_SET_PROC_INFO(thd, info) \
1080
(thd)->proc_info= (info)
1082
inline const char* get_proc_info() { return proc_info;}
1084
/* left public for the the storage engines, please avoid direct use */
1085
const char *proc_info;
408
1088
Used in error messages to tell user in what part of MySQL we found an
409
1089
error. E. g. when where= "having clause", if fix_fields() fails, user
410
1090
will know that the error was in having clause.
420
void setWhere(const char *arg)
1094
double tmp_double_value; /* Used in set_var.cc */
1095
ulong client_capabilities; /* What the client supports */
1096
ulong max_client_packet_length;
1098
HASH handler_tables_hash;
426
1100
One thread can hold up to one named user-level lock. This variable
427
1101
points to a lock object if the lock is present. See item_func.cc and
428
chapter 'Miscellaneous functions', for functions GET_LOCK, RELEASE_LOCK.
430
uint32_t dbug_sentry; /**< watch for memory corruption */
433
boost::thread::id boost_thread_id;
434
boost_thread_shared_ptr _thread;
435
boost::this_thread::disable_interruption *interrupt;
437
internal::st_my_thread_var *mysys_var;
440
boost_thread_shared_ptr &getThread()
445
void pushInterrupt(boost::this_thread::disable_interruption *interrupt_arg)
447
interrupt= interrupt_arg;
450
boost::this_thread::disable_interruption &getThreadInterupt()
456
internal::st_my_thread_var *getThreadVar()
462
* Type of current query: COM_STMT_PREPARE, COM_QUERY, etc. Set from
463
* first byte of the packet in executeStatement()
1102
chapter 'Miscellaneous functions', for functions GET_LOCK, RELEASE_LOCK.
1104
uint dbug_sentry; // watch out for memory corruption
1105
struct st_my_thread_var *mysys_var;
1107
Type of current query: COM_STMT_PREPARE, COM_QUERY, etc. Set from
1108
first byte of the packet in do_command()
465
1110
enum enum_server_command command;
466
uint32_t file_id; /**< File ID for LOAD DATA INFILE */
467
/* @note the following three members should likely move to Client */
468
uint32_t max_client_packet_length; /**< Maximum number of bytes a client can send in a single packet */
471
boost::posix_time::ptime _epoch;
472
boost::posix_time::ptime _connect_time;
473
boost::posix_time::ptime _start_timer;
474
boost::posix_time::ptime _end_timer;
476
boost::posix_time::ptime _user_time;
478
uint64_t utime_after_lock; // This used by Innodb.
482
_user_time= boost::posix_time::not_a_date_time;
485
const boost::posix_time::ptime &start_timer() const
490
void getTimeDifference(boost::posix_time::time_duration &result_arg, const boost::posix_time::ptime &arg) const
492
result_arg= arg - _start_timer;
1112
uint32 file_id; // for LOAD DATA INFILE
1113
/* remote (peer) port */
1115
time_t start_time, user_time;
1116
uint64_t connect_utime, thr_create_utime; // track down slow pthread_create
1117
uint64_t start_utime, utime_after_lock;
495
1119
thr_lock_type update_lock_default;
498
Both of the following container points in session will be converted to an API.
1121
/* <> 0 if we are inside of trigger or stored function. */
502
1124
/* container for handler's private per-connection data */
503
std::vector<Ha_data> ha_data;
505
Id of current query. Statement can be reused to execute several queries
506
query_id is global in context of the whole MySQL server.
507
ID is automatically generated from an atomic counter.
508
It's used in Cursor code for various purposes: to check which columns
509
from table are necessary for this select, to check if it's necessary to
510
update auto-updatable fields (like auto_increment and timestamp).
513
query_id_t warn_query_id;
516
void **getEngineData(const plugin::MonitoredInTransaction *monitored);
517
ResourceContext *getResourceContext(const plugin::MonitoredInTransaction *monitored,
520
session::Transactions transaction;
1125
Ha_data ha_data[MAX_HA];
1127
/* Place to store various things */
1129
#ifndef MYSQL_CLIENT
1130
int binlog_setup_trx_data();
1133
Public interface to write RBR events to the binlog
1135
void binlog_start_trans_and_stmt();
1136
void binlog_set_stmt_begin();
1137
int binlog_write_table_map(TABLE *table, bool is_transactional);
1138
int binlog_write_row(TABLE* table, bool is_transactional,
1139
const uchar *new_data);
1140
int binlog_delete_row(TABLE* table, bool is_transactional,
1141
const uchar *old_data);
1142
int binlog_update_row(TABLE* table, bool is_transactional,
1143
const uchar *old_data, const uchar *new_data);
1145
void set_server_id(uint32 sid) { server_id = sid; }
1148
Member functions to handle pending event for row-level logging.
1150
template <class RowsEventT> Rows_log_event*
1151
binlog_prepare_pending_rows_event(TABLE* table, uint32 serv_id,
1153
bool is_transactional,
1155
Rows_log_event* binlog_get_pending_rows_event() const;
1156
void binlog_set_pending_rows_event(Rows_log_event* ev);
1157
int binlog_flush_pending_rows_event(bool stmt_end);
1160
uint binlog_table_maps; // Number of table maps currently in the binlog
1162
enum enum_binlog_flag {
1163
BINLOG_FLAG_UNSAFE_STMT_PRINTED,
1168
Flags with per-thread information regarding the status of the
1171
uint32 binlog_flags;
1173
uint get_binlog_table_maps() const {
1174
return binlog_table_maps;
1176
void clear_binlog_table_maps() {
1177
binlog_table_maps= 0;
1179
#endif /* MYSQL_CLIENT */
1183
struct st_transactions {
1184
SAVEPOINT *savepoints;
1185
THD_TRANS all; // Trans since BEGIN WORK
1186
THD_TRANS stmt; // Trans for current statement
1187
bool on; // see ha_enable_transaction()
1188
XID_STATE xid_state;
1189
Rows_log_event *m_pending_rows_event;
1192
Tables changed in transaction (that must be invalidated in query cache).
1193
List contain only transactional tables, that not invalidated in query
1194
cache (instead of full list of changed in transaction tables).
1196
CHANGED_TABLE_LIST* changed_tables;
1197
MEM_ROOT mem_root; // Transaction-life memory allocation pool
1202
free_root(&mem_root,MYF(MY_KEEP_PREALLOC));
1206
bzero((char*)this, sizeof(*this));
1207
xid_state.xid.null();
1208
init_sql_alloc(&mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
523
1212
sigset_t signals;
525
// As of right now we do not allow a concurrent execute to launch itself
527
bool concurrent_execute_allowed;
531
void setConcurrentExecute(bool arg)
533
concurrent_execute_allowed= arg;
536
bool isConcurrentExecuteAllowed() const
538
return concurrent_execute_allowed;
1213
#ifdef SIGNAL_WITH_VIO_CLOSE
1217
This is to track items changed during execution of a prepared
1218
statement/stored procedure. It's created by
1219
register_item_tree_change() in memory root of THD, and freed in
1220
rollback_item_tree_changes(). For conventional execution it's always
1223
Item_change_list change_list;
1226
A permanent memory area of the statement. For conventional
1227
execution, the parsed tree and execution runtime reside in the same
1228
memory root. In this case stmt_arena points to THD. In case of
1229
a prepared statement or a stored procedure statement, thd->mem_root
1230
conventionally points to runtime memory, and thd->stmt_arena
1231
points to the memory of the PS/SP, where the parsed tree of the
1232
statement resides. Whenever you need to perform a permanent
1233
transformation of a parsed tree, you should allocate new memory in
1234
stmt_arena, to allow correct re-execution of PS/SP.
1235
Note: in the parser, stmt_arena == thd, even for PS/SP.
1237
Query_arena *stmt_arena;
541
1238
/* Tells if LAST_INSERT_ID(#) was called for the current statement */
542
1239
bool arg_of_last_insert_id_function;
545
1241
ALL OVER THIS FILE, "insert_id" means "*automatically generated* value for
546
1242
insertion into an auto_increment column".
549
1245
This is the first autogenerated insert id which was *successfully*
550
1246
inserted by the previous statement (exactly, if the previous statement
551
1247
didn't successfully insert an autogenerated insert id, then it's the one
588
1304
in the binlog is still needed; the list's minimum will contain 3.
590
1306
Discrete_intervals_list auto_inc_intervals_in_cur_stmt_for_binlog;
591
/** Used by replication and SET INSERT_ID */
1307
/* Used by replication and SET INSERT_ID */
592
1308
Discrete_intervals_list auto_inc_intervals_forced;
594
uint64_t limit_found_rows;
595
uint64_t options; /**< Bitmap of options */
596
int64_t row_count_func; /**< For the ROW_COUNT() function */
598
int64_t rowCount() const
600
return row_count_func;
603
ha_rows cuted_fields; /**< Count of "cut" or truncated fields. @todo Kill this friggin thing. */
606
* Number of rows we actually sent to the client, including "synthetic"
607
* rows in ROLLUP etc.
609
ha_rows sent_row_count;
612
* Number of rows we read, sent or not, including in create_sort_index()
614
ha_rows examined_row_count;
617
* The set of those tables whose fields are referenced in all subqueries
622
* Possibly this it is incorrect to have used tables in Session because
623
* with more than one subquery, it is not clear what does the field mean.
625
table_map used_tables;
630
This, and some other variables like 'count_cuted_fields'
631
maybe should be statement/cursor local, that is, moved to Statement
632
class. With current implementation warnings produced in each prepared
633
statement/cursor settle here.
635
List<DRIZZLE_ERROR> warn_list;
636
uint32_t warn_count[(uint32_t) DRIZZLE_ERROR::WARN_LEVEL_END];
637
uint32_t total_warn_count;
638
Diagnostics_area main_da;
642
/* Statement id is thread-wide. This counter is used to generate ids */
643
uint32_t statement_id_counter;
644
uint32_t rand_saved_seed1;
645
uint32_t rand_saved_seed2;
647
Row counter, mainly for errors and warnings. Not increased in
648
create_sort_index(); may differ from examined_row_count.
652
uint32_t getRowCount() const
657
session_id_t thread_id;
659
enum global_read_lock_t
662
GOT_GLOBAL_READ_LOCK= 1,
663
MADE_GLOBAL_READ_LOCK_BLOCK_COMMIT= 2
666
global_read_lock_t _global_read_lock;
670
global_read_lock_t isGlobalReadLock() const
672
return _global_read_lock;
675
void setGlobalReadLock(global_read_lock_t arg)
677
_global_read_lock= arg;
680
DrizzleLock *lockTables(Table **tables, uint32_t count, uint32_t flags);
681
bool lockGlobalReadLock();
682
bool lock_table_names(TableList *table_list);
683
bool lock_table_names_exclusively(TableList *table_list);
684
bool makeGlobalReadLockBlockCommit();
685
bool abortLockForThread(Table *table);
686
bool wait_if_global_read_lock(bool abort_on_refresh, bool is_not_commit);
687
int lock_table_name(TableList *table_list);
688
void abortLock(Table *table);
689
void removeLock(Table *table);
690
void unlockReadTables(DrizzleLock *sql_lock);
691
void unlockSomeTables(Table **table, uint32_t count);
692
void unlockTables(DrizzleLock *sql_lock);
693
void startWaitingGlobalReadLock();
694
void unlockGlobalReadLock();
697
int unlock_external(Table **table, uint32_t count);
698
int lock_external(Table **tables, uint32_t count);
699
bool wait_for_locked_table_names(TableList *table_list);
700
DrizzleLock *get_lock_data(Table **table_ptr, uint32_t count,
701
bool should_lock, Table **write_lock_used);
704
uint32_t server_status;
705
uint32_t open_options;
706
uint32_t select_number; /**< number of select (used for EXPLAIN) */
707
/* variables.transaction_isolation is reset to this after each commit */
708
enum_tx_isolation session_tx_isolation;
709
enum_check_fields count_cuted_fields;
717
KILLED_NO_VALUE /* means none of the above states apply */
720
killed_state_t volatile _killed;
724
void setKilled(killed_state_t arg)
729
killed_state_t getKilled()
734
volatile killed_state_t *getKilledPtr() // Do not use this method, it is here for historical convience.
739
bool is_admin_connection;
740
bool some_tables_deleted;
744
Set to true if execution of the current compound statement
745
can not continue. In particular, disables activation of
746
CONTINUE or EXIT handlers of stored routines.
747
Reset in the end of processing of the current user request, in
748
@see reset_session_for_next_command().
752
Set by a storage engine to request the entire
753
transaction (that possibly spans multiple engines) to
754
rollback. Reset in ha_rollback.
756
bool transaction_rollback_request;
758
true if we are in a sub-statement and the current error can
759
not be safely recovered until we left the sub-statement mode.
760
In particular, disables activation of CONTINUE and EXIT
761
handlers inside sub-statements. E.g. if it is a deadlock
762
error and requires a transaction-wide rollback, this flag is
763
raised (traditionally, MySQL first has to close all the reads
764
via @see handler::ha_index_or_rnd_end() and only then perform
766
Reset to false when we leave the sub-statement mode.
768
bool is_fatal_sub_stmt_error;
769
/** for IS NULL => = last_insert_id() fix in remove_eq_conds() */
770
bool substitute_null_with_insert_id;
774
bool abort_on_warning;
775
bool tablespace_op; /**< This is true in DISCARD/IMPORT TABLESPACE */
778
bool got_warning; /**< Set on call to push_warning() */
779
bool no_warnings_for_error; /**< no warnings on call to my_error() */
780
/** set during loop of derived table processing */
781
bool derived_tables_processing;
783
bool doing_tablespace_operation(void)
785
return tablespace_op;
788
void setDoingTablespaceOperation(bool doing)
790
tablespace_op= doing;
794
/** Used by the sys_var class to store temporary values */
798
uint32_t uint32_t_value;
799
int32_t int32_t_value;
800
uint64_t uint64_t_value;
804
Character input stream consumed by the lexical analyser,
806
Note that since the parser is not re-entrant, we keep only one input
807
stream here. This member is valid only when executing code during parsing,
808
and may point to invalid memory after that.
810
Lex_input_stream *m_lip;
812
/** Place to store various things */
813
void *session_marker;
815
/** Keeps a copy of the previous table around in case we are just slamming on particular table */
819
Points to info-string that we show in SHOW PROCESSLIST
820
You are supposed to call Session_SET_PROC_INFO only if you have coded
821
a time-consuming piece that MySQL can get stuck in for a long time.
823
Set it using the session_proc_info(Session *thread, const char *message)
826
inline void set_proc_info(const char *info)
830
inline const char* get_proc_info() const
835
/** Sets this Session's current query ID */
836
inline void setQueryId(query_id_t in_query_id)
838
query_id= in_query_id;
841
/** Returns the current query ID */
842
query_id_t getQueryId() const
848
/** Sets this Session's warning query ID */
849
inline void setWarningQueryId(query_id_t in_query_id)
851
warn_query_id= in_query_id;
854
/** Returns the Session's warning query ID */
855
inline query_id_t getWarningQueryId() const
857
return warn_query_id;
860
/** Accessor method returning the session's ID. */
861
inline session_id_t getSessionId() const
866
/** Accessor method returning the server's ID. */
867
inline uint32_t getServerId() const
869
/* We return the global server ID. */
873
/** Returns the current transaction ID for the session's current statement */
874
inline my_xid getTransactionId()
876
return transaction.xid_state.xid.quick_get_my_xid();
879
1310
There is BUG#19630 where statement-based replication of stored
880
1311
functions/triggers with two auto_increment columns breaks.
881
1312
We however ensure that it works when there is 0 or 1 auto_increment
931
1369
auto_inc_intervals_forced.append(next_id, UINT64_MAX, 0);
934
Session(plugin::Client *client_arg, catalog::Instance::shared_ptr catalog);
1372
uint64_t limit_found_rows;
1373
uint64_t options; /* Bitmap of states */
1374
int64_t row_count_func; /* For the ROW_COUNT() function */
1375
ha_rows cuted_fields;
1378
number of rows we actually sent to the client, including "synthetic"
1381
ha_rows sent_row_count;
1384
number of rows we read, sent or not, including in create_sort_index()
1386
ha_rows examined_row_count;
1389
The set of those tables whose fields are referenced in all subqueries
1391
TODO: possibly this it is incorrect to have used tables in THD because
1392
with more than one subquery, it is not clear what does the field mean.
1394
table_map used_tables;
1395
USER_CONN *user_connect;
1396
CHARSET_INFO *db_charset;
1398
FIXME: this, and some other variables like 'count_cuted_fields'
1399
maybe should be statement/cursor local, that is, moved to Statement
1400
class. With current implementation warnings produced in each prepared
1401
statement/cursor settle here.
1403
List <MYSQL_ERROR> warn_list;
1404
uint warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_END];
1405
uint total_warn_count;
1406
Diagnostics_area main_da;
1409
Id of current query. Statement can be reused to execute several queries
1410
query_id is global in context of the whole MySQL server.
1411
ID is automatically generated from mutex-protected counter.
1412
It's used in handler code for various purposes: to check which columns
1413
from table are necessary for this select, to check if it's necessary to
1414
update auto-updatable fields (like auto_increment and timestamp).
1416
query_id_t query_id, warn_id;
1419
#ifdef ERROR_INJECT_SUPPORT
1420
ulong error_inject_value;
1422
/* Statement id is thread-wide. This counter is used to generate ids */
1423
ulong statement_id_counter;
1424
ulong rand_saved_seed1, rand_saved_seed2;
1426
Row counter, mainly for errors and warnings. Not increased in
1427
create_sort_index(); may differ from examined_row_count.
1430
pthread_t real_id; /* For debugging */
1431
my_thread_id thread_id;
1432
uint tmp_table, global_read_lock;
1433
uint server_status,open_options;
1434
enum enum_thread_type system_thread;
1435
uint select_number; //number of select (used for EXPLAIN)
1436
/* variables.transaction_isolation is reset to this after each commit */
1437
enum_tx_isolation session_tx_isolation;
1438
enum_check_fields count_cuted_fields;
1440
DYNAMIC_ARRAY user_var_events; /* For user variables replication */
1441
MEM_ROOT *user_var_events_alloc; /* Allocate above array elements here */
1447
KILL_CONNECTION=ER_SERVER_SHUTDOWN,
1448
KILL_QUERY=ER_QUERY_INTERRUPTED,
1449
KILLED_NO_VALUE /* means neither of the states */
1451
killed_state volatile killed;
1453
/* scramble - random string sent to client on handshake */
1454
char scramble[SCRAMBLE_LENGTH+1];
1456
bool slave_thread, one_shot_set;
1457
/* tells if current statement should binlog row-based(1) or stmt-based(0) */
1458
bool current_stmt_binlog_row_based;
1459
bool some_tables_deleted;
1460
bool last_cuted_field;
1461
bool no_errors, password;
1463
Set to true if execution of the current compound statement
1464
can not continue. In particular, disables activation of
1465
CONTINUE or EXIT handlers of stored routines.
1466
Reset in the end of processing of the current user request, in
1467
@see mysql_reset_thd_for_next_command().
1469
bool is_fatal_error;
1471
Set by a storage engine to request the entire
1472
transaction (that possibly spans multiple engines) to
1473
rollback. Reset in ha_rollback.
1475
bool transaction_rollback_request;
1477
true if we are in a sub-statement and the current error can
1478
not be safely recovered until we left the sub-statement mode.
1479
In particular, disables activation of CONTINUE and EXIT
1480
handlers inside sub-statements. E.g. if it is a deadlock
1481
error and requires a transaction-wide rollback, this flag is
1482
raised (traditionally, MySQL first has to close all the reads
1483
via @see handler::ha_index_or_rnd_end() and only then perform
1485
Reset to false when we leave the sub-statement mode.
1487
bool is_fatal_sub_stmt_error;
1488
bool query_start_used, rand_used, time_zone_used;
1489
/* for IS NULL => = last_insert_id() fix in remove_eq_conds() */
1490
bool substitute_null_with_insert_id;
1491
bool in_lock_tables;
1493
True if a slave error. Causes the slave to stop. Not the same
1494
as the statement execution error (is_error()), since
1495
a statement may be expected to return an error, e.g. because
1496
it returned an error on master, and this is OK on the slave.
1498
bool is_slave_error;
1499
bool bootstrap, cleanup_done;
1501
/** is set if some thread specific value(s) used in a statement. */
1502
bool thread_specific_used;
1503
bool charset_is_system_charset, charset_is_collation_connection;
1504
bool charset_is_character_set_filesystem;
1505
bool enable_slow_log; /* enable slow log for current statement */
1506
bool abort_on_warning;
1507
bool got_warning; /* Set on call to push_warning() */
1508
bool no_warnings_for_error; /* no warnings on call to my_error() */
1509
/* set during loop of derived table processing */
1510
bool derived_tables_processing;
1511
bool tablespace_op; /* This is true in DISCARD/IMPORT TABLESPACE */
1514
If we do a purge of binary logs, log index info of the threads
1515
that are currently reading it needs to be adjusted. To do that
1516
each thread that is using LOG_INFO needs to adjust the pointer to it
1518
LOG_INFO* current_linfo;
1519
NET* slave_net; // network connection from slave -> m.
1520
/* Used by the sys_var class to store temporary values */
1523
my_bool my_bool_value;
1526
uint64_t uint64_t_value;
1531
If true, mysql_bin_log::write(Log_event) call will not write events to
1532
binlog, and maintain 2 below variables instead (use
1533
mysql_bin_log.start_union_events to turn this on)
1537
If true, at least one mysql_bin_log::write(Log_event) call has been
1538
made after last mysql_bin_log.start_union_events() call.
1540
bool unioned_events;
1542
If true, at least one mysql_bin_log::write(Log_event e), where
1543
e.cache_stmt == true call has been made after last
1544
mysql_bin_log.start_union_events() call.
1546
bool unioned_events_trans;
1549
'queries' (actually SP statements) that run under inside this binlog
1550
union have thd->query_id >= first_query_id.
1552
query_id_t first_query_id;
1556
Character input stream consumed by the lexical analyser,
1557
used during parsing.
1558
Note that since the parser is not re-entrant, we keep only one input
1559
stream here. This member is valid only when executing code during parsing,
1560
and may point to invalid memory after that.
1562
Lex_input_stream *m_lip;
1565
@todo The following is a work around for online backup and the DDL blocker.
1566
It should be removed when the generalized solution is in place.
1567
This is needed to ensure the restore (which uses DDL) is not blocked
1568
when the DDL blocker is engaged.
1570
my_bool DDL_exception; // Allow some DDL if there is an exception
1577
Initialize memory roots necessary for query processing and (!)
1578
pre-allocate memory for it. We can't do that in THD constructor because
1579
there are use cases (acl_init, watcher threads,
1580
killing mysqld) where it's vital to not allocate excessive and not used
1581
memory. Note, that we still don't return error from init_for_queries():
1582
if preallocation fails, we should notice that at the first call to
1585
void init_for_queries();
1586
void change_user(void);
937
1587
void cleanup(void);
939
* Cleans up after query.
943
* This function is used to reset thread data to its default state.
945
* This function is not suitable for setting thread data to some
946
* non-default values, as there is only one replication thread, so
947
* different master threads may overwrite data of each other on
950
1588
void cleanup_after_query();
952
void awake(Session::killed_state_t state_to_set);
954
* Pulls thread-specific variables into Session state.
956
* Returns true most times, or false if there was a problem
957
* allocating resources for thread-specific storage.
959
* @TODO Kill this. It's not necessary once my_thr_init() is bye bye.
965
Initialize memory roots necessary for query processing and (!)
966
pre-allocate memory for it. We can't do that in Session constructor because
967
there are use cases where it's vital to not allocate excessive and not used
970
void prepareForQueries();
973
* Executes a single statement received from the
976
* Returns true if the statement was successful, or false
981
* For profiling to work, it must never be called recursively.
983
* In MySQL, this used to be the do_command() C function whic
984
* accepted a single parameter of the THD pointer.
986
bool executeStatement();
989
* Reads a query from packet and stores it.
991
* Returns true if query is read and allocated successfully,
992
* false otherwise. On a return of false, Session::fatal_error
995
* @note Used in COM_QUERY and COM_STMT_PREPARE.
997
* Sets the following Session variables:
1001
* @param The packet pointer to read from
1002
* @param The length of the query to read
1004
bool readAndStoreQuery(const char *in_packet, uint32_t in_packet_length);
1007
* Ends the current transaction and (maybe) begins the next.
1009
* Returns true if the transaction completed successfully,
1012
* @param Completion type
1014
bool endTransaction(enum enum_mysql_completiontype completion);
1015
bool endActiveTransaction();
1016
bool startTransaction(start_transaction_option_t opt= START_TRANS_NO_OPTIONS);
1017
void markTransactionForRollback(bool all);
1020
* Authenticates users, with error reporting.
1022
* Returns true on success, or false on failure.
1024
bool authenticate();
1029
* This will initialize the session and begin the command loop.
1034
* Schedule a session to be run on the default scheduler.
1036
static bool schedule(Session::shared_ptr&);
1038
static void unlink(session_id_t &session_id);
1039
static void unlink(Session::shared_ptr&);
1589
bool store_globals();
1590
#ifdef SIGNAL_WITH_VIO_CLOSE
1591
inline void set_active_vio(Vio* vio)
1593
pthread_mutex_lock(&LOCK_delete);
1595
pthread_mutex_unlock(&LOCK_delete);
1597
inline void clear_active_vio()
1599
pthread_mutex_lock(&LOCK_delete);
1601
pthread_mutex_unlock(&LOCK_delete);
1603
void close_active_vio();
1605
void awake(THD::killed_state state_to_set);
1607
#ifndef MYSQL_CLIENT
1608
enum enum_binlog_query_type {
1610
The query can be logged row-based or statement-based
1615
The query has to be logged statement-based
1620
The query represents a change to a table in the "mysql"
1621
database and is currently mapped to ROW_QUERY_TYPE.
1627
int binlog_query(enum_binlog_query_type qtype,
1628
char const *query, ulong query_len,
1629
bool is_trans, bool suppress_use,
1630
THD::killed_state killed_err_arg= THD::KILLED_NO_VALUE);
1042
1634
For enter_cond() / exit_cond() to work the mutex must be got before
1043
1635
enter_cond(); this mutex is then released by exit_cond().
1044
1636
Usage must be: lock mutex; enter_cond(); your code; exit_cond().
1046
const char* enter_cond(boost::condition_variable_any &cond, boost::mutex &mutex, const char* msg);
1047
void exit_cond(const char* old_msg);
1049
type::Time::epoch_t query_start()
1051
return getCurrentTimestampEpoch();
1056
_end_timer= _start_timer= boost::posix_time::microsec_clock::universal_time();
1057
utime_after_lock= (_start_timer - _epoch).total_microseconds();
1060
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
1062
_user_time= boost::posix_time::from_time_t(t);
1065
void set_time_after_lock()
1067
boost::posix_time::ptime mytime(boost::posix_time::microsec_clock::universal_time());
1068
utime_after_lock= (mytime - _epoch).total_microseconds();
1071
void set_end_timer()
1073
_end_timer= boost::posix_time::microsec_clock::universal_time();
1074
status_var.execution_time_nsec+=(_end_timer - _start_timer).total_microseconds();
1077
uint64_t getElapsedTime() const
1079
return (_end_timer - _start_timer).total_microseconds();
1083
* Returns the current micro-timestamp
1085
type::Time::epoch_t getCurrentTimestamp(bool actual= true) const
1087
type::Time::epoch_t t_mark;
1638
inline const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex,
1641
const char* old_msg = get_proc_info();
1642
safe_mutex_assert_owner(mutex);
1643
mysys_var->current_mutex = mutex;
1644
mysys_var->current_cond = cond;
1645
thd_proc_info(this, msg);
1648
inline void exit_cond(const char* old_msg)
1651
Putting the mutex unlock in exit_cond() ensures that
1652
mysys_var->current_mutex is always unlocked _before_ mysys_var->mutex is
1653
locked (if that would not be the case, you'll get a deadlock if someone
1654
does a THD::awake() on you).
1656
pthread_mutex_unlock(mysys_var->current_mutex);
1657
pthread_mutex_lock(&mysys_var->mutex);
1658
mysys_var->current_mutex = 0;
1659
mysys_var->current_cond = 0;
1660
thd_proc_info(this, old_msg);
1661
pthread_mutex_unlock(&mysys_var->mutex);
1663
inline time_t query_start() { query_start_used=1; return start_time; }
1664
inline void set_time()
1091
boost::posix_time::ptime mytime(boost::posix_time::microsec_clock::universal_time());
1092
t_mark= (mytime - _epoch).total_microseconds();
1668
start_time= user_time;
1669
start_utime= utime_after_lock= my_micro_time();
1096
t_mark= (_end_timer - _epoch).total_microseconds();
1102
// We may need to set user on this
1103
type::Time::epoch_t getCurrentTimestampEpoch() const
1105
if (not _user_time.is_not_a_date_time())
1106
return (_user_time - _epoch).total_seconds();
1108
return (_start_timer - _epoch).total_seconds();
1111
type::Time::epoch_t getCurrentTimestampEpoch(type::Time::usec_t &fraction_arg) const
1113
if (not _user_time.is_not_a_date_time())
1116
return (_user_time - _epoch).total_seconds();
1119
fraction_arg= _start_timer.time_of_day().fractional_seconds() % 1000000;
1120
return (_start_timer - _epoch).total_seconds();
1123
uint64_t found_rows(void) const
1672
start_utime= utime_after_lock= my_micro_time_and_time(&start_time);
1674
inline void set_current_time() { start_time= my_time(MY_WME); }
1675
inline void set_time(time_t t)
1677
start_time= user_time= t;
1678
start_utime= utime_after_lock= my_micro_time();
1680
void set_time_after_lock() { utime_after_lock= my_micro_time(); }
1681
uint64_t current_utime() { return my_micro_time(); }
1682
inline uint64_t found_rows(void)
1125
1684
return limit_found_rows;
1128
/** Returns whether the session is currently inside a transaction */
1129
bool inTransaction() const
1686
inline bool active_transaction()
1131
1688
return server_status & SERVER_STATUS_IN_TRANS;
1134
LEX_STRING *make_lex_string(LEX_STRING *lex_str,
1135
const char* str, uint32_t length,
1136
bool allocate_lex_string);
1138
LEX_STRING *make_lex_string(LEX_STRING *lex_str,
1139
const std::string &str,
1140
bool allocate_lex_string);
1690
inline bool fill_derived_tables()
1692
return !lex->only_view_structure();
1694
inline void* trans_alloc(unsigned int size)
1696
return alloc_root(&transaction.mem_root,size);
1699
LEX_STRING *make_lex_string(LEX_STRING *lex_str,
1700
const char* str, uint length,
1701
bool allocate_lex_string);
1703
bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
1704
const char *from, uint from_length,
1705
CHARSET_INFO *from_cs);
1707
bool convert_string(String *s, CHARSET_INFO *from_cs, CHARSET_INFO *to_cs);
1709
void add_changed_table(TABLE *table);
1710
void add_changed_table(const char *key, long key_length);
1711
CHANGED_TABLE_LIST * changed_table_dup(const char *key, long key_length);
1142
1712
int send_explain_fields(select_result *result);
1145
1714
Clear the current error, if any.
1146
1715
We do not clear is_fatal_error or is_fatal_sub_stmt_error since we
1263
1929
@param level the error level
1264
1930
@return true if the error is handled
1266
virtual bool handle_error(drizzled::error_t sql_errno, const char *message,
1267
DRIZZLE_ERROR::enum_warning_level level);
1932
virtual bool handle_error(uint sql_errno, const char *message,
1933
MYSQL_ERROR::enum_warning_level level);
1270
1936
Remove the error handler last pushed.
1272
1938
void pop_internal_handler();
1275
Resets Session part responsible for command processing state.
1277
This needs to be called before execution of every statement
1278
(prepared or conventional).
1279
It is not called by substatements of routines.
1282
Make it a method of Session and align its name with the rest of
1283
reset/end/start/init methods.
1285
Call it after we use Session for queries, not before.
1287
void reset_for_next_command();
1290
* Disconnects the session from a client connection and
1291
* updates any status variables necessary.
1293
* @param errcode Error code to print to console
1295
* @note For the connection that is doing shutdown, this is called twice
1297
void disconnect(enum error_t errcode= EE_OK);
1300
* Check if user exists and the password supplied is correct.
1302
* Returns true on success, and false on failure.
1304
* @note Host, user and passwd may point to communication buffer.
1305
* Current implementation does not depend on that, but future changes
1306
* should be done with this in mind;
1308
* @param passwd Scrambled password received from client
1309
* @param db Database name to connect to, may be NULL
1311
bool checkUser(const std::string &passwd, const std::string &db);
1314
* Returns the timestamp (in microseconds) of when the Session
1315
* connected to the server.
1317
uint64_t getConnectMicroseconds() const
1319
return (_connect_time - _epoch).total_microseconds();
1322
uint64_t getConnectSeconds() const
1324
return (_connect_time - _epoch).total_seconds();
1328
* Returns a pointer to the active Transaction message for this
1329
* Session being managed by the ReplicationServices component, or
1330
* NULL if no active message.
1332
message::Transaction *getTransactionMessage() const
1334
return transaction_message;
1338
* Returns a pointer to the active Statement message for this
1339
* Session, or NULL if no active message.
1341
message::Statement *getStatementMessage() const
1343
return statement_message;
1347
* Returns a pointer to the current Resulset message for this
1348
* Session, or NULL if no active message.
1350
message::Resultset *getResultsetMessage() const
1355
* Sets the active transaction message used by the ReplicationServices
1358
* @param[in] Pointer to the message
1360
void setTransactionMessage(message::Transaction *in_message)
1362
transaction_message= in_message;
1366
* Sets the active statement message used by the ReplicationServices
1369
* @param[in] Pointer to the message
1371
void setStatementMessage(message::Statement *in_message)
1373
statement_message= in_message;
1377
* Sets the active Resultset message used by the Query Cache
1380
* @param[in] Pointer to the message
1382
void setResultsetMessage(message::Resultset *in_message)
1384
resultset= in_message;
1387
* reset the active Resultset message used by the Query Cache
1391
void resetResultsetMessage()
1397
/** Pointers to memory managed by the ReplicationServices component */
1398
message::Transaction *transaction_message;
1399
message::Statement *statement_message;
1400
/* Pointer to the current resultset of Select query */
1401
message::Resultset *resultset;
1402
plugin::EventObserverList *session_event_observers;
1404
/* Schema observers are mapped to databases. */
1405
std::map<std::string, plugin::EventObserverList *> schema_event_observers;
1409
plugin::EventObserverList *getSessionObservers()
1411
return session_event_observers;
1414
void setSessionObservers(plugin::EventObserverList *observers)
1416
session_event_observers= observers;
1419
/* For schema event observers there is one set of observers per database. */
1420
plugin::EventObserverList *getSchemaObservers(const std::string &db_name)
1422
std::map<std::string, plugin::EventObserverList *>::iterator it;
1424
it= schema_event_observers.find(db_name);
1425
if (it == schema_event_observers.end())
1431
void setSchemaObservers(const std::string &db_name, plugin::EventObserverList *observers)
1433
std::map<std::string, plugin::EventObserverList *>::iterator it;
1435
it= schema_event_observers.find(db_name);
1436
if (it != schema_event_observers.end())
1437
schema_event_observers.erase(it);;
1440
schema_event_observers[db_name] = observers;
1445
const char *proc_info;
1447
1941
/** The current internal error handler for this thread, or NULL. */
1448
1942
Internal_error_handler *m_internal_handler;
1461
1955
- for prepared queries, only to allocate runtime data. The parsed
1462
1956
tree itself is reused between executions and thus is stored elsewhere.
1464
memory::Root main_mem_root;
1467
* Marks all tables in the list which were used by current substatement
1468
* as free for reuse.
1470
* @param Head of the list of tables
1474
* The reason we reset query_id is that it's not enough to just test
1475
* if table->query_id != session->query_id to know if a table is in use.
1479
* SELECT f1_that_uses_t1() FROM t1;
1481
* In f1_that_uses_t1() we will see one instance of t1 where query_id is
1482
* set to query_id of original query.
1484
void mark_used_tables_as_free_for_reuse(Table *table);
1488
/** A short cut for session->main_da.set_ok_status(). */
1489
inline void my_ok(ha_rows affected_rows= 0, ha_rows found_rows_arg= 0,
1490
uint64_t passed_id= 0, const char *message= NULL)
1492
main_da.set_ok_status(this, affected_rows, found_rows_arg, passed_id, message);
1496
/** A short cut for session->main_da.set_eof_status(). */
1498
inline void my_eof()
1500
main_da.set_eof_status(this);
1503
/* Some inline functions for more speed */
1505
inline bool add_item_to_list(Item *item)
1507
return lex->current_select->add_item_to_list(this, item);
1510
inline bool add_value_to_list(Item *value)
1512
return lex->value_list.push_back(value);
1515
inline bool add_order_to_list(Item *item, bool asc)
1517
return lex->current_select->add_order_to_list(this, item, asc);
1520
inline bool add_group_to_list(Item *item, bool asc)
1522
return lex->current_select->add_group_to_list(this, item, asc);
1524
void refresh_status();
1525
user_var_entry *getVariable(LEX_STRING &name, bool create_if_not_exists);
1526
user_var_entry *getVariable(const std::string &name, bool create_if_not_exists);
1527
void setVariable(const std::string &name, const std::string &value);
1530
* Closes all tables used by the current substatement, or all tables
1531
* used by this thread if we are on the upper level.
1533
void close_thread_tables();
1534
void close_old_data_files(bool morph_locks= false,
1535
bool send_refresh= false);
1536
void close_open_tables();
1537
void close_data_files_and_morph_locks(const identifier::Table &identifier);
1540
bool free_cached_table(boost::mutex::scoped_lock &scopedLock);
1545
* Prepares statement for reopening of tables and recalculation of set of
1548
* @param Pointer to a pointer to a list of tables which we were trying to open and lock
1550
void close_tables_for_reopen(TableList **tables);
1554
* Open all tables in list, locks them (all, including derived)
1556
* @param Pointer to a list of tables for open & locking
1565
* The lock will automaticaly be freed by close_thread_tables()
1567
bool openTablesLock(TableList *tables);
1569
int open_tables_from_list(TableList **start, uint32_t *counter, uint32_t flags= 0);
1571
Table *openTableLock(TableList *table_list, thr_lock_type lock_type);
1572
Table *openTable(TableList *table_list, bool *refresh, uint32_t flags= 0);
1574
void unlink_open_table(Table *find);
1575
void drop_open_table(Table *table, const identifier::Table &identifier);
1576
void close_cached_table(Table *table);
1578
/* Create a lock in the cache */
1579
table::Placeholder *table_cache_insert_placeholder(const identifier::Table &identifier);
1580
bool lock_table_name_if_not_cached(const identifier::Table &identifier, Table **table);
1583
session::TableMessages _table_message_cache;
1586
session::TableMessages &getMessageCache()
1588
return _table_message_cache;
1591
/* Reopen operations */
1592
bool reopen_tables();
1593
bool close_cached_tables(TableList *tables, bool wait_for_refresh, bool wait_for_placeholders);
1595
void wait_for_condition(boost::mutex &mutex, boost::condition_variable_any &cond);
1596
int setup_conds(TableList *leaves, COND **conds);
1597
int lock_tables(TableList *tables, uint32_t count, bool *need_reopen);
1599
drizzled::util::Storable *getProperty(const std::string &arg)
1601
return life_properties.getProperty(arg);
1605
bool setProperty(const std::string &arg, T *value)
1607
life_properties.setProperty(arg, value);
1613
Return the default storage engine
1615
@param getDefaultStorageEngine()
1618
pointer to plugin::StorageEngine
1620
plugin::StorageEngine *getDefaultStorageEngine()
1622
if (variables.storage_engine)
1623
return variables.storage_engine;
1624
return global_system_variables.storage_engine;
1627
void get_xid(DrizzleXid *xid); // Innodb only
1629
table::Singular *getInstanceTable();
1630
table::Singular *getInstanceTable(List<CreateField> &field_list);
1635
if (getrusage(RUSAGE_THREAD, &usage))
1645
void setUsage(bool arg)
1650
const struct rusage &getUsage()
1655
catalog::Instance::const_reference catalog() const
1657
return *(_catalog.get());
1660
catalog::Instance::reference catalog()
1662
return *(_catalog.get());
1666
catalog::Instance::shared_ptr _catalog;
1668
// This lives throughout the life of Session
1670
session::PropertyMap life_properties;
1671
std::vector<table::Singular *> temporary_shares;
1672
struct rusage usage;
1958
MEM_ROOT main_mem_root;
1962
/** A short cut for thd->main_da.set_ok_status(). */
1965
my_ok(THD *thd, ha_rows affected_rows= 0, uint64_t id= 0,
1966
const char *message= NULL)
1968
thd->main_da.set_ok_status(thd, affected_rows, id, message);
1972
/** A short cut for thd->main_da.set_eof_status(). */
1977
thd->main_da.set_eof_status(thd);
1980
#define tmp_disable_binlog(A) \
1981
{uint64_t tmp_disable_binlog__save_options= (A)->options; \
1982
(A)->options&= ~OPTION_BIN_LOG
1984
#define reenable_binlog(A) (A)->options= tmp_disable_binlog__save_options;}
1988
Used to hold information about file and file structure in exchange
1989
via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
1990
XXX: We never call destructor for objects of this class.
1993
class sql_exchange :public Sql_alloc
1996
enum enum_filetype filetype; /* load XML, Added by Arnold & Erik */
1998
String *field_term,*enclosed,*line_term,*line_start,*escaped;
2003
sql_exchange(char *name, bool dumpfile_flag,
2004
enum_filetype filetype_arg= FILETYPE_CSV);
2007
#include "log_event.h"
2010
This is used to get result from a select
2015
class select_result :public Sql_alloc {
2018
SELECT_LEX_UNIT *unit;
2021
virtual ~select_result() {};
2022
virtual int prepare(List<Item> &list __attribute__((__unused__)),
2028
virtual int prepare2(void) { return 0; }
2030
Because of peculiarities of prepared statements protocol
2031
we need to know number of columns in the result set (if
2032
there is a result set) apart from sending columns metadata.
2034
virtual uint field_count(List<Item> &fields) const
2035
{ return fields.elements; }
2036
virtual bool send_fields(List<Item> &list, uint flags)=0;
2037
virtual bool send_data(List<Item> &items)=0;
2038
virtual bool initialize_tables (JOIN __attribute__((__unused__)) *join=0)
2040
virtual void send_error(uint errcode,const char *err);
2041
virtual bool send_eof()=0;
2043
Check if this query returns a result set and therefore is allowed in
2044
cursors and set an error message if it is not the case.
2046
@retval false success
2047
@retval true error, an error message is set
2049
virtual bool check_simple_select() const;
2050
virtual void abort() {}
2052
Cleanup instance of this class for next execution of a prepared
2053
statement/stored procedure.
2055
virtual void cleanup();
2056
void set_thd(THD *thd_arg) { thd= thd_arg; }
2057
void begin_dataset() {}
2062
Base class for select_result descendands which intercept and
2063
transform result set rows. As the rows are not sent to the client,
2064
sending of result set metadata should be suppressed as well.
2067
class select_result_interceptor: public select_result
2070
select_result_interceptor() {} /* Remove gcc warning */
2071
uint field_count(List<Item> &fields __attribute__((__unused__))) const
2073
bool send_fields(List<Item> &fields __attribute__((__unused__)),
2074
uint flag __attribute__((__unused__))) { return false; }
2078
class select_send :public select_result {
2080
True if we have sent result set metadata to the client.
2081
In this case the client always expects us to end the result
2082
set with an eof or error packet
2084
bool is_result_set_started;
2086
select_send() :is_result_set_started(false) {}
2087
bool send_fields(List<Item> &list, uint flags);
2088
bool send_data(List<Item> &items);
2090
virtual bool check_simple_select() const { return false; }
2092
virtual void cleanup();
2096
class select_to_file :public select_result_interceptor {
2098
sql_exchange *exchange;
2102
char path[FN_REFLEN];
2105
select_to_file(sql_exchange *ex) :exchange(ex), file(-1),row_count(0L)
2108
void send_error(uint errcode,const char *err);
1675
2114
#define ESCAPE_CHARS "ntrb0ZN" // keep synchronous with READ_INFO::unescape
2118
List of all possible characters of a numeric value text representation.
2120
#define NUMERIC_CHARS ".0123456789e+-"
2123
class select_export :public select_to_file {
2124
uint field_term_length;
2125
int field_sep_char,escape_char,line_sep_char;
2126
int field_term_char; // first char of FIELDS TERMINATED BY or MAX_INT
2128
The is_ambiguous_field_sep field is true if a value of the field_sep_char
2129
field is one of the 'n', 't', 'r' etc characters
2130
(see the READ_INFO::unescape method and the ESCAPE_CHARS constant value).
2132
bool is_ambiguous_field_sep;
2134
The is_ambiguous_field_term is true if field_sep_char contains the first
2135
char of the FIELDS TERMINATED BY (ENCLOSED BY is empty), and items can
2136
contain this character.
2138
bool is_ambiguous_field_term;
2140
The is_unsafe_field_sep field is true if a value of the field_sep_char
2141
field is one of the '0'..'9', '+', '-', '.' and 'e' characters
2142
(see the NUMERIC_CHARS constant value).
2144
bool is_unsafe_field_sep;
2145
bool fixed_row_size;
2147
select_export(sql_exchange *ex) :select_to_file(ex) {}
2149
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2150
bool send_data(List<Item> &items);
2154
class select_dump :public select_to_file {
2156
select_dump(sql_exchange *ex) :select_to_file(ex) {}
2157
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2158
bool send_data(List<Item> &items);
2162
class select_insert :public select_result_interceptor {
2164
TABLE_LIST *table_list;
2167
uint64_t autoinc_value_of_last_inserted_row; // autogenerated or not
2169
bool insert_into_view;
2170
select_insert(TABLE_LIST *table_list_par,
2171
TABLE *table_par, List<Item> *fields_par,
2172
List<Item> *update_fields, List<Item> *update_values,
2173
enum_duplicates duplic, bool ignore);
2175
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2176
virtual int prepare2(void);
2177
bool send_data(List<Item> &items);
2178
virtual void store_values(List<Item> &values);
2179
virtual bool can_rollback_data() { return 0; }
2180
void send_error(uint errcode,const char *err);
2183
/* not implemented: select_insert is never re-used in prepared statements */
2188
class select_create: public select_insert {
2190
TABLE_LIST *create_table;
2191
HA_CREATE_INFO *create_info;
2192
TABLE_LIST *select_tables;
2193
Alter_info *alter_info;
2195
/* lock data for tmp table */
2197
/* m_lock or thd->extra_lock */
2198
MYSQL_LOCK **m_plock;
2200
select_create (TABLE_LIST *table_arg,
2201
HA_CREATE_INFO *create_info_par,
2202
Alter_info *alter_info_arg,
2203
List<Item> &select_fields,enum_duplicates duplic, bool ignore,
2204
TABLE_LIST *select_tables_arg)
2205
:select_insert (NULL, NULL, &select_fields, 0, 0, duplic, ignore),
2206
create_table(table_arg),
2207
create_info(create_info_par),
2208
select_tables(select_tables_arg),
2209
alter_info(alter_info_arg),
2212
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2214
void binlog_show_create_table(TABLE **tables, uint count);
2215
void store_values(List<Item> &values);
2216
void send_error(uint errcode,const char *err);
2219
virtual bool can_rollback_data() { return 1; }
2221
// Needed for access from local class MY_HOOKS in prepare(), since thd is proteted.
2222
const THD *get_thd(void) { return thd; }
2223
const HA_CREATE_INFO *get_create_info() { return create_info; };
2224
int prepare2(void) { return 0; }
2230
Param to create temporary tables when doing SELECT:s
2232
This structure is copied using memcpy as a part of JOIN.
2235
class TMP_TABLE_PARAM :public Sql_alloc
2238
/* Prevent use of these (not safe because of lists and copy_field) */
2239
TMP_TABLE_PARAM(const TMP_TABLE_PARAM &);
2240
void operator=(TMP_TABLE_PARAM &);
2243
List<Item> copy_funcs;
2244
List<Item> save_copy_funcs;
2245
Copy_field *copy_field, *copy_field_end;
2246
Copy_field *save_copy_field, *save_copy_field_end;
2248
Item **items_to_copy; /* Fields in tmp table */
2249
MI_COLUMNDEF *recinfo,*start_recinfo;
2251
ha_rows end_write_records;
2252
uint field_count,sum_func_count,func_count;
2253
uint hidden_field_count;
2254
uint group_parts,group_length,group_null_parts;
2256
bool using_indirect_summary_function;
2257
/* If >0 convert all blob fields to varchar(convert_blob_length) */
2258
uint convert_blob_length;
2259
CHARSET_INFO *table_charset;
2262
True if GROUP BY and its aggregate functions are already computed
2263
by a table access method (e.g. by loose index scan). In this case
2264
query execution should not perform aggregation and should treat
2265
aggregate functions as normal functions.
2267
bool precomputed_group_by;
2268
bool force_copy_fields;
2270
If true, create_tmp_field called from create_tmp_table will convert
2271
all BIT fields to 64-bit longs. This is a workaround the limitation
2272
that MEMORY tables cannot index BIT columns.
2274
bool bit_fields_as_long;
2277
:copy_field(0), group_parts(0),
2278
group_length(0), group_null_parts(0), convert_blob_length(0),
2279
schema_table(0), precomputed_group_by(0), force_copy_fields(0),
2280
bit_fields_as_long(0)
2287
inline void cleanup(void)
2289
if (copy_field) /* Fix for Intel compiler */
2291
delete [] copy_field;
2292
save_copy_field= copy_field= 0;
2297
class select_union :public select_result_interceptor
2299
TMP_TABLE_PARAM tmp_table_param;
2303
select_union() :table(0) {}
2304
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2305
bool send_data(List<Item> &items);
2309
bool create_result_table(THD *thd, List<Item> *column_types,
2310
bool is_distinct, uint64_t options,
2311
const char *alias, bool bit_fields_as_long);
2314
/* Base subselect interface class */
2315
class select_subselect :public select_result_interceptor
2318
Item_subselect *item;
2320
select_subselect(Item_subselect *item);
2321
bool send_data(List<Item> &items)=0;
2322
bool send_eof() { return 0; };
2325
/* Single value subselect interface class */
2326
class select_singlerow_subselect :public select_subselect
2329
select_singlerow_subselect(Item_subselect *item_arg)
2330
:select_subselect(item_arg)
2332
bool send_data(List<Item> &items);
2335
/* used in independent ALL/ANY optimisation */
2336
class select_max_min_finder_subselect :public select_subselect
2339
bool (select_max_min_finder_subselect::*op)();
2342
select_max_min_finder_subselect(Item_subselect *item_arg, bool mx)
2343
:select_subselect(item_arg), cache(0), fmax(mx)
2346
bool send_data(List<Item> &items);
2353
/* EXISTS subselect interface class */
2354
class select_exists_subselect :public select_subselect
2357
select_exists_subselect(Item_subselect *item_arg)
2358
:select_subselect(item_arg){}
2359
bool send_data(List<Item> &items);
2362
/* Structs used when sorting */
2364
typedef struct st_sort_field {
2365
Field *field; /* Field to sort */
2366
Item *item; /* Item if not sorting fields */
2367
uint length; /* Length of sort field */
2368
uint suffix_length; /* Length suffix (0-4) */
2369
Item_result result_type; /* Type of item */
2370
bool reverse; /* if descending sort */
2371
bool need_strxnfrm; /* If we have to use strxnfrm() */
2375
typedef struct st_sort_buffer {
2376
uint index; /* 0 or 1 */
2378
uint change_pos; /* If sort-fields changed */
2380
SORT_FIELD *sortorder;
2383
/* Structure for db & table in sql_yacc */
2385
class Table_ident :public Sql_alloc
2390
SELECT_LEX_UNIT *sel;
2391
inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
2393
:table(table_arg), sel((SELECT_LEX_UNIT *)0)
2395
if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
2400
inline Table_ident(LEX_STRING table_arg)
2401
:table(table_arg), sel((SELECT_LEX_UNIT *)0)
2406
This constructor is used only for the case when we create a derived
2407
table. A derived table has no name and doesn't belong to any database.
2408
Later, if there was an alias specified for the table, it will be set
2409
by add_table_to_list.
2411
inline Table_ident(SELECT_LEX_UNIT *s) : sel(s)
2413
/* We must have a table name here as this is used with add_table_to_list */
2414
db.str= empty_c_string; /* a subject to casedn_str */
2416
table.str= internal_table_name;
2419
bool is_derived_table() const { return test(sel); }
2420
inline void change_db(char *db_name)
2422
db.str= db_name; db.length= (uint) strlen(db_name);
2426
// this is needed for user_vars hash
2427
class user_var_entry
2430
user_var_entry() {} /* Remove gcc warning */
2434
query_id_t update_query_id, used_query_id;
2438
double val_real(my_bool *null_value);
2439
int64_t val_int(my_bool *null_value) const;
2440
String *val_str(my_bool *null_value, String *str, uint decimals);
2441
my_decimal *val_decimal(my_bool *null_value, my_decimal *result);
2442
DTCollation collation;
2446
Unique -- class for unique (removing of duplicates).
2447
Puts all values to the TREE. If the tree becomes too big,
2448
it's dumped to the file. User can request sorted values, or
2449
just iterate through them. In the last case tree merging is performed in
2450
memory simultaneously with iteration, so it should be ~2-3x faster.
2453
class Unique :public Sql_alloc
2455
DYNAMIC_ARRAY file_ptrs;
2457
uint64_t max_in_memory_size;
2460
uchar *record_pointers;
2466
Unique(qsort_cmp2 comp_func, void *comp_func_fixed_arg,
2467
uint size_arg, uint64_t max_in_memory_size_arg);
2469
ulong elements_in_tree() { return tree.elements_in_tree; }
2470
inline bool unique_add(void *ptr)
2472
if (tree.elements_in_tree > max_elements && flush())
2474
return(!tree_insert(&tree, ptr, 0, tree.custom_arg));
2477
bool get(TABLE *table);
2478
static double get_use_cost(uint *buffer, uint nkeys, uint key_size,
2479
uint64_t max_in_memory_size);
2480
inline static int get_cost_calc_buff_size(ulong nkeys, uint key_size,
2481
uint64_t max_in_memory_size)
2483
register uint64_t max_elems_in_tree=
2484
(1 + max_in_memory_size / ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size));
2485
return (int) (sizeof(uint)*(1 + nkeys/max_elems_in_tree));
2489
bool walk(tree_walk_action action, void *walk_action_arg);
2491
friend int unique_write_to_file(uchar* key, element_count count, Unique *unique);
2492
friend int unique_write_to_ptrs(uchar* key, element_count count, Unique *unique);
2496
class multi_delete :public select_result_interceptor
2498
TABLE_LIST *delete_tables, *table_being_deleted;
2500
ha_rows deleted, found;
2504
/* True if at least one table we delete from is transactional */
2505
bool transactional_tables;
2506
/* True if at least one table we delete from is not transactional */
2508
bool delete_while_scanning;
2510
error handling (rollback and binlogging) can happen in send_eof()
2511
so that afterward send_error() needs to find out that.
2516
multi_delete(TABLE_LIST *dt, uint num_of_tables);
2518
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2519
bool send_data(List<Item> &items);
2520
bool initialize_tables (JOIN *join);
2521
void send_error(uint errcode,const char *err);
2524
virtual void abort();
2528
class multi_update :public select_result_interceptor
2530
TABLE_LIST *all_tables; /* query/update command tables */
2531
TABLE_LIST *leaves; /* list of leves of join table tree */
2532
TABLE_LIST *update_tables, *table_being_updated;
2533
TABLE **tmp_tables, *main_table, *table_to_update;
2534
TMP_TABLE_PARAM *tmp_table_param;
2535
ha_rows updated, found;
2536
List <Item> *fields, *values;
2537
List <Item> **fields_for_table, **values_for_table;
2540
List of tables referenced in the CHECK OPTION condition of
2541
the updated view excluding the updated table.
2543
List <TABLE> unupdated_check_opt_tables;
2544
Copy_field *copy_field;
2545
enum enum_duplicates handle_duplicates;
2546
bool do_update, trans_safe;
2547
/* True if the update operation has made a change in a transactional table */
2548
bool transactional_tables;
2551
error handling (rollback and binlogging) can happen in send_eof()
2552
so that afterward send_error() needs to find out that.
2557
multi_update(TABLE_LIST *ut, TABLE_LIST *leaves_list,
2558
List<Item> *fields, List<Item> *values,
2559
enum_duplicates handle_duplicates, bool ignore);
2561
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2562
bool send_data(List<Item> &items);
2563
bool initialize_tables (JOIN *join);
2564
void send_error(uint errcode,const char *err);
2567
virtual void abort();
2570
class my_var : public Sql_alloc {
2575
enum_field_types type;
2576
my_var (LEX_STRING& j, bool i, uint o, enum_field_types t)
2577
:s(j), local(i), offset(o), type(t)
2582
class select_dumpvar :public select_result_interceptor {
2585
List<my_var> var_list;
2586
select_dumpvar() { var_list.empty(); row_count= 0;}
2587
~select_dumpvar() {}
2588
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2589
bool send_data(List<Item> &items);
2591
virtual bool check_simple_select() const;
1677
2595
/* Bits in sql_command_flags */
1679
enum sql_command_flag_bits
1681
CF_BIT_CHANGES_DATA,
1682
CF_BIT_HAS_ROW_COUNT,
1683
CF_BIT_STATUS_COMMAND,
1684
CF_BIT_SHOW_TABLE_COMMAND,
1685
CF_BIT_WRITE_LOGS_COMMAND,
1689
static const std::bitset<CF_BIT_SIZE> CF_CHANGES_DATA(1 << CF_BIT_CHANGES_DATA);
1690
static const std::bitset<CF_BIT_SIZE> CF_HAS_ROW_COUNT(1 << CF_BIT_HAS_ROW_COUNT);
1691
static const std::bitset<CF_BIT_SIZE> CF_STATUS_COMMAND(1 << CF_BIT_STATUS_COMMAND);
1692
static const std::bitset<CF_BIT_SIZE> CF_SHOW_TABLE_COMMAND(1 << CF_BIT_SHOW_TABLE_COMMAND);
1693
static const std::bitset<CF_BIT_SIZE> CF_WRITE_LOGS_COMMAND(1 << CF_BIT_WRITE_LOGS_COMMAND);
1696
const std::string &type(drizzled::Session::global_read_lock_t type);
1697
size_t max_string_length(drizzled::Session::global_read_lock_t type);
1699
} /* namespace display */
1701
} /* namespace drizzled */
1703
#endif /* DRIZZLED_SESSION_H */
2597
#define CF_CHANGES_DATA 1
2598
#define CF_HAS_ROW_COUNT 2
2599
#define CF_STATUS_COMMAND 4
2600
#define CF_SHOW_TABLE_COMMAND 8
2601
#define CF_WRITE_LOGS_COMMAND 16
2603
/* Functions in sql_class.cc */
2605
void add_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var);
2607
void add_diff_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var,
2608
STATUS_VAR *dec_var);
2610
#endif /* MYSQL_SERVER */
added
removed
server/sql_class.h
