90
118
/* for VIEW ... WITH CHECK OPTION */
94
class Key_part_spec :public Sql_alloc {
96
LEX_STRING field_name;
98
Key_part_spec(const LEX_STRING &name, uint len)
99
: field_name(name), length(len)
101
Key_part_spec(const char *name, const size_t name_len, uint len)
103
{ field_name.str= (char *)name; field_name.length= name_len; }
104
bool operator==(const Key_part_spec& other) const;
106
Construct a copy of this Key_part_spec. field_name is copied
107
by-pointer as it is known to never change. At the same time
108
'length' may be reset in mysql_prepare_create_table, and this
109
is why we supply it with a copy.
111
@return If out of memory, 0 is returned and an error is set in
114
Key_part_spec *clone(MEM_ROOT *mem_root) const
115
{ return new (mem_root) Key_part_spec(*this); }
119
class Alter_drop :public Sql_alloc {
121
enum drop_type {KEY, COLUMN };
124
Alter_drop(enum drop_type par_type,const char *par_name)
125
:name(par_name), type(par_type) {}
127
Used to make a clone of this object for ALTER/CREATE TABLE
128
@sa comment for Key_part_spec::clone
130
Alter_drop *clone(MEM_ROOT *mem_root) const
131
{ return new (mem_root) Alter_drop(*this); }
135
class Alter_column :public Sql_alloc {
139
Alter_column(const char *par_name,Item *literal)
140
:name(par_name), def(literal) {}
142
Used to make a clone of this object for ALTER/CREATE TABLE
143
@sa comment for Key_part_spec::clone
145
Alter_column *clone(MEM_ROOT *mem_root) const
146
{ return new (mem_root) Alter_column(*this); }
150
class Key :public Sql_alloc {
152
enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FOREIGN_KEY};
154
KEY_CREATE_INFO key_create_info;
155
List<Key_part_spec> columns;
159
Key(enum Keytype type_par, const LEX_STRING &name_arg,
160
KEY_CREATE_INFO *key_info_arg,
161
bool generated_arg, List<Key_part_spec> &cols)
162
:type(type_par), key_create_info(*key_info_arg), columns(cols),
163
name(name_arg), generated(generated_arg)
165
Key(enum Keytype type_par, const char *name_arg, size_t name_len_arg,
166
KEY_CREATE_INFO *key_info_arg, bool generated_arg,
167
List<Key_part_spec> &cols)
168
:type(type_par), key_create_info(*key_info_arg), columns(cols),
169
generated(generated_arg)
171
name.str= (char *)name_arg;
172
name.length= name_len_arg;
174
Key(const Key &rhs, MEM_ROOT *mem_root);
176
/* Equality comparison of keys (ignoring name) */
177
friend bool foreign_key_prefix(Key *a, Key *b);
179
Used to make a clone of this object for ALTER/CREATE TABLE
180
@sa comment for Key_part_spec::clone
182
virtual Key *clone(MEM_ROOT *mem_root) const
183
{ return new (mem_root) Key(*this, mem_root); }
188
class Foreign_key: public Key {
190
enum fk_match_opt { FK_MATCH_UNDEF, FK_MATCH_FULL,
191
FK_MATCH_PARTIAL, FK_MATCH_SIMPLE};
192
enum fk_option { FK_OPTION_UNDEF, FK_OPTION_RESTRICT, FK_OPTION_CASCADE,
193
FK_OPTION_SET_NULL, FK_OPTION_NO_ACTION, FK_OPTION_DEFAULT};
195
Table_ident *ref_table;
196
List<Key_part_spec> ref_columns;
197
uint delete_opt, update_opt, match_opt;
198
Foreign_key(const LEX_STRING &name_arg, List<Key_part_spec> &cols,
199
Table_ident *table, List<Key_part_spec> &ref_cols,
200
uint delete_opt_arg, uint update_opt_arg, uint match_opt_arg)
201
:Key(FOREIGN_KEY, name_arg, &default_key_create_info, 0, cols),
202
ref_table(table), ref_columns(ref_cols),
203
delete_opt(delete_opt_arg), update_opt(update_opt_arg),
204
match_opt(match_opt_arg)
206
Foreign_key(const Foreign_key &rhs, MEM_ROOT *mem_root);
208
Used to make a clone of this object for ALTER/CREATE TABLE
209
@sa comment for Key_part_spec::clone
211
virtual Key *clone(MEM_ROOT *mem_root) const
212
{ return new (mem_root) Foreign_key(*this, mem_root); }
215
typedef struct st_mysql_lock
121
typedef struct drizzled_lock_st
218
uint table_count,lock_count;
124
uint32_t table_count;
219
126
THR_LOCK_DATA **locks;
223
class LEX_COLUMN : public Sql_alloc
129
} /* namespace drizzled */
131
/** @TODO why is this in the middle of the file */
132
#include <drizzled/lex_column.h>
228
LEX_COLUMN (const String& x,const uint& y ): column (x),rights (y) {}
231
#include "sql_lex.h" /* Must be here */
233
137
class select_result;
236
#define THD_SENTRY_MAGIC 0xfeedd1ff
237
#define THD_SENTRY_GONE 0xdeadbeef
140
#define Session_SENTRY_MAGIC 0xfeedd1ff
141
#define Session_SENTRY_GONE 0xdeadbeef
239
#define THD_CHECK_SENTRY(thd) assert(thd->dbug_sentry == THD_SENTRY_MAGIC)
143
#define Session_CHECK_SENTRY(session) assert(session->dbug_sentry == Session_SENTRY_MAGIC)
241
145
struct system_variables
147
system_variables() {};
244
149
How dynamically allocated system variables are handled:
246
151
The global_system_variables and max_system_variables are "authoritative"
247
152
They both should have the same 'version' and 'size'.
248
153
When attempting to access a dynamic variable, if the session version
249
154
is out of date, then the session version is updated and realloced if
250
155
neccessary and bytes copied from global to make up for missing data.
252
157
ulong dynamic_variables_version;
253
char* dynamic_variables_ptr;
254
uint dynamic_variables_head; /* largest valid variable offset */
255
uint dynamic_variables_size; /* how many bytes are in use */
158
char * dynamic_variables_ptr;
159
uint32_t dynamic_variables_head; /* largest valid variable offset */
160
uint32_t dynamic_variables_size; /* how many bytes are in use */
257
162
uint64_t myisam_max_extra_sort_file_size;
258
uint64_t myisam_max_sort_file_size;
259
163
uint64_t max_heap_table_size;
260
164
uint64_t tmp_table_size;
261
uint64_t long_query_time;
262
165
ha_rows select_limit;
263
166
ha_rows max_join_size;
264
ulong auto_increment_increment, auto_increment_offset;
265
ulong bulk_insert_buff_size;
266
ulong join_buff_size;
267
ulong max_allowed_packet;
268
ulong max_error_count;
269
ulong max_length_for_sort_data;
270
ulong max_sort_length;
271
ulong max_tmp_tables;
272
ulong min_examined_row_limit;
273
ulong myisam_repair_threads;
274
ulong myisam_sort_buff_size;
275
ulong myisam_stats_method;
276
ulong net_buffer_length;
277
ulong net_interactive_timeout;
278
ulong net_read_timeout;
279
ulong net_retry_count;
280
ulong net_wait_timeout;
281
ulong net_write_timeout;
282
ulong optimizer_prune_level;
283
ulong optimizer_search_depth;
285
Controls use of Engine-MRR:
286
0 - auto, based on cost
287
1 - force MRR when the storage engine is capable of doing it
290
ulong optimizer_use_mrr;
167
uint64_t auto_increment_increment;
168
uint64_t auto_increment_offset;
169
uint64_t bulk_insert_buff_size;
170
uint64_t join_buff_size;
171
uint32_t max_allowed_packet;
172
uint64_t max_error_count;
173
uint64_t max_length_for_sort_data;
174
size_t max_sort_length;
175
uint64_t min_examined_row_limit;
176
bool optimizer_prune_level;
179
uint32_t optimizer_search_depth;
291
180
/* A bitmap for switching optimizations on/off */
292
ulong optimizer_switch;
293
ulong preload_buff_size;
294
ulong profiling_history_size;
295
ulong query_cache_type;
296
ulong read_buff_size;
297
ulong read_rnd_buff_size;
298
ulong div_precincrement;
300
ulong thread_handling;
302
ulong completion_type;
181
uint32_t optimizer_switch;
182
uint32_t div_precincrement;
183
uint64_t preload_buff_size;
184
uint32_t read_buff_size;
185
uint32_t read_rnd_buff_size;
186
size_t sortbuff_size;
187
uint32_t thread_handling;
188
uint32_t tx_isolation;
189
uint32_t completion_type;
303
190
/* Determines which non-standard SQL behaviour should be enabled */
305
ulong default_week_format;
306
ulong max_seeks_for_key;
307
ulong range_alloc_block_size;
308
ulong query_alloc_block_size;
309
ulong query_prealloc_size;
310
ulong trans_alloc_block_size;
311
ulong trans_prealloc_size;
313
ulong group_concat_max_len;
314
ulong binlog_format; // binlog format for this thd (see enum_binlog_format)
316
In slave thread we need to know in behalf of which
317
thread the query is being run to replicate temp tables properly
319
my_thread_id pseudo_thread_id;
321
bool low_priority_updates;
324
compatibility option:
325
- index usage hints (USE INDEX without a FOR clause) behave as in 5.0
328
bool engine_condition_pushdown;
329
bool keep_files_on_create;
331
bool old_alter_table;
333
plugin_ref table_plugin;
192
uint64_t max_seeks_for_key;
193
size_t range_alloc_block_size;
194
uint32_t query_alloc_block_size;
195
uint32_t query_prealloc_size;
196
uint64_t group_concat_max_len;
197
uint64_t pseudo_thread_id;
199
plugin::StorageEngine *storage_engine;
335
201
/* Only charset part of these variables is sensible */
336
202
const CHARSET_INFO *character_set_filesystem;
337
const CHARSET_INFO *character_set_client;
338
const CHARSET_INFO *character_set_results;
340
204
/* Both charset and collation parts of these variables are important */
341
205
const CHARSET_INFO *collation_server;
342
const CHARSET_INFO *collation_database;
343
const CHARSET_INFO *collation_connection;
207
inline const CHARSET_INFO *getCollation(void)
209
return collation_server;
345
212
/* Locale Support */
346
213
MY_LOCALE *lc_time_names;
348
215
Time_zone *time_zone;
350
/* DATE, DATETIME and DRIZZLE_TIME formats */
351
DATE_TIME_FORMAT *date_format;
352
DATE_TIME_FORMAT *datetime_format;
353
DATE_TIME_FORMAT *time_format;
359
/* per thread status variables */
218
extern struct system_variables global_system_variables;
220
} /* namespace drizzled */
222
#include "drizzled/sql_lex.h"
228
* Per-session local status counters
361
230
typedef struct system_status_var
363
232
uint64_t bytes_received;
364
233
uint64_t bytes_sent;
366
ulong com_stat[(uint) SQLCOM_END];
235
ulong com_stat[(uint32_t) SQLCOM_END];
367
236
ulong created_tmp_disk_tables;
368
237
ulong created_tmp_tables;
369
238
ulong ha_commit_count;
438
297
#define last_system_status_var questions
440
void mark_transaction_to_rollback(THD *thd, bool all);
442
#ifdef DRIZZLE_SERVER
444
#define INIT_ARENA_DBUG_INFO is_backup_arena= 0
299
void mark_transaction_to_rollback(Session *session, bool all);
301
extern pthread_mutex_t LOCK_xid_cache;
302
extern HASH xid_cache;
306
Storage engine specific thread local data.
450
List of items created in the parser for this query. Every item puts
451
itself to the list on creation (see Item::Item() for details))
454
MEM_ROOT *mem_root; // Pointer to current memroot
455
bool is_backup_arena; /* True if this arena is used for backup. */
458
The states relfects three diffrent life cycles for three
459
different types of statements:
460
Prepared statement: INITIALIZED -> PREPARED -> EXECUTED.
461
Stored procedure: INITIALIZED_FOR_SP -> EXECUTED.
462
Other statements: CONVENTIONAL_EXECUTION never changes.
467
CONVENTIONAL_EXECUTION= 3, EXECUTED= 4, ERROR= -1
472
Query_arena(MEM_ROOT *mem_root_arg, enum enum_state state_arg) :
473
free_list(0), mem_root(mem_root_arg), state(state_arg)
474
{ INIT_ARENA_DBUG_INFO; }
476
This constructor is used only when Query_arena is created as
477
backup storage for another instance of Query_arena.
479
Query_arena() { INIT_ARENA_DBUG_INFO; }
481
virtual ~Query_arena() {};
483
inline bool is_conventional() const
484
{ assert(state == CONVENTIONAL_EXECUTION); return state == CONVENTIONAL_EXECUTION; }
486
inline void* alloc(size_t size) { return alloc_root(mem_root,size); }
487
inline void* calloc(size_t size)
490
if ((ptr=alloc_root(mem_root,size)))
491
memset(ptr, 0, size);
494
inline char *strdup(const char *str)
495
{ return strdup_root(mem_root,str); }
496
inline char *strmake(const char *str, size_t size)
497
{ return strmake_root(mem_root,str,size); }
498
inline void *memdup(const void *str, size_t size)
499
{ return memdup_root(mem_root,str,size); }
500
inline void *memdup_w_gap(const void *str, size_t size, uint gap)
503
if ((ptr= alloc_root(mem_root,size+gap)))
504
memcpy(ptr,str,size);
508
void set_query_arena(Query_arena *set);
511
/* Close the active state associated with execution of this statement */
512
virtual void cleanup_stmt();
311
Storage engine specific thread local data.
312
Lifetime: one user connection.
316
0: Life time: one statement within a transaction. If @@autocommit is
317
on, also represents the entire transaction.
318
@sa trans_register_ha()
320
1: Life time: one transaction within a connection.
321
If the storage engine does not participate in a transaction,
322
this should not be used.
323
@sa trans_register_ha()
325
Ha_trx_info ha_info[2];
327
Ha_data() :ha_ptr(NULL) {}
518
@brief State of a single command executed against this connection.
520
One connection can contain a lot of simultaneously running statements,
521
some of which could be:
522
- prepared, that is, contain placeholders,
523
To perform some action with statement we reset THD part to the state of
524
that statement, do the action, and then save back modified state from THD
525
to the statement. It will be changed in near future, and Statement will
529
class Statement: public ilink, public Query_arena
331
* Represents a client connection to the database server.
333
* Contains the client/server protocol object, the current statement
334
* being executed, local-to-session variables and status counters, and
335
* a host of other information.
339
* The Session class should have a vector of Statement object pointers which
340
* comprise the statements executed on the Session. Until this architectural
341
* change is done, we can forget about parallel operations inside a session.
345
* Make member variables private and have inlined accessors and setters. Hide
346
* all member variables that are not critical to non-internal operations of the
349
class Session : public Open_tables_state
531
Statement(const Statement &rhs); /* not implemented: */
532
Statement &operator=(const Statement &rhs); /* non-copyable */
535
Uniquely identifies each statement object in thread scope; change during
536
statement lifetime. FIXME: must be const
541
353
MARK_COLUMNS_NONE: Means mark_used_colums is not set and no indicator to
542
354
handler of fields used is set
543
355
MARK_COLUMNS_READ: Means a bit in read set is set to inform handler
544
356
that the field is to be read. If field list contains
545
duplicates, then thd->dup_field is set to point
357
duplicates, then session->dup_field is set to point
546
358
to the last found duplicate.
547
359
MARK_COLUMNS_WRITE: Means a bit is set in write set to inform handler
548
360
that it needs to update this field in write_row
551
363
enum enum_mark_columns mark_used_columns;
553
LEX_STRING name; /* name for named prepared statements */
554
LEX *lex; // parse tree descriptor
364
inline void* alloc(size_t size)
366
return alloc_root(mem_root,size);
368
inline void* calloc(size_t size)
371
if ((ptr= alloc_root(mem_root,size)))
372
memset(ptr, 0, size);
375
inline char *strdup(const char *str)
377
return strdup_root(mem_root,str);
379
inline char *strmake(const char *str, size_t size)
381
return strmake_root(mem_root,str,size);
383
inline void *memdup(const void *str, size_t size)
385
return memdup_root(mem_root,str,size);
387
inline void *memdup_w_gap(const void *str, size_t size, uint32_t gap)
390
if ((ptr= alloc_root(mem_root,size+gap)))
391
memcpy(ptr,str,size);
394
/** Frees all items attached to this Statement */
397
* List of items created in the parser for this query. Every item puts
398
* itself to the list on creation (see Item::Item() for details))
401
memory::Root *mem_root; /**< Pointer to current memroot */
403
* Uniquely identifies each statement object in thread scope; change during
404
* statement lifetime.
406
* @todo should be const
409
LEX *lex; /**< parse tree descriptor */
556
411
Points to the query associated with this statement. It's const, but
557
412
we need to declare it char * because all table handlers are written
558
413
in C and need to point to it.
586
441
valid database name.
588
443
@note this attribute is set and alloced by the slave SQL thread (for
589
the THD of that thread); that thread is (and must remain, for now) the
444
the Session of that thread); that thread is (and must remain, for now) the
590
445
only responsible for freeing this member.
598
/* This constructor is called for backup statements */
601
Statement(LEX *lex_arg, MEM_ROOT *mem_root_arg,
602
enum enum_state state_arg, ulong id_arg);
605
/* Assign execution context (note: not all members) of given stmt to self */
606
void set_statement(Statement *stmt);
607
void set_n_backup_statement(Statement *stmt, Statement *backup);
608
void restore_backup_statement(Statement *stmt, Statement *backup);
611
struct st_savepoint {
612
struct st_savepoint *prev;
615
Ha_trx_info *ha_list;
618
enum xa_states {XA_NOTR=0, XA_ACTIVE, XA_IDLE, XA_PREPARED};
619
extern const char *xa_state_names[];
621
typedef struct st_xid_state {
622
/* For now, this is only used to catch duplicated external xids */
623
XID xid; // transaction identifier
624
enum xa_states xa_state; // used by external XA only
628
extern pthread_mutex_t LOCK_xid_cache;
629
extern HASH xid_cache;
630
bool xid_cache_init(void);
631
void xid_cache_free(void);
632
XID_STATE *xid_cache_search(XID *xid);
633
bool xid_cache_insert(XID *xid, enum xa_states xa_state);
634
bool xid_cache_insert(XID_STATE *xid_state);
635
void xid_cache_delete(XID_STATE *xid_state);
638
@class Security_context
639
@brief A set of THD members describing the current authenticated user.
642
class Security_context {
644
Security_context() {} /* Remove gcc warning */
646
host - host of the client
647
user - user of the client, set to NULL until the user has been read from
649
priv_user - The user privilege we are using. May be "" for anonymous user.
658
inline char *priv_host_name()
660
return (ip ? ip : (char *)"%");
666
A registry for item tree transformations performed during
667
query optimization. We register only those changes which require
668
a rollback to re-execute a prepared statement or stored procedure
672
struct Item_change_record;
673
typedef I_List<Item_change_record> Item_change_list;
677
Class that holds information about tables which were opened and locked
678
by the thread. It is also used to save/restore this information in
679
push_open_tables_state()/pop_open_tables_state().
682
class Open_tables_state
686
List of regular tables in use by this thread. Contains temporary and
687
base tables that were opened with @see open_tables().
691
List of temporary tables used by this thread. Contains user-level
692
temporary tables, created with CREATE TEMPORARY TABLE, and
693
internal temporary tables, created, e.g., to resolve a SELECT,
694
or for an intermediate table used in ALTER.
695
XXX Why are internal temporary tables added to this list?
697
TABLE *temporary_tables;
699
List of tables that were opened with HANDLER OPEN and are
700
still in use by this thread.
702
TABLE *handler_tables;
703
TABLE *derived_tables;
705
During a MySQL session, one can lock tables in two modes: automatic
706
or manual. In automatic mode all necessary tables are locked just before
707
statement execution, and all acquired locks are stored in 'lock'
708
member. Unlocking takes place automatically as well, when the
710
Manual mode comes into play when a user issues a 'LOCK TABLES'
711
statement. In this mode the user can only use the locked tables.
712
Trying to use any other tables will give an error. The locked tables are
713
stored in 'locked_tables' member. Manual locking is described in
714
the 'LOCK_TABLES' chapter of the MySQL manual.
715
See also lock_tables() for details.
719
Tables that were locked with explicit or implicit LOCK TABLES.
720
(Implicit LOCK TABLES happens when we are prelocking tables for
721
execution of statement which uses stored routines. See description
722
THD::prelocked_mode for more info.)
724
DRIZZLE_LOCK *locked_tables;
727
CREATE-SELECT keeps an extra lock for the table being
728
created. This field is used to keep the extra lock available for
729
lower level routines, which would otherwise miss that lock.
731
DRIZZLE_LOCK *extra_lock;
734
uint current_tablenr;
737
BACKUPS_AVAIL = (1U << 0) /* There are backups available */
741
Flags with information about the open tables state.
746
This constructor serves for creation of Open_tables_state instances
747
which are used as backup storage.
749
Open_tables_state() : state_flags(0U) { }
751
Open_tables_state(ulong version_arg);
753
void set_open_tables_state(Open_tables_state *state)
758
void reset_open_tables_state()
760
open_tables= temporary_tables= handler_tables= derived_tables= 0;
761
extra_lock= lock= locked_tables= 0;
767
@class Sub_statement_state
768
@brief Used to save context when executing a function or trigger
771
/* Defines used for Sub_statement_state::in_sub_stmt */
773
#define SUB_STMT_TRIGGER 1
774
#define SUB_STMT_FUNCTION 2
777
class Sub_statement_state
781
uint64_t first_successful_insert_id_in_prev_stmt;
782
uint64_t first_successful_insert_id_in_cur_stmt, insert_id_for_cur_row;
783
Discrete_interval auto_inc_interval_for_cur_row;
784
Discrete_intervals_list auto_inc_intervals_forced;
785
uint64_t limit_found_rows;
786
ha_rows cuted_fields, sent_row_count, examined_row_count;
787
ulong client_capabilities;
789
bool enable_slow_log;
790
bool last_insert_id_used;
791
SAVEPOINT *savepoints;
795
/* Flags for the THD::system_thread variable */
796
enum enum_thread_type
799
SYSTEM_THREAD_SLAVE_IO,
800
SYSTEM_THREAD_SLAVE_SQL
805
This class represents the interface for internal error handlers.
806
Internal error handlers are exception handlers used by the server
809
class Internal_error_handler
812
Internal_error_handler() {}
813
virtual ~Internal_error_handler() {}
817
Handle an error condition.
818
This method can be implemented by a subclass to achieve any of the
820
- mask an error internally, prevent exposing it to the user,
821
- mask an error and throw another one instead.
822
When this method returns true, the error condition is considered
823
'handled', and will not be propagated to upper layers.
824
It is the responsability of the code installing an internal handler
825
to then check for trapped conditions, and implement logic to recover
826
from the anticipated conditions trapped during runtime.
828
This mechanism is similar to C++ try/throw/catch:
829
- 'try' correspond to <code>THD::push_internal_handler()</code>,
830
- 'throw' correspond to <code>my_error()</code>,
831
which invokes <code>my_message_sql()</code>,
832
- 'catch' correspond to checking how/if an internal handler was invoked,
833
before removing it from the exception stack with
834
<code>THD::pop_internal_handler()</code>.
836
@param sql_errno the error number
837
@param level the error level
838
@param thd the calling thread
839
@return true if the error is handled
841
virtual bool handle_error(uint sql_errno,
843
DRIZZLE_ERROR::enum_warning_level level,
849
Stores status of the currently executed statement.
850
Cleared at the beginning of the statement, and then
851
can hold either OK, ERROR, or EOF status.
852
Can not be assigned twice per statement.
855
class Diagnostics_area
858
enum enum_diagnostics_status
860
/** The area is cleared at start of a statement. */
862
/** Set whenever one calls my_ok(). */
864
/** Set whenever one calls my_eof(). */
866
/** Set whenever one calls my_error() or my_message(). */
868
/** Set in case of a custom response, such as one from COM_STMT_PREPARE. */
871
/** True if status information is sent to the client. */
873
/** Set to make set_error_status after set_{ok,eof}_status possible. */
874
bool can_overwrite_status;
876
void set_ok_status(THD *thd, ha_rows affected_rows_arg,
877
uint64_t last_insert_id_arg,
878
const char *message);
879
void set_eof_status(THD *thd);
880
void set_error_status(THD *thd, uint sql_errno_arg, const char *message_arg);
882
void disable_status();
884
void reset_diagnostics_area();
886
bool is_set() const { return m_status != DA_EMPTY; }
887
bool is_error() const { return m_status == DA_ERROR; }
888
bool is_eof() const { return m_status == DA_EOF; }
889
bool is_ok() const { return m_status == DA_OK; }
890
bool is_disabled() const { return m_status == DA_DISABLED; }
891
enum_diagnostics_status status() const { return m_status; }
893
const char *message() const
894
{ assert(m_status == DA_ERROR || m_status == DA_OK); return m_message; }
896
uint sql_errno() const
897
{ assert(m_status == DA_ERROR); return m_sql_errno; }
899
uint server_status() const
901
assert(m_status == DA_OK || m_status == DA_EOF);
902
return m_server_status;
905
ha_rows affected_rows() const
906
{ assert(m_status == DA_OK); return m_affected_rows; }
908
uint64_t last_insert_id() const
909
{ assert(m_status == DA_OK); return m_last_insert_id; }
911
uint total_warn_count() const
913
assert(m_status == DA_OK || m_status == DA_EOF);
914
return m_total_warn_count;
917
Diagnostics_area() { reset_diagnostics_area(); }
920
/** Message buffer. Can be used by OK or ERROR status. */
921
char m_message[DRIZZLE_ERRMSG_SIZE];
923
SQL error number. One of ER_ codes from share/errmsg.txt.
924
Set by set_error_status.
929
Copied from thd->server_status when the diagnostics area is assigned.
930
We need this member as some places in the code use the following pattern:
931
thd->server_status|= ...
933
thd->server_status&= ~...
934
Assigned by OK, EOF or ERROR.
936
uint m_server_status;
938
The number of rows affected by the last statement. This is
939
semantically close to thd->row_count_func, but has a different
940
life cycle. thd->row_count_func stores the value returned by
941
function ROW_COUNT() and is cleared only by statements that
942
update its value, such as INSERT, UPDATE, DELETE and few others.
943
This member is cleared at the beginning of the next statement.
945
We could possibly merge the two, but life cycle of thd->row_count_func
948
ha_rows m_affected_rows;
950
Similarly to the previous member, this is a replacement of
951
thd->first_successful_insert_id_in_prev_stmt, which is used
952
to implement LAST_INSERT_ID().
954
uint64_t m_last_insert_id;
955
/** The total number of warnings. */
956
uint m_total_warn_count;
957
enum_diagnostics_status m_status;
959
@todo: the following THD members belong here:
960
- warn_list, warn_count,
966
Storage engine specific thread local data.
972
Storage engine specific thread local data.
973
Lifetime: one user connection.
977
0: Life time: one statement within a transaction. If @@autocommit is
978
on, also represents the entire transaction.
979
@sa trans_register_ha()
981
1: Life time: one transaction within a connection.
982
If the storage engine does not participate in a transaction,
983
this should not be used.
984
@sa trans_register_ha()
986
Ha_trx_info ha_info[2];
988
Ha_data() :ha_ptr(NULL) {}
994
For each client connection we create a separate thread with THD serving as
995
a thread/connection descriptor
998
class THD :public Statement,
999
public Open_tables_state
1002
/* Used to execute base64 coded binlog events in MySQL server */
1003
Relay_log_info* rli_fake;
1006
Constant for THD::where initialization in the beginning of every query.
1008
It's needed because we do not save/restore THD::where normally during
450
Constant for Session::where initialization in the beginning of every query.
452
It's needed because we do not save/restore Session::where normally during
1009
453
primary (non subselect) query execution.
1011
455
static const char * const DEFAULT_WHERE;
1013
NET net; // client connection descriptor
1014
MEM_ROOT warn_root; // For warnings and errors
1015
Protocol *protocol; // Current protocol
1016
Protocol_text protocol_text; // Normal protocol
1017
HASH user_vars; // hash for user variables
1018
String packet; // dynamic buffer for network I/O
1019
String convert_buffer; // buffer for charset conversions
1020
struct rand_struct rand; // used for authentication
1021
struct system_variables variables; // Changeable local variables
1022
struct system_status_var status_var; // Per thread statistic vars
1023
struct system_status_var *initial_status_var; /* used by show status */
1024
THR_LOCK_INFO lock_info; // Locking info of this thread
1025
THR_LOCK_OWNER main_lock_id; // To use for conventional queries
1026
THR_LOCK_OWNER *lock_id; // If not main_lock_id, points to
1027
// the lock_id of a cursor.
1028
pthread_mutex_t LOCK_delete; // Locked before thd is deleted
1030
A pointer to the stack frame of handle_one_connection(),
1031
which is called first in the thread for handling a client
1036
Currently selected catalog.
457
memory::Root warn_root; /**< Allocation area for warnings and errors */
458
plugin::Client *client; /**< Pointer to client object */
459
plugin::Scheduler *scheduler; /**< Pointer to scheduler object */
460
void *scheduler_arg; /**< Pointer to the optional scheduler argument */
461
HASH user_vars; /**< Hash of user variables defined during the session's lifetime */
462
struct system_variables variables; /**< Mutable local variables local to the session */
463
struct system_status_var status_var; /**< Session-local status counters */
464
struct system_status_var *initial_status_var; /* used by show status */
465
THR_LOCK_INFO lock_info; /**< Locking information for this session */
466
THR_LOCK_OWNER main_lock_id; /**< To use for conventional queries */
467
THR_LOCK_OWNER *lock_id; /**< If not main_lock_id, points to the lock_id of a cursor. */
468
pthread_mutex_t LOCK_delete; /**< Locked before session is deleted */
471
* A peek into the query string for the session. This is a best effort
472
* delivery, there is no guarantee whether the content is meaningful.
474
char process_list_info[PROCESS_LIST_WIDTH+1];
477
* A pointer to the stack frame of the scheduler thread
478
* which is called first in the thread for handling a client
1042
Some members of THD (currently 'Statement::db',
1043
'catalog' and 'query') are set and alloced by the slave SQL thread
1044
(for the THD of that thread); that thread is (and must remain, for now)
484
Some members of Session (currently 'Statement::db',
485
'query') are set and alloced by the slave SQL thread
486
(for the Session of that thread); that thread is (and must remain, for now)
1045
487
the only responsible for freeing these 3 members. If you add members
1046
488
here, and you add code to set them in replication, don't forget to
1047
489
free_them_and_set_them_to_0 in replication properly. For details see
1050
492
@see handle_slave_sql
1053
Security_context main_security_ctx;
1054
Security_context *security_ctx;
1057
Points to info-string that we show in SHOW PROCESSLIST
1058
You are supposed to call THD_SET_PROC_INFO only if you have coded
1059
a time-consuming piece that MySQL can get stuck in for a long time.
1061
Set it using the thd_proc_info(THD *thread, const char *message)
1064
#define THD_SET_PROC_INFO(thd, info) \
1065
(thd)->proc_info= (info)
1067
inline const char* get_proc_info() { return proc_info;}
1069
/* left public for the the storage engines, please avoid direct use */
1070
const char *proc_info;
494
Security_context security_ctx;
1073
497
Used in error messages to tell user in what part of MySQL we found an
1074
498
error. E. g. when where= "having clause", if fix_fields() fails, user
1075
499
will know that the error was in having clause.
1077
501
const char *where;
1079
double tmp_double_value; /* Used in set_var.cc */
1080
ulong client_capabilities; /* What the client supports */
1081
ulong max_client_packet_length;
1083
HASH handler_tables_hash;
1085
504
One thread can hold up to one named user-level lock. This variable
1086
505
points to a lock object if the lock is present. See item_func.cc and
1087
chapter 'Miscellaneous functions', for functions GET_LOCK, RELEASE_LOCK.
1089
uint dbug_sentry; // watch out for memory corruption
1090
struct st_my_thread_var *mysys_var;
1092
Type of current query: COM_STMT_PREPARE, COM_QUERY, etc. Set from
1093
first byte of the packet in do_command()
506
chapter 'Miscellaneous functions', for functions GET_LOCK, RELEASE_LOCK.
508
uint32_t dbug_sentry; /**< watch for memory corruption */
509
internal::st_my_thread_var *mysys_var;
511
* Type of current query: COM_STMT_PREPARE, COM_QUERY, etc. Set from
512
* first byte of the packet in executeStatement()
1095
514
enum enum_server_command command;
1097
uint32_t file_id; // for LOAD DATA INFILE
1098
/* remote (peer) port */
1100
time_t start_time, user_time;
1101
uint64_t connect_utime, thr_create_utime; // track down slow pthread_create
1102
uint64_t start_utime, utime_after_lock;
515
uint32_t file_id; /**< File ID for LOAD DATA INFILE */
516
/* @note the following three members should likely move to Client */
517
uint32_t max_client_packet_length; /**< Maximum number of bytes a client can send in a single packet */
520
uint64_t thr_create_utime; /**< track down slow pthread_create */
521
uint64_t start_utime;
522
uint64_t utime_after_lock;
1104
524
thr_lock_type update_lock_default;
1106
/* <> 0 if we are inside of trigger or stored function. */
527
Both of the following container points in session will be converted to an API.
1109
531
/* container for handler's private per-connection data */
1110
532
Ha_data ha_data[MAX_HA];
1112
/* Place to store various things */
1114
#ifndef DRIZZLE_CLIENT
1115
int binlog_setup_trx_data();
1118
Public interface to write RBR events to the binlog
1120
void binlog_start_trans_and_stmt();
1121
void binlog_set_stmt_begin();
1122
int binlog_write_table_map(TABLE *table, bool is_transactional);
1123
int binlog_write_row(TABLE* table, bool is_transactional,
1124
const uchar *new_data);
1125
int binlog_delete_row(TABLE* table, bool is_transactional,
1126
const uchar *old_data);
1127
int binlog_update_row(TABLE* table, bool is_transactional,
1128
const uchar *old_data, const uchar *new_data);
1130
void set_server_id(uint32_t sid) { server_id = sid; }
1133
Member functions to handle pending event for row-level logging.
1135
template <class RowsEventT> Rows_log_event*
1136
binlog_prepare_pending_rows_event(TABLE* table, uint32_t serv_id,
1138
bool is_transactional,
1140
Rows_log_event* binlog_get_pending_rows_event() const;
1141
void binlog_set_pending_rows_event(Rows_log_event* ev);
1142
int binlog_flush_pending_rows_event(bool stmt_end);
1145
uint binlog_table_maps; // Number of table maps currently in the binlog
1147
enum enum_binlog_flag {
1148
BINLOG_FLAG_UNSAFE_STMT_PRINTED,
1153
Flags with per-thread information regarding the status of the
1156
uint32_t binlog_flags;
1158
uint get_binlog_table_maps() const {
1159
return binlog_table_maps;
1161
void clear_binlog_table_maps() {
1162
binlog_table_maps= 0;
1164
#endif /* DRIZZLE_CLIENT */
534
Id of current query. Statement can be reused to execute several queries
535
query_id is global in context of the whole MySQL server.
536
ID is automatically generated from an atomic counter.
537
It's used in Cursor code for various purposes: to check which columns
538
from table are necessary for this select, to check if it's necessary to
539
update auto-updatable fields (like auto_increment and timestamp).
542
query_id_t warn_query_id;
544
void **getEngineData(const plugin::StorageEngine *engine);
545
Ha_trx_info *getEngineInfo(const plugin::StorageEngine *engine,
1168
548
struct st_transactions {
1169
SAVEPOINT *savepoints;
1170
THD_TRANS all; // Trans since BEGIN WORK
1171
THD_TRANS stmt; // Trans for current statement
1172
bool on; // see ha_enable_transaction()
549
std::deque<drizzled::NamedSavepoint> savepoints;
550
Session_TRANS all; // Trans since BEGIN WORK
551
Session_TRANS stmt; // Trans for current statement
1173
552
XID_STATE xid_state;
1174
Rows_log_event *m_pending_rows_event;
1177
555
Tables changed in transaction (that must be invalidated in query cache).
1178
556
List contain only transactional tables, that not invalidated in query
1179
557
cache (instead of full list of changed in transaction tables).
1181
CHANGED_TABLE_LIST* changed_tables;
1182
MEM_ROOT mem_root; // Transaction-life memory allocation pool
1187
free_root(&mem_root,MYF(MY_KEEP_PREALLOC));
1191
memset(this, 0, sizeof(*this));
1192
xid_state.xid.null();
1193
init_sql_alloc(&mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
1197
571
sigset_t signals;
1198
#ifdef SIGNAL_WITH_VIO_CLOSE
1202
This is to track items changed during execution of a prepared
1203
statement/stored procedure. It's created by
1204
register_item_tree_change() in memory root of THD, and freed in
1205
rollback_item_tree_changes(). For conventional execution it's always
1208
Item_change_list change_list;
1211
A permanent memory area of the statement. For conventional
1212
execution, the parsed tree and execution runtime reside in the same
1213
memory root. In this case stmt_arena points to THD. In case of
1214
a prepared statement or a stored procedure statement, thd->mem_root
1215
conventionally points to runtime memory, and thd->stmt_arena
1216
points to the memory of the PS/SP, where the parsed tree of the
1217
statement resides. Whenever you need to perform a permanent
1218
transformation of a parsed tree, you should allocate new memory in
1219
stmt_arena, to allow correct re-execution of PS/SP.
1220
Note: in the parser, stmt_arena == thd, even for PS/SP.
1222
Query_arena *stmt_arena;
1223
573
/* Tells if LAST_INSERT_ID(#) was called for the current statement */
1224
574
bool arg_of_last_insert_id_function;
1226
576
ALL OVER THIS FILE, "insert_id" means "*automatically generated* value for
1227
577
insertion into an auto_increment column".
1230
580
This is the first autogenerated insert id which was *successfully*
1231
581
inserted by the previous statement (exactly, if the previous statement
1232
582
didn't successfully insert an autogenerated insert id, then it's the one
1289
619
in the binlog is still needed; the list's minimum will contain 3.
1291
621
Discrete_intervals_list auto_inc_intervals_in_cur_stmt_for_binlog;
1292
/* Used by replication and SET INSERT_ID */
622
/** Used by replication and SET INSERT_ID */
1293
623
Discrete_intervals_list auto_inc_intervals_forced;
625
uint64_t limit_found_rows;
626
uint64_t options; /**< Bitmap of options */
627
int64_t row_count_func; /**< For the ROW_COUNT() function */
628
ha_rows cuted_fields; /**< Count of "cut" or truncated fields. @todo Kill this friggin thing. */
631
* Number of rows we actually sent to the client, including "synthetic"
632
* rows in ROLLUP etc.
634
ha_rows sent_row_count;
637
* Number of rows we read, sent or not, including in create_sort_index()
639
ha_rows examined_row_count;
642
* The set of those tables whose fields are referenced in all subqueries
647
* Possibly this it is incorrect to have used tables in Session because
648
* with more than one subquery, it is not clear what does the field mean.
650
table_map used_tables;
655
This, and some other variables like 'count_cuted_fields'
656
maybe should be statement/cursor local, that is, moved to Statement
657
class. With current implementation warnings produced in each prepared
658
statement/cursor settle here.
660
List<DRIZZLE_ERROR> warn_list;
661
uint32_t warn_count[(uint32_t) DRIZZLE_ERROR::WARN_LEVEL_END];
662
uint32_t total_warn_count;
663
Diagnostics_area main_da;
667
/* Statement id is thread-wide. This counter is used to generate ids */
668
uint32_t statement_id_counter;
669
uint32_t rand_saved_seed1;
670
uint32_t rand_saved_seed2;
672
Row counter, mainly for errors and warnings. Not increased in
673
create_sort_index(); may differ from examined_row_count.
676
pthread_t real_id; /**< For debugging */
679
uint32_t global_read_lock;
680
uint32_t server_status;
681
uint32_t open_options;
682
uint32_t select_number; /**< number of select (used for EXPLAIN) */
683
/* variables.transaction_isolation is reset to this after each commit */
684
enum_tx_isolation session_tx_isolation;
685
enum_check_fields count_cuted_fields;
693
KILLED_NO_VALUE /* means none of the above states apply */
695
killed_state volatile killed;
697
bool some_tables_deleted;
701
Set to true if execution of the current compound statement
702
can not continue. In particular, disables activation of
703
CONTINUE or EXIT handlers of stored routines.
704
Reset in the end of processing of the current user request, in
705
@see mysql_reset_session_for_next_command().
709
Set by a storage engine to request the entire
710
transaction (that possibly spans multiple engines) to
711
rollback. Reset in ha_rollback.
713
bool transaction_rollback_request;
715
true if we are in a sub-statement and the current error can
716
not be safely recovered until we left the sub-statement mode.
717
In particular, disables activation of CONTINUE and EXIT
718
handlers inside sub-statements. E.g. if it is a deadlock
719
error and requires a transaction-wide rollback, this flag is
720
raised (traditionally, MySQL first has to close all the reads
721
via @see handler::ha_index_or_rnd_end() and only then perform
723
Reset to false when we leave the sub-statement mode.
725
bool is_fatal_sub_stmt_error;
726
/** for IS NULL => = last_insert_id() fix in remove_eq_conds() */
727
bool substitute_null_with_insert_id;
730
bool abort_on_warning;
731
bool got_warning; /**< Set on call to push_warning() */
732
bool no_warnings_for_error; /**< no warnings on call to my_error() */
733
/** set during loop of derived table processing */
734
bool derived_tables_processing;
735
bool tablespace_op; /**< This is true in DISCARD/IMPORT TABLESPACE */
737
/** Used by the sys_var class to store temporary values */
741
uint32_t uint32_t_value;
742
int32_t int32_t_value;
743
uint64_t uint64_t_value;
747
Character input stream consumed by the lexical analyser,
749
Note that since the parser is not re-entrant, we keep only one input
750
stream here. This member is valid only when executing code during parsing,
751
and may point to invalid memory after that.
753
Lex_input_stream *m_lip;
755
/** Place to store various things */
756
void *session_marker;
758
/** Keeps a copy of the previous table around in case we are just slamming on particular table */
762
Points to info-string that we show in SHOW PROCESSLIST
763
You are supposed to call Session_SET_PROC_INFO only if you have coded
764
a time-consuming piece that MySQL can get stuck in for a long time.
766
Set it using the session_proc_info(Session *thread, const char *message)
769
inline void set_proc_info(const char *info)
773
inline const char* get_proc_info() const
778
/** Sets this Session's current query ID */
779
inline void setQueryId(query_id_t in_query_id)
781
query_id= in_query_id;
784
/** Returns the current query ID */
785
inline query_id_t getQueryId() const
791
/** Sets this Session's warning query ID */
792
inline void setWarningQueryId(query_id_t in_query_id)
794
warn_query_id= in_query_id;
797
/** Returns the Session's warning query ID */
798
inline query_id_t getWarningQueryId() const
800
return warn_query_id;
803
/** Returns the current query text */
804
inline const char *getQueryString() const
809
/** Returns the length of the current query text */
810
inline size_t getQueryLength() const
813
return strlen(query);
818
/** Accessor method returning the session's ID. */
819
inline uint64_t getSessionId() const
824
/** Accessor method returning the server's ID. */
825
inline uint32_t getServerId() const
827
/* We return the global server ID. */
831
/** Returns the current transaction ID for the session's current statement */
832
inline my_xid getTransactionId()
834
return transaction.xid_state.xid.quick_get_my_xid();
1295
837
There is BUG#19630 where statement-based replication of stored
1296
838
functions/triggers with two auto_increment columns breaks.
1297
839
We however ensure that it works when there is 0 or 1 auto_increment
1354
889
auto_inc_intervals_forced.append(next_id, UINT64_MAX, 0);
1357
uint64_t limit_found_rows;
1358
uint64_t options; /* Bitmap of states */
1359
int64_t row_count_func; /* For the ROW_COUNT() function */
1360
ha_rows cuted_fields;
1363
number of rows we actually sent to the client, including "synthetic"
1366
ha_rows sent_row_count;
1369
number of rows we read, sent or not, including in create_sort_index()
1371
ha_rows examined_row_count;
1374
The set of those tables whose fields are referenced in all subqueries
1376
TODO: possibly this it is incorrect to have used tables in THD because
1377
with more than one subquery, it is not clear what does the field mean.
1379
table_map used_tables;
1380
USER_CONN *user_connect;
1381
const CHARSET_INFO *db_charset;
1383
FIXME: this, and some other variables like 'count_cuted_fields'
1384
maybe should be statement/cursor local, that is, moved to Statement
1385
class. With current implementation warnings produced in each prepared
1386
statement/cursor settle here.
1388
List <DRIZZLE_ERROR> warn_list;
1389
uint warn_count[(uint) DRIZZLE_ERROR::WARN_LEVEL_END];
1390
uint total_warn_count;
1391
Diagnostics_area main_da;
1394
Id of current query. Statement can be reused to execute several queries
1395
query_id is global in context of the whole MySQL server.
1396
ID is automatically generated from mutex-protected counter.
1397
It's used in handler code for various purposes: to check which columns
1398
from table are necessary for this select, to check if it's necessary to
1399
update auto-updatable fields (like auto_increment and timestamp).
1401
query_id_t query_id, warn_id;
1404
#ifdef ERROR_INJECT_SUPPORT
1405
ulong error_inject_value;
1407
/* Statement id is thread-wide. This counter is used to generate ids */
1408
ulong statement_id_counter;
1409
ulong rand_saved_seed1, rand_saved_seed2;
1411
Row counter, mainly for errors and warnings. Not increased in
1412
create_sort_index(); may differ from examined_row_count.
1415
pthread_t real_id; /* For debugging */
1416
my_thread_id thread_id;
1417
uint tmp_table, global_read_lock;
1418
uint server_status,open_options;
1419
enum enum_thread_type system_thread;
1420
uint select_number; //number of select (used for EXPLAIN)
1421
/* variables.transaction_isolation is reset to this after each commit */
1422
enum_tx_isolation session_tx_isolation;
1423
enum_check_fields count_cuted_fields;
1425
DYNAMIC_ARRAY user_var_events; /* For user variables replication */
1426
MEM_ROOT *user_var_events_alloc; /* Allocate above array elements here */
1432
KILL_CONNECTION=ER_SERVER_SHUTDOWN,
1433
KILL_QUERY=ER_QUERY_INTERRUPTED,
1434
KILLED_NO_VALUE /* means neither of the states */
1436
killed_state volatile killed;
1438
/* scramble - random string sent to client on handshake */
1439
char scramble[SCRAMBLE_LENGTH+1];
1441
bool slave_thread, one_shot_set;
1442
/* tells if current statement should binlog row-based(1) or stmt-based(0) */
1443
bool current_stmt_binlog_row_based;
1444
bool some_tables_deleted;
1445
bool last_cuted_field;
1446
bool no_errors, password;
1448
Set to true if execution of the current compound statement
1449
can not continue. In particular, disables activation of
1450
CONTINUE or EXIT handlers of stored routines.
1451
Reset in the end of processing of the current user request, in
1452
@see mysql_reset_thd_for_next_command().
1454
bool is_fatal_error;
1456
Set by a storage engine to request the entire
1457
transaction (that possibly spans multiple engines) to
1458
rollback. Reset in ha_rollback.
1460
bool transaction_rollback_request;
1462
true if we are in a sub-statement and the current error can
1463
not be safely recovered until we left the sub-statement mode.
1464
In particular, disables activation of CONTINUE and EXIT
1465
handlers inside sub-statements. E.g. if it is a deadlock
1466
error and requires a transaction-wide rollback, this flag is
1467
raised (traditionally, MySQL first has to close all the reads
1468
via @see handler::ha_index_or_rnd_end() and only then perform
1470
Reset to false when we leave the sub-statement mode.
1472
bool is_fatal_sub_stmt_error;
1473
bool query_start_used, rand_used, time_zone_used;
1474
/* for IS NULL => = last_insert_id() fix in remove_eq_conds() */
1475
bool substitute_null_with_insert_id;
1476
bool in_lock_tables;
1478
True if a slave error. Causes the slave to stop. Not the same
1479
as the statement execution error (is_error()), since
1480
a statement may be expected to return an error, e.g. because
1481
it returned an error on master, and this is OK on the slave.
1483
bool is_slave_error;
1484
bool bootstrap, cleanup_done;
1486
/** is set if some thread specific value(s) used in a statement. */
1487
bool thread_specific_used;
1488
bool charset_is_system_charset, charset_is_collation_connection;
1489
bool charset_is_character_set_filesystem;
1490
bool enable_slow_log; /* enable slow log for current statement */
1491
bool abort_on_warning;
1492
bool got_warning; /* Set on call to push_warning() */
1493
bool no_warnings_for_error; /* no warnings on call to my_error() */
1494
/* set during loop of derived table processing */
1495
bool derived_tables_processing;
1496
bool tablespace_op; /* This is true in DISCARD/IMPORT TABLESPACE */
1499
If we do a purge of binary logs, log index info of the threads
1500
that are currently reading it needs to be adjusted. To do that
1501
each thread that is using LOG_INFO needs to adjust the pointer to it
1503
LOG_INFO* current_linfo;
1504
NET* slave_net; // network connection from slave -> m.
1505
/* Used by the sys_var class to store temporary values */
1511
uint64_t uint64_t_value;
1516
If true, mysql_bin_log::write(Log_event) call will not write events to
1517
binlog, and maintain 2 below variables instead (use
1518
mysql_bin_log.start_union_events to turn this on)
1522
If true, at least one mysql_bin_log::write(Log_event) call has been
1523
made after last mysql_bin_log.start_union_events() call.
1525
bool unioned_events;
1527
If true, at least one mysql_bin_log::write(Log_event e), where
1528
e.cache_stmt == true call has been made after last
1529
mysql_bin_log.start_union_events() call.
1531
bool unioned_events_trans;
1534
'queries' (actually SP statements) that run under inside this binlog
1535
union have thd->query_id >= first_query_id.
1537
query_id_t first_query_id;
1541
Character input stream consumed by the lexical analyser,
1542
used during parsing.
1543
Note that since the parser is not re-entrant, we keep only one input
1544
stream here. This member is valid only when executing code during parsing,
1545
and may point to invalid memory after that.
1547
Lex_input_stream *m_lip;
1554
Initialize memory roots necessary for query processing and (!)
1555
pre-allocate memory for it. We can't do that in THD constructor because
1556
there are use cases (acl_init, watcher threads,
1557
killing mysqld) where it's vital to not allocate excessive and not used
1558
memory. Note, that we still don't return error from init_for_queries():
1559
if preallocation fails, we should notice that at the first call to
1562
void init_for_queries();
1563
void change_user(void);
892
Session(plugin::Client *client_arg);
1564
895
void cleanup(void);
897
* Cleans up after query.
901
* This function is used to reset thread data to its default state.
903
* This function is not suitable for setting thread data to some
904
* non-default values, as there is only one replication thread, so
905
* different master threads may overwrite data of each other on
1565
908
void cleanup_after_query();
1566
bool store_globals();
1567
#ifdef SIGNAL_WITH_VIO_CLOSE
1568
inline void set_active_vio(Vio* vio)
1570
pthread_mutex_lock(&LOCK_delete);
1572
pthread_mutex_unlock(&LOCK_delete);
1574
inline void clear_active_vio()
1576
pthread_mutex_lock(&LOCK_delete);
1578
pthread_mutex_unlock(&LOCK_delete);
1580
void close_active_vio();
1582
void awake(THD::killed_state state_to_set);
1584
#ifndef DRIZZLE_CLIENT
1585
enum enum_binlog_query_type {
1587
The query can be logged row-based or statement-based
1592
The query has to be logged statement-based
1597
The query represents a change to a table in the "mysql"
1598
database and is currently mapped to ROW_QUERY_TYPE.
1604
int binlog_query(enum_binlog_query_type qtype,
1605
char const *query, ulong query_len,
1606
bool is_trans, bool suppress_use,
1607
THD::killed_state killed_err_arg= THD::KILLED_NO_VALUE);
910
void awake(Session::killed_state state_to_set);
912
* Pulls thread-specific variables into Session state.
914
* Returns true most times, or false if there was a problem
915
* allocating resources for thread-specific storage.
917
* @TODO Kill this. It's not necessary once my_thr_init() is bye bye.
923
Initialize memory roots necessary for query processing and (!)
924
pre-allocate memory for it. We can't do that in Session constructor because
925
there are use cases where it's vital to not allocate excessive and not used
928
void prepareForQueries();
931
* Executes a single statement received from the
934
* Returns true if the statement was successful, or false
939
* For profiling to work, it must never be called recursively.
941
* In MySQL, this used to be the do_command() C function whic
942
* accepted a single parameter of the THD pointer.
944
bool executeStatement();
947
* Reads a query from packet and stores it.
949
* Returns true if query is read and allocated successfully,
950
* false otherwise. On a return of false, Session::fatal_error
953
* @note Used in COM_QUERY and COM_STMT_PREPARE.
955
* Sets the following Session variables:
959
* @param The packet pointer to read from
960
* @param The length of the query to read
962
bool readAndStoreQuery(const char *in_packet, uint32_t in_packet_length);
965
* Ends the current transaction and (maybe) begins the next.
967
* Returns true if the transaction completed successfully,
970
* @param Completion type
972
bool endTransaction(enum enum_mysql_completiontype completion);
973
bool endActiveTransaction();
974
bool startTransaction(start_transaction_option_t opt= START_TRANS_NO_OPTIONS);
977
* Authenticates users, with error reporting.
979
* Returns true on success, or false on failure.
986
* This will initialize the session and begin the command loop.
991
* Schedule a session to be run on the default scheduler.
1611
996
For enter_cond() / exit_cond() to work the mutex must be got before
1612
997
enter_cond(); this mutex is then released by exit_cond().
1613
998
Usage must be: lock mutex; enter_cond(); your code; exit_cond().
1615
inline const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex,
1618
const char* old_msg = get_proc_info();
1619
safe_mutex_assert_owner(mutex);
1620
mysys_var->current_mutex = mutex;
1621
mysys_var->current_cond = cond;
1622
thd_proc_info(this, msg);
1625
inline void exit_cond(const char* old_msg)
1628
Putting the mutex unlock in exit_cond() ensures that
1629
mysys_var->current_mutex is always unlocked _before_ mysys_var->mutex is
1630
locked (if that would not be the case, you'll get a deadlock if someone
1631
does a THD::awake() on you).
1633
pthread_mutex_unlock(mysys_var->current_mutex);
1634
pthread_mutex_lock(&mysys_var->mutex);
1635
mysys_var->current_mutex = 0;
1636
mysys_var->current_cond = 0;
1637
thd_proc_info(this, old_msg);
1638
pthread_mutex_unlock(&mysys_var->mutex);
1640
inline time_t query_start() { query_start_used=1; return start_time; }
1000
const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex, const char* msg);
1001
void exit_cond(const char* old_msg);
1003
inline time_t query_start() { return start_time; }
1641
1004
inline void set_time()
1645
1008
start_time= user_time;
1646
start_utime= utime_after_lock= my_micro_time();
1009
connect_microseconds= start_utime= utime_after_lock= my_micro_time();
1649
1012
start_utime= utime_after_lock= my_micro_time_and_time(&start_time);
1651
inline void set_current_time() { start_time= my_time(MY_WME); }
1014
inline void set_current_time() { start_time= time(NULL); }
1652
1015
inline void set_time(time_t t)
1654
1017
start_time= user_time= t;
1655
1018
start_utime= utime_after_lock= my_micro_time();
1657
1020
void set_time_after_lock() { utime_after_lock= my_micro_time(); }
1658
uint64_t current_utime() { return my_micro_time(); }
1022
* Returns the current micro-timestamp
1024
inline uint64_t getCurrentTimestamp()
1026
return my_micro_time();
1659
1028
inline uint64_t found_rows(void)
1661
1030
return limit_found_rows;
1663
inline bool active_transaction()
1032
/** Returns whether the session is currently inside a transaction */
1033
inline bool inTransaction()
1665
1035
return server_status & SERVER_STATUS_IN_TRANS;
1915
1278
- for prepared queries, only to allocate runtime data. The parsed
1916
1279
tree itself is reused between executions and thus is stored elsewhere.
1918
MEM_ROOT main_mem_root;
1922
/** A short cut for thd->main_da.set_ok_status(). */
1925
my_ok(THD *thd, ha_rows affected_rows= 0, uint64_t id= 0,
1926
const char *message= NULL)
1928
thd->main_da.set_ok_status(thd, affected_rows, id, message);
1932
/** A short cut for thd->main_da.set_eof_status(). */
1937
thd->main_da.set_eof_status(thd);
1940
#define tmp_disable_binlog(A) \
1941
{uint64_t tmp_disable_binlog__save_options= (A)->options; \
1942
(A)->options&= ~OPTION_BIN_LOG
1944
#define reenable_binlog(A) (A)->options= tmp_disable_binlog__save_options;}
1948
Used to hold information about file and file structure in exchange
1949
via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
1950
XXX: We never call destructor for objects of this class.
1953
class sql_exchange :public Sql_alloc
1956
enum enum_filetype filetype; /* load XML, Added by Arnold & Erik */
1958
String *field_term,*enclosed,*line_term,*line_start,*escaped;
1962
const CHARSET_INFO *cs;
1963
sql_exchange(char *name, bool dumpfile_flag,
1964
enum_filetype filetype_arg= FILETYPE_CSV);
1967
#include "log_event.h"
1970
This is used to get result from a select
1281
memory::Root main_mem_root;
1284
* Marks all tables in the list which were used by current substatement
1285
* as free for reuse.
1287
* @param Head of the list of tables
1291
* The reason we reset query_id is that it's not enough to just test
1292
* if table->query_id != session->query_id to know if a table is in use.
1296
* SELECT f1_that_uses_t1() FROM t1;
1298
* In f1_that_uses_t1() we will see one instance of t1 where query_id is
1299
* set to query_id of original query.
1301
void mark_used_tables_as_free_for_reuse(Table *table);
1303
Mark all temporary tables which were used by the current statement or
1304
substatement as free for reuse, but only if the query_id can be cleared.
1306
@param session thread context
1308
@remark For temp tables associated with a open SQL HANDLER the query_id
1309
is not reset until the HANDLER is closed.
1311
void mark_temp_tables_as_free_for_reuse();
1315
/** A short cut for session->main_da.set_ok_status(). */
1316
inline void my_ok(ha_rows affected_rows= 0, ha_rows found_rows_arg= 0,
1317
uint64_t passed_id= 0, const char *message= NULL)
1319
main_da.set_ok_status(this, affected_rows, found_rows_arg, passed_id, message);
1323
/** A short cut for session->main_da.set_eof_status(). */
1325
inline void my_eof()
1327
main_da.set_eof_status(this);
1330
/* Some inline functions for more speed */
1332
inline bool add_item_to_list(Item *item)
1334
return lex->current_select->add_item_to_list(this, item);
1337
inline bool add_value_to_list(Item *value)
1339
return lex->value_list.push_back(value);
1342
inline bool add_order_to_list(Item *item, bool asc)
1344
return lex->current_select->add_order_to_list(this, item, asc);
1347
inline bool add_group_to_list(Item *item, bool asc)
1349
return lex->current_select->add_group_to_list(this, item, asc);
1351
void refresh_status();
1352
user_var_entry *getVariable(LEX_STRING &name, bool create_if_not_exists);
1355
* Closes all tables used by the current substatement, or all tables
1356
* used by this thread if we are on the upper level.
1358
void close_thread_tables();
1359
void close_old_data_files(bool morph_locks= false,
1360
bool send_refresh= false);
1361
void close_open_tables();
1362
void close_data_files_and_morph_locks(const char *db, const char *table_name);
1365
bool free_cached_table();
1369
* Prepares statement for reopening of tables and recalculation of set of
1372
* @param Pointer to a pointer to a list of tables which we were trying to open and lock
1374
void close_tables_for_reopen(TableList **tables);
1378
* Open all tables in list, locks them (all, including derived)
1380
* @param Pointer to a list of tables for open & locking
1389
* The lock will automaticaly be freed by close_thread_tables()
1391
bool openTablesLock(TableList *tables);
1394
* Open all tables in list and process derived tables
1396
* @param Pointer to a list of tables for open
1397
* @param Bitmap of flags to modify how the tables will be open:
1398
* DRIZZLE_LOCK_IGNORE_FLUSH - open table even if someone has
1399
* done a flush or namelock on it.
1408
* This is to be used on prepare stage when you don't read any
1409
* data from the tables.
1411
bool openTables(TableList *tables, uint32_t flags= 0);
1413
int open_tables_from_list(TableList **start, uint32_t *counter, uint32_t flags= 0);
1415
Table *openTableLock(TableList *table_list, thr_lock_type lock_type);
1416
Table *openTable(TableList *table_list, bool *refresh, uint32_t flags= 0);
1418
void unlink_open_table(Table *find);
1419
void drop_open_table(Table *table, const char *db_name,
1420
const char *table_name);
1421
void close_cached_table(Table *table);
1423
/* Create a lock in the cache */
1424
Table *table_cache_insert_placeholder(const char *key, uint32_t key_length);
1425
bool lock_table_name_if_not_cached(const char *db,
1426
const char *table_name, Table **table);
1428
/* Work with temporary tables */
1429
Table *find_temporary_table(TableList *table_list);
1430
Table *find_temporary_table(const char *db, const char *table_name);
1432
void close_temporary_tables();
1433
void close_temporary_table(Table *table);
1434
// The method below just handles the de-allocation of the table. In
1435
// a better memory type world, this would not be needed.
1437
void close_temporary(Table *table);
1440
int drop_temporary_table(TableList *table_list);
1441
bool rm_temporary_table(plugin::StorageEngine *base, const char *path);
1442
bool rm_temporary_table(plugin::StorageEngine *base, TableIdentifier &identifier);
1443
Table *open_temporary_table(TableIdentifier &identifier,
1444
bool link_in_list= true);
1446
/* Reopen operations */
1447
bool reopen_tables(bool get_locks, bool mark_share_as_old);
1448
bool reopen_name_locked_table(TableList* table_list, bool link_in);
1449
bool close_cached_tables(TableList *tables, bool wait_for_refresh, bool wait_for_placeholders);
1451
void wait_for_condition(pthread_mutex_t *mutex, pthread_cond_t *cond);
1452
int setup_conds(TableList *leaves, COND **conds);
1453
int lock_tables(TableList *tables, uint32_t count, bool *need_reopen);
1457
Return the default storage engine
1459
@param getDefaultStorageEngine()
1462
pointer to plugin::StorageEngine
1464
plugin::StorageEngine *getDefaultStorageEngine()
1466
if (variables.storage_engine)
1467
return variables.storage_engine;
1468
return global_system_variables.storage_engine;
1471
static void unlink(Session *session);
1975
class select_result :public Sql_alloc {
1978
SELECT_LEX_UNIT *unit;
1981
virtual ~select_result() {};
1982
virtual int prepare(List<Item> &list __attribute__((unused)),
1988
virtual int prepare2(void) { return 0; }
1990
Because of peculiarities of prepared statements protocol
1991
we need to know number of columns in the result set (if
1992
there is a result set) apart from sending columns metadata.
1994
virtual uint field_count(List<Item> &fields) const
1995
{ return fields.elements; }
1996
virtual bool send_fields(List<Item> &list, uint flags)=0;
1997
virtual bool send_data(List<Item> &items)=0;
1998
virtual bool initialize_tables (JOIN __attribute__((unused)) *join=0)
2000
virtual void send_error(uint errcode,const char *err);
2001
virtual bool send_eof()=0;
2003
Check if this query returns a result set and therefore is allowed in
2004
cursors and set an error message if it is not the case.
2006
@retval false success
2007
@retval true error, an error message is set
2009
virtual bool check_simple_select() const;
2010
virtual void abort() {}
2012
Cleanup instance of this class for next execution of a prepared
2013
statement/stored procedure.
2015
virtual void cleanup();
2016
void set_thd(THD *thd_arg) { thd= thd_arg; }
2017
void begin_dataset() {}
2022
Base class for select_result descendands which intercept and
2023
transform result set rows. As the rows are not sent to the client,
2024
sending of result set metadata should be suppressed as well.
2027
class select_result_interceptor: public select_result
2030
select_result_interceptor() {} /* Remove gcc warning */
2031
uint field_count(List<Item> &fields __attribute__((unused))) const
2033
bool send_fields(List<Item> &fields __attribute__((unused)),
2034
uint flag __attribute__((unused))) { return false; }
2038
class select_send :public select_result {
2040
True if we have sent result set metadata to the client.
2041
In this case the client always expects us to end the result
2042
set with an eof or error packet
2044
bool is_result_set_started;
2046
select_send() :is_result_set_started(false) {}
2047
bool send_fields(List<Item> &list, uint flags);
2048
bool send_data(List<Item> &items);
2050
virtual bool check_simple_select() const { return false; }
2052
virtual void cleanup();
2056
class select_to_file :public select_result_interceptor {
2058
sql_exchange *exchange;
2062
char path[FN_REFLEN];
2065
select_to_file(sql_exchange *ex) :exchange(ex), file(-1),row_count(0L)
2068
void send_error(uint errcode,const char *err);
2074
1477
#define ESCAPE_CHARS "ntrb0ZN" // keep synchronous with READ_INFO::unescape
2078
List of all possible characters of a numeric value text representation.
2080
#define NUMERIC_CHARS ".0123456789e+-"
2083
class select_export :public select_to_file {
2084
uint field_term_length;
2085
int field_sep_char,escape_char,line_sep_char;
2086
int field_term_char; // first char of FIELDS TERMINATED BY or MAX_INT
2088
The is_ambiguous_field_sep field is true if a value of the field_sep_char
2089
field is one of the 'n', 't', 'r' etc characters
2090
(see the READ_INFO::unescape method and the ESCAPE_CHARS constant value).
2092
bool is_ambiguous_field_sep;
2094
The is_ambiguous_field_term is true if field_sep_char contains the first
2095
char of the FIELDS TERMINATED BY (ENCLOSED BY is empty), and items can
2096
contain this character.
2098
bool is_ambiguous_field_term;
2100
The is_unsafe_field_sep field is true if a value of the field_sep_char
2101
field is one of the '0'..'9', '+', '-', '.' and 'e' characters
2102
(see the NUMERIC_CHARS constant value).
2104
bool is_unsafe_field_sep;
2105
bool fixed_row_size;
2107
select_export(sql_exchange *ex) :select_to_file(ex) {}
2109
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2110
bool send_data(List<Item> &items);
2114
class select_dump :public select_to_file {
2116
select_dump(sql_exchange *ex) :select_to_file(ex) {}
2117
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2118
bool send_data(List<Item> &items);
2122
class select_insert :public select_result_interceptor {
2124
TABLE_LIST *table_list;
2127
uint64_t autoinc_value_of_last_inserted_row; // autogenerated or not
2129
bool insert_into_view;
2130
select_insert(TABLE_LIST *table_list_par,
2131
TABLE *table_par, List<Item> *fields_par,
2132
List<Item> *update_fields, List<Item> *update_values,
2133
enum_duplicates duplic, bool ignore);
2135
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2136
virtual int prepare2(void);
2137
bool send_data(List<Item> &items);
2138
virtual void store_values(List<Item> &values);
2139
virtual bool can_rollback_data() { return 0; }
2140
void send_error(uint errcode,const char *err);
2143
/* not implemented: select_insert is never re-used in prepared statements */
2148
class select_create: public select_insert {
2150
TABLE_LIST *create_table;
2151
HA_CREATE_INFO *create_info;
2152
TABLE_LIST *select_tables;
2153
Alter_info *alter_info;
2155
/* lock data for tmp table */
2156
DRIZZLE_LOCK *m_lock;
2157
/* m_lock or thd->extra_lock */
2158
DRIZZLE_LOCK **m_plock;
2160
select_create (TABLE_LIST *table_arg,
2161
HA_CREATE_INFO *create_info_par,
2162
Alter_info *alter_info_arg,
2163
List<Item> &select_fields,enum_duplicates duplic, bool ignore,
2164
TABLE_LIST *select_tables_arg)
2165
:select_insert (NULL, NULL, &select_fields, 0, 0, duplic, ignore),
2166
create_table(table_arg),
2167
create_info(create_info_par),
2168
select_tables(select_tables_arg),
2169
alter_info(alter_info_arg),
2172
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2174
void binlog_show_create_table(TABLE **tables, uint count);
2175
void store_values(List<Item> &values);
2176
void send_error(uint errcode,const char *err);
2179
virtual bool can_rollback_data() { return 1; }
2181
// Needed for access from local class MY_HOOKS in prepare(), since thd is proteted.
2182
const THD *get_thd(void) { return thd; }
2183
const HA_CREATE_INFO *get_create_info() { return create_info; };
2184
int prepare2(void) { return 0; }
2187
#include <storage/myisam/myisam.h>
2190
Param to create temporary tables when doing SELECT:s
2192
This structure is copied using memcpy as a part of JOIN.
2195
class TMP_TABLE_PARAM :public Sql_alloc
2198
/* Prevent use of these (not safe because of lists and copy_field) */
2199
TMP_TABLE_PARAM(const TMP_TABLE_PARAM &);
2200
void operator=(TMP_TABLE_PARAM &);
2203
List<Item> copy_funcs;
2204
List<Item> save_copy_funcs;
2205
Copy_field *copy_field, *copy_field_end;
2206
Copy_field *save_copy_field, *save_copy_field_end;
2208
Item **items_to_copy; /* Fields in tmp table */
2209
MI_COLUMNDEF *recinfo,*start_recinfo;
2211
ha_rows end_write_records;
2212
uint field_count,sum_func_count,func_count;
2213
uint hidden_field_count;
2214
uint group_parts,group_length,group_null_parts;
2216
bool using_indirect_summary_function;
2217
/* If >0 convert all blob fields to varchar(convert_blob_length) */
2218
uint convert_blob_length;
2219
const CHARSET_INFO *table_charset;
2222
True if GROUP BY and its aggregate functions are already computed
2223
by a table access method (e.g. by loose index scan). In this case
2224
query execution should not perform aggregation and should treat
2225
aggregate functions as normal functions.
2227
bool precomputed_group_by;
2228
bool force_copy_fields;
2230
If true, create_tmp_field called from create_tmp_table will convert
2231
all BIT fields to 64-bit longs. This is a workaround the limitation
2232
that MEMORY tables cannot index BIT columns.
2234
bool bit_fields_as_long;
2237
:copy_field(0), group_parts(0),
2238
group_length(0), group_null_parts(0), convert_blob_length(0),
2239
schema_table(0), precomputed_group_by(0), force_copy_fields(0),
2240
bit_fields_as_long(0)
2247
inline void cleanup(void)
2249
if (copy_field) /* Fix for Intel compiler */
2251
delete [] copy_field;
2252
save_copy_field= copy_field= 0;
2257
class select_union :public select_result_interceptor
2259
TMP_TABLE_PARAM tmp_table_param;
2263
select_union() :table(0) {}
2264
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2265
bool send_data(List<Item> &items);
2269
bool create_result_table(THD *thd, List<Item> *column_types,
2270
bool is_distinct, uint64_t options,
2271
const char *alias, bool bit_fields_as_long);
2274
/* Base subselect interface class */
2275
class select_subselect :public select_result_interceptor
2278
Item_subselect *item;
2280
select_subselect(Item_subselect *item);
2281
bool send_data(List<Item> &items)=0;
2282
bool send_eof() { return 0; };
2285
/* Single value subselect interface class */
2286
class select_singlerow_subselect :public select_subselect
2289
select_singlerow_subselect(Item_subselect *item_arg)
2290
:select_subselect(item_arg)
2292
bool send_data(List<Item> &items);
2295
/* used in independent ALL/ANY optimisation */
2296
class select_max_min_finder_subselect :public select_subselect
2299
bool (select_max_min_finder_subselect::*op)();
2302
select_max_min_finder_subselect(Item_subselect *item_arg, bool mx)
2303
:select_subselect(item_arg), cache(0), fmax(mx)
2306
bool send_data(List<Item> &items);
2313
/* EXISTS subselect interface class */
2314
class select_exists_subselect :public select_subselect
2317
select_exists_subselect(Item_subselect *item_arg)
2318
:select_subselect(item_arg){}
2319
bool send_data(List<Item> &items);
2322
/* Structs used when sorting */
2324
typedef struct st_sort_field {
2325
Field *field; /* Field to sort */
2326
Item *item; /* Item if not sorting fields */
2327
uint length; /* Length of sort field */
2328
uint suffix_length; /* Length suffix (0-4) */
2329
Item_result result_type; /* Type of item */
2330
bool reverse; /* if descending sort */
2331
bool need_strxnfrm; /* If we have to use strxnfrm() */
1479
} /* namespace drizzled */
1481
/** @TODO why is this in the middle of the file */
1482
#include <drizzled/select_to_file.h>
1483
#include <drizzled/select_export.h>
1484
#include <drizzled/select_dump.h>
1485
#include <drizzled/select_insert.h>
1486
#include <drizzled/select_create.h>
1487
#include <drizzled/tmp_table_param.h>
1488
#include <drizzled/select_union.h>
1489
#include <drizzled/select_subselect.h>
1490
#include <drizzled/select_singlerow_subselect.h>
1491
#include <drizzled/select_max_min_finder_subselect.h>
1492
#include <drizzled/select_exists_subselect.h>
1498
* A structure used to describe sort information
1499
* for a field or item used in ORDER BY.
1501
typedef struct st_sort_field
1503
Field *field; /**< Field to sort */
1504
Item *item; /**< Item if not sorting fields */
1505
size_t length; /**< Length of sort field */
1506
uint32_t suffix_length; /**< Length suffix (0-4) */
1507
Item_result result_type; /**< Type of item */
1508
bool reverse; /**< if descending sort */
1509
bool need_strxnfrm; /**< If we have to use strxnfrm() */
2335
typedef struct st_sort_buffer {
2336
uint index; /* 0 or 1 */
2338
uint change_pos; /* If sort-fields changed */
1512
typedef struct st_sort_buffer
1514
uint32_t index; /* 0 or 1 */
1515
uint32_t sort_orders;
1516
uint32_t change_pos; /* If sort-fields changed */
2340
1518
SORT_FIELD *sortorder;
2343
/* Structure for db & table in sql_yacc */
2345
class Table_ident :public Sql_alloc
2350
SELECT_LEX_UNIT *sel;
2351
inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
2353
:table(table_arg), sel((SELECT_LEX_UNIT *)0)
2355
if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
2360
inline Table_ident(LEX_STRING table_arg)
2361
:table(table_arg), sel((SELECT_LEX_UNIT *)0)
2366
This constructor is used only for the case when we create a derived
2367
table. A derived table has no name and doesn't belong to any database.
2368
Later, if there was an alias specified for the table, it will be set
2369
by add_table_to_list.
2371
inline Table_ident(SELECT_LEX_UNIT *s) : sel(s)
2373
/* We must have a table name here as this is used with add_table_to_list */
2374
db.str= empty_c_string; /* a subject to casedn_str */
2376
table.str= internal_table_name;
2379
bool is_derived_table() const { return test(sel); }
2380
inline void change_db(char *db_name)
2382
db.str= db_name; db.length= (uint) strlen(db_name);
2386
// this is needed for user_vars hash
2387
class user_var_entry
2390
user_var_entry() {} /* Remove gcc warning */
2394
query_id_t update_query_id, used_query_id;
2398
double val_real(bool *null_value);
2399
int64_t val_int(bool *null_value) const;
2400
String *val_str(bool *null_value, String *str, uint decimals);
2401
my_decimal *val_decimal(bool *null_value, my_decimal *result);
2402
DTCollation collation;
2406
Unique -- class for unique (removing of duplicates).
2407
Puts all values to the TREE. If the tree becomes too big,
2408
it's dumped to the file. User can request sorted values, or
2409
just iterate through them. In the last case tree merging is performed in
2410
memory simultaneously with iteration, so it should be ~2-3x faster.
2413
class Unique :public Sql_alloc
2415
DYNAMIC_ARRAY file_ptrs;
2417
uint64_t max_in_memory_size;
2420
uchar *record_pointers;
2426
Unique(qsort_cmp2 comp_func, void *comp_func_fixed_arg,
2427
uint size_arg, uint64_t max_in_memory_size_arg);
2429
ulong elements_in_tree() { return tree.elements_in_tree; }
2430
inline bool unique_add(void *ptr)
2432
if (tree.elements_in_tree > max_elements && flush())
2434
return(!tree_insert(&tree, ptr, 0, tree.custom_arg));
2437
bool get(TABLE *table);
2438
static double get_use_cost(uint *buffer, uint nkeys, uint key_size,
2439
uint64_t max_in_memory_size);
2440
inline static int get_cost_calc_buff_size(ulong nkeys, uint key_size,
2441
uint64_t max_in_memory_size)
2443
register uint64_t max_elems_in_tree=
2444
(1 + max_in_memory_size / ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size));
2445
return (int) (sizeof(uint)*(1 + nkeys/max_elems_in_tree));
2449
bool walk(tree_walk_action action, void *walk_action_arg);
2451
friend int unique_write_to_file(uchar* key, element_count count, Unique *unique);
2452
friend int unique_write_to_ptrs(uchar* key, element_count count, Unique *unique);
2456
class multi_delete :public select_result_interceptor
2458
TABLE_LIST *delete_tables, *table_being_deleted;
2460
ha_rows deleted, found;
2464
/* True if at least one table we delete from is transactional */
2465
bool transactional_tables;
2466
/* True if at least one table we delete from is not transactional */
2468
bool delete_while_scanning;
2470
error handling (rollback and binlogging) can happen in send_eof()
2471
so that afterward send_error() needs to find out that.
2476
multi_delete(TABLE_LIST *dt, uint num_of_tables);
2478
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2479
bool send_data(List<Item> &items);
2480
bool initialize_tables (JOIN *join);
2481
void send_error(uint errcode,const char *err);
2484
virtual void abort();
2488
class multi_update :public select_result_interceptor
2490
TABLE_LIST *all_tables; /* query/update command tables */
2491
TABLE_LIST *leaves; /* list of leves of join table tree */
2492
TABLE_LIST *update_tables, *table_being_updated;
2493
TABLE **tmp_tables, *main_table, *table_to_update;
2494
TMP_TABLE_PARAM *tmp_table_param;
2495
ha_rows updated, found;
2496
List <Item> *fields, *values;
2497
List <Item> **fields_for_table, **values_for_table;
2500
List of tables referenced in the CHECK OPTION condition of
2501
the updated view excluding the updated table.
2503
List <TABLE> unupdated_check_opt_tables;
2504
Copy_field *copy_field;
2505
enum enum_duplicates handle_duplicates;
2506
bool do_update, trans_safe;
2507
/* True if the update operation has made a change in a transactional table */
2508
bool transactional_tables;
2511
error handling (rollback and binlogging) can happen in send_eof()
2512
so that afterward send_error() needs to find out that.
2517
multi_update(TABLE_LIST *ut, TABLE_LIST *leaves_list,
2518
List<Item> *fields, List<Item> *values,
2519
enum_duplicates handle_duplicates, bool ignore);
2521
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2522
bool send_data(List<Item> &items);
2523
bool initialize_tables (JOIN *join);
2524
void send_error(uint errcode,const char *err);
2527
virtual void abort();
2530
class my_var : public Sql_alloc {
2535
enum_field_types type;
2536
my_var (LEX_STRING& j, bool i, uint o, enum_field_types t)
2537
:s(j), local(i), offset(o), type(t)
2542
class select_dumpvar :public select_result_interceptor {
2545
List<my_var> var_list;
2546
select_dumpvar() { var_list.empty(); row_count= 0;}
2547
~select_dumpvar() {}
2548
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2549
bool send_data(List<Item> &items);
2551
virtual bool check_simple_select() const;
1521
} /* namespace drizzled */
1523
/** @TODO why is this in the middle of the file */
1525
#include <drizzled/table_ident.h>
1526
#include <drizzled/user_var_entry.h>
1527
#include <drizzled/unique.h>
1528
#include <drizzled/my_var.h>
1529
#include <drizzled/select_dumpvar.h>
2555
1534
/* Bits in sql_command_flags */
2557
#define CF_CHANGES_DATA 1
2558
#define CF_HAS_ROW_COUNT 2
2559
#define CF_STATUS_COMMAND 4
2560
#define CF_SHOW_TABLE_COMMAND 8
2561
#define CF_WRITE_LOGS_COMMAND 16
1536
enum sql_command_flag_bits
1538
CF_BIT_CHANGES_DATA,
1539
CF_BIT_HAS_ROW_COUNT,
1540
CF_BIT_STATUS_COMMAND,
1541
CF_BIT_SHOW_TABLE_COMMAND,
1542
CF_BIT_WRITE_LOGS_COMMAND,
1546
static const std::bitset<CF_BIT_SIZE> CF_CHANGES_DATA(1 << CF_BIT_CHANGES_DATA);
1547
static const std::bitset<CF_BIT_SIZE> CF_HAS_ROW_COUNT(1 << CF_BIT_HAS_ROW_COUNT);
1548
static const std::bitset<CF_BIT_SIZE> CF_STATUS_COMMAND(1 << CF_BIT_STATUS_COMMAND);
1549
static const std::bitset<CF_BIT_SIZE> CF_SHOW_TABLE_COMMAND(1 << CF_BIT_SHOW_TABLE_COMMAND);
1550
static const std::bitset<CF_BIT_SIZE> CF_WRITE_LOGS_COMMAND(1 << CF_BIT_WRITE_LOGS_COMMAND);
2563
1552
/* Functions in sql_class.cc */
2565
1553
void add_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var);
2567
1555
void add_diff_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var,
2568
1556
STATUS_VAR *dec_var);
2570
#endif /* DRIZZLE_SERVER */
1558
} /* namespace drizzled */
1560
#endif /* DRIZZLED_SESSION_H */
added
removed
drizzled/session.h
