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;
32
class Lex_input_stream;
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 };
47
extern char internal_table_name[2];
48
extern char empty_c_string[1];
49
extern const char **errmesg;
51
#define TC_LOG_PAGE_SIZE 8192
52
#define TC_LOG_MIN_SIZE (3*TC_LOG_PAGE_SIZE)
54
#define TC_HEURISTIC_RECOVER_COMMIT 1
55
#define TC_HEURISTIC_RECOVER_ROLLBACK 2
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) {}
237
Query_cache_tls -- query cache thread local data.
240
struct Query_cache_block;
242
struct Query_cache_tls
245
'first_query_block' should be accessed only via query cache
246
functions and methods to maintain proper locking.
248
Query_cache_block *first_query_block;
249
void set_first_query_block(Query_cache_block *first_query_block_arg)
251
first_query_block= first_query_block_arg;
254
Query_cache_tls() :first_query_block(NULL) {}
257
#include "sql_lex.h" /* Must be here */
262
#define THD_SENTRY_MAGIC 0xfeedd1ff
263
#define THD_SENTRY_GONE 0xdeadbeef
265
#define THD_CHECK_SENTRY(thd) DBUG_ASSERT(thd->dbug_sentry == THD_SENTRY_MAGIC)
267
struct system_variables
270
How dynamically allocated system variables are handled:
272
The global_system_variables and max_system_variables are "authoritative"
273
They both should have the same 'version' and 'size'.
274
When attempting to access a dynamic variable, if the session version
275
is out of date, then the session version is updated and realloced if
276
neccessary and bytes copied from global to make up for missing data.
278
ulong dynamic_variables_version;
279
char* dynamic_variables_ptr;
280
uint dynamic_variables_head; /* largest valid variable offset */
281
uint dynamic_variables_size; /* how many bytes are in use */
283
ulonglong myisam_max_extra_sort_file_size;
284
ulonglong myisam_max_sort_file_size;
285
ulonglong max_heap_table_size;
286
ulonglong tmp_table_size;
287
ulonglong long_query_time;
288
ha_rows select_limit;
289
ha_rows max_join_size;
290
ulong auto_increment_increment, auto_increment_offset;
291
ulong bulk_insert_buff_size;
292
ulong join_buff_size;
293
ulong max_allowed_packet;
294
ulong max_error_count;
295
ulong max_length_for_sort_data;
296
ulong max_sort_length;
297
ulong max_tmp_tables;
298
ulong min_examined_row_limit;
299
ulong myisam_repair_threads;
300
ulong myisam_sort_buff_size;
301
ulong myisam_stats_method;
302
ulong net_buffer_length;
303
ulong net_interactive_timeout;
304
ulong net_read_timeout;
305
ulong net_retry_count;
306
ulong net_wait_timeout;
307
ulong net_write_timeout;
308
ulong optimizer_prune_level;
309
ulong optimizer_search_depth;
311
Controls use of Engine-MRR:
312
0 - auto, based on cost
313
1 - force MRR when the storage engine is capable of doing it
316
ulong optimizer_use_mrr;
317
/* A bitmap for switching optimizations on/off */
318
ulong optimizer_switch;
319
ulong preload_buff_size;
320
ulong profiling_history_size;
321
ulong query_cache_type;
322
ulong read_buff_size;
323
ulong read_rnd_buff_size;
324
ulong div_precincrement;
326
ulong thread_handling;
328
ulong completion_type;
329
/* Determines which non-standard SQL behaviour should be enabled */
331
ulong default_week_format;
332
ulong max_seeks_for_key;
333
ulong range_alloc_block_size;
334
ulong query_alloc_block_size;
335
ulong query_prealloc_size;
336
ulong trans_alloc_block_size;
337
ulong trans_prealloc_size;
339
ulong group_concat_max_len;
340
ulong binlog_format; // binlog format for this thd (see enum_binlog_format)
342
In slave thread we need to know in behalf of which
343
thread the query is being run to replicate temp tables properly
345
my_thread_id pseudo_thread_id;
347
my_bool low_priority_updates;
350
compatibility option:
351
- index usage hints (USE INDEX without a FOR clause) behave as in 5.0
354
my_bool query_cache_wlock_invalidate;
355
my_bool engine_condition_pushdown;
356
my_bool keep_files_on_create;
358
my_bool old_alter_table;
359
my_bool old_passwords;
361
plugin_ref table_plugin;
363
/* Only charset part of these variables is sensible */
364
CHARSET_INFO *character_set_filesystem;
365
CHARSET_INFO *character_set_client;
366
CHARSET_INFO *character_set_results;
368
/* Both charset and collation parts of these variables are important */
369
CHARSET_INFO *collation_server;
370
CHARSET_INFO *collation_database;
371
CHARSET_INFO *collation_connection;
374
MY_LOCALE *lc_time_names;
376
Time_zone *time_zone;
378
/* DATE, DATETIME and MYSQL_TIME formats */
379
DATE_TIME_FORMAT *date_format;
380
DATE_TIME_FORMAT *datetime_format;
381
DATE_TIME_FORMAT *time_format;
382
my_bool sysdate_is_now;
387
/* per thread status variables */
389
typedef struct system_status_var
391
ulonglong bytes_received;
392
ulonglong bytes_sent;
394
ulong com_stat[(uint) SQLCOM_END];
395
ulong created_tmp_disk_tables;
396
ulong created_tmp_tables;
397
ulong ha_commit_count;
398
ulong ha_delete_count;
399
ulong ha_read_first_count;
400
ulong ha_read_last_count;
401
ulong ha_read_key_count;
402
ulong ha_read_next_count;
403
ulong ha_read_prev_count;
404
ulong ha_read_rnd_count;
405
ulong ha_read_rnd_next_count;
406
ulong ha_rollback_count;
407
ulong ha_update_count;
408
ulong ha_write_count;
409
ulong ha_prepare_count;
410
ulong ha_discover_count;
411
ulong ha_savepoint_count;
412
ulong ha_savepoint_rollback_count;
414
/* KEY_CACHE parts. These are copies of the original */
415
ulong key_blocks_changed;
416
ulong key_blocks_used;
417
ulong key_cache_r_requests;
418
ulong key_cache_read;
419
ulong key_cache_w_requests;
420
ulong key_cache_write;
421
/* END OF KEY_CACHE parts */
423
ulong net_big_packet_count;
426
ulong select_full_join_count;
427
ulong select_full_range_join_count;
428
ulong select_range_count;
429
ulong select_range_check_count;
430
ulong select_scan_count;
431
ulong long_query_count;
432
ulong filesort_merge_passes;
433
ulong filesort_range_count;
435
ulong filesort_scan_count;
436
/* Prepared statements and binary protocol */
437
ulong com_stmt_prepare;
438
ulong com_stmt_execute;
439
ulong com_stmt_send_long_data;
440
ulong com_stmt_fetch;
441
ulong com_stmt_reset;
442
ulong com_stmt_close;
444
Number of statements sent from the client
450
SEE last_system_status_var DEFINITION BELOW.
452
Below 'last_system_status_var' are all variables which doesn't make any
453
sense to add to the /global/ status variable counter.
455
double last_query_cost;
461
This is used for 'SHOW STATUS'. It must be updated to the last ulong
462
variable in system_status_var which is makes sens to add to the global
466
#define last_system_status_var questions
468
void mark_transaction_to_rollback(THD *thd, bool all);
472
void free_tmp_table(THD *thd, TABLE *entry);
475
/* The following macro is to make init of Query_arena simpler */
477
#define INIT_ARENA_DBUG_INFO is_backup_arena= 0
479
#define INIT_ARENA_DBUG_INFO
486
List of items created in the parser for this query. Every item puts
487
itself to the list on creation (see Item::Item() for details))
490
MEM_ROOT *mem_root; // Pointer to current memroot
492
bool is_backup_arena; /* True if this arena is used for backup. */
495
The states relfects three diffrent life cycles for three
496
different types of statements:
497
Prepared statement: INITIALIZED -> PREPARED -> EXECUTED.
498
Stored procedure: INITIALIZED_FOR_SP -> EXECUTED.
499
Other statements: CONVENTIONAL_EXECUTION never changes.
503
INITIALIZED= 0, INITIALIZED_FOR_SP= 1, PREPARED= 2,
504
CONVENTIONAL_EXECUTION= 3, EXECUTED= 4, ERROR= -1
509
/* We build without RTTI, so dynamic_cast can't be used. */
512
STATEMENT, PREPARED_STATEMENT, STORED_PROCEDURE
515
Query_arena(MEM_ROOT *mem_root_arg, enum enum_state state_arg) :
516
free_list(0), mem_root(mem_root_arg), state(state_arg)
517
{ INIT_ARENA_DBUG_INFO; }
519
This constructor is used only when Query_arena is created as
520
backup storage for another instance of Query_arena.
522
Query_arena() { INIT_ARENA_DBUG_INFO; }
524
virtual ~Query_arena() {};
526
inline bool is_conventional() const
527
{ assert(state == CONVENTIONAL_EXECUTION); return state == CONVENTIONAL_EXECUTION; }
529
inline void* alloc(size_t size) { return alloc_root(mem_root,size); }
530
inline void* calloc(size_t size)
533
if ((ptr=alloc_root(mem_root,size)))
537
inline char *strdup(const char *str)
538
{ return strdup_root(mem_root,str); }
539
inline char *strmake(const char *str, size_t size)
540
{ return strmake_root(mem_root,str,size); }
541
inline void *memdup(const void *str, size_t size)
542
{ return memdup_root(mem_root,str,size); }
543
inline void *memdup_w_gap(const void *str, size_t size, uint gap)
546
if ((ptr= alloc_root(mem_root,size+gap)))
547
memcpy(ptr,str,size);
551
void set_query_arena(Query_arena *set);
554
/* Close the active state associated with execution of this statement */
555
virtual void cleanup_stmt();
561
@brief State of a single command executed against this connection.
563
One connection can contain a lot of simultaneously running statements,
564
some of which could be:
565
- prepared, that is, contain placeholders,
566
To perform some action with statement we reset THD part to the state of
567
that statement, do the action, and then save back modified state from THD
568
to the statement. It will be changed in near future, and Statement will
572
class Statement: public ilink, public Query_arena
574
Statement(const Statement &rhs); /* not implemented: */
575
Statement &operator=(const Statement &rhs); /* non-copyable */
578
Uniquely identifies each statement object in thread scope; change during
579
statement lifetime. FIXME: must be const
584
MARK_COLUMNS_NONE: Means mark_used_colums is not set and no indicator to
585
handler of fields used is set
586
MARK_COLUMNS_READ: Means a bit in read set is set to inform handler
587
that the field is to be read. If field list contains
588
duplicates, then thd->dup_field is set to point
589
to the last found duplicate.
590
MARK_COLUMNS_WRITE: Means a bit is set in write set to inform handler
591
that it needs to update this field in write_row
594
enum enum_mark_columns mark_used_columns;
596
LEX_STRING name; /* name for named prepared statements */
597
LEX *lex; // parse tree descriptor
599
Points to the query associated with this statement. It's const, but
600
we need to declare it char * because all table handlers are written
601
in C and need to point to it.
603
Note that (A) if we set query = NULL, we must at the same time set
604
query_length = 0, and protect the whole operation with the
605
LOCK_thread_count mutex. And (B) we are ONLY allowed to set query to a
606
non-NULL value if its previous value is NULL. We do not need to protect
607
operation (B) with any mutex. To avoid crashes in races, if we do not
608
know that thd->query cannot change at the moment, one should print
609
thd->query like this:
610
(1) reserve the LOCK_thread_count mutex;
611
(2) check if thd->query is NULL;
612
(3) if not NULL, then print at most thd->query_length characters from
613
it. We will see the query_length field as either 0, or the right value
615
Assuming that the write and read of an n-bit memory field in an n-bit
616
computer is atomic, we can avoid races in the above way.
617
This printing is needed at least in SHOW PROCESSLIST and SHOW INNODB
621
uint32 query_length; // current query length
624
Name of the current (default) database.
626
If there is the current (default) database, "db" contains its name. If
627
there is no current (default) database, "db" is NULL and "db_length" is
628
0. In other words, "db", "db_length" must either be NULL, or contain a
631
@note this attribute is set and alloced by the slave SQL thread (for
632
the THD of that thread); that thread is (and must remain, for now) the
633
only responsible for freeing this member.
641
/* This constructor is called for backup statements */
644
Statement(LEX *lex_arg, MEM_ROOT *mem_root_arg,
645
enum enum_state state_arg, ulong id_arg);
648
/* Assign execution context (note: not all members) of given stmt to self */
649
void set_statement(Statement *stmt);
650
void set_n_backup_statement(Statement *stmt, Statement *backup);
651
void restore_backup_statement(Statement *stmt, Statement *backup);
654
struct st_savepoint {
655
struct st_savepoint *prev;
658
Ha_trx_info *ha_list;
661
enum xa_states {XA_NOTR=0, XA_ACTIVE, XA_IDLE, XA_PREPARED};
662
extern const char *xa_state_names[];
664
typedef struct st_xid_state {
665
/* For now, this is only used to catch duplicated external xids */
666
XID xid; // transaction identifier
667
enum xa_states xa_state; // used by external XA only
671
extern pthread_mutex_t LOCK_xid_cache;
672
extern HASH xid_cache;
673
bool xid_cache_init(void);
674
void xid_cache_free(void);
675
XID_STATE *xid_cache_search(XID *xid);
676
bool xid_cache_insert(XID *xid, enum xa_states xa_state);
677
bool xid_cache_insert(XID_STATE *xid_state);
678
void xid_cache_delete(XID_STATE *xid_state);
681
@class Security_context
682
@brief A set of THD members describing the current authenticated user.
685
class Security_context {
687
Security_context() {} /* Remove gcc warning */
689
host - host of the client
690
user - user of the client, set to NULL until the user has been read from
692
priv_user - The user privilege we are using. May be "" for anonymous user.
695
char *host, *user, *priv_user, *ip;
696
/* The host privilege we are using */
697
char priv_host[MAX_HOSTNAME];
698
/* points to host if host is available, otherwise points to ip */
699
const char *host_or_ip;
700
ulong db_access; /* Privileges for current db */
705
inline char *priv_host_name()
707
return (*priv_host ? priv_host : (char *)"%");
713
A registry for item tree transformations performed during
714
query optimization. We register only those changes which require
715
a rollback to re-execute a prepared statement or stored procedure
719
struct Item_change_record;
720
typedef I_List<Item_change_record> Item_change_list;
724
Class that holds information about tables which were opened and locked
725
by the thread. It is also used to save/restore this information in
726
push_open_tables_state()/pop_open_tables_state().
729
class Open_tables_state
733
List of regular tables in use by this thread. Contains temporary and
734
base tables that were opened with @see open_tables().
738
List of temporary tables used by this thread. Contains user-level
739
temporary tables, created with CREATE TEMPORARY TABLE, and
740
internal temporary tables, created, e.g., to resolve a SELECT,
741
or for an intermediate table used in ALTER.
742
XXX Why are internal temporary tables added to this list?
744
TABLE *temporary_tables;
746
List of tables that were opened with HANDLER OPEN and are
747
still in use by this thread.
749
TABLE *handler_tables;
750
TABLE *derived_tables;
752
During a MySQL session, one can lock tables in two modes: automatic
753
or manual. In automatic mode all necessary tables are locked just before
754
statement execution, and all acquired locks are stored in 'lock'
755
member. Unlocking takes place automatically as well, when the
757
Manual mode comes into play when a user issues a 'LOCK TABLES'
758
statement. In this mode the user can only use the locked tables.
759
Trying to use any other tables will give an error. The locked tables are
760
stored in 'locked_tables' member. Manual locking is described in
761
the 'LOCK_TABLES' chapter of the MySQL manual.
762
See also lock_tables() for details.
766
Tables that were locked with explicit or implicit LOCK TABLES.
767
(Implicit LOCK TABLES happens when we are prelocking tables for
768
execution of statement which uses stored routines. See description
769
THD::prelocked_mode for more info.)
771
MYSQL_LOCK *locked_tables;
774
CREATE-SELECT keeps an extra lock for the table being
775
created. This field is used to keep the extra lock available for
776
lower level routines, which would otherwise miss that lock.
778
MYSQL_LOCK *extra_lock;
781
uint current_tablenr;
784
BACKUPS_AVAIL = (1U << 0) /* There are backups available */
788
Flags with information about the open tables state.
793
This constructor serves for creation of Open_tables_state instances
794
which are used as backup storage.
796
Open_tables_state() : state_flags(0U) { }
798
Open_tables_state(ulong version_arg);
800
void set_open_tables_state(Open_tables_state *state)
805
void reset_open_tables_state()
807
open_tables= temporary_tables= handler_tables= derived_tables= 0;
808
extra_lock= lock= locked_tables= 0;
814
@class Sub_statement_state
815
@brief Used to save context when executing a function or trigger
818
/* Defines used for Sub_statement_state::in_sub_stmt */
820
#define SUB_STMT_TRIGGER 1
821
#define SUB_STMT_FUNCTION 2
824
class Sub_statement_state
828
ulonglong first_successful_insert_id_in_prev_stmt;
829
ulonglong first_successful_insert_id_in_cur_stmt, insert_id_for_cur_row;
830
Discrete_interval auto_inc_interval_for_cur_row;
831
Discrete_intervals_list auto_inc_intervals_forced;
832
ulonglong limit_found_rows;
833
ha_rows cuted_fields, sent_row_count, examined_row_count;
834
ulong client_capabilities;
836
bool enable_slow_log;
837
bool last_insert_id_used;
838
SAVEPOINT *savepoints;
842
/* Flags for the THD::system_thread variable */
843
enum enum_thread_type
845
NON_SYSTEM_THREAD= 0,
846
SYSTEM_THREAD_DELAYED_INSERT= 1,
847
SYSTEM_THREAD_SLAVE_IO= 2,
848
SYSTEM_THREAD_SLAVE_SQL= 4,
849
SYSTEM_THREAD_NDBCLUSTER_BINLOG= 8,
850
SYSTEM_THREAD_EVENT_SCHEDULER= 16,
851
SYSTEM_THREAD_EVENT_WORKER= 32,
852
SYSTEM_THREAD_BACKUP= 64
857
This class represents the interface for internal error handlers.
858
Internal error handlers are exception handlers used by the server
861
class Internal_error_handler
864
Internal_error_handler() {}
865
virtual ~Internal_error_handler() {}
869
Handle an error condition.
870
This method can be implemented by a subclass to achieve any of the
872
- mask an error internally, prevent exposing it to the user,
873
- mask an error and throw another one instead.
874
When this method returns true, the error condition is considered
875
'handled', and will not be propagated to upper layers.
876
It is the responsability of the code installing an internal handler
877
to then check for trapped conditions, and implement logic to recover
878
from the anticipated conditions trapped during runtime.
880
This mechanism is similar to C++ try/throw/catch:
881
- 'try' correspond to <code>THD::push_internal_handler()</code>,
882
- 'throw' correspond to <code>my_error()</code>,
883
which invokes <code>my_message_sql()</code>,
884
- 'catch' correspond to checking how/if an internal handler was invoked,
885
before removing it from the exception stack with
886
<code>THD::pop_internal_handler()</code>.
888
@param sql_errno the error number
889
@param level the error level
890
@param thd the calling thread
891
@return true if the error is handled
893
virtual bool handle_error(uint sql_errno,
895
MYSQL_ERROR::enum_warning_level level,
901
Stores status of the currently executed statement.
902
Cleared at the beginning of the statement, and then
903
can hold either OK, ERROR, or EOF status.
904
Can not be assigned twice per statement.
907
class Diagnostics_area
910
enum enum_diagnostics_status
912
/** The area is cleared at start of a statement. */
914
/** Set whenever one calls my_ok(). */
916
/** Set whenever one calls my_eof(). */
918
/** Set whenever one calls my_error() or my_message(). */
920
/** Set in case of a custom response, such as one from COM_STMT_PREPARE. */
923
/** True if status information is sent to the client. */
925
/** Set to make set_error_status after set_{ok,eof}_status possible. */
926
bool can_overwrite_status;
928
void set_ok_status(THD *thd, ha_rows affected_rows_arg,
929
ulonglong last_insert_id_arg,
930
const char *message);
931
void set_eof_status(THD *thd);
932
void set_error_status(THD *thd, uint sql_errno_arg, const char *message_arg);
934
void disable_status();
936
void reset_diagnostics_area();
938
bool is_set() const { return m_status != DA_EMPTY; }
939
bool is_error() const { return m_status == DA_ERROR; }
940
bool is_eof() const { return m_status == DA_EOF; }
941
bool is_ok() const { return m_status == DA_OK; }
942
bool is_disabled() const { return m_status == DA_DISABLED; }
943
enum_diagnostics_status status() const { return m_status; }
945
const char *message() const
946
{ DBUG_ASSERT(m_status == DA_ERROR || m_status == DA_OK); return m_message; }
948
uint sql_errno() const
949
{ DBUG_ASSERT(m_status == DA_ERROR); return m_sql_errno; }
951
uint server_status() const
953
DBUG_ASSERT(m_status == DA_OK || m_status == DA_EOF);
954
return m_server_status;
957
ha_rows affected_rows() const
958
{ DBUG_ASSERT(m_status == DA_OK); return m_affected_rows; }
960
ulonglong last_insert_id() const
961
{ DBUG_ASSERT(m_status == DA_OK); return m_last_insert_id; }
963
uint total_warn_count() const
965
DBUG_ASSERT(m_status == DA_OK || m_status == DA_EOF);
966
return m_total_warn_count;
969
Diagnostics_area() { reset_diagnostics_area(); }
972
/** Message buffer. Can be used by OK or ERROR status. */
973
char m_message[MYSQL_ERRMSG_SIZE];
975
SQL error number. One of ER_ codes from share/errmsg.txt.
976
Set by set_error_status.
981
Copied from thd->server_status when the diagnostics area is assigned.
982
We need this member as some places in the code use the following pattern:
983
thd->server_status|= ...
985
thd->server_status&= ~...
986
Assigned by OK, EOF or ERROR.
988
uint m_server_status;
990
The number of rows affected by the last statement. This is
991
semantically close to thd->row_count_func, but has a different
992
life cycle. thd->row_count_func stores the value returned by
993
function ROW_COUNT() and is cleared only by statements that
994
update its value, such as INSERT, UPDATE, DELETE and few others.
995
This member is cleared at the beginning of the next statement.
997
We could possibly merge the two, but life cycle of thd->row_count_func
1000
ha_rows m_affected_rows;
1002
Similarly to the previous member, this is a replacement of
1003
thd->first_successful_insert_id_in_prev_stmt, which is used
1004
to implement LAST_INSERT_ID().
1006
ulonglong m_last_insert_id;
1007
/** The total number of warnings. */
1008
uint m_total_warn_count;
1009
enum_diagnostics_status m_status;
1011
@todo: the following THD members belong here:
1012
- warn_list, warn_count,
1018
Storage engine specific thread local data.
1024
Storage engine specific thread local data.
1025
Lifetime: one user connection.
1029
0: Life time: one statement within a transaction. If @@autocommit is
1030
on, also represents the entire transaction.
1031
@sa trans_register_ha()
1033
1: Life time: one transaction within a connection.
1034
If the storage engine does not participate in a transaction,
1035
this should not be used.
1036
@sa trans_register_ha()
1038
Ha_trx_info ha_info[2];
1040
Ha_data() :ha_ptr(NULL) {}
1046
For each client connection we create a separate thread with THD serving as
1047
a thread/connection descriptor
1050
class THD :public Statement,
1051
public Open_tables_state
1054
/* Used to execute base64 coded binlog events in MySQL server */
1055
Relay_log_info* rli_fake;
1058
Constant for THD::where initialization in the beginning of every query.
1060
It's needed because we do not save/restore THD::where normally during
1061
primary (non subselect) query execution.
1063
static const char * const DEFAULT_WHERE;
1065
NET net; // client connection descriptor
1066
MEM_ROOT warn_root; // For warnings and errors
1067
Protocol *protocol; // Current protocol
1068
Protocol_text protocol_text; // Normal protocol
1069
HASH user_vars; // hash for user variables
1070
String packet; // dynamic buffer for network I/O
1071
String convert_buffer; // buffer for charset conversions
1072
struct rand_struct rand; // used for authentication
1073
struct system_variables variables; // Changeable local variables
1074
struct system_status_var status_var; // Per thread statistic vars
1075
struct system_status_var *initial_status_var; /* used by show status */
1076
THR_LOCK_INFO lock_info; // Locking info of this thread
1077
THR_LOCK_OWNER main_lock_id; // To use for conventional queries
1078
THR_LOCK_OWNER *lock_id; // If not main_lock_id, points to
1079
// the lock_id of a cursor.
1080
pthread_mutex_t LOCK_delete; // Locked before thd is deleted
1082
A pointer to the stack frame of handle_one_connection(),
1083
which is called first in the thread for handling a client
1088
Currently selected catalog.
1094
Some members of THD (currently 'Statement::db',
1095
'catalog' and 'query') are set and alloced by the slave SQL thread
1096
(for the THD of that thread); that thread is (and must remain, for now)
1097
the only responsible for freeing these 3 members. If you add members
1098
here, and you add code to set them in replication, don't forget to
1099
free_them_and_set_them_to_0 in replication properly. For details see
1100
the 'err:' label of the handle_slave_sql() in sql/slave.cc.
1102
@see handle_slave_sql
1105
Security_context main_security_ctx;
1106
Security_context *security_ctx;
1109
Points to info-string that we show in SHOW PROCESSLIST
1110
You are supposed to call THD_SET_PROC_INFO only if you have coded
1111
a time-consuming piece that MySQL can get stuck in for a long time.
1113
Set it using the thd_proc_info(THD *thread, const char *message)
1117
#define THD_SET_PROC_INFO(thd, info) \
1118
(thd)->set_proc_info(__FILE__, __LINE__, (info))
1120
void set_proc_info(const char* file, int line, const char* info);
1122
#define THD_SET_PROC_INFO(thd, info) \
1123
(thd)->proc_info= (info)
1126
inline const char* get_proc_info() { return proc_info;}
1128
/* left public for the the storage engines, please avoid direct use */
1129
const char *proc_info;
1132
Used in error messages to tell user in what part of MySQL we found an
1133
error. E. g. when where= "having clause", if fix_fields() fails, user
1134
will know that the error was in having clause.
1138
double tmp_double_value; /* Used in set_var.cc */
1139
ulong client_capabilities; /* What the client supports */
1140
ulong max_client_packet_length;
1142
HASH handler_tables_hash;
1144
One thread can hold up to one named user-level lock. This variable
1145
points to a lock object if the lock is present. See item_func.cc and
1146
chapter 'Miscellaneous functions', for functions GET_LOCK, RELEASE_LOCK.
1149
uint dbug_sentry; // watch out for memory corruption
1151
struct st_my_thread_var *mysys_var;
1153
Type of current query: COM_STMT_PREPARE, COM_QUERY, etc. Set from
1154
first byte of the packet in do_command()
1156
enum enum_server_command command;
1158
uint32 file_id; // for LOAD DATA INFILE
1159
/* remote (peer) port */
1161
time_t start_time, user_time;
1162
ulonglong connect_utime, thr_create_utime; // track down slow pthread_create
1163
ulonglong start_utime, utime_after_lock;
1165
thr_lock_type update_lock_default;
1167
/* <> 0 if we are inside of trigger or stored function. */
1170
/* container for handler's private per-connection data */
1171
Ha_data ha_data[MAX_HA];
1173
/* Place to store various things */
1175
#ifndef MYSQL_CLIENT
1176
int binlog_setup_trx_data();
1179
Public interface to write RBR events to the binlog
1181
void binlog_start_trans_and_stmt();
1182
void binlog_set_stmt_begin();
1183
int binlog_write_table_map(TABLE *table, bool is_transactional);
1184
int binlog_write_row(TABLE* table, bool is_transactional,
1185
const uchar *new_data);
1186
int binlog_delete_row(TABLE* table, bool is_transactional,
1187
const uchar *old_data);
1188
int binlog_update_row(TABLE* table, bool is_transactional,
1189
const uchar *old_data, const uchar *new_data);
1191
void set_server_id(uint32 sid) { server_id = sid; }
1194
Member functions to handle pending event for row-level logging.
1196
template <class RowsEventT> Rows_log_event*
1197
binlog_prepare_pending_rows_event(TABLE* table, uint32 serv_id,
1199
bool is_transactional,
1201
Rows_log_event* binlog_get_pending_rows_event() const;
1202
void binlog_set_pending_rows_event(Rows_log_event* ev);
1203
int binlog_flush_pending_rows_event(bool stmt_end);
1206
uint binlog_table_maps; // Number of table maps currently in the binlog
1208
enum enum_binlog_flag {
1209
BINLOG_FLAG_UNSAFE_STMT_PRINTED,
1214
Flags with per-thread information regarding the status of the
1217
uint32 binlog_flags;
1219
uint get_binlog_table_maps() const {
1220
return binlog_table_maps;
1222
void clear_binlog_table_maps() {
1223
binlog_table_maps= 0;
1225
#endif /* MYSQL_CLIENT */
1229
struct st_transactions {
1230
SAVEPOINT *savepoints;
1231
THD_TRANS all; // Trans since BEGIN WORK
1232
THD_TRANS stmt; // Trans for current statement
1233
bool on; // see ha_enable_transaction()
1234
XID_STATE xid_state;
1235
Rows_log_event *m_pending_rows_event;
1238
Tables changed in transaction (that must be invalidated in query cache).
1239
List contain only transactional tables, that not invalidated in query
1240
cache (instead of full list of changed in transaction tables).
1242
CHANGED_TABLE_LIST* changed_tables;
1243
MEM_ROOT mem_root; // Transaction-life memory allocation pool
1248
free_root(&mem_root,MYF(MY_KEEP_PREALLOC));
1252
bzero((char*)this, sizeof(*this));
1253
xid_state.xid.null();
1254
init_sql_alloc(&mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
1259
#ifdef SIGNAL_WITH_VIO_CLOSE
1263
This is to track items changed during execution of a prepared
1264
statement/stored procedure. It's created by
1265
register_item_tree_change() in memory root of THD, and freed in
1266
rollback_item_tree_changes(). For conventional execution it's always
1269
Item_change_list change_list;
1272
A permanent memory area of the statement. For conventional
1273
execution, the parsed tree and execution runtime reside in the same
1274
memory root. In this case stmt_arena points to THD. In case of
1275
a prepared statement or a stored procedure statement, thd->mem_root
1276
conventionally points to runtime memory, and thd->stmt_arena
1277
points to the memory of the PS/SP, where the parsed tree of the
1278
statement resides. Whenever you need to perform a permanent
1279
transformation of a parsed tree, you should allocate new memory in
1280
stmt_arena, to allow correct re-execution of PS/SP.
1281
Note: in the parser, stmt_arena == thd, even for PS/SP.
1283
Query_arena *stmt_arena;
1284
/* Tells if LAST_INSERT_ID(#) was called for the current statement */
1285
bool arg_of_last_insert_id_function;
1287
ALL OVER THIS FILE, "insert_id" means "*automatically generated* value for
1288
insertion into an auto_increment column".
1291
This is the first autogenerated insert id which was *successfully*
1292
inserted by the previous statement (exactly, if the previous statement
1293
didn't successfully insert an autogenerated insert id, then it's the one
1294
of the statement before, etc).
1295
It can also be set by SET LAST_INSERT_ID=# or SELECT LAST_INSERT_ID(#).
1296
It is returned by LAST_INSERT_ID().
1298
ulonglong first_successful_insert_id_in_prev_stmt;
1300
Variant of the above, used for storing in statement-based binlog. The
1301
difference is that the one above can change as the execution of a stored
1302
function progresses, while the one below is set once and then does not
1303
change (which is the value which statement-based binlog needs).
1305
ulonglong first_successful_insert_id_in_prev_stmt_for_binlog;
1307
This is the first autogenerated insert id which was *successfully*
1308
inserted by the current statement. It is maintained only to set
1309
first_successful_insert_id_in_prev_stmt when statement ends.
1311
ulonglong first_successful_insert_id_in_cur_stmt;
1313
We follow this logic:
1314
- when stmt starts, first_successful_insert_id_in_prev_stmt contains the
1315
first insert id successfully inserted by the previous stmt.
1316
- as stmt makes progress, handler::insert_id_for_cur_row changes;
1317
every time get_auto_increment() is called,
1318
auto_inc_intervals_in_cur_stmt_for_binlog is augmented with the
1319
reserved interval (if statement-based binlogging).
1320
- at first successful insertion of an autogenerated value,
1321
first_successful_insert_id_in_cur_stmt is set to
1322
handler::insert_id_for_cur_row.
1323
- when stmt goes to binlog,
1324
auto_inc_intervals_in_cur_stmt_for_binlog is binlogged if
1326
- when stmt ends, first_successful_insert_id_in_prev_stmt is set to
1327
first_successful_insert_id_in_cur_stmt.
1330
stmt_depends_on_first_successful_insert_id_in_prev_stmt is set when
1331
LAST_INSERT_ID() is used by a statement.
1332
If it is set, first_successful_insert_id_in_prev_stmt_for_binlog will be
1333
stored in the statement-based binlog.
1334
This variable is CUMULATIVE along the execution of a stored function or
1335
trigger: if one substatement sets it to 1 it will stay 1 until the
1336
function/trigger ends, thus making sure that
1337
first_successful_insert_id_in_prev_stmt_for_binlog does not change anymore
1338
and is propagated to the caller for binlogging.
1340
bool stmt_depends_on_first_successful_insert_id_in_prev_stmt;
1342
List of auto_increment intervals reserved by the thread so far, for
1343
storage in the statement-based binlog.
1344
Note that its minimum is not first_successful_insert_id_in_cur_stmt:
1345
assuming a table with an autoinc column, and this happens:
1346
INSERT INTO ... VALUES(3);
1347
SET INSERT_ID=3; INSERT IGNORE ... VALUES (NULL);
1348
then the latter INSERT will insert no rows
1349
(first_successful_insert_id_in_cur_stmt == 0), but storing "INSERT_ID=3"
1350
in the binlog is still needed; the list's minimum will contain 3.
1352
Discrete_intervals_list auto_inc_intervals_in_cur_stmt_for_binlog;
1353
/* Used by replication and SET INSERT_ID */
1354
Discrete_intervals_list auto_inc_intervals_forced;
1356
There is BUG#19630 where statement-based replication of stored
1357
functions/triggers with two auto_increment columns breaks.
1358
We however ensure that it works when there is 0 or 1 auto_increment
1359
column; our rules are
1360
a) on master, while executing a top statement involving substatements,
1361
first top- or sub- statement to generate auto_increment values wins the
1362
exclusive right to see its values be written to binlog (the write
1363
will be done by the statement or its caller), and the losers won't see
1364
their values be written to binlog.
1365
b) on slave, while replicating a top statement involving substatements,
1366
first top- or sub- statement to need to read auto_increment values from
1367
the master's binlog wins the exclusive right to read them (so the losers
1368
won't read their values from binlog but instead generate on their own).
1369
a) implies that we mustn't backup/restore
1370
auto_inc_intervals_in_cur_stmt_for_binlog.
1371
b) implies that we mustn't backup/restore auto_inc_intervals_forced.
1373
If there are more than 1 auto_increment columns, then intervals for
1374
different columns may mix into the
1375
auto_inc_intervals_in_cur_stmt_for_binlog list, which is logically wrong,
1376
but there is no point in preventing this mixing by preventing intervals
1377
from the secondly inserted column to come into the list, as such
1378
prevention would be wrong too.
1379
What will happen in the case of
1380
INSERT INTO t1 (auto_inc) VALUES(NULL);
1381
where t1 has a trigger which inserts into an auto_inc column of t2, is
1382
that in binlog we'll store the interval of t1 and the interval of t2 (when
1383
we store intervals, soon), then in slave, t1 will use both intervals, t2
1384
will use none; if t1 inserts the same number of rows as on master,
1385
normally the 2nd interval will not be used by t1, which is fine. t2's
1386
values will be wrong if t2's internal auto_increment counter is different
1387
from what it was on master (which is likely). In 5.1, in mixed binlogging
1388
mode, row-based binlogging is used for such cases where two
1389
auto_increment columns are inserted.
1391
inline void record_first_successful_insert_id_in_cur_stmt(ulonglong id_arg)
1393
if (first_successful_insert_id_in_cur_stmt == 0)
1394
first_successful_insert_id_in_cur_stmt= id_arg;
1396
inline ulonglong read_first_successful_insert_id_in_prev_stmt(void)
1398
if (!stmt_depends_on_first_successful_insert_id_in_prev_stmt)
1400
/* It's the first time we read it */
1401
first_successful_insert_id_in_prev_stmt_for_binlog=
1402
first_successful_insert_id_in_prev_stmt;
1403
stmt_depends_on_first_successful_insert_id_in_prev_stmt= 1;
1405
return first_successful_insert_id_in_prev_stmt;
1408
Used by Intvar_log_event::do_apply_event() and by "SET INSERT_ID=#"
1409
(mysqlbinlog). We'll soon add a variant which can take many intervals in
1412
inline void force_one_auto_inc_interval(ulonglong next_id)
1414
auto_inc_intervals_forced.empty(); // in case of multiple SET INSERT_ID
1415
auto_inc_intervals_forced.append(next_id, ULONGLONG_MAX, 0);
1418
ulonglong limit_found_rows;
1419
ulonglong options; /* Bitmap of states */
1420
longlong row_count_func; /* For the ROW_COUNT() function */
1421
ha_rows cuted_fields;
1424
number of rows we actually sent to the client, including "synthetic"
1427
ha_rows sent_row_count;
1430
number of rows we read, sent or not, including in create_sort_index()
1432
ha_rows examined_row_count;
1435
The set of those tables whose fields are referenced in all subqueries
1437
TODO: possibly this it is incorrect to have used tables in THD because
1438
with more than one subquery, it is not clear what does the field mean.
1440
table_map used_tables;
1441
USER_CONN *user_connect;
1442
CHARSET_INFO *db_charset;
1444
FIXME: this, and some other variables like 'count_cuted_fields'
1445
maybe should be statement/cursor local, that is, moved to Statement
1446
class. With current implementation warnings produced in each prepared
1447
statement/cursor settle here.
1449
List <MYSQL_ERROR> warn_list;
1450
uint warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_END];
1451
uint total_warn_count;
1452
Diagnostics_area main_da;
1455
Id of current query. Statement can be reused to execute several queries
1456
query_id is global in context of the whole MySQL server.
1457
ID is automatically generated from mutex-protected counter.
1458
It's used in handler code for various purposes: to check which columns
1459
from table are necessary for this select, to check if it's necessary to
1460
update auto-updatable fields (like auto_increment and timestamp).
1462
query_id_t query_id, warn_id;
1465
#ifdef ERROR_INJECT_SUPPORT
1466
ulong error_inject_value;
1468
/* Statement id is thread-wide. This counter is used to generate ids */
1469
ulong statement_id_counter;
1470
ulong rand_saved_seed1, rand_saved_seed2;
1472
Row counter, mainly for errors and warnings. Not increased in
1473
create_sort_index(); may differ from examined_row_count.
1476
pthread_t real_id; /* For debugging */
1477
my_thread_id thread_id;
1478
uint tmp_table, global_read_lock;
1479
uint server_status,open_options;
1480
enum enum_thread_type system_thread;
1481
uint select_number; //number of select (used for EXPLAIN)
1482
/* variables.transaction_isolation is reset to this after each commit */
1483
enum_tx_isolation session_tx_isolation;
1484
enum_check_fields count_cuted_fields;
1486
DYNAMIC_ARRAY user_var_events; /* For user variables replication */
1487
MEM_ROOT *user_var_events_alloc; /* Allocate above array elements here */
1493
KILL_CONNECTION=ER_SERVER_SHUTDOWN,
1494
KILL_QUERY=ER_QUERY_INTERRUPTED,
1495
KILLED_NO_VALUE /* means neither of the states */
1497
killed_state volatile killed;
1499
/* scramble - random string sent to client on handshake */
1500
char scramble[SCRAMBLE_LENGTH+1];
1502
bool slave_thread, one_shot_set;
1503
/* tells if current statement should binlog row-based(1) or stmt-based(0) */
1504
bool current_stmt_binlog_row_based;
1505
bool some_tables_deleted;
1506
bool last_cuted_field;
1507
bool no_errors, password;
1509
Set to TRUE if execution of the current compound statement
1510
can not continue. In particular, disables activation of
1511
CONTINUE or EXIT handlers of stored routines.
1512
Reset in the end of processing of the current user request, in
1513
@see mysql_reset_thd_for_next_command().
1515
bool is_fatal_error;
1517
Set by a storage engine to request the entire
1518
transaction (that possibly spans multiple engines) to
1519
rollback. Reset in ha_rollback.
1521
bool transaction_rollback_request;
1523
TRUE if we are in a sub-statement and the current error can
1524
not be safely recovered until we left the sub-statement mode.
1525
In particular, disables activation of CONTINUE and EXIT
1526
handlers inside sub-statements. E.g. if it is a deadlock
1527
error and requires a transaction-wide rollback, this flag is
1528
raised (traditionally, MySQL first has to close all the reads
1529
via @see handler::ha_index_or_rnd_end() and only then perform
1531
Reset to FALSE when we leave the sub-statement mode.
1533
bool is_fatal_sub_stmt_error;
1534
bool query_start_used, rand_used, time_zone_used;
1535
/* for IS NULL => = last_insert_id() fix in remove_eq_conds() */
1536
bool substitute_null_with_insert_id;
1537
bool in_lock_tables;
1539
True if a slave error. Causes the slave to stop. Not the same
1540
as the statement execution error (is_error()), since
1541
a statement may be expected to return an error, e.g. because
1542
it returned an error on master, and this is OK on the slave.
1544
bool is_slave_error;
1545
bool bootstrap, cleanup_done;
1547
/** is set if some thread specific value(s) used in a statement. */
1548
bool thread_specific_used;
1549
bool charset_is_system_charset, charset_is_collation_connection;
1550
bool charset_is_character_set_filesystem;
1551
bool enable_slow_log; /* enable slow log for current statement */
1552
bool abort_on_warning;
1553
bool got_warning; /* Set on call to push_warning() */
1554
bool no_warnings_for_error; /* no warnings on call to my_error() */
1555
/* set during loop of derived table processing */
1556
bool derived_tables_processing;
1557
my_bool tablespace_op; /* This is TRUE in DISCARD/IMPORT TABLESPACE */
1560
If we do a purge of binary logs, log index info of the threads
1561
that are currently reading it needs to be adjusted. To do that
1562
each thread that is using LOG_INFO needs to adjust the pointer to it
1564
LOG_INFO* current_linfo;
1565
NET* slave_net; // network connection from slave -> m.
1566
/* Used by the sys_var class to store temporary values */
1569
my_bool my_bool_value;
1572
ulonglong ulonglong_value;
1577
If true, mysql_bin_log::write(Log_event) call will not write events to
1578
binlog, and maintain 2 below variables instead (use
1579
mysql_bin_log.start_union_events to turn this on)
1583
If TRUE, at least one mysql_bin_log::write(Log_event) call has been
1584
made after last mysql_bin_log.start_union_events() call.
1586
bool unioned_events;
1588
If TRUE, at least one mysql_bin_log::write(Log_event e), where
1589
e.cache_stmt == TRUE call has been made after last
1590
mysql_bin_log.start_union_events() call.
1592
bool unioned_events_trans;
1595
'queries' (actually SP statements) that run under inside this binlog
1596
union have thd->query_id >= first_query_id.
1598
query_id_t first_query_id;
1602
Character input stream consumed by the lexical analyser,
1603
used during parsing.
1604
Note that since the parser is not re-entrant, we keep only one input
1605
stream here. This member is valid only when executing code during parsing,
1606
and may point to invalid memory after that.
1608
Lex_input_stream *m_lip;
1611
@todo The following is a work around for online backup and the DDL blocker.
1612
It should be removed when the generalized solution is in place.
1613
This is needed to ensure the restore (which uses DDL) is not blocked
1614
when the DDL blocker is engaged.
1616
my_bool DDL_exception; // Allow some DDL if there is an exception
1623
Initialize memory roots necessary for query processing and (!)
1624
pre-allocate memory for it. We can't do that in THD constructor because
1625
there are use cases (acl_init, watcher threads,
1626
killing mysqld) where it's vital to not allocate excessive and not used
1627
memory. Note, that we still don't return error from init_for_queries():
1628
if preallocation fails, we should notice that at the first call to
1631
void init_for_queries();
1632
void change_user(void);
1634
void cleanup_after_query();
1635
bool store_globals();
1636
#ifdef SIGNAL_WITH_VIO_CLOSE
1637
inline void set_active_vio(Vio* vio)
1639
pthread_mutex_lock(&LOCK_delete);
1641
pthread_mutex_unlock(&LOCK_delete);
1643
inline void clear_active_vio()
1645
pthread_mutex_lock(&LOCK_delete);
1647
pthread_mutex_unlock(&LOCK_delete);
1649
void close_active_vio();
1651
void awake(THD::killed_state state_to_set);
1653
#ifndef MYSQL_CLIENT
1654
enum enum_binlog_query_type {
1656
The query can be logged row-based or statement-based
1661
The query has to be logged statement-based
1666
The query represents a change to a table in the "mysql"
1667
database and is currently mapped to ROW_QUERY_TYPE.
1673
int binlog_query(enum_binlog_query_type qtype,
1674
char const *query, ulong query_len,
1675
bool is_trans, bool suppress_use,
1676
THD::killed_state killed_err_arg= THD::KILLED_NO_VALUE);
1680
For enter_cond() / exit_cond() to work the mutex must be got before
1681
enter_cond(); this mutex is then released by exit_cond().
1682
Usage must be: lock mutex; enter_cond(); your code; exit_cond().
1684
inline const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex,
1687
const char* old_msg = get_proc_info();
1688
safe_mutex_assert_owner(mutex);
1689
mysys_var->current_mutex = mutex;
1690
mysys_var->current_cond = cond;
1691
thd_proc_info(this, msg);
1694
inline void exit_cond(const char* old_msg)
1697
Putting the mutex unlock in exit_cond() ensures that
1698
mysys_var->current_mutex is always unlocked _before_ mysys_var->mutex is
1699
locked (if that would not be the case, you'll get a deadlock if someone
1700
does a THD::awake() on you).
1702
pthread_mutex_unlock(mysys_var->current_mutex);
1703
pthread_mutex_lock(&mysys_var->mutex);
1704
mysys_var->current_mutex = 0;
1705
mysys_var->current_cond = 0;
1706
thd_proc_info(this, old_msg);
1707
pthread_mutex_unlock(&mysys_var->mutex);
1709
inline time_t query_start() { query_start_used=1; return start_time; }
1710
inline void set_time()
1714
start_time= user_time;
1715
start_utime= utime_after_lock= my_micro_time();
1718
start_utime= utime_after_lock= my_micro_time_and_time(&start_time);
1720
inline void set_current_time() { start_time= my_time(MY_WME); }
1721
inline void set_time(time_t t)
1723
start_time= user_time= t;
1724
start_utime= utime_after_lock= my_micro_time();
1726
void set_time_after_lock() { utime_after_lock= my_micro_time(); }
1727
ulonglong current_utime() { return my_micro_time(); }
1728
inline ulonglong found_rows(void)
1730
return limit_found_rows;
1732
inline bool active_transaction()
1734
return server_status & SERVER_STATUS_IN_TRANS;
1736
inline bool fill_derived_tables()
1738
return !lex->only_view_structure();
1740
inline void* trans_alloc(unsigned int size)
1742
return alloc_root(&transaction.mem_root,size);
1745
LEX_STRING *make_lex_string(LEX_STRING *lex_str,
1746
const char* str, uint length,
1747
bool allocate_lex_string);
1749
bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
1750
const char *from, uint from_length,
1751
CHARSET_INFO *from_cs);
1753
bool convert_string(String *s, CHARSET_INFO *from_cs, CHARSET_INFO *to_cs);
1755
void add_changed_table(TABLE *table);
1756
void add_changed_table(const char *key, long key_length);
1757
CHANGED_TABLE_LIST * changed_table_dup(const char *key, long key_length);
1758
int send_explain_fields(select_result *result);
1760
Clear the current error, if any.
1761
We do not clear is_fatal_error or is_fatal_sub_stmt_error since we
1762
assume this is never called if the fatal error is set.
1763
@todo: To silence an error, one should use Internal_error_handler
1764
mechanism. In future this function will be removed.
1766
inline void clear_error()
1768
DBUG_ENTER("clear_error");
1769
if (main_da.is_error())
1770
main_da.reset_diagnostics_area();
1774
inline bool vio_ok() const { return net.vio != 0; }
1775
/** Return FALSE if connection to client is broken. */
1776
bool vio_is_connected();
1778
Mark the current error as fatal. Warning: this does not
1779
set any error, it sets a property of the error, so must be
1780
followed or prefixed with my_error().
1782
inline void fatal_error()
1784
DBUG_ASSERT(main_da.is_error());
1786
DBUG_PRINT("error",("Fatal error set"));
1789
TRUE if there is an error in the error stack.
1791
Please use this method instead of direct access to
1794
If TRUE, the current (sub)-statement should be aborted.
1795
The main difference between this member and is_fatal_error
1796
is that a fatal error can not be handled by a stored
1797
procedure continue handler, whereas a normal error can.
1799
To raise this flag, use my_error().
1801
inline bool is_error() const { return main_da.is_error(); }
1802
inline CHARSET_INFO *charset() { return variables.character_set_client; }
1803
void update_charset();
1805
void change_item_tree(Item **place, Item *new_value)
1807
/* TODO: check for OOM condition here */
1808
if (!stmt_arena->is_conventional())
1809
nocheck_register_item_tree_change(place, *place, mem_root);
1812
void nocheck_register_item_tree_change(Item **place, Item *old_value,
1813
MEM_ROOT *runtime_memroot);
1814
void rollback_item_tree_changes();
1817
Cleanup statement parse state (parse tree, lex) and execution
1818
state after execution of a non-prepared SQL statement.
1820
void end_statement();
1821
inline int killed_errno() const
1823
killed_state killed_val; /* to cache the volatile 'killed' */
1824
return (killed_val= killed) != KILL_BAD_DATA ? killed_val : 0;
1826
inline void send_kill_message() const
1828
int err= killed_errno();
1830
my_message(err, ER(err), MYF(0));
1832
/* return TRUE if we will abort query if we make a warning now */
1833
inline bool really_abort_on_warning()
1835
return (abort_on_warning);
1837
void set_status_var_init();
1838
bool is_context_analysis_only()
1839
{ return lex->view_prepare_mode; }
1840
void reset_n_backup_open_tables_state(Open_tables_state *backup);
1841
void restore_backup_open_tables_state(Open_tables_state *backup);
1842
void restore_sub_statement_state(Sub_statement_state *backup);
1843
void set_n_backup_active_arena(Query_arena *set, Query_arena *backup);
1844
void restore_active_arena(Query_arena *set, Query_arena *backup);
1846
inline void set_current_stmt_binlog_row_based_if_mixed()
1849
If in a stored/function trigger, the caller should already have done the
1850
change. We test in_sub_stmt to prevent introducing bugs where people
1851
wouldn't ensure that, and would switch to row-based mode in the middle
1852
of executing a stored function/trigger (which is too late, see also
1853
reset_current_stmt_binlog_row_based()); this condition will make their
1854
tests fail and so force them to propagate the
1855
lex->binlog_row_based_if_mixed upwards to the caller.
1857
if ((variables.binlog_format == BINLOG_FORMAT_MIXED) &&
1859
current_stmt_binlog_row_based= TRUE;
1861
inline void set_current_stmt_binlog_row_based()
1863
current_stmt_binlog_row_based= TRUE;
1865
inline void clear_current_stmt_binlog_row_based()
1867
current_stmt_binlog_row_based= FALSE;
1869
inline void reset_current_stmt_binlog_row_based()
1872
If there are temporary tables, don't reset back to
1873
statement-based. Indeed it could be that:
1874
CREATE TEMPORARY TABLE t SELECT UUID(); # row-based
1875
# and row-based does not store updates to temp tables
1877
INSERT INTO u SELECT * FROM t; # stmt-based
1878
and then the INSERT will fail as data inserted into t was not logged.
1879
So we continue with row-based until the temp table is dropped.
1880
If we are in a stored function or trigger, we mustn't reset in the
1881
middle of its execution (as the binary logging way of a stored function
1882
or trigger is decided when it starts executing, depending for example on
1883
the caller (for a stored function: if caller is SELECT or
1884
INSERT/UPDATE/DELETE...).
1886
Don't reset binlog format for NDB binlog injector thread.
1888
if ((temporary_tables == NULL) && (in_sub_stmt == 0) &&
1889
(system_thread != SYSTEM_THREAD_NDBCLUSTER_BINLOG))
1891
current_stmt_binlog_row_based=
1892
test(variables.binlog_format == BINLOG_FORMAT_ROW);
1897
Set the current database; use deep copy of C-string.
1899
@param new_db a pointer to the new database name.
1900
@param new_db_len length of the new database name.
1902
Initialize the current database from a NULL-terminated string with
1903
length. If we run out of memory, we free the current database and
1904
return TRUE. This way the user will notice the error as there will be
1905
no current database selected (in addition to the error message set by
1908
@note This operation just sets {db, db_length}. Switching the current
1909
database usually involves other actions, like switching other database
1910
attributes including security context. In the future, this operation
1911
will be made private and more convenient interface will be provided.
1913
@return Operation status
1914
@retval FALSE Success
1915
@retval TRUE Out-of-memory error
1917
bool set_db(const char *new_db, size_t new_db_len)
1919
/* Do not reallocate memory if current chunk is big enough. */
1920
if (db && new_db && db_length >= new_db_len)
1921
memcpy(db, new_db, new_db_len+1);
1926
db= my_strndup(new_db, new_db_len, MYF(MY_WME | ME_FATALERROR));
1930
db_length= db ? new_db_len : 0;
1931
return new_db && !db;
1935
Set the current database; use shallow copy of C-string.
1937
@param new_db a pointer to the new database name.
1938
@param new_db_len length of the new database name.
1940
@note This operation just sets {db, db_length}. Switching the current
1941
database usually involves other actions, like switching other database
1942
attributes including security context. In the future, this operation
1943
will be made private and more convenient interface will be provided.
1945
void reset_db(char *new_db, size_t new_db_len)
1948
db_length= new_db_len;
1951
Copy the current database to the argument. Use the current arena to
1952
allocate memory for a deep copy: current database may be freed after
1953
a statement is parsed but before it's executed.
1955
bool copy_db_to(char **p_db, size_t *p_db_length)
1959
my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
1962
*p_db= strmake(db, db_length);
1963
*p_db_length= db_length;
1966
thd_scheduler scheduler;
1970
Add an internal error handler to the thread execution context.
1971
@param handler the exception handler to add
1973
void push_internal_handler(Internal_error_handler *handler);
1976
Handle an error condition.
1977
@param sql_errno the error number
1978
@param level the error level
1979
@return true if the error is handled
1981
virtual bool handle_error(uint sql_errno, const char *message,
1982
MYSQL_ERROR::enum_warning_level level);
1985
Remove the error handler last pushed.
1987
void pop_internal_handler();
1990
/** The current internal error handler for this thread, or NULL. */
1991
Internal_error_handler *m_internal_handler;
1993
The lex to hold the parsed tree of conventional (non-prepared) queries.
1994
Whereas for prepared and stored procedure statements we use an own lex
1995
instance for each new query, for conventional statements we reuse
1996
the same lex. (@see mysql_parse for details).
2000
This memory root is used for two purposes:
2001
- for conventional queries, to allocate structures stored in main_lex
2002
during parsing, and allocate runtime data (execution plan, etc.)
2004
- for prepared queries, only to allocate runtime data. The parsed
2005
tree itself is reused between executions and thus is stored elsewhere.
2007
MEM_ROOT main_mem_root;
2011
/** A short cut for thd->main_da.set_ok_status(). */
2014
my_ok(THD *thd, ha_rows affected_rows= 0, ulonglong id= 0,
2015
const char *message= NULL)
2017
thd->main_da.set_ok_status(thd, affected_rows, id, message);
2021
/** A short cut for thd->main_da.set_eof_status(). */
2026
thd->main_da.set_eof_status(thd);
2029
#define tmp_disable_binlog(A) \
2030
{ulonglong tmp_disable_binlog__save_options= (A)->options; \
2031
(A)->options&= ~OPTION_BIN_LOG
2033
#define reenable_binlog(A) (A)->options= tmp_disable_binlog__save_options;}
2037
Used to hold information about file and file structure in exchange
2038
via non-DB file (...INTO OUTFILE..., ...LOAD DATA...)
2039
XXX: We never call destructor for objects of this class.
2042
class sql_exchange :public Sql_alloc
2045
enum enum_filetype filetype; /* load XML, Added by Arnold & Erik */
2047
String *field_term,*enclosed,*line_term,*line_start,*escaped;
2052
sql_exchange(char *name, bool dumpfile_flag,
2053
enum_filetype filetype_arg= FILETYPE_CSV);
2056
#include "log_event.h"
2059
This is used to get result from a select
2064
class select_result :public Sql_alloc {
2067
SELECT_LEX_UNIT *unit;
2070
virtual ~select_result() {};
2071
virtual int prepare(List<Item> &list, SELECT_LEX_UNIT *u)
2076
virtual int prepare2(void) { return 0; }
2078
Because of peculiarities of prepared statements protocol
2079
we need to know number of columns in the result set (if
2080
there is a result set) apart from sending columns metadata.
2082
virtual uint field_count(List<Item> &fields) const
2083
{ return fields.elements; }
2084
virtual bool send_fields(List<Item> &list, uint flags)=0;
2085
virtual bool send_data(List<Item> &items)=0;
2086
virtual bool initialize_tables (JOIN *join=0) { return 0; }
2087
virtual void send_error(uint errcode,const char *err);
2088
virtual bool send_eof()=0;
2090
Check if this query returns a result set and therefore is allowed in
2091
cursors and set an error message if it is not the case.
2093
@retval FALSE success
2094
@retval TRUE error, an error message is set
2096
virtual bool check_simple_select() const;
2097
virtual void abort() {}
2099
Cleanup instance of this class for next execution of a prepared
2100
statement/stored procedure.
2102
virtual void cleanup();
2103
void set_thd(THD *thd_arg) { thd= thd_arg; }
2104
void begin_dataset() {}
2109
Base class for select_result descendands which intercept and
2110
transform result set rows. As the rows are not sent to the client,
2111
sending of result set metadata should be suppressed as well.
2114
class select_result_interceptor: public select_result
2117
select_result_interceptor() {} /* Remove gcc warning */
2118
uint field_count(List<Item> &fields) const { return 0; }
2119
bool send_fields(List<Item> &fields, uint flag) { return FALSE; }
2123
class select_send :public select_result {
2125
True if we have sent result set metadata to the client.
2126
In this case the client always expects us to end the result
2127
set with an eof or error packet
2129
bool is_result_set_started;
2131
select_send() :is_result_set_started(FALSE) {}
2132
bool send_fields(List<Item> &list, uint flags);
2133
bool send_data(List<Item> &items);
2135
virtual bool check_simple_select() const { return FALSE; }
2137
virtual void cleanup();
2141
class select_to_file :public select_result_interceptor {
2143
sql_exchange *exchange;
2147
char path[FN_REFLEN];
2150
select_to_file(sql_exchange *ex) :exchange(ex), file(-1),row_count(0L)
2153
void send_error(uint errcode,const char *err);
2159
#define ESCAPE_CHARS "ntrb0ZN" // keep synchronous with READ_INFO::unescape
2163
List of all possible characters of a numeric value text representation.
2165
#define NUMERIC_CHARS ".0123456789e+-"
2168
class select_export :public select_to_file {
2169
uint field_term_length;
2170
int field_sep_char,escape_char,line_sep_char;
2171
int field_term_char; // first char of FIELDS TERMINATED BY or MAX_INT
2173
The is_ambiguous_field_sep field is true if a value of the field_sep_char
2174
field is one of the 'n', 't', 'r' etc characters
2175
(see the READ_INFO::unescape method and the ESCAPE_CHARS constant value).
2177
bool is_ambiguous_field_sep;
2179
The is_ambiguous_field_term is true if field_sep_char contains the first
2180
char of the FIELDS TERMINATED BY (ENCLOSED BY is empty), and items can
2181
contain this character.
2183
bool is_ambiguous_field_term;
2185
The is_unsafe_field_sep field is true if a value of the field_sep_char
2186
field is one of the '0'..'9', '+', '-', '.' and 'e' characters
2187
(see the NUMERIC_CHARS constant value).
2189
bool is_unsafe_field_sep;
2190
bool fixed_row_size;
2192
select_export(sql_exchange *ex) :select_to_file(ex) {}
2194
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2195
bool send_data(List<Item> &items);
2199
class select_dump :public select_to_file {
2201
select_dump(sql_exchange *ex) :select_to_file(ex) {}
2202
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2203
bool send_data(List<Item> &items);
2207
class select_insert :public select_result_interceptor {
2209
TABLE_LIST *table_list;
2212
ulonglong autoinc_value_of_last_inserted_row; // autogenerated or not
2214
bool insert_into_view;
2215
select_insert(TABLE_LIST *table_list_par,
2216
TABLE *table_par, List<Item> *fields_par,
2217
List<Item> *update_fields, List<Item> *update_values,
2218
enum_duplicates duplic, bool ignore);
2220
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2221
virtual int prepare2(void);
2222
bool send_data(List<Item> &items);
2223
virtual void store_values(List<Item> &values);
2224
virtual bool can_rollback_data() { return 0; }
2225
void send_error(uint errcode,const char *err);
2228
/* not implemented: select_insert is never re-used in prepared statements */
2233
class select_create: public select_insert {
2235
TABLE_LIST *create_table;
2236
HA_CREATE_INFO *create_info;
2237
TABLE_LIST *select_tables;
2238
Alter_info *alter_info;
2240
/* lock data for tmp table */
2242
/* m_lock or thd->extra_lock */
2243
MYSQL_LOCK **m_plock;
2245
select_create (TABLE_LIST *table_arg,
2246
HA_CREATE_INFO *create_info_par,
2247
Alter_info *alter_info_arg,
2248
List<Item> &select_fields,enum_duplicates duplic, bool ignore,
2249
TABLE_LIST *select_tables_arg)
2250
:select_insert (NULL, NULL, &select_fields, 0, 0, duplic, ignore),
2251
create_table(table_arg),
2252
create_info(create_info_par),
2253
select_tables(select_tables_arg),
2254
alter_info(alter_info_arg),
2257
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2259
void binlog_show_create_table(TABLE **tables, uint count);
2260
void store_values(List<Item> &values);
2261
void send_error(uint errcode,const char *err);
2264
virtual bool can_rollback_data() { return 1; }
2266
// Needed for access from local class MY_HOOKS in prepare(), since thd is proteted.
2267
const THD *get_thd(void) { return thd; }
2268
const HA_CREATE_INFO *get_create_info() { return create_info; };
2269
int prepare2(void) { return 0; }
2275
Param to create temporary tables when doing SELECT:s
2277
This structure is copied using memcpy as a part of JOIN.
2280
class TMP_TABLE_PARAM :public Sql_alloc
2283
/* Prevent use of these (not safe because of lists and copy_field) */
2284
TMP_TABLE_PARAM(const TMP_TABLE_PARAM &);
2285
void operator=(TMP_TABLE_PARAM &);
2288
List<Item> copy_funcs;
2289
List<Item> save_copy_funcs;
2290
Copy_field *copy_field, *copy_field_end;
2291
Copy_field *save_copy_field, *save_copy_field_end;
2293
Item **items_to_copy; /* Fields in tmp table */
2294
MI_COLUMNDEF *recinfo,*start_recinfo;
2296
ha_rows end_write_records;
2297
uint field_count,sum_func_count,func_count;
2298
uint hidden_field_count;
2299
uint group_parts,group_length,group_null_parts;
2301
bool using_indirect_summary_function;
2302
/* If >0 convert all blob fields to varchar(convert_blob_length) */
2303
uint convert_blob_length;
2304
CHARSET_INFO *table_charset;
2307
True if GROUP BY and its aggregate functions are already computed
2308
by a table access method (e.g. by loose index scan). In this case
2309
query execution should not perform aggregation and should treat
2310
aggregate functions as normal functions.
2312
bool precomputed_group_by;
2313
bool force_copy_fields;
2315
If TRUE, create_tmp_field called from create_tmp_table will convert
2316
all BIT fields to 64-bit longs. This is a workaround the limitation
2317
that MEMORY tables cannot index BIT columns.
2319
bool bit_fields_as_long;
2322
:copy_field(0), group_parts(0),
2323
group_length(0), group_null_parts(0), convert_blob_length(0),
2324
schema_table(0), precomputed_group_by(0), force_copy_fields(0),
2325
bit_fields_as_long(0)
2332
inline void cleanup(void)
2334
if (copy_field) /* Fix for Intel compiler */
2336
delete [] copy_field;
2337
save_copy_field= copy_field= 0;
2342
class select_union :public select_result_interceptor
2344
TMP_TABLE_PARAM tmp_table_param;
2348
select_union() :table(0) {}
2349
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2350
bool send_data(List<Item> &items);
2354
bool create_result_table(THD *thd, List<Item> *column_types,
2355
bool is_distinct, ulonglong options,
2356
const char *alias, bool bit_fields_as_long);
2359
/* Base subselect interface class */
2360
class select_subselect :public select_result_interceptor
2363
Item_subselect *item;
2365
select_subselect(Item_subselect *item);
2366
bool send_data(List<Item> &items)=0;
2367
bool send_eof() { return 0; };
2370
/* Single value subselect interface class */
2371
class select_singlerow_subselect :public select_subselect
2374
select_singlerow_subselect(Item_subselect *item_arg)
2375
:select_subselect(item_arg)
2377
bool send_data(List<Item> &items);
2380
/* used in independent ALL/ANY optimisation */
2381
class select_max_min_finder_subselect :public select_subselect
2384
bool (select_max_min_finder_subselect::*op)();
2387
select_max_min_finder_subselect(Item_subselect *item_arg, bool mx)
2388
:select_subselect(item_arg), cache(0), fmax(mx)
2391
bool send_data(List<Item> &items);
2398
/* EXISTS subselect interface class */
2399
class select_exists_subselect :public select_subselect
2402
select_exists_subselect(Item_subselect *item_arg)
2403
:select_subselect(item_arg){}
2404
bool send_data(List<Item> &items);
2407
/* Structs used when sorting */
2409
typedef struct st_sort_field {
2410
Field *field; /* Field to sort */
2411
Item *item; /* Item if not sorting fields */
2412
uint length; /* Length of sort field */
2413
uint suffix_length; /* Length suffix (0-4) */
2414
Item_result result_type; /* Type of item */
2415
bool reverse; /* if descending sort */
2416
bool need_strxnfrm; /* If we have to use strxnfrm() */
2420
typedef struct st_sort_buffer {
2421
uint index; /* 0 or 1 */
2423
uint change_pos; /* If sort-fields changed */
2425
SORT_FIELD *sortorder;
2428
/* Structure for db & table in sql_yacc */
2430
class Table_ident :public Sql_alloc
2435
SELECT_LEX_UNIT *sel;
2436
inline Table_ident(THD *thd, LEX_STRING db_arg, LEX_STRING table_arg,
2438
:table(table_arg), sel((SELECT_LEX_UNIT *)0)
2440
if (!force && (thd->client_capabilities & CLIENT_NO_SCHEMA))
2445
inline Table_ident(LEX_STRING table_arg)
2446
:table(table_arg), sel((SELECT_LEX_UNIT *)0)
2451
This constructor is used only for the case when we create a derived
2452
table. A derived table has no name and doesn't belong to any database.
2453
Later, if there was an alias specified for the table, it will be set
2454
by add_table_to_list.
2456
inline Table_ident(SELECT_LEX_UNIT *s) : sel(s)
2458
/* We must have a table name here as this is used with add_table_to_list */
2459
db.str= empty_c_string; /* a subject to casedn_str */
2461
table.str= internal_table_name;
2464
bool is_derived_table() const { return test(sel); }
2465
inline void change_db(char *db_name)
2467
db.str= db_name; db.length= (uint) strlen(db_name);
2471
// this is needed for user_vars hash
2472
class user_var_entry
2475
user_var_entry() {} /* Remove gcc warning */
2479
query_id_t update_query_id, used_query_id;
2483
double val_real(my_bool *null_value);
2484
longlong val_int(my_bool *null_value) const;
2485
String *val_str(my_bool *null_value, String *str, uint decimals);
2486
my_decimal *val_decimal(my_bool *null_value, my_decimal *result);
2487
DTCollation collation;
2491
Unique -- class for unique (removing of duplicates).
2492
Puts all values to the TREE. If the tree becomes too big,
2493
it's dumped to the file. User can request sorted values, or
2494
just iterate through them. In the last case tree merging is performed in
2495
memory simultaneously with iteration, so it should be ~2-3x faster.
2498
class Unique :public Sql_alloc
2500
DYNAMIC_ARRAY file_ptrs;
2502
ulonglong max_in_memory_size;
2505
uchar *record_pointers;
2511
Unique(qsort_cmp2 comp_func, void *comp_func_fixed_arg,
2512
uint size_arg, ulonglong max_in_memory_size_arg);
2514
ulong elements_in_tree() { return tree.elements_in_tree; }
2515
inline bool unique_add(void *ptr)
2517
DBUG_ENTER("unique_add");
2518
DBUG_PRINT("info", ("tree %u - %lu", tree.elements_in_tree, max_elements));
2519
if (tree.elements_in_tree > max_elements && flush())
2521
DBUG_RETURN(!tree_insert(&tree, ptr, 0, tree.custom_arg));
2524
bool get(TABLE *table);
2525
static double get_use_cost(uint *buffer, uint nkeys, uint key_size,
2526
ulonglong max_in_memory_size);
2527
inline static int get_cost_calc_buff_size(ulong nkeys, uint key_size,
2528
ulonglong max_in_memory_size)
2530
register ulonglong max_elems_in_tree=
2531
(1 + max_in_memory_size / ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size));
2532
return (int) (sizeof(uint)*(1 + nkeys/max_elems_in_tree));
2536
bool walk(tree_walk_action action, void *walk_action_arg);
2538
friend int unique_write_to_file(uchar* key, element_count count, Unique *unique);
2539
friend int unique_write_to_ptrs(uchar* key, element_count count, Unique *unique);
2543
class multi_delete :public select_result_interceptor
2545
TABLE_LIST *delete_tables, *table_being_deleted;
2547
ha_rows deleted, found;
2551
/* True if at least one table we delete from is transactional */
2552
bool transactional_tables;
2553
/* True if at least one table we delete from is not transactional */
2555
bool delete_while_scanning;
2557
error handling (rollback and binlogging) can happen in send_eof()
2558
so that afterward send_error() needs to find out that.
2563
multi_delete(TABLE_LIST *dt, uint num_of_tables);
2565
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2566
bool send_data(List<Item> &items);
2567
bool initialize_tables (JOIN *join);
2568
void send_error(uint errcode,const char *err);
2571
virtual void abort();
2575
class multi_update :public select_result_interceptor
2577
TABLE_LIST *all_tables; /* query/update command tables */
2578
TABLE_LIST *leaves; /* list of leves of join table tree */
2579
TABLE_LIST *update_tables, *table_being_updated;
2580
TABLE **tmp_tables, *main_table, *table_to_update;
2581
TMP_TABLE_PARAM *tmp_table_param;
2582
ha_rows updated, found;
2583
List <Item> *fields, *values;
2584
List <Item> **fields_for_table, **values_for_table;
2587
List of tables referenced in the CHECK OPTION condition of
2588
the updated view excluding the updated table.
2590
List <TABLE> unupdated_check_opt_tables;
2591
Copy_field *copy_field;
2592
enum enum_duplicates handle_duplicates;
2593
bool do_update, trans_safe;
2594
/* True if the update operation has made a change in a transactional table */
2595
bool transactional_tables;
2598
error handling (rollback and binlogging) can happen in send_eof()
2599
so that afterward send_error() needs to find out that.
2604
multi_update(TABLE_LIST *ut, TABLE_LIST *leaves_list,
2605
List<Item> *fields, List<Item> *values,
2606
enum_duplicates handle_duplicates, bool ignore);
2608
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2609
bool send_data(List<Item> &items);
2610
bool initialize_tables (JOIN *join);
2611
void send_error(uint errcode,const char *err);
2614
virtual void abort();
2617
class my_var : public Sql_alloc {
2622
enum_field_types type;
2623
my_var (LEX_STRING& j, bool i, uint o, enum_field_types t)
2624
:s(j), local(i), offset(o), type(t)
2629
class select_dumpvar :public select_result_interceptor {
2632
List<my_var> var_list;
2633
select_dumpvar() { var_list.empty(); row_count= 0;}
2634
~select_dumpvar() {}
2635
int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
2636
bool send_data(List<Item> &items);
2638
virtual bool check_simple_select() const;
2642
/* Bits in sql_command_flags */
2644
#define CF_CHANGES_DATA 1
2645
#define CF_HAS_ROW_COUNT 2
2646
#define CF_STATUS_COMMAND 4
2647
#define CF_SHOW_TABLE_COMMAND 8
2648
#define CF_WRITE_LOGS_COMMAND 16
2650
/* Functions in sql_class.cc */
2652
void add_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var);
2654
void add_diff_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var,
2655
STATUS_VAR *dec_var);
2656
void mark_transaction_to_rollback(THD *thd, bool all);
2658
#endif /* MYSQL_SERVER */
added
removed
sql/sql_class.h
