MySQL 8.0.30
Source Code Documentation
sql_class.h
Go to the documentation of this file.
1/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is also distributed with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have included with MySQL.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License, version 2.0, for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
22
23#ifndef SQL_CLASS_INCLUDED
24#define SQL_CLASS_INCLUDED
25
26/*
27 This file contains the declaration of the THD class and classes which THD
28 depends on. It should contain as little else as possible to increase
29 cohesion and reduce coupling. Since THD is used in many places, many files
30 are dependent on this header and thus require recompilation if it changes.
31 Historically this file contained "Classes in mysql".
32*/
33
34#include "my_config.h"
35
36#include <limits.h>
37#include <stdarg.h>
38#include <stdio.h>
39#include <string.h>
40#ifdef HAVE_SYS_TIME_H
41#include <sys/time.h>
42#endif
43#include <sys/types.h>
44#include <atomic>
45#include <bitset>
46#include <memory>
47#include <new>
48#include <string>
49
50#include "dur_prop.h" // durability_properties
51#include "lex_string.h"
52#include "m_ctype.h"
53#include "map_helpers.h"
54#include "my_alloc.h"
55#include "my_base.h"
56#include "my_command.h"
57#include "my_compiler.h"
58#include "my_dbug.h"
59#include "my_inttypes.h"
60#include "my_io.h"
61#include "my_psi_config.h"
62#include "my_sqlcommand.h"
63#include "my_sys.h"
64#include "my_table_map.h"
65#include "my_thread_local.h"
66#include "my_time_t.h"
79#include "mysql/thread_type.h"
80#include "mysql_com.h"
81#include "mysql_com_server.h" // NET_SERVER
82#include "mysqld_error.h"
83#include "pfs_thread_provider.h"
84#include "prealloced_array.h"
85#include "sql/auth/sql_security_ctx.h" // Security_context
86#include "sql/current_thd.h"
87#include "sql/dd/string_type.h" // dd::string_type
88#include "sql/discrete_interval.h" // Discrete_interval
89#include "sql/locked_tables_list.h" // enum_locked_tables_mode
90#include "sql/mdl.h"
91#include "sql/opt_costmodel.h"
92#include "sql/opt_trace_context.h" // Opt_trace_context
93#include "sql/psi_memory_key.h"
94#include "sql/query_options.h"
96#include "sql/rpl_context.h" // Rpl_thd_context
97#include "sql/rpl_gtid.h"
98#include "sql/session_tracker.h" // Session_tracker
99#include "sql/sql_connect.h"
100#include "sql/sql_const.h"
101#include "sql/sql_digest_stream.h" // sql_digest_state
102#include "sql/sql_error.h"
103#include "sql/sql_list.h"
104#include "sql/sql_plugin_ref.h"
105#include "sql/sys_vars_resource_mgr.h" // Session_sysvar_resource_manager
106#include "sql/system_variables.h" // system_variables
107#include "sql/transaction_info.h" // Ha_trx_info
108#include "sql/xa.h"
109#include "sql_string.h"
110#include "template_utils.h"
111#include "thr_lock.h"
112#include "violite.h"
113
114enum enum_check_fields : int;
115enum enum_tx_isolation : int;
116enum ha_notification_type : int;
117class Item;
118class Parser_state;
119class PROFILING;
121class Relay_log_info;
122class THD;
123class partition_info;
124class Protocol;
125class Protocol_binary;
126class Protocol_classic;
127class Protocol_text;
128template <class T>
129class mem_root_deque;
130class sp_rcontext;
131class user_var_entry;
132struct LEX;
133struct LEX_USER;
134struct TABLE;
135struct TABLE_LIST;
136struct timeval;
137struct User_level_lock;
138struct YYLTYPE;
139
140namespace dd {
141namespace cache {
142class Dictionary_client;
143}
144
145class DD_kill_immunizer;
146} // namespace dd
147
150class Query_result;
152class Rows_log_event;
153class Time_zone;
154class sp_cache;
156struct LOG_INFO;
157
158typedef struct user_conn USER_CONN;
159struct MYSQL_LOCK;
160
161extern "C" void thd_enter_cond(void *opaque_thd, mysql_cond_t *cond,
162 mysql_mutex_t *mutex,
163 const PSI_stage_info *stage,
164 PSI_stage_info *old_stage,
165 const char *src_function, const char *src_file,
166 int src_line);
167extern "C" void thd_exit_cond(void *opaque_thd, const PSI_stage_info *stage,
168 const char *src_function, const char *src_file,
169 int src_line);
170
171extern "C" void thd_enter_stage(void *opaque_thd,
172 const PSI_stage_info *new_stage,
173 PSI_stage_info *old_stage,
174 const char *src_function, const char *src_file,
175 int src_line);
176
177extern "C" void thd_set_waiting_for_disk_space(void *opaque_thd,
178 const bool waiting);
179
180#define THD_STAGE_INFO(thd, stage) \
181 (thd)->enter_stage(&stage, NULL, __func__, __FILE__, __LINE__)
182
183extern char empty_c_string[1];
184
185/*
186 We preallocate data for several storage engine plugins.
187 so: innodb + bdb + ndb + binlog + myisam + myisammrg + archive +
188 example + csv + heap + blackhole + federated + 0
189 (yes, the sum is deliberately inaccurate)
190*/
191constexpr size_t PREALLOC_NUM_HA = 15;
192
193/**
194 To be used for pool-of-threads (implemented differently on various OSs)
195*/
197 public:
198 void *data; /* scheduler-specific data structure */
199
201
202 ~thd_scheduler() = default;
203};
204
206void thd_set_psi(THD *thd, PSI_thread *psi);
207
208/**
209 Return @@session.terminology_use_previous for the current THD.
210
211 @return the integer value of one of the enumeration values in
212 terminology_use_previous::enum_compatibility_version.
213*/
214extern "C" unsigned int thd_get_current_thd_terminology_use_previous();
215
217 /**
218 Memory counter object doesn't update global memory counter and doesn't throw
219 OOM error.
220 */
222 /**
223 if MEM_CNT_UPDATE_GLOBAL_COUNTER is set, memory counter object updates
224 global memory counter.
225 */
227 /**
228 if MEM_CNT_GENERATE_ERROR is set, memory counter object generates OOM error if
229 any.
230*/
232 /**
233 if MEM_CNT_GENERATE_LOG_ERROR is set, memory counter object generates OOM
234 error to error log if any.
235*/
238
240 private:
241 bool m_enabled{false};
242 THD *m_thd{nullptr}; // Pointer to THD object.
243 Diagnostics_area m_da{false}; // Diagnostics area.
244 ulonglong mem_counter{0}; // Amount of memory consumed by thread.
245 ulonglong max_conn_mem{0}; // Max amount memory consumed by thread.
246 ulonglong glob_mem_counter{0}; // Amount of memory added to global
247 // memory counter.
248 uint curr_mode{MEM_CNT_DEFAULT}; // Current memory counter mode.
249 uint orig_mode{MEM_CNT_DEFAULT}; // Original memory counter mode
250 // (sets at init_mode() stage).
251 bool is_connection_stage{true}; // True on connection stage,
252 // resets to false after successful
253 // connection.
254 public:
257 assert(!m_enabled);
258 assert(mem_counter == 0 && glob_mem_counter == 0);
259 }
260 void set_thd(THD *thd) { m_thd = thd; }
261 void enable() { m_enabled = true; }
262 void disable();
263
264 bool alloc_cnt(size_t size);
265 void free_cnt(size_t size);
266 int reset();
267 void flush();
268 /**
269 Restore original memory counter mode.
270 */
272 /**
273 Set NO ERROR memory counter mode.
274 */
277 }
278 /**
279 Function sets current memory counter mode.
280
281 @param mode_arg current memory counter mode.
282 */
283 void set_curr_mode(uint mode_arg) { curr_mode = mode_arg; }
284 /**
285 Function sets original memory counter mode.
286
287 @param mode_arg original memory counter mode.
288 */
289 void set_orig_mode(uint mode_arg) { orig_mode = mode_arg; }
290 /**
291 Check if memory counter error is issued.
292
293 @retval true if memory counter error is issued, false otherwise.
294 */
295 bool is_error() const { return m_da.is_error(); }
296 void set_thd_error_status() const;
297
298 private:
299 int generate_error(int err_no, ulonglong mem_limit, ulonglong mem_size);
300 /**
301 Check if memory counter is in error mode.
302
303 @retval true if memory counter is in error mode, false otherwise.
304 */
305 bool is_error_mode() const { return (curr_mode & MEM_CNT_GENERATE_ERROR); }
306 /**
307 Check if memory counter is in error log mode.
308
309 @retval true if memory counter is in error log mode, false otherwise.
310 */
311 bool is_error_log_mode() const {
313 }
314};
315
316/**
317 the struct aggregates two parameters that identify an event
318 uniquely in scope of communication of a particular master and slave couple.
319 I.e there can not be 2 events from the same staying connected master which
320 have the same coordinates.
321 @note
322 Such identifier is not yet unique generally as the event originating master
323 is resettable. Also the crashed master can be replaced with some other.
324*/
325typedef struct rpl_event_coordinates {
326 char *file_name; // binlog file name (directories stripped)
327 my_off_t pos; // event's position in the binlog file
329
330#define THD_SENTRY_MAGIC 0xfeedd1ff
331#define THD_SENTRY_GONE 0xdeadbeef
332
333#define THD_CHECK_SENTRY(thd) assert(thd->dbug_sentry == THD_SENTRY_MAGIC)
334
336 private:
337 /*
338 List of items created for this query. Every item adds itself to the list
339 on creation (see Item::Item() for details)
340 */
342
343 public:
344 MEM_ROOT *mem_root; // Pointer to current memroot
345 /// To check whether a reprepare operation is active
346 bool is_repreparing{false};
347 /*
348 The states reflects three different life cycles for three
349 different types of statements:
350 Prepared statement: STMT_INITIALIZED -> STMT_PREPARED -> STMT_EXECUTED.
351 Stored procedure: STMT_INITIALIZED_FOR_SP -> STMT_EXECUTED.
352 Other statements: STMT_REGULAR_EXECUTION never changes.
353 */
360 STMT_ERROR = -1
361 };
362
363 /*
364 State and state changes in SP:
365 1) When state is STMT_INITIALIZED_FOR_SP, objects in the item tree are
366 created on the statement memroot. This is enforced through
367 ps_arena_holder checking the state.
368 2) After the first execute (call p1()), this state should change to
369 STMT_EXECUTED. Objects will be created on the execution memroot and will
370 be destroyed at the end of each execution.
371 3) In case an ER_NEED_REPREPARE error occurs, state should be changed to
372 STMT_INITIALIZED_FOR_SP and objects will again be created on the
373 statement memroot. At the end of this execution, state should change to
374 STMT_EXECUTED.
375 */
376 private:
378
379 public:
380 Query_arena(MEM_ROOT *mem_root_arg, enum enum_state state_arg)
381 : m_item_list(nullptr), mem_root(mem_root_arg), state(state_arg) {}
382
383 /*
384 This constructor is used only when Query_arena is created as
385 backup storage for another instance of Query_arena.
386 */
389
390 virtual ~Query_arena() = default;
391
392 Item *item_list() const { return m_item_list; }
393 void reset_item_list() { m_item_list = nullptr; }
394 void set_item_list(Item *item) { m_item_list = item; }
395 void add_item(Item *item);
396 void free_items();
397 void set_state(enum_state state_arg) { state = state_arg; }
398 enum_state get_state() const { return state; }
399 bool is_stmt_prepare() const { return state == STMT_INITIALIZED; }
401 return (int)state < (int)STMT_PREPARED;
402 }
404 return (int)state <= (int)STMT_PREPARED;
405 }
406 /// @returns true if a regular statement, ie not prepared and not stored proc
407 bool is_regular() const { return state == STMT_REGULAR_EXECUTION; }
408
409 void *alloc(size_t size) { return mem_root->Alloc(size); }
410 void *mem_calloc(size_t size) {
411 void *ptr;
412 if ((ptr = mem_root->Alloc(size))) memset(ptr, 0, size);
413 return ptr;
414 }
415 template <typename T>
417 void *m = alloc(sizeof(T));
418 return m == nullptr ? nullptr : new (m) T;
419 }
420 template <typename T>
421 T *memdup_typed(const T *mem) {
422 return static_cast<T *>(memdup_root(mem_root, mem, sizeof(T)));
423 }
424 char *mem_strdup(const char *str) { return strdup_root(mem_root, str); }
425 char *strmake(const char *str, size_t size) const {
426 return strmake_root(mem_root, str, size);
427 }
429 LEX_CSTRING ret;
430 ret.str = strmake(str.str, str.length);
431 ret.length = ret.str ? str.length : 0;
432 return ret;
433 }
434 void *memdup(const void *str, size_t size) {
435 return memdup_root(mem_root, str, size);
436 }
437
438 /**
439 Copies memory-managing members from `set`. No references are kept to it.
440
441 @param set A Query_arena from which members are copied.
442 */
443 void set_query_arena(const Query_arena &set);
444
445 /**
446 Copy the current arena to `backup` and set the current
447 arena to match `source`
448
449 @param source A Query_arena from which members are copied.
450 @param backup A Query_arena to which members are first saved.
451 */
453};
454
456
457/**
458 Container for all prepared statements created/used in a connection.
459
460 Prepared statements in Prepared_statement_map have unique id
461 (guaranteed by id assignment in Prepared_statement::Prepared_statement).
462
463 Non-empty statement names are unique too: attempt to insert a new statement
464 with duplicate name causes older statement to be deleted.
465
466 Prepared statements are auto-deleted when they are removed from the map
467 and when the map is deleted.
468*/
469
471 public:
473
474 /**
475 Insert a new statement to the thread-local prepared statement map.
476
477 If there was an old statement with the same name, replace it with the
478 new one. Otherwise, check if max_prepared_stmt_count is not reached yet,
479 increase prepared_stmt_count, and insert the new statement. It's okay
480 to delete an old statement and fail to insert the new one.
481
482 All named prepared statements are also present in names_hash.
483 Prepared statement names in names_hash are unique.
484 The statement is added only if prepared_stmt_count < max_prepard_stmt_count
485 m_last_found_statement always points to a valid statement or is 0
486
487 @retval 0 success
488 @retval 1 error: out of resources or max_prepared_stmt_count limit has been
489 reached. An error is sent to the client, the statement
490 is deleted.
491 */
493
494 /** Find prepared statement by name. */
496
497 /** Find prepared statement by ID. */
498 Prepared_statement *find(ulong id);
499
500 /** Erase all prepared statements (calls Prepared_statement destructor). */
502
503 void claim_memory_ownership(bool claim);
504
505 void reset();
506
508
509 private:
513};
514
515/**
516 A registry for item tree transformations performed during
517 query optimization. We register only those changes which require
518 a rollback to re-execute a prepared statement or stored procedure
519 yet another time.
520*/
521
522class Item_change_record : public ilink<Item_change_record> {
523 private:
524 // not used
526
527 public:
533 bool m_cancel{false};
534};
535
537
538/**
539 Class that holds information about tables which were opened and locked
540 by the thread. It is also used to save/restore this information in
541 push_open_tables_state()/pop_open_tables_state().
542*/
543
545 private:
546 /**
547 A stack of Reprepare_observer-instances. The top most instance is the
548 currently active one. This stack is used during execution of prepared
549 statements and stored programs in order to detect metadata changes.
550 The locking subsystem reports a metadata change if the top-most item is not
551 NULL.
552
553 When Open_tables_state part of THD is reset to open a system or
554 INFORMATION_SCHEMA table, NULL is temporarily pushed to avoid spurious
555 ER_NEED_REPREPARE errors -- system and INFORMATION_SCHEMA tables are not
556 subject to metadata version tracking.
557
558 A stack is used here for the convenience -- in some cases we need to
559 temporarily override/disable current Reprepare_observer-instance.
560
561 NOTE: This is not a list of observers, only the top-most element will be
562 notified in case of a metadata change.
563
564 @sa check_and_update_table_version()
565 */
567
568 public:
570 return m_reprepare_observers.size() > 0 ? m_reprepare_observers.back()
571 : NULL;
572 }
573
575 m_reprepare_observers.push_back(o);
576 }
577
580 m_reprepare_observers.pop_back();
581 return retval;
582 }
583
585
586 public:
587 /**
588 List of regular tables in use by this thread. Contains persistent base
589 tables that were opened with @see open_tables().
590 */
592 /**
593 List of temporary tables used by this thread. Contains user-level
594 temporary tables, created with CREATE TEMPORARY TABLE, and
595 intermediate tables used in ALTER TABLE implementation.
596 */
598 /*
599 During a MySQL session, one can lock tables in two modes: automatic
600 or manual. In automatic mode all necessary tables are locked just before
601 statement execution, and all acquired locks are stored in 'lock'
602 member. Unlocking takes place automatically as well, when the
603 statement ends.
604 Manual mode comes into play when a user issues a 'LOCK TABLES'
605 statement. In this mode the user can only use the locked tables.
606 Trying to use any other tables will give an error.
607 The locked tables are also stored in this member, however,
608 thd->locked_tables_mode is turned on. Manual locking is described in
609 the 'LOCK_TABLES' chapter of the MySQL manual.
610 See also lock_tables() for details.
611 */
613
614 /*
615 CREATE-SELECT keeps an extra lock for the table being
616 created. This field is used to keep the extra lock available for
617 lower level routines, which would otherwise miss that lock.
618 */
620
621 /*
622 Enum enum_locked_tables_mode and locked_tables_mode member are
623 used to indicate whether the so-called "locked tables mode" is on,
624 and what kind of mode is active.
625
626 Locked tables mode is used when it's necessary to open and
627 lock many tables at once, for usage across multiple
628 (sub-)statements.
629 This may be necessary either for queries that use stored functions
630 and triggers, in which case the statements inside functions and
631 triggers may be executed many times, or for implementation of
632 LOCK TABLES, in which case the opened tables are reused by all
633 subsequent statements until a call to UNLOCK TABLES.
634
635 The kind of locked tables mode employed for stored functions and
636 triggers is also called "prelocked mode".
637 In this mode, first open_tables() call to open the tables used
638 in a statement analyses all functions used by the statement
639 and adds all indirectly used tables to the list of tables to
640 open and lock.
641 It also marks the parse tree of the statement as requiring
642 prelocking. After that, lock_tables() locks the entire list
643 of tables and changes THD::locked_tables_modeto LTM_PRELOCKED.
644 All statements executed inside functions or triggers
645 use the prelocked tables, instead of opening their own ones.
646 Prelocked mode is turned off automatically once close_thread_tables()
647 of the main statement is called.
648 */
650
652 BACKUPS_AVAIL = (1U << 0), /* There are backups available. */
653 SYSTEM_TABLES = (1U << 1) /* We are opening system tables. */
654 };
655
656 /*
657 Flags with information about the open tables state.
658 */
660 /**
661 This constructor initializes Open_tables_state instance which can only
662 be used as backup storage. To prepare Open_tables_state instance for
663 operations which open/lock/close tables (e.g. open_table()) one has to
664 call init_open_tables_state().
665 */
668
670
672};
673
674/**
675 Storage for backup of Open_tables_state. Must
676 be used only to open system tables (TABLE_CATEGORY_SYSTEM
677 and TABLE_CATEGORY_LOG).
678*/
679
681 public:
682 /**
683 When we backup the open tables state to open a system
684 table or tables, we want to save state of metadata
685 locks which were acquired before the backup. It is used
686 to release metadata locks on system tables after they are
687 no longer used.
688 */
690};
691
692/**
693 Enum that represents which phase of secondary engine optimization
694 the current statement is in.
695*/
697 /**
698 The current statement should only use tables from primary storage
699 engines. Use of secondary storage engines is disabled.
700 */
702
703 /**
704 The current statement should only use tables from the primary
705 storage engine. However, use of secondary storage engines is not
706 disabled, so the optimizer may choose to trigger a repreparation
707 against the secondary storage engine if it believes that use of a
708 secondary storage engine is beneficial.
709 */
711
712 /**
713 The current statement should use tables from a secondary storage
714 engine if possible. Otherwise, fall back to using tables from
715 primary storage engine only.
716 */
717 SECONDARY,
718};
719
720/**
721 @class Sub_statement_state
722 @brief Used to save context when executing a function or trigger
723*/
724
725/* Defines used for Sub_statement_state::in_sub_stmt */
726
727#define SUB_STMT_TRIGGER 1
728#define SUB_STMT_FUNCTION 2
729
731 public:
744};
745
746inline char const *show_system_thread(enum_thread_type thread) {
747#define RETURN_NAME_AS_STRING(NAME) \
748 case (NAME): \
749 return #NAME
750 switch (thread) {
751 static char buf[64];
766 default:
767 sprintf(buf, "<UNKNOWN SYSTEM THREAD: %d>", thread);
768 return buf;
769 }
770#undef RETURN_NAME_AS_STRING
771}
772
773/**
774 Storage engine specific thread local data.
775*/
776
777struct Ha_data {
778 /**
779 Storage engine specific thread local data.
780 Lifetime: one user connection.
781 */
782 void *ha_ptr;
783 /**
784 A memorizer to engine specific "native" transaction object to provide
785 storage engine detach-re-attach facility.
786 The server level transaction object can dissociate from storage engine
787 transactions. The released "native" transaction reference
788 can be hold in the member until it is reconciled later.
789 Lifetime: Depends on caller of @c hton::replace_native_transaction_in_thd.
790 For instance in the case of slave server applier handling XA transaction
791 it is from XA START to XA PREPARE.
792 */
794 /**
795 0: Life time: one statement within a transaction. If @@autocommit is
796 on, also represents the entire transaction.
797 @sa trans_register_ha()
798
799 1: Life time: one transaction within a connection.
800 If the storage engine does not participate in a transaction,
801 this should not be used.
802 @sa trans_register_ha()
803 */
805
806 /**
807 NULL: engine is not bound to this thread
808 non-NULL: engine is bound to this thread, engine shutdown forbidden
809 */
811
813};
814
815/**
816 An instance of the global read lock in a connection.
817 Implemented in lock.cc.
818*/
819
821 public:
826 };
827
829 : m_state(GRL_NONE),
832
833 bool lock_global_read_lock(THD *thd);
834 void unlock_global_read_lock(THD *thd);
835
836 /**
837 Used by innodb memcached server to check if any connections
838 have global read lock
839 */
841
842 /**
843 Check if this connection can acquire protection against GRL and
844 emit error if otherwise.
845 */
847 if (m_state) {
848 my_error(ER_CANT_UPDATE_WITH_READLOCK, MYF(0));
849 return true;
850 }
851 return false;
852 }
854 bool is_acquired() const { return m_state != GRL_NONE; }
856
857 private:
858 static std::atomic<int32> m_atomic_active_requests;
860 /**
861 In order to acquire the global read lock, the connection must
862 acquire shared metadata lock in GLOBAL namespace, to prohibit
863 all DDL.
864 */
866 /**
867 Also in order to acquire the global read lock, the connection
868 must acquire a shared metadata lock in COMMIT namespace, to
869 prohibit commits.
870 */
872};
873
874extern "C" void my_message_sql(uint error, const char *str, myf MyFlags);
875
876/**
877 This class keeps the context of transactional DDL statements. Currently only
878 CREATE TABLE with START TRANSACTION uses this context.
879*/
881 public:
882 explicit Transactional_ddl_context(THD *thd) : m_thd(thd) {
883 assert(m_thd != nullptr);
884 }
885
887 assert(!m_hton);
888 post_ddl();
889 }
890
891 void init(dd::String_type db, dd::String_type tablename,
892 const handlerton *hton);
893
894 bool inited() { return m_hton != nullptr; }
895
896 void rollback();
897
898 void post_ddl();
899
900 private:
901 // The current thread.
902 THD *m_thd{nullptr};
903
904 // Handlerton pointer to table's engine begin created.
905 const handlerton *m_hton{nullptr};
906
907 // Schema and table name being created.
910};
911
912struct PS_PARAM;
913
914/**
915 @class THD
916 For each client connection we create a separate thread with THD serving as
917 a thread/connection descriptor
918*/
919
920class THD : public MDL_context_owner,
921 public Query_arena,
922 public Open_tables_state {
923 public:
924 /**
925 Controlled memory stats for this session.
926 This member is the first in THD,
927 to initialize Thd_mem_cnt() before allocating more memory.
928 */
930
931 private:
932 inline bool is_stmt_prepare() const {
933 assert(0);
935 }
936
938 assert(0);
940 }
941
943 assert(0);
945 }
946
947 inline bool is_regular() const {
948 assert(0);
950 }
951
952 public:
954
955 /**
956 MARK_COLUMNS_NONE: Means mark_used_columns is not set and no indicator to
957 handler of fields used is set
958 MARK_COLUMNS_READ: Means a bit in read set is set to inform handler
959 that the field is to be read. Update covering_keys
960 and merge_keys too.
961 MARK_COLUMNS_WRITE: Means a bit is set in write set to inform handler
962 that it needs to update this field in write_row
963 and update_row.
964 MARK_COLUMNS_TEMP: Mark bit in read set, but ignore key sets.
965 Used by filesort().
966 */
968 /**
969 Used by Item::check_column_privileges() to tell which privileges
970 to check for.
971 Set to ~0ULL before starting to resolve a statement.
972 Set to desired privilege mask before calling a resolver function that will
973 call Item::check_column_privileges().
974 After use, restore previous value as current value.
975 */
977
978 private:
979 /**
980 The lex to hold the parsed tree of conventional (non-prepared) queries.
981 Whereas for prepared and stored procedure statements we use an own lex
982 instance for each new query, for conventional statements we reuse
983 the same lex. (@see dispatch_sql_command for details).
984 */
985 std::unique_ptr<LEX> main_lex;
986
987 public:
988 LEX *lex; // parse tree descriptor
989 dd::cache::Dictionary_client *dd_client() const // Get the dictionary client.
990 {
991 return m_dd_client.get();
992 }
993
994 private:
995 std::unique_ptr<dd::cache::Dictionary_client> m_dd_client;
996
997 /**
998 The query associated with this statement.
999 */
1002 std::atomic<bool> m_safe_to_display;
1003
1004 /**
1005 Currently selected catalog.
1006 */
1007
1009 /**
1010 Name of the current (default) database.
1011
1012 If there is the current (default) database, "db" contains its name. If
1013 there is no current (default) database, "db" is NULL and "db_length" is
1014 0. In other words, "db", "db_length" must either be NULL, or contain a
1015 valid database name.
1016
1017 @note this attribute is set and allocated by the slave SQL thread (for
1018 the THD of that thread); that thread is (and must remain, for now) the
1019 only responsible for freeing this member.
1020 */
1022
1023 /**
1024 Resource group context indicating the current resource group
1025 and the name of the resource group to switch to during execution
1026 of a query.
1027 */
1029
1030 /**
1031 In some cases, we may want to modify the query (i.e. replace
1032 passwords with their hashes before logging the statement etc.).
1033
1034 In case the query was rewritten, the original query will live in
1035 m_query_string, while the rewritten query lives in rewritten_query.
1036 If rewritten_query is empty, m_query_string should be logged.
1037 If rewritten_query is non-empty, the rewritten query it contains
1038 should be used in logs (general log, slow query log, binary log).
1039
1040 Currently, password obfuscation is the only rewriting we do; more
1041 may follow at a later date, both pre- and post parsing of the query.
1042 Rewriting of binloggable statements must preserve all pertinent
1043 information.
1044
1045 Similar restrictions as for m_query_string (see there) hold for locking:
1046 - Value may only be (re)set from owning thread (current_thd)
1047 - Value must be modified using (reset|swap)_rewritten_query().
1048 Doing so will protect the update with LOCK_thd_query.
1049 - The owner (current_thd) may read the value without holding the lock.
1050 - Other threads may read the value, but must hold LOCK_thd_query to do so.
1051 */
1053
1054 public:
1055 /* Used to execute base64 coded binlog events in MySQL server */
1057 /* Slave applier execution context */
1059
1060 /* Is transaction commit still pending */
1062
1063 /**
1064 The function checks whether the thread is processing queries from binlog,
1065 as automatically generated by mysqlbinlog.
1066
1067 @return true when the thread is a binlog applier
1068 */
1069 bool is_binlog_applier() const {
1071 }
1072
1073 /**
1074 When the thread is a binlog or slave applier it detaches the engine
1075 ha_data associated with it and memorizes the fact of that.
1076 */
1078
1079 /**
1080 When the thread is a binlog or slave applier it reattaches the engine
1081 ha_data associated with it and memorizes the fact of that.
1082 */
1084
1085 /**
1086 @return true when the current binlog (rli_fake) or slave (rli_slave)
1087 applier thread has detached the engine ha_data,
1088 see @c rpl_detach_engine_ha_data.
1089 @note The detached transaction applier resets a memo
1090 mark at once with this check.
1091 */
1092 bool is_engine_ha_data_detached() const;
1093
1095 /*
1096 Constant for THD::where initialization in the beginning of every query.
1097
1098 It's needed because we do not save/restore THD::where normally during
1099 primary (non subselect) query execution.
1100 */
1101 static const char *const DEFAULT_WHERE;
1102
1103 /** Additional network instrumentation for the server only. */
1105 /**
1106 Hash for user variables.
1107 User variables are per session,
1108 but can also be monitored outside of the session,
1109 so a lock is needed to prevent race conditions.
1110 Protected by @c LOCK_thd_data.
1111 */
1114 struct rand_struct rand; // used for authentication
1115 struct System_variables variables; // Changeable local variables
1116 struct System_status_var status_var; // Per thread statistic vars
1117 struct System_status_var
1118 *copy_status_var_ptr; // A copy of the statistic vars asof the start of
1119 // the query
1120 struct System_status_var *initial_status_var; /* used by show status */
1121 // has status_var already been added to global_status_var?
1123
1124 /**
1125 Session's connection attributes for the connected client
1126 */
1127 std::vector<char> m_connection_attributes;
1128
1129 /**
1130 Current query cost.
1131 @sa system_status_var::last_query_cost
1132 */
1134 /**
1135 Current query partial plans.
1136 @sa system_status_var::last_query_partial_plans
1137 */
1139
1140 /**
1141 Clear the query costs attributes for the current query.
1142 */
1146 }
1147
1148 /**
1149 Save the current query costs attributes in
1150 the thread session status.
1151 Use this method only after the query execution is completed,
1152 so that
1153 @code SHOW SESSION STATUS like 'last_query_%' @endcode
1154 @code SELECT * from performance_schema.session_status
1155 WHERE VARIABLE_NAME like 'last_query_%' @endcode
1156 actually reports the previous query, not itself.
1157 */
1159 assert(!status_var_aggregated);
1162 }
1163
1164 /**
1165 Clear copy of the status variables.
1166 */
1168
1169 /**
1170 Copy status variables into a structure pointed by the specified pointer and
1171 keep track of the pointer internally.
1172
1173 @param dst_var status variable structure pointer, where internal status
1174 variables are copied into.
1175 */
1177 *dst_var = status_var;
1178 copy_status_var_ptr = dst_var;
1179 }
1180
1181 /**
1182 Copy status variables into a structure pointed by the specified pointer
1183 passed into copy_status_var method call.
1184 */
1186 if (copy_status_var_ptr) {
1187 /* Reset for values at start of next statement */
1189 }
1190 }
1191
1192 THR_LOCK_INFO lock_info; // Locking info of this thread
1193 /**
1194 Protects THD data accessed from other threads.
1195 The attributes protected are:
1196 - thd->is_killable (used by KILL statement and shutdown).
1197 - thd->user_vars (user variables, inspected by monitoring)
1198 Is locked when THD is deleted.
1199 */
1201
1202 /**
1203 Protects THD::m_query_string. No other mutexes should be locked
1204 while having this mutex locked.
1205 */
1207
1208 /**
1209 Protects THD::variables while being updated. This should be taken inside
1210 of LOCK_thd_data and outside of LOCK_global_system_variables.
1211 */
1213
1214#ifndef NDEBUG
1216#endif
1217
1218 /**
1219 Protects THD::m_protocol when it gets removed in x plugin.
1220 */
1222
1223 /**
1224 Protects THD::m_security_ctx from inspection (e.g. by old-style
1225 SHOW PROCESSLIST) while COM_CHANGE_USER changes the context.
1226 */
1228
1229 /**
1230 Protects query plan (SELECT/UPDATE/DELETE's) from being freed/changed
1231 while another thread explains it. Following structures are protected by
1232 this mutex:
1233 THD::Query_plan
1234 Modification_plan
1235 Query_block::join
1236 JOIN::plan_state
1237 Tree of Query_expression after THD::Query_plan was set till
1238 THD::Query_plan cleanup
1239 JOIN_TAB::select->quick
1240 Code that changes objects above should take this mutex.
1241 Explain code takes this mutex to block changes to named structures to
1242 avoid crashes in following functions:
1243 explain_single_table_modification
1244 explain_query
1245 Sql_cmd_explain_other_thread::execute
1246 When doing EXPLAIN CONNECTION:
1247 all explain code assumes that this mutex is already taken.
1248 When doing ordinary EXPLAIN:
1249 the mutex does need to be taken (no need to protect reading my own data,
1250 moreover EXPLAIN CONNECTION can't run on an ordinary EXPLAIN).
1251 */
1252 private:
1254
1255 public:
1256 /// Locks the query plan of this THD
1259
1260 /** All prepared statements of this connection. */
1262 /*
1263 A pointer to the stack frame of handle_one_connection(),
1264 which is called first in the thread for handling a client
1265 */
1266 const char *thread_stack;
1267
1268 /**
1269 @note
1270 Some members of THD (currently 'Statement::db',
1271 'catalog' and 'query') are set and allocated by the slave SQL thread
1272 (for the THD of that thread); that thread is (and must remain, for now)
1273 the only responsible for freeing these 3 members. If you add members
1274 here, and you add code to set them in replication, don't forget to
1275 free_them_and_set_them_to_0 in replication properly. For details see
1276 the 'err:' label of the handle_slave_sql() in sql/slave.cc.
1277
1278 @see handle_slave_sql
1279 */
1280
1283
1287
1288 /**
1289 @note
1290 The optional password validation plugin doesn't have any API for
1291 temporally disable its functionality for a particular session.
1292 To get around this issue we introduce a boolean variable in the THD
1293 which we check before each call to the password validation plugin.
1294 Password validation is invoked from within the authentication plugin
1295 in the generate_authentication_string() method.
1296
1297 @see generate_authentication_string
1298 */
1300
1301 std::unique_ptr<Protocol_text> protocol_text; // Normal protocol
1302 std::unique_ptr<Protocol_binary> protocol_binary; // Binary protocol
1303
1304 const Protocol *get_protocol() const { return m_protocol; }
1305
1307
1309#ifndef NDEBUG
1310 if (current_thd != this) {
1311 /*
1312 When inspecting this thread from monitoring,
1313 the monitoring thread MUST lock LOCK_thd_data,
1314 to be allowed to safely inspect SSL status variables.
1315 */
1317 }
1318#endif
1319 return m_SSL;
1320 }
1321
1322 /**
1323 Asserts that the protocol is of type text or binary and then
1324 returns the m_protocol casted to Protocol_classic. This method
1325 is needed to prevent misuse of pluggable protocols by legacy code
1326 */
1328 assert(is_classic_protocol());
1329 return pointer_cast<const Protocol_classic *>(m_protocol);
1330 }
1331
1333 assert(is_classic_protocol());
1334 return pointer_cast<Protocol_classic *>(m_protocol);
1335 }
1336
1337 private:
1338 Protocol *m_protocol; // Current protocol
1339 /**
1340 SSL data attached to this connection.
1341 This is an opaque pointer,
1342 When building with SSL, this pointer is non NULL
1343 only if the connection is using SSL.
1344 When building without SSL, this pointer is always NULL.
1345 The SSL data can be inspected to read per thread
1346 status variables,
1347 and this can be inspected while the thread is running.
1348 */
1349 SSL_handle m_SSL = {nullptr};
1350
1351 public:
1352 /**
1353 Query plan for EXPLAINable commands, should be locked with
1354 LOCK_query_plan before using.
1355 */
1357 private:
1358 THD *const thd;
1359 /// Original sql_command;
1361 /// LEX of topmost statement
1363 /// Query plan for UPDATE/DELETE/INSERT/REPLACE
1365 /// True if query is run in prepared statement
1366 bool is_ps;
1367
1368 explicit Query_plan(const Query_plan &); ///< not defined
1369 Query_plan &operator=(const Query_plan &); ///< not defined
1370
1371 public:
1372 /// Asserts that current_thd has locked this plan, if it does not own it.
1374#ifdef NDEBUG
1375 {
1376 }
1377#else
1378 ;
1379#endif
1380
1381 explicit Query_plan(THD *thd_arg)
1382 : thd(thd_arg),
1384 lex(nullptr),
1386 is_ps(false) {}
1387
1388 /**
1389 Set query plan.
1390
1391 @note This function takes THD::LOCK_query_plan mutex.
1392 */
1393 void set_query_plan(enum_sql_command sql_cmd, LEX *lex_arg, bool ps);
1394
1395 /*
1396 The 4 getters below expect THD::LOCK_query_plan to be already taken
1397 if called from another thread.
1398 */
1401 return sql_command;
1402 }
1403 LEX *get_lex() const {
1405 return lex;
1406 }
1409 return modification_plan;
1410 }
1411 bool is_ps_query() const {
1413 return is_ps;
1414 }
1415 bool is_single_table_plan() const;
1417
1419
1420 const LEX_CSTRING &catalog() const { return m_catalog; }
1421
1423
1424 private:
1426
1427 /*
1428 Points to info-string that we show in SHOW PROCESSLIST
1429 You are supposed to update thd->proc_info only if you have coded
1430 a time-consuming piece that MySQL can get stuck in for a long time.
1431
1432 Set it using the thd_proc_info(THD *thread, const char *message)
1433 macro/function.
1434
1435 This member is accessed and assigned without any synchronization.
1436 Therefore, it may point only to constant (statically
1437 allocated) strings, which memory won't go away over time.
1438 */
1439 const char *m_proc_info;
1440 /**
1441 Return the m_proc_info, possibly using the string of an older
1442 server release, according to @@terminology_use_previous.
1443
1444 @param sysvars Use the value of
1445 @@terminology_use_previous stored in this
1446 System_variables object.
1447
1448 @return The "proc_info", also known as "stage", of this thread.
1449 */
1450 const char *proc_info(const System_variables &sysvars) const;
1451
1452 public:
1453 // See comment in THD::enter_cond about why SUPPRESS_TSAN is needed.
1454 void enter_stage(const PSI_stage_info *stage, PSI_stage_info *old_stage,
1455 const char *calling_func, const char *calling_file,
1456 const unsigned int calling_line) SUPPRESS_TSAN;
1457 const char *proc_info() const { return m_proc_info; }
1458 /**
1459 Return the m_proc_info, possibly using the string of an older
1460 server release, according to
1461 @@session.terminology_use_previous.
1462
1463 @param invoking_thd Use
1464 @@session.terminology_use_previous of this session.
1465
1466 @return The "proc_info", also known as "stage", of this thread.
1467 */
1468 const char *proc_info_session(THD *invoking_thd) const {
1469 return proc_info(invoking_thd->variables);
1470 }
1473
1474 /*
1475 Used in error messages to tell user in what part of MySQL we found an
1476 error. E. g. when where= "having clause", if fix_fields() fails, user
1477 will know that the error was in having clause.
1478 */
1479 const char *where;
1480
1482
1486 /*
1487 A thread can hold named user-level locks. This variable
1488 contains granted tickets if a lock is present. See item_func.cc and
1489 chapter 'Miscellaneous functions', for functions GET_LOCK, RELEASE_LOCK.
1490 */
1493#ifndef NDEBUG
1494 uint dbug_sentry; // watch out for memory corruption
1495#endif
1497 /**
1498 Mutex protecting access to current_mutex and current_cond.
1499 */
1501 /**
1502 The mutex used with current_cond.
1503 @see current_cond
1504 */
1505 std::atomic<mysql_mutex_t *> current_mutex;
1506 /**
1507 Pointer to the condition variable the thread owning this THD
1508 is currently waiting for. If the thread is not waiting, the
1509 value is NULL. Set by THD::enter_cond().
1510
1511 If this thread is killed (shutdown or KILL stmt), another
1512 thread will broadcast on this condition variable so that the
1513 thread can be unstuck.
1514 */
1515 std::atomic<mysql_cond_t *> current_cond;
1516 /**
1517 Condition variable used for waiting by the THR_LOCK.c subsystem.
1518 */
1520
1521 private:
1522 /**
1523 Type of current query: COM_STMT_PREPARE, COM_QUERY, etc.
1524 Set from first byte of the packet in do_command()
1525 */
1527
1528 private:
1530
1531 public:
1532 void set_admin_connection(bool admin) { m_is_admin_conn = admin; }
1533 bool is_admin_connection() const { return m_is_admin_conn; }
1534
1537 uint32 file_id; // for LOAD DATA INFILE
1538 /* remote (peer) port */
1540 struct timeval start_time;
1541 struct timeval user_time;
1542 /**
1543 Query start time, expressed in microseconds.
1544 */
1546
1547 private:
1548 /**
1549 Time spent waiting for TABLE locks and DATA locks.
1550 Expressed in microseconds.
1551 */
1553
1554 public:
1556 void inc_lock_usec(ulonglong usec);
1558 top = m_lock_usec;
1559 m_lock_usec = 0;
1560 }
1562
1563 /**
1564 Type of lock to be used for all DML statements, except INSERT, in cases
1565 when lock is not specified explicitly. Set to TL_WRITE or
1566 TL_WRITE_LOW_PRIORITY depending on whether low_priority_updates option is
1567 off or on.
1568 */
1570 /**
1571 Type of lock to be used for INSERT statement if lock is not specified
1572 explicitly. Set to TL_WRITE_CONCURRENT_INSERT or TL_WRITE_LOW_PRIORITY
1573 depending on whether low_priority_updates option is off or on.
1574 */
1576
1577 /* <> 0 if we are inside of trigger or stored function. */
1579
1580 /**
1581 Used by fill_status() to avoid acquiring LOCK_status mutex twice
1582 when this function is called recursively (e.g. queries
1583 that contains SELECT on I_S.GLOBAL_STATUS with subquery on the
1584 same I_S table).
1585 Incremented each time fill_status() function is entered and
1586 decremented each time before it returns from the function.
1587 */
1590
1591 private:
1592 /* container for handler's private per-connection data */
1594
1595 public:
1596 /**
1597 Retrieve Ha_data for a given slot. Each handler has a fixed slot nr.
1598 */
1599 Ha_data *get_ha_data(int slot) { return &ha_data[slot]; }
1600
1601 /**
1602 Copy ha_data into the provided argument. Used by Attachble_transaction.
1603 */
1605 /*
1606 Protect with LOCK_thd_data avoid accessing ha_data while it
1607 is being modified.
1608 */
1609 mysql_mutex_lock(&this->LOCK_thd_data);
1610 *backup = ha_data;
1611 mysql_mutex_unlock(&this->LOCK_thd_data);
1612 }
1613
1614 /**
1615 Restore ha_data from the provided backup copy.
1616 Used by Attachable_Transaction.
1617 */
1620 /*
1621 Protect with LOCK_thd_data to avoid e.g. KILL CONNECTION
1622 reading ha_data while it is being modified.
1623 */
1624 mysql_mutex_lock(&this->LOCK_thd_data);
1625 ha_data = backup;
1626 mysql_mutex_unlock(&this->LOCK_thd_data);
1627 }
1628
1629 /*
1630 Position of first event in Binlog
1631 *after* last event written by this
1632 thread.
1633 */
1635 void set_next_event_pos(const char *_filename, ulonglong _pos);
1636 void clear_next_event_pos();
1637
1638 /*
1639 Ptr to row event extra data to be written to Binlog /
1640 received from Binlog.
1641
1642 */
1644
1646
1647 /*
1648 Public interface to write RBR events to the binlog
1649 */
1650 int binlog_write_table_map(TABLE *table, bool is_transactional,
1651 bool binlog_rows_query);
1652 int binlog_write_row(TABLE *table, bool is_transactional,
1653 const uchar *new_data,
1654 const unsigned char *extra_row_info);
1655 int binlog_delete_row(TABLE *table, bool is_transactional,
1656 const uchar *old_data,
1657 const unsigned char *extra_row_info);
1658 int binlog_update_row(TABLE *table, bool is_transactional,
1659 const uchar *old_data, const uchar *new_data,
1660 const uchar *extra_row_info);
1661 void set_server_id(uint32 sid) { server_id = sid; }
1662
1663 /*
1664 Member functions to handle pending event for row-level logging.
1665 */
1666 template <class RowsEventT>
1668 TABLE *table, uint32 serv_id, size_t needed, bool is_transactional,
1669 const unsigned char *extra_row_info, uint32 source_part_id = INT_MAX);
1670 Rows_log_event *binlog_get_pending_rows_event(bool is_transactional) const;
1671 inline int binlog_flush_pending_rows_event(bool stmt_end) {
1672 return (binlog_flush_pending_rows_event(stmt_end, false) ||
1673 binlog_flush_pending_rows_event(stmt_end, true));
1674 }
1675 int binlog_flush_pending_rows_event(bool stmt_end, bool is_transactional);
1676
1677 /**
1678 Determine the binlog format of the current statement.
1679
1680 @retval 0 if the current statement will be logged in statement
1681 format.
1682 @retval nonzero if the current statement will be logged in row
1683 format.
1684 */
1689 }
1690
1691 /**
1692 Determine if binlogging is currently disabled for this session.
1693
1694 There are two ways that binlogging can be disabled:
1695
1696 1. The binary log file is closed (globally). This can happen for
1697 two reasons: either --skip-log-bin was used on the command line,
1698 or a binlog write error happened when binlog_error_action=IGNORE_ERROR.
1699
1700 2. The binary log is disabled on session level. This can happen for
1701 two reasons: either the user has set @@session.sql_log_bin = 0,
1702 or the server code has internally disabled the binary log (by
1703 either setting thd->variables.option_bits &= ~OPTION_BIN_LOG or
1704 creating a Disable_binlog_guard object).
1705
1706 Even if this function returns true and the binary log is disabled,
1707 it is possible that the statement will be written to the binary log,
1708 in the cases where the server has merely temporarily disabled binary
1709 logging.
1710
1711 And even if this function returns false and the binary log is
1712 enabled, it is possible that the statement will not be written to
1713 the binary log, e.g. in case it is a no-op, it fails, it gets rolled
1714 back, or some other session closes the binary log due to a write
1715 error when using binlog_error_action=IGNORE_ERROR.
1716
1717 @retval true The binary log is currently disabled for the statement.
1718
1719 @retval false The binary log is currently enabled for the statement.
1720 */
1722
1723 /**
1724 Determine if binlogging is currently disabled for this session.
1725 If the binary log is disabled for this thread (either by log_bin=0 or
1726 sql_log_bin=0 or by log_replica_updates=0 for a slave thread), then the
1727 statement will not be written to the binary log.
1728
1729 @retval true The binary log is currently disabled for the statement.
1730
1731 @retval false The binary log is currently enabled for the statement.
1732 */
1734
1735 /**
1736 Determine if binloging is enabled in row format and write set extraction is
1737 enabled for this session
1738 @retval true if is enable
1739 @retval false otherwise
1740 */
1742
1743 /** Tells whether the given optimizer_switch flag is on */
1745 return (variables.optimizer_switch & flag);
1746 }
1747
1753
1756 }
1757
1761 }
1762
1766 }
1767
1769 return m_binlog_filter_state;
1770 }
1771
1772 /** Holds active timer object */
1774 /**
1775 After resetting(cancelling) timer, current timer object is cached
1776 with timer_cache timer to reuse.
1777 */
1779
1780 private:
1781 /*
1782 Indicates that the command which is under execution should ignore the
1783 'read_only' and 'super_read_only' options.
1784 */
1786 /**
1787 Indicate if the current statement should be discarded
1788 instead of written to the binlog.
1789 This is used to discard special statements, such as
1790 DML or DDL that affects only 'local' (non replicated)
1791 tables, such as performance_schema.*
1792 */
1794
1795 /**
1796 Indicates the format in which the current statement will be
1797 logged. This can only be set from @c decide_logging_format().
1798 */
1800
1801 /**
1802 Bit field for the state of binlog warnings.
1803
1804 The first Lex::BINLOG_STMT_UNSAFE_COUNT bits list all types of
1805 unsafeness that the current statement has.
1806
1807 This must be a member of THD and not of LEX, because warnings are
1808 detected and issued in different places (@c
1809 decide_logging_format() and @c binlog_query(), respectively).
1810 Between these calls, the THD->lex object may change; e.g., if a
1811 stored routine is invoked. Only THD persists between the calls.
1812 */
1814
1815 /*
1816 Number of outstanding table maps, i.e., table maps in the
1817 transaction cache.
1818 */
1820 /*
1821 MTS: db names listing to be updated by the query databases
1822 */
1824
1825 /**
1826 The binary log position of the transaction.
1827
1828 The file and position are zero if the current transaction has not
1829 been written to the binary log.
1830
1831 @see set_trans_pos
1832 @see get_trans_pos
1833
1834 @todo Similar information is kept in the patch for BUG#11762277
1835 and by the master/slave heartbeat implementation. We should merge
1836 these positions instead of maintaining three different ones.
1837 */
1838 /**@{*/
1839 const char *m_trans_log_file;
1842 /**@}*/
1843 // NOTE: Ideally those two should be in Protocol,
1844 // but currently its design doesn't allow that.
1845 NET net; // client connection descriptor
1846 String packet; // dynamic buffer for network I/O
1847 public:
1849
1851
1854 }
1855
1856 void issue_unsafe_warnings();
1857
1860
1861 /*
1862 MTS: accessor to binlog_accessed_db_names list
1863 */
1866 }
1867
1868 /* MTS: method inserts a new unique name into binlog_updated_dbs */
1869 void add_to_binlog_accessed_dbs(const char *db);
1870
1871 private:
1872 std::unique_ptr<Transaction_ctx> m_transaction;
1873
1874 /** An utility struct for @c Attachable_trx */
1878 void backup(THD *thd);
1879 void restore(THD *thd);
1880
1881 /// SQL-command.
1883
1885
1886 /// Open-tables state.
1888
1889 /// SQL_MODE.
1891
1892 /// Transaction isolation level.
1894
1895 /// Ha_data array.
1897
1898 /// Transaction_ctx instance.
1900
1901 /// Transaction read-only state.
1903
1904 /// THD options.
1906
1907 /// Current transaction instrumentation.
1909
1910 /// Server status flags.
1912
1913 /// THD::in_lock_tables value.
1915
1916 /**
1917 Current time zone (i.e. @@session.time_zone) usage indicator.
1918
1919 Saving it allows data-dictionary code to read timestamp values
1920 as datetimes from system tables without disturbing user's statement.
1921
1922 TODO: We need to change DD code not to use @@session.time_zone at all and
1923 stick to UTC for internal storage of timestamps in DD objects.
1924 */
1926
1927 /**
1928 Transaction rollback request flag.
1929
1930 InnoDB can try to access table definition while rolling back regular
1931 transaction. So we need to be able to start attachable transaction
1932 without being affected by, and affecting, the rollback state of regular
1933 transaction.
1934 */
1936 };
1937
1938 public:
1940
1941 private:
1942 /**
1943 Class representing read-only attachable transaction, encapsulates
1944 knowledge how to backup state of current transaction, start
1945 read-only attachable transaction in SE, finalize it and then restore
1946 state of original transaction back. Also serves as a base class for
1947 read-write attachable transaction implementation.
1948 */
1950 public:
1951 Attachable_trx(THD *thd, Attachable_trx *prev_trx);
1952 virtual ~Attachable_trx();
1954 return m_prev_attachable_trx;
1955 }
1956 virtual bool is_read_only() const { return true; }
1957
1958 protected:
1959 /// THD instance.
1961
1963
1964 /**
1965 Attachable_trx which was active for the THD before when this
1966 transaction was started (NULL in most cases).
1967 */
1969
1970 /// Transaction state data.
1972
1973 private:
1976 };
1977
1978 /**
1979 A derived from THD::Attachable_trx class allows updates in
1980 the attachable transaction. Callers of the class methods must
1981 make sure the attachable_rw won't cause deadlock with the main transaction.
1982 The destructor does not invoke ha_commit_{stmt,trans} nor ha_rollback_trans
1983 on purpose.
1984 Burden to terminate the read-write instance also lies on the caller!
1985 In order to use this interface it *MUST* prove that no side effect to
1986 the global transaction state can be inflicted by a chosen method.
1987
1988 This class is being used only by class Gtid_table_access_context by
1989 replication and by dd::info_schema::Table_statistics.
1990 */
1991
1993 public:
1994 bool is_read_only() const override { return false; }
1995 explicit Attachable_trx_rw(THD *thd);
1996
1997 private:
2000 };
2001
2003
2004 public:
2006
2007 const Transaction_ctx *get_transaction() const { return m_transaction.get(); }
2008
2009 /**
2010 Changes the Transaction_ctx instance within THD-object. The previous
2011 Transaction_ctx instance is destroyed.
2012
2013 @note this is a THD-internal operation which MUST NOT be used outside.
2014
2015 @param transaction_ctx new Transaction_ctx instance to be associated with
2016 the THD-object.
2017 */
2018 void set_transaction(Transaction_ctx *transaction_ctx);
2019
2021
2022 Vio *active_vio = {nullptr};
2023
2024 /* Active network vio for clone remote connection. */
2025 Vio *clone_vio = {nullptr};
2026
2027 /**
2028 This is used to track transient changes to items during optimization of a
2029 prepared statement/stored procedure. Change objects are created by
2030 change_item_tree() in memory root of THD, and freed by
2031 rollback_item_tree_changes(). Changes recorded here are rolled back at
2032 the end of execution.
2033
2034 Transient changes require the following conditions:
2035 - The statement is not regular (ie. it is prepared or part of SP).
2036 - The change is performed outside preparation code (ie. it is
2037 performed during the optimization phase).
2038 - The change is applied to non-transient items (ie. items that have
2039 been created before or during preparation, not items that have been
2040 created in the optimization phase. Notice that the tree of AND/OR
2041 conditions is always as transient objects during optimization.
2042 Doing this should be quite harmless, though.)
2043 change_item_tree() only records changes to non-regular statements.
2044 It is also ensured that no changes are applied in preparation phase by
2045 asserting that the list of items is empty (see Sql_cmd_dml::prepare()).
2046 Other constraints are not enforced, in particular care must be taken
2047 so that all changes made during optimization to non-transient Items in
2048 non-regular statements must be recorded.
2049 */
2051
2052 /*
2053 A permanent memory area of the statement. For conventional
2054 execution, the parsed tree and execution runtime reside in the same
2055 memory root. In this case stmt_arena points to THD. In case of
2056 a prepared statement or a stored procedure statement, thd->mem_root
2057 conventionally points to runtime memory, and thd->stmt_arena
2058 points to the memory of the PS/SP, where the parsed tree of the
2059 statement resides. Whenever you need to perform a permanent
2060 transformation of a parsed tree, you should allocate new memory in
2061 stmt_arena, to allow correct re-execution of PS/SP.
2062 Note: in the parser, stmt_arena == thd, even for PS/SP.
2063 */
2065
2066 /*
2067 map for tables that will be updated for a multi-table update query
2068 statement, for other query statements, this will be zero.
2069 */
2071
2072 /* Tells if LAST_INSERT_ID(#) was called for the current statement */
2074 /*
2075 ALL OVER THIS FILE, "insert_id" means "*automatically generated* value for
2076 insertion into an auto_increment column".
2077 */
2078 /*
2079 This is the first autogenerated insert id which was *successfully*
2080 inserted by the previous statement (exactly, if the previous statement
2081 didn't successfully insert an autogenerated insert id, then it's the one
2082 of the statement before, etc).
2083 It can also be set by SET LAST_INSERT_ID=# or SELECT LAST_INSERT_ID(#).
2084 It is returned by LAST_INSERT_ID().
2085 */
2087 /*
2088 Variant of the above, used for storing in statement-based binlog. The
2089 difference is that the one above can change as the execution of a stored
2090 function progresses, while the one below is set once and then does not
2091 change (which is the value which statement-based binlog needs).
2092 */
2094 /*
2095 This is the first autogenerated insert id which was *successfully*
2096 inserted by the current statement. It is maintained only to set
2097 first_successful_insert_id_in_prev_stmt when statement ends.
2098 */
2100 /*
2101 We follow this logic:
2102 - when stmt starts, first_successful_insert_id_in_prev_stmt contains the
2103 first insert id successfully inserted by the previous stmt.
2104 - as stmt makes progress, handler::insert_id_for_cur_row changes;
2105 every time get_auto_increment() is called,
2106 auto_inc_intervals_in_cur_stmt_for_binlog is augmented with the
2107 reserved interval (if statement-based binlogging).
2108 - at first successful insertion of an autogenerated value,
2109 first_successful_insert_id_in_cur_stmt is set to
2110 handler::insert_id_for_cur_row.
2111 - when stmt goes to binlog,
2112 auto_inc_intervals_in_cur_stmt_for_binlog is binlogged if
2113 non-empty.
2114 - when stmt ends, first_successful_insert_id_in_prev_stmt is set to
2115 first_successful_insert_id_in_cur_stmt.
2116 */
2117 /*
2118 stmt_depends_on_first_successful_insert_id_in_prev_stmt is set when
2119 LAST_INSERT_ID() is used by a statement.
2120 If it is set, first_successful_insert_id_in_prev_stmt_for_binlog will be
2121 stored in the statement-based binlog.
2122 This variable is CUMULATIVE along the execution of a stored function or
2123 trigger: if one substatement sets it to 1 it will stay 1 until the
2124 function/trigger ends, thus making sure that
2125 first_successful_insert_id_in_prev_stmt_for_binlog does not change anymore
2126 and is propagated to the caller for binlogging.
2127 */
2129 /*
2130 List of auto_increment intervals reserved by the thread so far, for
2131 storage in the statement-based binlog.
2132 Note that its minimum is not first_successful_insert_id_in_cur_stmt:
2133 assuming a table with an autoinc column, and this happens:
2134 INSERT INTO ... VALUES(3);
2135 SET INSERT_ID=3; INSERT IGNORE ... VALUES (NULL);
2136 then the latter INSERT will insert no rows
2137 (first_successful_insert_id_in_cur_stmt == 0), but storing "INSERT_ID=3"
2138 in the binlog is still needed; the list's minimum will contain 3.
2139 This variable is cumulative: if several statements are written to binlog
2140 as one (stored functions or triggers are used) this list is the
2141 concatenation of all intervals reserved by all statements.
2142 */
2144 /* Used by replication and SET INSERT_ID */
2146 /*
2147 There is BUG#19630 where statement-based replication of stored
2148 functions/triggers with two auto_increment columns breaks.
2149 We however ensure that it works when there is 0 or 1 auto_increment
2150 column; our rules are
2151 a) on master, while executing a top statement involving substatements,
2152 first top- or sub- statement to generate auto_increment values wins the
2153 exclusive right to see its values be written to binlog (the write
2154 will be done by the statement or its caller), and the losers won't see
2155 their values be written to binlog.
2156 b) on slave, while replicating a top statement involving substatements,
2157 first top- or sub- statement to need to read auto_increment values from
2158 the master's binlog wins the exclusive right to read them (so the losers
2159 won't read their values from binlog but instead generate on their own).
2160 a) implies that we mustn't backup/restore
2161 auto_inc_intervals_in_cur_stmt_for_binlog.
2162 b) implies that we mustn't backup/restore auto_inc_intervals_forced.
2163
2164 If there are more than 1 auto_increment columns, then intervals for
2165 different columns may mix into the
2166 auto_inc_intervals_in_cur_stmt_for_binlog list, which is logically wrong,
2167 but there is no point in preventing this mixing by preventing intervals
2168 from the secondly inserted column to come into the list, as such
2169 prevention would be wrong too.
2170 What will happen in the case of
2171 INSERT INTO t1 (auto_inc) VALUES(NULL);
2172 where t1 has a trigger which inserts into an auto_inc column of t2, is
2173 that in binlog we'll store the interval of t1 and the interval of t2 (when
2174 we store intervals, soon), then in slave, t1 will use both intervals, t2
2175 will use none; if t1 inserts the same number of rows as on master,
2176 normally the 2nd interval will not be used by t1, which is fine. t2's
2177 values will be wrong if t2's internal auto_increment counter is different
2178 from what it was on master (which is likely). In 5.1, in mixed binlogging
2179 mode, row-based binlogging is used for such cases where two
2180 auto_increment columns are inserted.
2181 */
2185 }
2188 /* It's the first time we read it */
2192 }
2194 }
2201 }
2202
2203 /*
2204 Used by Intvar_log_event::do_apply_event() and by "SET INSERT_ID=#"
2205 (mysqlbinlog). We'll soon add a variant which can take many intervals in
2206 argument.
2207 */
2209 auto_inc_intervals_forced.clear(); // in case of multiple SET INSERT_ID
2210 auto_inc_intervals_forced.append(next_id, ULLONG_MAX, 0);
2211 }
2212
2213 /**
2214 Stores the result of the FOUND_ROWS() function. Set at query end, stable
2215 throughout the query.
2216 */
2218 /**
2219 Dynamic, collected and set also in subqueries. Not stable throughout query.
2220 previous_found_rows is a snapshot of this take at query end making it
2221 stable throughout the next query, see update_previous_found_rows.
2222 */
2224
2225 /*
2226 Indicate if the gtid_executed table is being operated implicitly
2227 within current transaction. This happens because we are inserting
2228 a GTID specified through SET GTID_NEXT by user client or
2229 slave SQL thread/workers.
2230 */
2232 /*
2233 Indicate that a sub-statement is being operated implicitly
2234 within current transaction.
2235 As we don't want that this implicit sub-statement to consume the
2236 GTID of the actual transaction, we set it true at the beginning of
2237 the sub-statement and set it false again after "committing" the
2238 sub-statement.
2239 When it is true, the applier will not save the transaction owned
2240 gtid into mysql.gtid_executed table before transaction prepare, as
2241 it does when binlog is disabled, or binlog is enabled and
2242 log_replica_updates is disabled.
2243 Also the flag is made to defer updates to the slave info table from
2244 intermediate commits by non-atomic DDL.
2245 Rpl_info_table::do_flush_info(), rpl_rli.h::is_atomic_ddl_commit_on_slave()
2246 uses this flag.
2247 */
2249
2250 private:
2251 /**
2252 Stores the result of ROW_COUNT() function.
2253
2254 ROW_COUNT() function is a MySQL extension, but we try to keep it
2255 similar to ROW_COUNT member of the GET DIAGNOSTICS stack of the SQL
2256 standard (see SQL99, part 2, search for ROW_COUNT). Its value is
2257 implementation defined for anything except INSERT, DELETE, UPDATE.
2258
2259 ROW_COUNT is assigned according to the following rules:
2260
2261 - In my_ok():
2262 - for DML statements: to the number of affected rows;
2263 - for DDL statements: to 0.
2264
2265 - In my_eof(): to -1 to indicate that there was a result set.
2266
2267 We derive this semantics from the JDBC specification, where int
2268 java.sql.Statement.getUpdateCount() is defined to (sic) "return the
2269 current result as an update count; if the result is a ResultSet
2270 object or there are no more results, -1 is returned".
2271
2272 - In my_error(): to -1 to be compatible with the MySQL C API and
2273 MySQL ODBC driver.
2274
2275 - For SIGNAL statements: to 0 per WL#2110 specification (see also
2276 sql_signal.cc comment). Zero is used since that's the "default"
2277 value of ROW_COUNT in the Diagnostics Area.
2278 */
2279
2280 longlong m_row_count_func; /* For the ROW_COUNT() function */
2281
2282 public:
2284
2285 inline void set_row_count_func(longlong row_count_func) {
2286 m_row_count_func = row_count_func;
2287 }
2288
2290
2291 private:
2292 /**
2293 Number of rows we actually sent to the client, including "synthetic"
2294 rows in ROLLUP etc.
2295 */
2297
2298 /**
2299 Number of rows read and/or evaluated for a statement. Used for
2300 slow log reporting.
2301
2302 An examined row is defined as a row that is read and/or evaluated
2303 according to a statement condition, including in
2304 create_sort_index(). Rows may be counted more than once, e.g., a
2305 statement including ORDER BY could possibly evaluate the row in
2306 filesort() before reading it for e.g. update.
2307 */
2309
2310 private:
2312
2313 public:
2314 void set_user_connect(USER_CONN *uc);
2315 const USER_CONN *get_user_connect() const { return m_user_connect; }
2316
2319
2321
2323
2325
2327
2328 public:
2330
2332
2334
2337
2346 void inc_status_sort_range();
2348 void inc_status_sort_scan();
2351
2353#if defined(ENABLED_PROFILING)
2354 std::unique_ptr<PROFILING> profiling;
2355#endif
2356
2357 /** Current stage progress instrumentation. */
2359 /** Current statement digest. */
2361 /** Current statement digest token array. */
2362 unsigned char *m_token_array;
2363 /** Top level statement digest. */
2365
2366 /** Current statement instrumentation. */
2368#ifdef HAVE_PSI_STATEMENT_INTERFACE
2369 /** Current statement instrumentation state. */
2371#endif /* HAVE_PSI_STATEMENT_INTERFACE */
2372
2373 /** Current transaction instrumentation. */
2375#ifdef HAVE_PSI_TRANSACTION_INTERFACE
2376 /** Current transaction instrumentation state. */
2378#endif /* HAVE_PSI_TRANSACTION_INTERFACE */
2379
2380 /** Idle instrumentation. */
2382#ifdef HAVE_PSI_IDLE_INTERFACE
2383 /** Idle instrumentation state. */
2385#endif /* HAVE_PSI_IDLE_INTERFACE */
2386 /** True if the server code is IDLE for this connection. */
2388
2389 /*
2390 Id of current query. Statement can be reused to execute several queries
2391 query_id is global in context of the whole MySQL server.
2392 ID is automatically generated from mutex-protected counter.
2393 It's used in handler code for various purposes: to check which columns
2394 from table are necessary for this select, to check if it's necessary to
2395 update auto-updatable fields (like auto_increment and timestamp).
2396 */
2398
2399 /* Statement id is thread-wide. This counter is used to generate ids */
2402 my_thread_t real_id; /* For debugging */
2403 /**
2404 This counter is 32 bit because of the client protocol.
2405
2406 @note It is not meant to be used for my_thread_self(), see @c real_id for
2407 this.
2408
2409 @note Set to reserved_thread_id on initialization. This is a magic
2410 value that is only to be used for temporary THDs not present in
2411 the global THD list.
2412 */
2413 private:
2415
2416 public:
2417 /**
2418 Assign a value to m_thread_id by calling
2419 Global_THD_manager::get_new_thread_id().
2420 */
2421 void set_new_thread_id();
2426
2427 // Check if this THD belongs to a system thread.
2429
2430 // Check if this THD belongs to a dd bootstrap system thread.
2431 bool is_dd_system_thread() const {
2434 }
2435
2436 // Check if this THD belongs to the initialize system thread. The
2437 // initialize thread executes statements that are compiled into the
2438 // server.
2441 }
2442
2443 // Check if this THD is executing statements passed through a init file.
2446 }
2447
2448 // Check if this THD belongs to a bootstrap system thread. Note that
2449 // this thread type may execute statements submitted by the user.
2453 }
2454
2455 // Check if this THD belongs to a server upgrade thread. Server upgrade
2456 // threads execute statements that are compiled into the server.
2459 }
2460
2461 /*
2462 Current or next transaction isolation level.
2463 When a connection is established, the value is taken from
2464 @@session.tx_isolation (default transaction isolation for
2465 the session), which is in turn taken from @@global.tx_isolation
2466 (the global value).
2467 If there is no transaction started, this variable
2468 holds the value of the next transaction's isolation level.
2469 When a transaction starts, the value stored in this variable
2470 becomes "actual".
2471 At transaction commit or rollback, we assign this variable
2472 again from @@session.tx_isolation.
2473 The only statement that can otherwise change the value
2474 of this variable is SET TRANSACTION ISOLATION LEVEL.
2475 Its purpose is to effect the isolation level of the next
2476 transaction in this session. When this statement is executed,
2477 the value in this variable is changed. However, since
2478 this statement is only allowed when there is no active
2479 transaction, this assignment (naturally) only affects the
2480 upcoming transaction.
2481 At the end of the current active transaction the value is
2482 be reset again from @@session.tx_isolation, as described
2483 above.
2484 */
2486 /*
2487 Current or next transaction access mode.
2488 See comment above regarding tx_isolation.
2489 */
2491 /*
2492 Transaction cannot be rolled back must be given priority.
2493 When two transactions conflict inside InnoDB, the one with
2494 greater priority wins.
2495 */
2497 /*
2498 All transactions executed by this thread will have high
2499 priority mode, independent of tx_priority value.
2500 */
2502
2504
2505 // For user variables replication
2507 MEM_ROOT *user_var_events_alloc; /* Allocate above array elements here */
2508
2509 /**
2510 Used by MYSQL_BIN_LOG to maintain the commit queue for binary log
2511 group commit.
2512 */
2514
2515 /**
2516 The member is served for marking a query that CREATEs or ALTERs
2517 a table declared with a TIMESTAMP column as dependent on
2518 @@session.explicit_defaults_for_timestamp.
2519 Is set to true by parser, unset at the end of the query.
2520 Possible marking in checked by binary logger.
2521 */
2523
2524 /**
2525 Functions to set and get transaction position.
2526
2527 These functions are used to set the transaction position for the
2528 transaction written when committing this transaction.
2529 */
2530 /**@{*/
2531 void set_trans_pos(const char *file, my_off_t pos) {
2532 DBUG_TRACE;
2533 assert(((file == nullptr) && (pos == 0)) ||
2534 ((file != nullptr) && (pos != 0)));
2535 if (file) {
2536 DBUG_PRINT("enter", ("file: %s, pos: %llu", file, pos));
2537 // Only the file name should be used, not the full path
2541 assert(strlen(m_trans_log_file) <= FN_REFLEN);
2543 } else {
2544 m_trans_log_file = nullptr;
2545 m_trans_fixed_log_file = nullptr;
2546 }
2547
2549 DBUG_PRINT("return",
2550 ("m_trans_log_file: %s, m_trans_fixed_log_file: %s, "
2551 "m_trans_end_pos: %llu",
2553 return;
2554 }
2555
2556 void get_trans_pos(const char **file_var, my_off_t *pos_var) const {
2557 DBUG_TRACE;
2558 if (file_var) *file_var = m_trans_log_file;
2559 if (pos_var) *pos_var = m_trans_end_pos;
2560 DBUG_PRINT("return",
2561 ("file: %s, pos: %llu", file_var ? *file_var : "<none>",
2562 pos_var ? *pos_var : 0));
2563 return;
2564 }
2565
2566 void get_trans_fixed_pos(const char **file_var, my_off_t *pos_var) const {
2567 DBUG_TRACE;
2568 if (file_var) *file_var = m_trans_fixed_log_file;
2569 if (pos_var) *pos_var = m_trans_end_pos;
2570 DBUG_PRINT("return",
2571 ("file: %s, pos: %llu", file_var ? *file_var : "<none>",
2572 pos_var ? *pos_var : 0));
2573 return;
2574 }
2575
2576 /**@}*/
2577
2578 /*
2579 Error code from committing or rolling back the transaction.
2580 */
2589
2590 /*
2591 Define durability properties that engines may check to
2592 improve performance.
2593 */
2595
2596 /*
2597 If checking this in conjunction with a wait condition, please
2598 include a check after enter_cond() if you want to avoid a race
2599 condition. For details see the implementation of awake(),
2600 especially the "broadcast" part.
2601 */
2604 KILL_CONNECTION = ER_SERVER_SHUTDOWN,
2605 KILL_QUERY = ER_QUERY_INTERRUPTED,
2606 KILL_TIMEOUT = ER_QUERY_TIMEOUT,
2607 KILLED_NO_VALUE /* means neither of the states */
2609 std::atomic<killed_state> killed;
2610
2611 /**
2612 Whether we are currently in the execution phase of an EXPLAIN ANALYZE query.
2613 If so, send_kill_message() won't actually set an error; we will add a
2614 warning near the end of the execution instead.
2615 */
2617
2618 /**
2619 When operation on DD tables is in progress then THD is set to kill immune
2620 mode.
2621 This member holds DD_kill_immunizer object created to make DD operations
2622 immune from the kill operations. Member also indicated whether THD is in
2623 kill immune mode or not.
2624 */
2626
2627 /* scramble - random string sent to client on handshake */
2629
2630 /// @todo: slave_thread is completely redundant, we should use 'system_thread'
2631 /// instead /sven
2633
2635
2636 private:
2637 /**
2638 Set to true if execution of the current compound statement
2639 can not continue. In particular, disables activation of
2640 CONTINUE or EXIT handlers of stored routines.
2641 Reset in the end of processing of the current user request, in
2642 @see mysql_reset_thd_for_next_command().
2643 */
2645
2646 public:
2647 /**
2648 Set by a storage engine to request the entire
2649 transaction (that possibly spans multiple engines) to
2650 rollback. Reset in ha_rollback.
2651 */
2653 /**
2654 true if we are in a sub-statement and the current error can
2655 not be safely recovered until we left the sub-statement mode.
2656 In particular, disables activation of CONTINUE and EXIT
2657 handlers inside sub-statements. E.g. if it is a deadlock
2658 error and requires a transaction-wide rollback, this flag is
2659 raised (traditionally, MySQL first has to close all the reads
2660 via @see handler::ha_index_or_rnd_end() and only then perform
2661 the rollback).
2662 Reset to false when we leave the sub-statement mode.
2663 */
2668 /**
2669 True if a slave error. Causes the slave to stop. Not the same
2670 as the statement execution error (is_error()), since
2671 a statement may be expected to return an error, e.g. because
2672 it returned an error on master, and this is OK on the slave.
2673 */
2675
2676 /** is set if some thread specific value(s) used in a statement. */
2678 /**
2679 is set if a statement accesses a temporary table created through
2680 CREATE TEMPORARY TABLE.
2681 */
2684 bool enable_slow_log; /* enable slow log for current statement */
2685 /* set during loop of derived table processing */
2687 // Set while parsing INFORMATION_SCHEMA system views.
2689
2690 /** Current SP-runtime context. */
2694
2695 /** number of name_const() substitutions, see sp_head.cc:subst_spvars() */
2697
2698 /*
2699 If we do a purge of binary logs, log index info of the threads
2700 that are currently reading it needs to be adjusted. To do that
2701 each thread that is using LOG_INFO needs to adjust the pointer to it
2702 */
2704 /* Used by the sys_var class to store temporary values */
2705 union {
2712
2713 struct {
2714 /*
2715 If true, mysql_bin_log::write(Log_event) call will not write events to
2716 binlog, and maintain 2 below variables instead (use
2717 mysql_bin_log.start_union_events to turn this on)
2718 */
2720 /*
2721 If true, at least one mysql_bin_log::write(Log_event) call has been
2722 made after last mysql_bin_log.start_union_events() call.
2723 */
2725 /*
2726 If true, at least one mysql_bin_log::write(Log_event e), where
2727 e.cache_stmt == true call has been made after last
2728 mysql_bin_log.start_union_events() call.
2729 */
2731
2732 /*
2733 'queries' (actually SP statements) that run under inside this binlog
2734 union have thd->query_id >= first_query_id.
2735 */
2738
2739 /**
2740 Internal parser state.
2741 Note that since the parser is not re-entrant, we keep only one parser
2742 state here. This member is valid only when executing code during parsing.
2743 */
2745
2747
2749
2750 /**
2751 Array of active audit plugins which have been used by this THD.
2752 This list is later iterated to invoke release_thd() on those
2753 plugins.
2754 */
2756 /**
2757 Array of bits indicating which audit classes have already been
2758 added to the list of audit plugins which are currently in use.
2759 */
2761
2762#if defined(ENABLED_DEBUG_SYNC)
2763 /* Debug Sync facility. See debug_sync.cc. */
2764 struct st_debug_sync_control *debug_sync_control;
2765#endif /* defined(ENABLED_DEBUG_SYNC) */
2766
2767 // We don't want to load/unload plugins for unit tests.
2769
2770 /*
2771 Audit API events are generated, when this flag is true. The flag
2772 is initially true, but it can be set false in some cases, e.g.
2773 Session Service's THDs are created with auditing disabled. Auditing
2774 is enabled on MYSQL_AUDIT_CONNECTION_CONNECT event.
2775 */
2777
2778 THD(bool enable_plugins = true);
2779
2780 /*
2781 The THD dtor is effectively split in two:
2782 THD::release_resources() and ~THD().
2783
2784 We want to minimize the time we hold LOCK_thd_list,
2785 so when destroying a global thread, do:
2786
2787 thd->release_resources()
2788 Global_THD_manager::get_instance()->remove_thd();
2789 delete thd;
2790 */
2791 ~THD() override;
2792
2793 void release_resources();
2794 /**
2795 @returns true if THD resources are released.
2796 */
2797 bool release_resources_done() const;
2798 /**
2799 Check if THD is being disposed (i.e. m_thd_life_cycle_stage >=
2800 SCHEDULED_FOR_DISPOSAL)
2801
2802 Non-owner thread should acquire LOCK_thd_data to check THD state without
2803 getting into races.
2804
2805 @returns true of THD is being disposed.
2806 */
2807 bool is_being_disposed() const;
2808
2809 private:
2810 /**
2811 Represents life cycle stages of THD instance.
2812 Stage transition in THD clean up:
2813 1. ACTIVE -> ACTIVE_AND_CLEAN
2814
2815 Stage transition in THD disposal:
2816 1. ACTIVE -> SCHEDULED_FOR_DISPOSAL -> CLEANED_UP -> RESOURCES_RELEASED
2817 -> DISPOSED.
2818 2. ACTIVE_AND_CLEAN -> CLEANED_UP -> RESOURCES_RELEASED -> DISPOSED.
2819 */
2826 DISPOSED
2829 enum_thd_life_cycle_stages::ACTIVE};
2830
2831 /**
2832 Set THD in ACTIVE life stage to disposal stage.
2833
2834 To avoid race conditions with non-owner thread checking THD disposal state,
2835 LOCK_thd_data should be acquired before changing THD stage to disposal
2836 stage.
2837 */
2838 void start_disposal();
2839
2840 /**
2841 @returns true if THD is cleaned up.
2842 */
2843 bool is_cleanup_done();
2844 void cleanup(void);
2845
2846 void init(void);
2847
2848 public:
2849 /**
2850 Initialize memory roots necessary for query processing and (!)
2851 pre-allocate memory for it. We can't do that in THD constructor because
2852 there are use cases (acl_init, watcher threads,
2853 killing mysqld) where it's vital to not allocate excessive and not used
2854 memory. Note, that we still don't return error from init_query_mem_roots()
2855 if preallocation fails, we should notice that at the first call to
2856 alloc_root.
2857 */
2858 void init_query_mem_roots();
2859 void cleanup_connection(void);
2860 void cleanup_after_query();
2861 void store_globals();
2862 void restore_globals();
2863
2864 inline void set_active_vio(Vio *vio) {
2866 active_vio = vio;
2868 }
2869
2870 inline void set_ssl(Vio *vio) {
2872 m_SSL = (SSL *)vio->ssl_arg;
2874 }
2875
2876 inline void clear_active_vio() {
2878 active_vio = nullptr;
2879 m_SSL = nullptr;
2881 }
2882
2883 /** Set active clone network Vio for remote clone.
2884 @param[in] vio network vio */
2885 inline void set_clone_vio(Vio *vio) {
2887 clone_vio = vio;
2889 }
2890
2891 /** Clear clone network Vio for remote clone. */
2892 inline void clear_clone_vio() {
2894 clone_vio = nullptr;
2896 }
2897
2898 /** Check if clone network Vio is active. */
2899 inline bool check_clone_vio() {
2901 bool is_active = (clone_vio != nullptr);
2903 return (is_active);
2904 }
2905
2906 /** Shutdown clone vio, if active. */
2907 void shutdown_clone_vio();
2908
2910
2911 void shutdown_active_vio();
2912 void awake(THD::killed_state state_to_set);
2913
2914 /** Disconnect the associated communication endpoint. */
2915 void disconnect(bool server_shutdown = false);
2916
2918 /* The query can be logged in row format or in statement format. */
2920
2921 /* The query has to be logged in statement format. */
2923
2926
2927 int binlog_query(enum_binlog_query_type qtype, const char *query,
2928 size_t query_len, bool is_trans, bool direct,
2929 bool suppress_use, int errcode);
2930
2931 // Begin implementation of MDL_context_owner interface.
2932
2934 const PSI_stage_info *stage, PSI_stage_info *old_stage,
2935 const char *src_function, const char *src_file,
2936 int src_line) override {
2937 DBUG_TRACE;
2939 /*
2940 Sic: We don't lock LOCK_current_cond here.
2941 If we did, we could end up in deadlock with THD::awake()
2942 which locks current_mutex while LOCK_current_cond is locked.
2943 */
2944 current_mutex = mutex;
2945 current_cond = cond;
2946 enter_stage(stage, old_stage, src_function, src_file, src_line);
2947 return;
2948 }
2949
2950 void exit_cond(const PSI_stage_info *stage, const char *src_function,
2951 const char *src_file, int src_line) override {
2952 DBUG_TRACE;
2953 /*
2954 current_mutex must be unlocked _before_ LOCK_current_cond is
2955 locked (if that would not be the case, you'll get a deadlock if someone
2956 does a THD::awake() on you).
2957 */
2960 current_mutex = nullptr;
2961 current_cond = nullptr;
2963 enter_stage(stage, nullptr, src_function, src_file, src_line);
2964 return;
2965 }
2966
2967 int is_killed() const final { return killed; }
2969 /*
2970 We need to return if this thread can have any commit order waiters
2971 which are still accounted by MDL deadlock detector (even in absence
2972 of any MDL locks). We approximate this check by testing whether
2973 this thread is replication applier. Doing more precise check is going
2974 to be more expensive and possibly racy.
2975 */
2976 return slave_thread;
2977 }
2978
2979 THD *get_thd() override { return this; }
2980
2981 /**
2982 A callback to the server internals that is used to address
2983 special cases of the locking protocol.
2984 Invoked when acquiring an exclusive lock, for each thread that
2985 has a conflicting shared metadata lock.
2986
2987 This function aborts waiting of the thread on a data lock, to make
2988 it notice the pending exclusive lock and back off.
2989
2990 @note This function does not wait for the thread to give away its
2991 locks. Waiting is done outside for all threads at once.
2992
2993 @param ctx_in_use The MDL context owner (thread) to wake up.
2994 @param needs_thr_lock_abort Indicates that to wake up thread
2995 this call needs to abort its waiting
2996 on table-level lock.
2997 */
2998 void notify_shared_lock(MDL_context_owner *ctx_in_use,
2999 bool needs_thr_lock_abort) override;
3000
3001 bool notify_hton_pre_acquire_exclusive(const MDL_key *mdl_key,
3002 bool *victimized) override;
3003
3004 void notify_hton_post_release_exclusive(const MDL_key *mdl_key) override;
3005
3006 /**
3007 Provide thread specific random seed for MDL_context's PRNG.
3008
3009 Note that even if two connections will request seed during handling of
3010 statements which were started at exactly the same time, and thus will
3011 get the same values in PRNG at the start, they will naturally diverge
3012 soon, since calls to PRNG in MDL subsystem are affected by many factors
3013 making process quite random. OTOH the fact that we use time as a seed
3014 gives more randomness and thus better coverage in tests as opposed to
3015 using thread_id for the same purpose.
3016 */
3017 uint get_rand_seed() const override { return (uint)start_utime; }
3018
3019 // End implementation of MDL_context_owner interface.
3020
3021 inline bool is_strict_mode() const {
3022 return (variables.sql_mode &
3024 }
3025 inline const CHARSET_INFO *collation() {
3028 }
3030 time_zone_used = true;
3031 return variables.time_zone;
3032 }
3033 time_t query_start_in_secs() const { return start_time.tv_sec; }
3035 void set_time();
3036 void set_time(const struct timeval *t) {
3037 user_time = *t;
3038 set_time();
3039 }
3040 inline bool is_fsp_truncate_mode() const {
3042 }
3043
3044 /**
3045 Evaluate the current time, and if it exceeds the long-query-time
3046 setting, mark the query as slow.
3047 */
3049
3051
3052 /*
3053 Call when it is clear that the query is ended and we have collected the
3054 right value for current_found_rows. Calling this method makes a snapshot of
3055 that value and makes it ready and stable for subsequent FOUND_ROWS() call
3056 in the next statement.
3057 */
3060 }
3061
3062 /**
3063 Returns true if session is in a multi-statement transaction mode.
3064
3065 OPTION_NOT_AUTOCOMMIT: When autocommit is off, a multi-statement
3066 transaction is implicitly started on the first statement after a
3067 previous transaction has been ended.
3068
3069 OPTION_BEGIN: Regardless of the autocommit status, a multi-statement
3070 transaction can be explicitly started with the statements "START
3071 TRANSACTION", "BEGIN [WORK]", "[COMMIT | ROLLBACK] AND CHAIN", etc.
3072
3073 Note: this doesn't tell you whether a transaction is active.
3074 A session can be in multi-statement transaction mode, and yet
3075 have no active transaction, e.g., in case of:
3076 set \@\@autocommit=0;
3077 set \@a= 3; <-- these statements don't
3078 set transaction isolation level serializable; <-- start an active
3079 flush tables; <-- transaction
3080
3081 I.e. for the above scenario this function returns true, even
3082 though no active transaction has begun.
3083 @sa in_active_multi_stmt_transaction()
3084 */
3087 }
3088 /**
3089 true if the session is in a multi-statement transaction mode
3090 (@sa in_multi_stmt_transaction_mode()) *and* there is an
3091 active transaction, i.e. there is an explicit start of a
3092 transaction with BEGIN statement, or implicit with a
3093 statement that uses a transactional engine.
3094
3095 For example, these scenarios don't start an active transaction
3096 (even though the server is in multi-statement transaction mode):
3097
3098 @verbatim
3099 set @@autocommit=0;
3100 select * from nontrans_table;
3101 set @var = true;
3102 flush tables;
3103 @endverbatim
3104
3105 Note, that even for a statement that starts a multi-statement
3106 transaction (i.e. select * from trans_table), this
3107 flag won't be set until we open the statement's tables
3108 and the engines register themselves for the transaction
3109 (see trans_register_ha()),
3110 hence this method is reliable to use only after
3111 open_tables() has completed.
3112
3113 Why do we need a flag?
3114 ----------------------
3115 We need to maintain a (at first glance redundant)
3116 session flag, rather than looking at thd->transaction.all.ha_list
3117 because of explicit start of a transaction with BEGIN.
3118
3119 I.e. in case of
3120 BEGIN;
3121 select * from nontrans_t1; <-- in_active_multi_stmt_transaction() is true
3122 */
3125 }
3127 return !stmt_arena->is_stmt_prepare();
3128 }
3129
3130 bool convert_string(LEX_STRING *to, const CHARSET_INFO *to_cs,
3131 const char *from, size_t from_length,
3132 const CHARSET_INFO *from_cs, bool report_error = false);
3133
3135
3136 /**
3137 Clear the current error, if any.
3138 We do not clear is_fatal_error or is_fatal_sub_stmt_error since we
3139 assume this is never called if the fatal error is set.
3140 @todo: To silence an error, one should use Internal_error_handler
3141 mechanism. In future this function will be removed.
3142 */
3143 inline void clear_error() {
3144 DBUG_TRACE;
3146 is_slave_error = false;
3147 return;
3148 }
3149
3150 bool is_classic_protocol() const;
3151
3152 /** Return false if connection to client is broken. */
3153 bool is_connected() final;
3154
3155 /**
3156 Mark the current error as fatal. Warning: this does not
3157 set any error, it sets a property of the error, so must be
3158 followed or prefixed with my_error().
3159 */
3161 bool is_fatal_error() const { return m_is_fatal_error; }
3162 /**
3163 true if there is an error in the error stack.
3164
3165 Please use this method instead of direct access to
3166 net.report_error.
3167
3168 If true, the current (sub)-statement should be aborted.
3169 The main difference between this member and is_fatal_error
3170 is that a fatal error can not be handled by a stored
3171 procedure continue handler, whereas a normal error can.
3172
3173 To raise this flag, use my_error().
3174 */
3175 inline bool is_error() const { return get_stmt_da()->is_error(); }
3176
3177 /// Returns first Diagnostics Area for the current statement.
3179
3180 /// Returns first Diagnostics Area for the current statement.
3181 const Diagnostics_area *get_stmt_da() const { return m_stmt_da; }
3182
3183 /// Returns the second Diagnostics Area for the current statement.
3185 return get_stmt_da()->stacked_da();
3186 }
3187
3188 /**
3189 Returns thread-local Diagnostics Area for parsing.
3190 We need to have a clean DA in case errors or warnings are thrown
3191 during parsing, but we can't just reset the main DA in case we
3192 have a diagnostic statement on our hand that needs the old DA
3193 to answer questions about the previous execution.
3194 Keeping a static per-thread DA for parsing is less costly than
3195 allocating a temporary one for each statement we parse.
3196 */
3198
3199 /**
3200 Returns thread-local Diagnostics Area to be used by query rewrite plugins.
3201 Query rewrite plugins use their own diagnostics area. The reason is that
3202 they are invoked right before and right after parsing, and we don't want
3203 conditions raised by plugins in either statement nor parser DA until we
3204 know which type of statement we have parsed.
3205
3206 @note The diagnostics area is instantiated the first time it is asked for.
3207 */
3210 }
3211
3212 /**
3213 Push the given Diagnostics Area on top of the stack, making
3214 it the new first Diagnostics Area. Conditions in the new second
3215 Diagnostics Area will be copied to the new first Diagnostics Area.
3216
3217 @param da Diagnostics Area to be come the top of
3218 the Diagnostics Area stack.
3219 @param copy_conditions
3220 Copy the conditions from the new second Diagnostics Area
3221 to the new first Diagnostics Area, as per SQL standard.
3222 */
3224 bool copy_conditions = true) {
3225 get_stmt_da()->push_diagnostics_area(this, da, copy_conditions);
3226 m_stmt_da = da;
3227 }
3228
3229 /// Pop the top DA off the Diagnostics Area stack.
3232 }
3233
3234 /**
3235 Inserts the new protocol at the top of the protocol stack, and make it
3236 the current protocol for this thd.
3237
3238 @param protocol Protocol to be inserted.
3239 */
3240 void push_protocol(Protocol *protocol);
3241
3242 template <typename ProtocolClass>
3243 void push_protocol(const std::unique_ptr<ProtocolClass> &protocol) {
3244 push_protocol(protocol.get());
3245 }
3246
3247 /**
3248 Pops the top protocol of the Protocol stack and sets the previous one
3249 as the current protocol.
3250 */
3251 void pop_protocol();
3252
3253 public:
3255 void update_charset();
3256
3257 /**
3258 Record a transient change to a pointer to an Item within another Item.
3259 */
3260 void change_item_tree(Item **place, Item *new_value) {
3261 /* TODO: check for OOM condition here */
3262 if (!stmt_arena->is_regular()) {
3263 DBUG_PRINT("info", ("change_item_tree place %p old_value %p new_value %p",
3264 place, *place, new_value));
3265 nocheck_register_item_tree_change(place, new_value);
3266 }
3267 *place = new_value;
3268 }
3269
3270 /**
3271 Remember that place was updated with new_value so it can be restored
3272 by rollback_item_tree_changes().
3273
3274 @param[in] place the location that will change, and whose old value
3275 we need to remember for restoration
3276 @param[in] new_value new value about to be inserted into *place
3277 */
3278 void nocheck_register_item_tree_change(Item **place, Item *new_value);
3279
3280 /**
3281 Restore locations set by calls to nocheck_register_item_tree_change().
3282 */
3284
3285 /*
3286 Cleanup statement parse state (parse tree, lex) and execution
3287 state after execution of a non-prepared SQL statement.
3288 */
3289 void end_statement();
3290 void send_kill_message() const;
3291
3293 uint add_state_flags);
3297
3298 public:
3299 /**
3300 Start a read-only attachable transaction.
3301 There must be no active attachable transactions (in other words, there can
3302 be only one active attachable transaction at a time).
3303 */
3305
3306 /**
3307 Start a read-write attachable transaction.
3308 All the read-only class' requirements apply.
3309 Additional requirements are documented along the class
3310 declaration.
3311 */
3313
3314 /**
3315 End an active attachable transaction. Applies to both the read-only
3316 and the read-write versions.
3317 Note, that the read-write attachable transaction won't be terminated
3318 inside this method.
3319 To invoke the function there must be active attachable transaction.
3320 */
3322
3323 /**
3324 @return true if there is an active attachable transaction.
3325 */
3327 return m_attachable_trx != nullptr && m_attachable_trx->is_read_only();
3328 }
3329
3330 /**
3331 @return true if there is an active attachable transaction.
3332 */
3334 return m_attachable_trx != nullptr;
3335 }
3336
3337 /**
3338 @return true if there is an active rw attachable transaction.
3339 */
3341 return m_attachable_trx != nullptr && !m_attachable_trx->is_read_only();
3342 }
3343
3344 public:
3345 /*
3346 @todo Make these methods private or remove them completely. Only
3347 decide_logging_format should call them. /Sven
3348 */
3350 DBUG_TRACE;
3351 /*
3352 This should only be called from decide_logging_format.
3353
3354 @todo Once we have ensured this, uncomment the following
3355 statement, remove the big comment below that, and remove the
3356 in_sub_stmt==0 condition from the following 'if'.
3357 */
3358 /* assert(in_sub_stmt == 0); */
3359 /*
3360 If in a stored/function trigger, the caller should already have done the
3361 change. We test in_sub_stmt to prevent introducing bugs where people
3362 wouldn't ensure that, and would switch to row-based mode in the middle
3363 of executing a stored function/trigger (which is too late, see also
3364 reset_current_stmt_binlog_format_row()); this condition will make their
3365 tests fail and so force them to propagate the
3366 lex->binlog_row_based_if_mixed upwards to the caller.
3367 */
3370
3371 return;
3372 }
3374 DBUG_TRACE;
3376 return;
3377 }
3379 DBUG_TRACE;
3381 return;
3382 }
3384 DBUG_TRACE;
3385 DBUG_PRINT("debug", ("in_sub_stmt: %d, system_thread: %s", in_sub_stmt != 0,
3387 if (in_sub_stmt == 0) {
3390 else
3392 }
3393 return;
3394 }
3395
3396 /**
3397 Copies variables.original_commit_timestamp to
3398 ((Slave_worker *)rli_slave)->original_commit_timestamp,
3399 if this is a slave thread.
3400 */
3402
3403 /// Return the value of @@gtid_next_list: either a Gtid_set or NULL.
3407 : nullptr;
3408 }
3409
3410 /// Return the value of @@gtid_next_list: either a Gtid_set or NULL.
3412 return const_cast<THD *>(this)->get_gtid_next_list();
3413 }
3414
3415 /**
3416 Return true if the statement/transaction cache is currently empty,
3417 false otherwise.
3418
3419 @param is_transactional if true, check the transaction cache.
3420 If false, check the statement cache.
3421 */
3422 bool is_binlog_cache_empty(bool is_transactional) const;
3423
3424 /**
3425 The GTID of the currently owned transaction.
3426
3427 ==== Modes of ownership ====
3428
3429 The following modes of ownership are possible:
3430
3431 - owned_gtid.sidno==0: the thread does not own any transaction.
3432
3433 - owned_gtid.sidno==THD::OWNED_SIDNO_ANONYMOUS(==-2): the thread
3434 owns an anonymous transaction
3435
3436 - owned_gtid.sidno>0 and owned_gtid.gno>0: the thread owns a GTID
3437 transaction.
3438
3439 - (owned_gtid.sidno==THD::OWNED_SIDNO_GTID_SET(==-1): this is
3440 currently not used. It was reserved for the case where multiple
3441 GTIDs are owned (using gtid_next_list). This was one idea to
3442 make GTIDs work with NDB: due to the epoch concept, multiple
3443 transactions can be combined into one in NDB, and therefore a
3444 single transaction on a slave can have multiple GTIDs.)
3445
3446 ==== Life cycle of ownership ====
3447
3448 Generally, transaction ownership starts when the transaction is
3449 assigned its GTID and ends when the transaction commits or rolls
3450 back. On a master (GTID_NEXT=AUTOMATIC), the GTID is assigned
3451 just before binlog flush; on a slave (GTID_NEXT=UUID:NUMBER or
3452 GTID_NEXT=ANONYMOUS) it is assigned before starting the
3453 transaction.
3454
3455 A new client always starts with owned_gtid.sidno=0.
3456
3457 Ownership can be acquired in the following ways:
3458
3459 A1. If GTID_NEXT = 'AUTOMATIC' and GTID_MODE = OFF/OFF_PERMISSIVE:
3460 The thread acquires anonymous ownership in
3461 gtid_state->generate_automatic_gtid called from
3462 MYSQL_BIN_LOG::write_transaction.
3463
3464 A2. If GTID_NEXT = 'AUTOMATIC' and GTID_MODE = ON/ON_PERMISSIVE:
3465 The thread generates the GTID and acquires ownership in
3466 gtid_state->generate_automatic_gtid called from
3467 MYSQL_BIN_LOG::write_transaction.
3468
3469 A3. If GTID_NEXT = 'UUID:NUMBER': The thread acquires ownership in
3470 the following ways:
3471
3472 - In a client, the SET GTID_NEXT statement acquires ownership.
3473
3474 - The slave's analogy to a clients SET GTID_NEXT statement is
3475 Gtid_log_event::do_apply_event. So the slave acquires
3476 ownership in this function.
3477
3478 Note: if the GTID UUID:NUMBER is already included in
3479 GTID_EXECUTED, then the transaction must be skipped (the GTID
3480 auto-skip feature). Thus, ownership is *not* acquired in this
3481 case and owned_gtid.sidno==0.
3482
3483 A4. If GTID_NEXT = 'ANONYMOUS':
3484
3485 - In a client, the SET GTID_NEXT statement acquires ownership.
3486
3487 - In a slave thread, Gtid_log_event::do_apply_event acquires
3488 ownership.
3489
3490 - Contrary to the case of GTID_NEXT='UUID:NUMBER', it is
3491 allowed to execute two transactions in sequence without
3492 changing GTID_NEXT (cf. R1 and R2 below). Both transactions
3493 should be executed as anonymous transactions. But ownership
3494 is released when the first transaction commits. Therefore,
3495 when GTID_NEXT='ANONYMOUS', we also acquire anonymous
3496 ownership when starting to execute a statement, in
3497 gtid_reacquire_ownership_if_anonymous called from
3498 gtid_pre_statement_checks (usually called from
3499 mysql_execute_command).
3500
3501 A5. Slave applier threads start in a special mode, having
3502 GTID_NEXT='NOT_YET_DETERMINED'. This mode cannot be set in a
3503 regular client. When GTID_NEXT=NOT_YET_DETERMINED, the slave
3504 thread is postponing the decision of the value of GTID_NEXT
3505 until it has more information. There are three cases:
3506
3507 - If the first transaction of the relay log has a
3508 Gtid_log_event, then it will set GTID_NEXT=GTID:NUMBER and
3509 acquire GTID ownership in Gtid_log_event::do_apply_event.
3510
3511 - If the first transaction of the relay log has a
3512 Anonymous_gtid_log_event, then it will set
3513 GTID_NEXT=ANONYMOUS and acquire anonymous ownership in
3514 Gtid_log_event::do_apply_event.
3515
3516 - If the relay log was received from a pre-5.7.6 master with
3517 GTID_MODE=OFF (or a pre-5.6 master), then there are neither
3518 Gtid_log_events nor Anonymous_log_events in the relay log.
3519 In this case, the slave sets GTID_NEXT=ANONYMOUS and
3520 acquires anonymous ownership when executing a
3521 Query_log_event (Query_log_event::do_apply_event calls
3522 dispatch_sql_command which calls gtid_pre_statement_checks which
3523 calls gtid_reacquire_ownership_if_anonymous).
3524
3525 Ownership is released in the following ways:
3526
3527 R1. A thread that holds GTID ownership releases ownership at
3528 transaction commit or rollback. If GTID_NEXT=AUTOMATIC, all
3529 is fine. If GTID_NEXT=UUID:NUMBER, the UUID:NUMBER cannot be
3530 used for another transaction, since only one transaction can
3531 have any given GTID. To avoid the user mistake of forgetting
3532 to set back GTID_NEXT, on commit we set
3533 thd->variables.gtid_next.type=UNDEFINED_GTID. Then, any
3534 statement that user tries to execute other than SET GTID_NEXT
3535 will generate an error.
3536
3537 R2. A thread that holds anonymous ownership releases ownership at
3538 transaction commit or rollback. In this case there is no harm
3539 in leaving GTID_NEXT='ANONYMOUS', so
3540 thd->variables.gtid_next.type will remain ANONYMOUS_GTID and
3541 not UNDEFINED_GTID.
3542
3543 There are statements that generate multiple transactions in the
3544 binary log. This includes the following:
3545
3546 M1. DROP TABLE that is used with multiple tables, and the tables
3547 belong to more than one of the following groups: non-temporary
3548 table, temporary transactional table, temporary
3549 non-transactional table. DROP TABLE is split into one
3550 transaction for each of these groups of tables.
3551
3552 M2. DROP DATABASE that fails e.g. because rmdir fails. Then a
3553 single DROP TABLE is generated, which lists all tables that
3554 were dropped before the failure happened. But if the list of
3555 tables is big, and grows over a limit, the statement will be
3556 split into multiple statements.
3557
3558 M3. CREATE TABLE ... SELECT that is logged in row format. Then
3559 the server generates a single CREATE statement, followed by a
3560 BEGIN ... row events ... COMMIT transaction.
3561
3562 M4. A statement that updates both transactional and
3563 non-transactional tables in the same statement, and is logged
3564 in row format. Then it generates one transaction for the
3565 non-transactional row updates, followed by one transaction for
3566 the transactional row updates.
3567
3568 M5. CALL is executed as multiple transactions and logged as
3569 multiple transactions.
3570
3571 The general rules for multi-transaction statements are:
3572
3573 - If GTID_NEXT=AUTOMATIC and GTID_MODE=ON or ON_PERMISSIVE, one
3574 GTID should be generated for each transaction within the
3575 statement. Therefore, ownership must be released after each
3576 commit so that a new GTID can be generated by the next
3577 transaction. Typically mysql_bin_log.commit() is called to
3578 achieve this. (Note that some of these statements are currently
3579 disallowed when GTID_MODE=ON.)
3580
3581 - If GTID_NEXT=AUTOMATIC and GTID_MODE=OFF or OFF_PERMISSIVE, one
3582 Anonymous_gtid_log_event should be generated for each
3583 transaction within the statement. Similar to the case above, we
3584 call mysql_bin_log.commit() and release ownership between
3585 transactions within the statement.
3586
3587 This works for all the special cases M1-M5 except M4. When a
3588 statement writes both non-transactional and transactional
3589 updates to the binary log, both the transaction cache and the
3590 statement cache are flushed within the same call to
3591 flush_thread_caches(THD) from within the binary log group commit
3592 code. At that point we cannot use mysql_bin_log.commit().
3593 Instead we release ownership using direct calls to
3594 gtid_state->release_anonymous_ownership() and
3595 thd->clear_owned_gtids() from binlog_cache_mngr::flush.
3596
3597 - If GTID_NEXT=ANONYMOUS, anonymous ownership must be *preserved*
3598 between transactions within the statement, to prevent that a
3599 concurrent SET GTID_MODE=ON makes it impossible to log the
3600 statement. To avoid that ownership is released if
3601 mysql_bin_log.commit() is called, we set
3602 thd->is_commit_in_middle_of_statement before calling
3603 mysql_bin_log.commit. Note that we must set this flag only if
3604 GTID_NEXT=ANONYMOUS, not if the transaction is anonymous when
3605 GTID_NEXT=AUTOMATIC and GTID_MODE=OFF.
3606
3607 This works for all the special cases M1-M5 except M4. When a
3608 statement writes non-transactional updates in the middle of a
3609 transaction, but keeps some transactional updates in the
3610 transaction cache, then it is not easy to know at the time of
3611 calling mysql_bin_log.commit() whether anonymous ownership needs
3612 to be preserved or not. Instead, we directly check if the
3613 transaction cache is nonempty before releasing anonymous
3614 ownership inside Gtid_state::update_gtids_impl.
3615
3616 - If GTID_NEXT='UUID:NUMBER', it is impossible to log a
3617 multi-transaction statement, since each GTID can only be used by
3618 one transaction. Therefore, an error must be generated in this
3619 case. Errors are generated in different ways for the different
3620 statement types:
3621
3622 - DROP TABLE: we can detect the situation before it happens,
3623 since the table type is known once the tables are opened. So
3624 we generate an error before even executing the statement.
3625
3626 - DROP DATABASE: we can't detect the situation until it is too
3627 late; the tables have already been dropped and we cannot log
3628 anything meaningful. So we don't log at all.
3629
3630 - CREATE TABLE ... SELECT: this is not allowed when
3631 enforce_gtid_consistency is ON; the statement will be
3632 forbidden in is_ddl_gtid_compatible.
3633
3634 - Statements that update both transactional and
3635 non-transactional tables are disallowed when GTID_MODE=ON, so
3636 this normally does not happen. However, it can happen if the
3637 slave uses a different engine type than the master, so that a
3638 statement that updates InnoDB+InnoDB on master updates
3639 InnoDB+MyISAM on slave. In this case the statement will be
3640 forbidden in is_dml_gtid_compatible and will not be allowed to
3641 execute.
3642
3643 - CALL: the second statement will generate an error because
3644 GTID_NEXT is 'undefined'. Note that this situation can only
3645 happen if user does it on purpose: A CALL on master is logged
3646 as multiple statements, so a slave never executes CALL with
3647 GTID_NEXT='UUID:NUMBER'.
3648
3649 Finally, ownership release is suppressed in one more corner case:
3650
3651 C1. Administration statements including OPTIMIZE TABLE, REPAIR
3652 TABLE, or ANALYZE TABLE are written to the binary log even if
3653 they fail. This means that the thread first calls
3654 trans_rollack, and then writes the statement to the binlog.
3655 Rollback normally releases ownership. But ownership must be
3656 kept until writing the binlog. The solution is that these
3657 statements set thd->skip_gtid_rollback=true before calling
3658 trans_rollback, and Gtid_state::update_on_rollback does not
3659 release ownership if the flag is set.
3660
3661 @todo It would probably be better to encapsulate this more, maybe
3662 use Gtid_specification instead of Gtid.
3663 */
3665 static const int OWNED_SIDNO_GTID_SET = -1;
3666 static const int OWNED_SIDNO_ANONYMOUS = -2;
3667
3668 /**
3669 For convenience, this contains the SID component of the GTID
3670 stored in owned_gtid.
3671 */
3673
3674 /** SE GTID persistence flag types. */
3675 enum Se_GTID_flag : size_t {
3676 /** Pin owned GTID */
3678 /** Cleanup GTID during unpin. */
3680 /** SE would persist GTID for current transaction. */
3682 /** If RESET log in progress. */
3684 /** Explicit request for SE to persist GTID for current transaction. */
3686 /** Max element holding the biset size. */
3689
3690 using Se_GTID_flagset = std::bitset<SE_GTID_MAX>;
3691
3692 /** Flags for SE GTID persistence. */
3694
3695 /** Defer freeing owned GTID and SID till unpinned. */
3697
3698 /** Unpin and free GTID and SID. */
3699 void unpin_gtid() {
3701 /* Do any deferred cleanup */
3705 }
3706 }
3707
3708 /** @return true, if single phase XA commit operation. */
3709 bool is_one_phase_commit();
3710
3711 /** Set when binlog reset operation is started. */
3713
3714 /** Cleared after flushing SE logs during binlog reset. */
3716
3717 /** @return true, if binlog reset operation. */
3719
3720 /** Set by SE when it guarantees GTID persistence. */
3722
3723 /** Request SE to persist GTID explicitly. */
3727 }
3728
3729 /** Reset by SE at transaction end after persisting GTID. */
3733 }
3734
3735 /** @return true, if SE persists GTID for current transaction. */
3736 bool se_persists_gtid() const {
3737 DBUG_EXECUTE_IF("disable_se_persists_gtid", return (false););
3738 auto trx = get_transaction();
3739 auto xid_state = trx->xid_state();
3740 /* XA transactions are always persisted by Innodb. */
3741 return (!xid_state->has_state(XID_STATE::XA_NOTR) ||
3743 }
3744
3745 /** @return true, if SE is explicitly set to persists GTID. */
3747 DBUG_EXECUTE_IF("disable_se_persists_gtid", return (false););
3749 }
3750
3751 /** @return true, if external XA transaction is in progress. */
3752 bool is_extrenal_xa() const {
3753 auto trx = get_transaction();
3754 auto xid_state = trx->xid_state();
3755 return !xid_state->has_state(XID_STATE::XA_NOTR);
3756 }
3757
3758#ifdef HAVE_GTID_NEXT_LIST
3759 /**
3760 If this thread owns a set of GTIDs (i.e., GTID_NEXT_LIST != NULL),
3761 then this member variable contains the subset of those GTIDs that
3762 are owned by this thread.
3763 */
3764 Gtid_set owned_gtid_set;
3765#endif
3766
3767 /*
3768 Replication related context.
3769
3770 @todo: move more parts of replication related fields in THD to inside this
3771 class.
3772 */
3774
3776 /* Defer GTID cleanup if pinned. Used for XA transactions where
3777 SE(Innodb) needs to read GTID. */
3780 return;
3781 }
3783#ifdef HAVE_GTID_NEXT_LIST
3784 owned_gtid_set.clear();
3785#else
3786 assert(0);
3787#endif
3788 }
3789 owned_gtid.clear();
3790 owned_sid.clear();
3791 owned_gtid.dbug_print(nullptr, "set owned_gtid in clear_owned_gtids");
3792 }
3793
3794 /** @return true, if owned GTID is empty or waiting for deferred cleanup. */
3797 return (true);
3798 }
3799 return (owned_gtid.is_empty());
3800 }
3801
3802 /*
3803 There are some statements (like OPTIMIZE TABLE, ANALYZE TABLE and
3804 REPAIR TABLE) that might call trans_rollback_stmt() and also will be
3805 successfully executed and will have to go to the binary log.
3806 For these statements, the skip_gtid_rollback flag must be set to avoid
3807 problems when the statement is executed with a GTID_NEXT set to
3808 ASSIGNED_GTID (like the SQL thread do when applying events from other
3809 server). When this flag is set, a call to gtid_rollback() will do nothing.
3810 */
3812 /*
3813 There are some statements (like DROP DATABASE that fails on rmdir
3814 and gets rewritten to multiple DROP TABLE statements) that may
3815 call trans_commit_stmt() before it has written all statements to
3816 the binlog. When using GTID_NEXT = ANONYMOUS, such statements
3817 should not release ownership of the anonymous transaction until
3818 all statements have been written to the binlog. To prevent that
3819 update_gtid_impl releases ownership, such statements must set this
3820 flag.
3821 */
3823
3824 /*
3825 True while the transaction is executing, if one of
3826 is_ddl_gtid_consistent or is_dml_gtid_consistent returned false.
3827 */
3829
3830 const LEX_CSTRING &db() const { return m_db; }
3831
3832 /**
3833 Set the current database; use deep copy of C-string.
3834
3835 @param new_db the new database name.
3836
3837 Initialize the current database from a NULL-terminated string with
3838 length. If we run out of memory, we free the current database and
3839 return true. This way the user will notice the error as there will be
3840 no current database selected (in addition to the error message set by
3841 malloc).
3842
3843 @note This operation just sets {db, db_length}. Switching the current
3844 database usually involves other actions, like switching other database
3845 attributes including security context. In the future, this operation
3846 will be made private and more convenient interface will be provided.
3847
3848 @return Operation status
3849 @retval false Success
3850 @retval true Out-of-memory error
3851 */
3852 bool set_db(const LEX_CSTRING &new_db);
3853
3854 /**
3855 Set the current database; use shallow copy of C-string.
3856
3857 @param new_db the new database name.
3858
3859 @note This operation just sets {db, db_length}. Switching the current
3860 database usually involves other actions, like switching other database
3861 attributes including security context. In the future, this operation
3862 will be made private and more convenient interface will be provided.
3863 */
3864 void reset_db(const LEX_CSTRING &new_db) {
3865 m_db.str = new_db.str;
3866 m_db.length = new_db.length;
3867#ifdef HAVE_PSI_THREAD_INTERFACE
3868 PSI_THREAD_CALL(set_thread_db)(new_db.str, static_cast<int>(new_db.length));
3869#endif
3870 }
3871 /*
3872 Copy the current database to the argument. Use the current arena to
3873 allocate memory for a deep copy: current database may be freed after
3874 a statement is parsed but before it's executed.
3875 */
3876 bool copy_db_to(char const **p_db, size_t *p_db_length) const {
3877 if (m_db.str == nullptr) {
3878 my_error(ER_NO_DB_ERROR, MYF(0));
3879 return true;
3880 }
3881 *p_db = strmake(m_db.str, m_db.length);
3882 *p_db_length = m_db.length;
3883 return false;
3884 }
3885
3886 bool copy_db_to(char **p_db, size_t *p_db_length) const {
3887 return copy_db_to(const_cast<char const **>(p_db), p_db_length);
3888 }
3889
3891
3892 /**
3893 Get resource group context.
3894
3895 @returns pointer to resource group context.
3896 */
3897
3899 return &m_resource_group_ctx;
3900 }
3901
3902 public:
3903 /**
3904 Save the performance schema thread instrumentation
3905 associated with this user session.
3906 @param psi Performance schema thread instrumentation
3907 */
3908 void set_psi(PSI_thread *psi) { m_psi = psi; }
3909
3910 /**
3911 Read the performance schema thread instrumentation
3912 associated with this user session.
3913 This method is safe to use from a different thread.
3914 */
3915 PSI_thread *get_psi() const { return m_psi; }
3916
3917 private:
3918 /**
3919 Performance schema thread instrumentation for this session.
3920 This member is maintained using atomic operations,
3921 do not access it directly.
3922 @sa set_psi
3923 @sa get_psi
3924 */
3925 std::atomic<PSI_thread *> m_psi;
3926
3927 public:
3929 return m_internal_handler;
3930 }
3931
3932 /**
3933 Add an internal error handler to the thread execution context.
3934 @param handler the exception handler to add
3935 */
3937
3938 private:
3939 /**
3940 Handle a sql condition.
3941 @param sql_errno the condition error number
3942 @param sqlstate the condition sqlstate
3943 @param level the condition level
3944 @param msg the condition message text
3945 @return true if the condition is handled
3946 */
3947 bool handle_condition(uint sql_errno, const char *sqlstate,
3949 const char *msg);
3950
3951 public:
3952 /**
3953 Remove the error handler last pushed.
3954 */
3956
3957 Opt_trace_context opt_trace; ///< optimizer trace of current statement
3958 /**
3959 Raise an exception condition.
3960 @param code the MYSQL_ERRNO error code of the error
3961 */
3962 void raise_error(uint code);
3963
3964 /**
3965 Raise an exception condition, with a formatted message.
3966 @param code the MYSQL_ERRNO error code of the error
3967 */
3968 void raise_error_printf(uint code, ...);
3969
3970 /**
3971 Raise a completion condition (warning).
3972 @param code the MYSQL_ERRNO error code of the warning
3973 */
3974 void raise_warning(uint code);
3975
3976 /**
3977 Raise a completion condition (warning), with a formatted message.
3978 @param code the MYSQL_ERRNO error code of the warning
3979 */
3980 void raise_warning_printf(uint code, ...);
3981
3982 /**
3983 Raise a completion condition (note), with a fixed message.
3984 @param code the MYSQL_ERRNO error code of the note
3985 */
3986 void raise_note(uint code);
3987
3988 /**
3989 Raise an completion condition (note), with a formatted message.
3990 @param code the MYSQL_ERRNO error code of the note
3991 */
3992 void raise_note_printf(uint code, ...);
3993
3994 private:
3995 /*
3996 Only the implementation of the SIGNAL and RESIGNAL statements
3997 is permitted to raise SQL conditions in a generic way,
3998 or to raise them by bypassing handlers (RESIGNAL).
3999 To raise a SQL condition, the code should use the public
4000 raise_error() or raise_warning() methods provided by class THD.
4001 */
4003 friend class Sql_cmd_signal;
4004 friend class Sql_cmd_resignal;
4005 friend void push_warning(THD *thd,
4007 uint code, const char *message_text);
4008 friend void my_message_sql(uint, const char *, myf);
4009
4010 /**
4011 Raise a generic SQL condition. Also calls mysql_audit_notify() unless
4012 the condition is handled by a SQL condition handler.
4013
4014 @param sql_errno the condition error number
4015 @param sqlstate the condition SQLSTATE
4016 @param level the condition level
4017 @param msg the condition message text
4018 @param fatal_error should the fatal_error flag be set?
4019 @return The condition raised, or NULL
4020 */
4021 Sql_condition *raise_condition(uint sql_errno, const char *sqlstate,
4023 const char *msg, bool fatal_error = false);
4024
4025 public:
4027
4028 inline enum enum_server_command get_command() const { return m_command; }
4029
4030 /**
4031 For safe and protected access to the query string, the following
4032 rules should be followed:
4033 1: Only the owner (current_thd) can set the query string.
4034 This will be protected by LOCK_thd_query.
4035 2: The owner (current_thd) can read the query string without
4036 locking LOCK_thd_query.
4037 3: Other threads must lock LOCK_thd_query before reading
4038 the query string.
4039
4040 This means that write-write conflicts are avoided by LOCK_thd_query.
4041 Read(by owner or other thread)-write(other thread) are disallowed.
4042 Read(other thread)-write(by owner) conflicts are avoided by LOCK_thd_query.
4043 Read(by owner)-write(by owner) won't happen as THD=thread.
4044
4045 We want to keep current_thd out of header files, so the debug assert,
4046 is moved to the .cc file. In optimized mode, we want this getter to
4047 be fast, so we inline it.
4048 */
4049 void debug_assert_query_locked() const;
4050 const LEX_CSTRING &query() const {
4051#ifndef NDEBUG
4053#endif
4054 return m_query_string;
4055 }
4056
4057 /**
4058 The current query in normalized form. The format is intended to be
4059 identical to the digest text of performance_schema, but not limited in
4060 size. In this case the parse tree is traversed as opposed to a (limited)
4061 token buffer. The string is allocated by this Statement and will be
4062 available until the next call to this function or this object is deleted.
4063
4064 @note We have no protection against out-of-memory errors as this function
4065 relies on the Item::print() interface which does not propagate errors.
4066
4067 @return The current query in normalized form.
4068 */
4069 const String normalized_query();
4070
4071 /**
4072 Set query to be displayed in performance schema (threads table etc.). Also
4073 mark the query safe to display for information_schema.process_list.
4074 */
4075 void set_query_for_display(const char *query_arg [[maybe_unused]],
4076 size_t query_length_arg [[maybe_unused]]) {
4077 // Set in pfs events statements table
4079 static_cast<uint>(query_length_arg));
4080#ifdef HAVE_PSI_THREAD_INTERFACE
4081 // Set in pfs threads table
4082 PSI_THREAD_CALL(set_thread_info)
4083 (query_arg, static_cast<uint>(query_length_arg));
4084#endif
4085 set_safe_display(true);
4086 }
4087
4088 /**
4089 Reset query string to be displayed in PFS. Also reset the safety flag
4090 for information_schema.process_list for next query.
4091 */
4093 set_query_for_display(nullptr, 0);
4094 m_safe_to_display.store(false);
4095 }
4096
4097 /** @return true, if safe to display the query string. */
4098 bool safe_to_display() const { return m_safe_to_display.load(); }
4099
4100 /** Set if the query string to be safe to display.
4101 @param[in] safe if it is safe to display query string */
4102 void set_safe_display(bool safe) { m_safe_to_display.store(safe); }
4103
4104 /**
4105 Assign a new value to thd->m_query_string.
4106 Protected with the LOCK_thd_query mutex.
4107 */
4108 void set_query(const char *query_arg, size_t query_length_arg) {
4109 LEX_CSTRING tmp = {query_arg, query_length_arg};
4110 set_query(tmp);
4111 }
4112 void set_query(LEX_CSTRING query_arg);
4114
4115 /**
4116 Set the rewritten query (with passwords obfuscated etc.) on the THD.
4117 Wraps this in the LOCK_thd_query mutex to protect against race conditions
4118 with SHOW PROCESSLIST inspecting that string.
4119
4120 This uses swap() and therefore "steals" the argument from the caller;
4121 the caller MUST take care not to try to use its own string after calling
4122 this function! This is an optimization for mysql_rewrite_query() so we
4123 don't copy its temporary string (which may get very long, up to
4124 @@max_allowed_packet).
4125
4126 Using this outside of mysql_rewrite_query() is almost certainly wrong;
4127 please check with the runtime team!
4128
4129 @param query_arg The rewritten query to use for slow/bin/general logging.
4130 The value will be released in the caller and MUST NOT
4131 be used there after calling this function.
4132 */
4133 void swap_rewritten_query(String &query_arg);
4134
4135 /**
4136 Get the rewritten query (with passwords obfuscated etc.) from the THD.
4137 If done from a different thread (from the one that the rewritten_query
4138 is set on), the caller must hold LOCK_thd_query while calling this!
4139 */
4140 const String &rewritten_query() const {
4141#ifndef NDEBUG
4143#endif
4144 return m_rewritten_query;
4145 }
4146
4147 /**
4148 Reset thd->m_rewritten_query. Protected with the LOCK_thd_query mutex.
4149 */
4151 if (rewritten_query().length()) {
4152 String empty;
4153 swap_rewritten_query(empty);
4154 }
4155 }
4156
4157 /**
4158 Assign a new value to thd->query_id.
4159 Protected with the LOCK_thd_data mutex.
4160 */
4161 void set_query_id(query_id_t new_query_id) {
4163 query_id = new_query_id;
4166 }
4167
4168 /**
4169 Assign a new value to open_tables.
4170 Protected with the LOCK_thd_data mutex.
4171 */
4172 void set_open_tables(TABLE *open_tables_arg) {
4174 open_tables = open_tables_arg;
4176 }
4177
4178 /**
4179 Assign a new value to is_killable
4180 Protected with the LOCK_thd_data mutex.
4181 */
4182 void set_is_killable(bool is_killable_arg) {
4184 is_killable = is_killable_arg;
4186 }
4187
4189 assert(locked_tables_mode == LTM_NONE);
4190
4191 if (mode_arg == LTM_LOCK_TABLES) {
4192 /*
4193 When entering LOCK TABLES mode we should set explicit duration
4194 for all metadata locks acquired so far in order to avoid releasing
4195 them till UNLOCK TABLES statement.
4196 We don't do this when entering prelocked mode since sub-statements
4197 don't release metadata locks and restoring status-quo after leaving
4198 prelocking mode gets complicated.
4199 */
4201 }
4202
4203 locked_tables_mode = mode_arg;
4204 }
4206 int decide_logging_format(TABLE_LIST *tables);
4207 /**
4208 is_dml_gtid_compatible() and is_ddl_gtid_compatible() check if the
4209 statement that is about to be processed will safely get a
4210 GTID. Currently, the following cases may lead to errors
4211 (e.g. duplicated GTIDs) and as such are forbidden:
4212
4213 1. DML statements that mix non-transactional updates with
4214 transactional updates.
4215
4216 2. Transactions that use non-transactional tables after
4217 having used transactional tables.
4218
4219 3. CREATE...SELECT statement;
4220
4221 4. CREATE TEMPORARY TABLE or DROP TEMPORARY TABLE within a
4222 transaction
4223
4224 The first two conditions have to be checked in
4225 decide_logging_format, because that's where we know if the table
4226 is transactional or not. These are implemented in
4227 is_dml_gtid_compatible().
4228
4229 The third and fourth conditions have to be checked in
4230 mysql_execute_command because (1) that prevents implicit commit
4231 from being executed if the statement fails; (2) DROP TEMPORARY
4232 TABLE does not invoke decide_logging_format. These are
4233 implemented in is_ddl_gtid_compatible().
4234
4235 In the cases where GTID violations generate errors,
4236 is_ddl_gtid_compatible() needs to be called before the implicit
4237 pre-commit, so that there is no implicit commit if the statement
4238 fails.
4239
4240 In the cases where GTID violations do not generate errors,
4241 is_ddl_gtid_compatible() needs to be called after the implicit
4242 pre-commit, because in these cases the function will increase the
4243 global counter automatic_gtid_violating_transaction_count or
4244 anonymous_gtid_violating_transaction_count. If there is an
4245 ongoing transaction, the implicit commit will commit the
4246 transaction, which will call update_gtids_impl, which should
4247 decrease the counters depending on whether the *old* was violating
4248 GTID-consistency or not. Thus, we should increase the counters
4249 only after the old transaction is committed.
4250
4251 @param some_transactional_table true if the statement updates some
4252 transactional table; false otherwise.
4253
4254 @param some_non_transactional_table true if the statement updates
4255 some non-transactional table; false otherwise.
4256
4257 @param non_transactional_tables_are_tmp true if all updated
4258 non-transactional tables are temporary.
4259
4260 @retval true if the statement is compatible;
4261 @retval false if the statement is not compatible.
4262 */
4263 bool is_dml_gtid_compatible(bool some_transactional_table,
4264 bool some_non_transactional_table,
4265 bool non_transactional_tables_are_tmp);
4268 bool need_binlog_invoker() const { return m_binlog_invoker; }
4269 void get_definer(LEX_USER *definer);
4271 m_invoker_user.str = user->str;
4272 m_invoker_user.length = user->length;
4273 m_invoker_host.str = host->str;
4274 m_invoker_host.length = host->length;
4275 }
4278 bool has_invoker() const { return m_invoker_user.str != nullptr; }
4279
4281
4282 private:
4283 /** The current internal error handler for this thread, or NULL. */
4285
4286 /**
4287 This memory root is used for two purposes:
4288 - for conventional queries, to allocate structures stored in main_lex
4289 during parsing, and allocate runtime data (execution plan, etc.)
4290 during execution.
4291 - for prepared queries, only to allocate runtime data. The parsed
4292 tree itself is reused between executions and thus is stored elsewhere.
4293 */
4296 Diagnostics_area m_parser_da; /**< cf. get_parser_da() */
4299
4301
4302 /**
4303 It will be set TRUE if CURRENT_USER() is called in account management
4304 statements or default definer is set in CREATE/ALTER SP, SF, Event,
4305 TRIGGER or VIEW statements.
4306
4307 Current user will be binlogged into Query_log_event if current_user_used
4308 is true; It will be stored into m_invoker_host and m_invoker_user by SQL
4309 thread.
4310 */
4312
4313 /**
4314 It points to the invoker in the Query_log_event.
4315 SQL thread use it as the default definer in CREATE/ALTER SP, SF, Event,
4316 TRIGGER or VIEW statements or current user in account management
4317 statements if it is not NULL.
4318 */
4321
4322 friend class Protocol_classic;
4323
4324 private:
4325 /**
4326 Optimizer cost model for server operations.
4327 */
4329
4330 public:
4331 /**
4332 Initialize the optimizer cost model.
4333
4334 This function should be called each time a new query is started.
4335 */
4337
4338 /**
4339 Retrieve the optimizer cost model for this connection.
4340 */
4341 const Cost_model_server *cost_model() const { return &m_cost_model; }
4342
4345
4346 void syntax_error() { syntax_error(ER_SYNTAX_ERROR); }
4347 void syntax_error(const char *format, ...)
4348 MY_ATTRIBUTE((format(printf, 2, 3)));
4349 void syntax_error(int mysql_errno, ...);
4350
4351 void syntax_error_at(const YYLTYPE &location) {
4352 syntax_error_at(location, ER_SYNTAX_ERROR);
4353 }
4354 void syntax_error_at(const YYLTYPE &location, const char *format, ...)
4355 MY_ATTRIBUTE((format(printf, 3, 4)));
4356 void syntax_error_at(const YYLTYPE &location, int mysql_errno, ...);
4357
4358 void vsyntax_error_at(const YYLTYPE &location, const char *format,
4359 va_list args) MY_ATTRIBUTE((format(printf, 3, 0)));
4360 void vsyntax_error_at(const char *pos_in_lexer_raw_buffer, const char *format,
4361 va_list args) MY_ATTRIBUTE((format(printf, 3, 0)));
4362
4363 /**
4364 Send name and type of result to client.
4365
4366 Sum fields has table name empty and field_name.
4367
4368 @param list List of items to send to client
4369 @param flags Bit mask with the following functions:
4370 - 1 send number of rows
4371 - 2 send default values
4372 - 4 don't write eof packet
4373
4374 @retval
4375 false ok
4376 @retval
4377 true Error (Note that in this case the error is not sent to the client)
4378 */
4379
4381
4382 /**
4383 Send one result set row.
4384
4385 @param row_items a collection of column values for that row
4386
4387 @return Error status.
4388 @retval true Error.
4389 @retval false Success.
4390 */
4391
4392 bool send_result_set_row(const mem_root_deque<Item *> &row_items);
4393
4394 /*
4395 Send the status of the current statement execution over network.
4396
4397 In MySQL, there are two types of SQL statements: those that return
4398 a result set and those that return status information only.
4399
4400 If a statement returns a result set, it consists of 3 parts:
4401 - result set meta-data
4402 - variable number of result set rows (can be 0)
4403 - followed and terminated by EOF or ERROR packet
4404
4405 Once the client has seen the meta-data information, it always
4406 expects an EOF or ERROR to terminate the result set. If ERROR is
4407 received, the result set rows are normally discarded (this is up
4408 to the client implementation, libmysql at least does discard them).
4409 EOF, on the contrary, means "successfully evaluated the entire
4410 result set". Since we don't know how many rows belong to a result
4411 set until it's evaluated, EOF/ERROR is the indicator of the end
4412 of the row stream. Note, that we can not buffer result set rows
4413 on the server -- there may be an arbitrary number of rows. But
4414 we do buffer the last packet (EOF/ERROR) in the Diagnostics_area and
4415 delay sending it till the very end of execution (here), to be able to
4416 change EOF to an ERROR if commit failed or some other error occurred
4417 during the last cleanup steps taken after execution.
4418
4419 A statement that does not return a result set doesn't send result
4420 set meta-data either. Instead it returns one of:
4421 - OK packet
4422 - ERROR packet.
4423 Similarly to the EOF/ERROR of the previous statement type, OK/ERROR
4424 packet is "buffered" in the Diagnostics Area and sent to the client
4425 in the end of statement.
4426
4427 @note This method defines a template, but delegates actual
4428 sending of data to virtual Protocol::send_{ok,eof,error}. This
4429 allows for implementation of protocols that "intercept" ok/eof/error
4430 messages, and store them in memory, etc, instead of sending to
4431 the client.
4432
4433 @pre The Diagnostics Area is assigned or disabled. It can not be empty
4434 -- we assume that every SQL statement or COM_* command
4435 generates OK, ERROR, or EOF status.
4436
4437 @post The status information is encoded to protocol format and sent to the
4438 client.
4439
4440 @return We conventionally return void, since the only type of error
4441 that can happen here is a NET (transport) error, and that one
4442 will become visible when we attempt to read from the NET the
4443 next command.
4444 Diagnostics_area::is_sent is set for debugging purposes only.
4445 */
4446
4447 void send_statement_status();
4448
4449 /**
4450 This is only used by master dump threads.
4451 When the master receives a new connection from a slave with a
4452 UUID (for slave versions >= 5.6)/server_id(for slave versions < 5.6)
4453 that is already connected, it will set this flag true
4454 before killing the old slave connection.
4455 */
4457
4458 /**
4459 Claim all the memory used by the THD object.
4460 This method is to keep memory instrumentation statistics
4461 updated, when an object is transferred across threads.
4462 */
4463 void claim_memory_ownership(bool claim);
4464
4467
4468 /**
4469 Returns the plugin, the thd belongs to.
4470 @return pointer to the plugin id
4471 */
4472 const st_plugin_int *get_plugin() const { return m_plugin; }
4473 /**
4474 Sets the plugin id to the value provided as parameter
4475 @param plugin the id of the plugin the thd belongs to
4476 */
4477 void set_plugin(const st_plugin_int *plugin) { m_plugin = plugin; }
4478#ifndef NDEBUG
4481#endif
4482
4485
4486 private:
4487 /**
4488 Variable to mark if the object is part of a Srv_session object, which
4489 aggregates THD.
4490 */
4492
4493 /// Stores the plugin id it is attached to (if any).
4494 const st_plugin_int *m_plugin{nullptr};
4495
4496 /**
4497 Creating or dropping plugin native table through a plugin service.
4498 This variable enables the DDL command execution from
4499 dd::create_native_table() to be executed without committing the
4500 transaction.
4501 */
4503
4504#ifndef NDEBUG
4505 /**
4506 Sequential number of internal tmp table created in the statement. Useful for
4507 tracking tmp tables when number of them is involved in a query.
4508 */
4510
4511 public:
4512 /*
4513 The member serves to guard against duplicate use of the same xid
4514 at binary logging.
4515 */
4517#endif
4518 private:
4519 /*
4520 Flag set by my_write before waiting for disk space.
4521
4522 This is used by replication to decide if the I/O thread should be
4523 killed or not when stopping the replication threads.
4524
4525 In ordinary STOP SLAVE case, the I/O thread will wait for disk space
4526 or to be killed regardless of this flag value.
4527
4528 In server shutdown case, if this flag is true, the I/O thread will be
4529 signaled with KILL_CONNECTION to abort the waiting, letting the server
4530 to shutdown promptly.
4531 */
4533
4534 public:
4535 /**
4536 Set the waiting_for_disk_space flag.
4537
4538 @param waiting The value to set in the flag.
4539 */
4540 void set_waiting_for_disk_space(bool waiting) {
4541 waiting_for_disk_space = waiting;
4542 }
4543 /**
4544 Returns the current waiting_for_disk_space flag value.
4545 */
4547
4548 bool sql_parser();
4549
4550 /// Enables or disables use of secondary storage engines in this session.
4553 }
4554
4555 /**
4556 Can secondary storage engines be used for query execution in
4557 this session?
4558 */
4561 }
4562
4563 /**
4564 Checks if queries in this session can use a secondary storage engine for
4565 execution.
4566
4567 @return true if secondary storage engines can be used in this
4568 session, or false otherwise
4569 */
4571
4572 private:
4573 /**
4574 This flag tells if a secondary storage engine can be used to
4575 execute a query in this session.
4576 */
4579
4581 /**
4582 Flag that indicates if the user of current session has SYSTEM_USER privilege
4583 */
4584 std::atomic<bool> m_is_system_user;
4585 /**
4586 Flag that indicates if the user of current session has CONNECTION_ADMIN
4587 privilege
4588 */
4589 std::atomic<bool> m_is_connection_admin;
4590
4591 public:
4592 bool is_system_user();
4593 void set_system_user(bool system_user_flag);
4594
4595 bool is_connection_admin();
4596 void set_connection_admin(bool connection_admin_flag);
4597
4598 public:
4600
4601 /**
4602 Flag to indicate this thread is executing
4603 @ref sys_var::update for a @ref OPT_GLOBAL variable.
4604
4605 This flag imply the thread already holds @ref LOCK_global_system_variables.
4606 Knowing this is required to resolve reentrancy issues
4607 in the system variable code, when callers
4608 read system variable Y while inside an update function
4609 for system variable X.
4610 Executing table io while inside a system variable update function
4611 will indirectly cause this.
4612 @todo Clean up callers and remove m_inside_system_variable_global_update.
4613 */
4615
4616 public:
4617 /** The parameter value bindings for the current query. Allocated on the THD
4618 * memroot. Can be empty */
4620 /** the number of elements in parameters */
4622
4623 public:
4624 /**
4625 Copy session properties that affect table access
4626 from the parent session to the current session.
4627
4628 The following properties:
4629 - the OPTION_BIN_LOG flag,
4630 - the skip_readonly_check flag,
4631 - the transaction isolation (tx_isolation)
4632 are copied from the parent to the current THD.
4633
4634 This is useful to execute an isolated, internal THD session
4635 to access tables, while leaving tables in the parent session
4636 unchanged.
4637
4638 @param thd parent session
4639 */
4643
4646
4647#ifndef NDEBUG
4648 const char *current_key_name;
4652 return (is_error() &&
4653 (get_stmt_da()->mysql_errno() == ER_DA_GLOBAL_CONN_LIMIT ||
4654 get_stmt_da()->mysql_errno() == ER_DA_CONN_LIMIT));
4655 }
4656#endif
4657};
4658
4659/**
4660 Return lock_tables_mode for secondary engine.
4661 @param cthd thread context
4662 @retval true if lock_tables_mode is on
4663 @retval false, otherwise
4664 */
4665inline bool secondary_engine_lock_tables_mode(const THD &cthd) {
4666 return (cthd.locked_tables_mode == LTM_LOCK_TABLES ||
4668}
4669
4670/** A short cut for thd->get_stmt_da()->set_ok_status(). */
4671void my_ok(THD *thd, ulonglong affected_rows = 0, ulonglong id = 0,
4672 const char *message = nullptr);
4673
4674/** A short cut for thd->get_stmt_da()->set_eof_status(). */
4675void my_eof(THD *thd);
4676
4677bool add_item_to_list(THD *thd, Item *item);
4678
4679/*************************************************************************/
4680
4681/**
4682 Check if engine substitution is allowed in the current thread context.
4683
4684 @param thd thread context
4685 @retval true if engine substitution is allowed
4686 @retval false otherwise
4687*/
4688
4689inline bool is_engine_substitution_allowed(const THD *thd) {
4691}
4692
4693/**
4694 Returns if the user of the session has the SYSTEM_USER privilege or not.
4695
4696 @retval true User has SYSTEM_USER privilege
4697 @retval false Otherwise
4698*/
4699inline bool THD::is_system_user() {
4700 return m_is_system_user.load(std::memory_order_seq_cst);
4701}
4702
4703/**
4704 Sets the system_user flag atomically for the current session.
4705
4706 @param [in] system_user_flag boolean flag that indicates value to set.
4707*/
4708inline void THD::set_system_user(bool system_user_flag) {
4709 m_is_system_user.store(system_user_flag, std::memory_order_seq_cst);
4710}
4711
4712/**
4713 Returns if the user of the session has the CONNECTION_ADMIN privilege or not.
4714
4715 @retval true User has CONNECTION_ADMIN privilege
4716 @retval false Otherwise
4717*/
4719 return m_is_connection_admin.load(std::memory_order_seq_cst);
4720}
4721
4722/**
4723 Sets the connection_admin flag atomically for the current session.
4724
4725 @param [in] connection_admin_flag boolean flag that indicates value to set.
4726*/
4727inline void THD::set_connection_admin(bool connection_admin_flag) {
4728 m_is_connection_admin.store(connection_admin_flag, std::memory_order_seq_cst);
4729}
4730
4731/**
4732 Returns true if xa transactions are detached as part of executing XA PREPARE.
4733*/
4734inline bool is_xa_tran_detached_on_prepare(const THD *thd) {
4735 return thd->variables.xa_detach_on_prepare;
4736}
4737
4738#endif /* SQL_CLASS_INCLUDED */
app_data_ptr new_data(u_int n, char *val, cons_type consensus)
int64 query_id_t
Definition: binlog.h:70
API for getting cost estimates for server operations that are not directly related to a table object.
Definition: opt_costmodel.h:51
void init()
Initialize the cost model object for a query.
Definition: opt_costmodel.cc:44
Stores status of the currently executed statement.
Definition: sql_error.h:268
bool is_error() const
Definition: sql_error.h:365
void reset_diagnostics_area()
Clear this Diagnostics Area.
Definition: sql_error.cc:354
Diagnostics_area * pop_diagnostics_area()
Pop "this" off the Diagnostics Area stack.
Definition: sql_error.cc:631
const Diagnostics_area * stacked_da() const
Returns the Diagnostics Area below the current diagnostics area on the stack.
Definition: sql_error.h:586
void push_diagnostics_area(THD *thd, Diagnostics_area *da, bool copy_conditions)
Push the given Diagnostics Area on top of the stack.
Definition: sql_error.cc:620
List of Discrete_interval objects.
Definition: discrete_interval.h:86
bool append(Discrete_interval *new_interval)
Definition: discrete_interval.h:116
void clear()
Definition: discrete_interval.h:143
An instance of the global read lock in a connection.
Definition: sql_class.h:820
bool can_acquire_protection() const
Check if this connection can acquire protection against GRL and emit error if otherwise.
Definition: sql_class.h:846
MDL_ticket * m_mdl_blocks_commits_lock
Also in order to acquire the global read lock, the connection must acquire a shared metadata lock in ...
Definition: sql_class.h:871
MDL_ticket * m_mdl_global_shared_lock
In order to acquire the global read lock, the connection must acquire shared metadata lock in GLOBAL ...
Definition: sql_class.h:865
enum_grl_state m_state
Definition: sql_class.h:859
bool is_acquired() const
Definition: sql_class.h:854
Global_read_lock()
Definition: sql_class.h:828
static bool global_read_lock_active()
Used by innodb memcached server to check if any connections have global read lock.
Definition: sql_class.h:840
enum_grl_state
Definition: sql_class.h:822
@ GRL_ACQUIRED_AND_BLOCKS_COMMIT
Definition: sql_class.h:825
@ GRL_ACQUIRED
Definition: sql_class.h:824
@ GRL_NONE
Definition: sql_class.h:823
Represents a set of GTIDs.
Definition: rpl_gtid.h:1454
void clear()
Removes all gtids from this Gtid_set.
Definition: rpl_gtid_set.cc:262
Either statement transaction or normal transaction - related thread-specific storage engine data.
Definition: transaction_info.h:401
This class represents the interface for internal error handlers.
Definition: error_handler.h:46
A registry for item tree transformations performed during query optimization.
Definition: sql_class.h:522
bool m_cancel
Definition: sql_class.h:533
Item * old_value
Definition: sql_class.h:531
Item_change_record(Item **place, Item *new_value)
Definition: sql_class.h:528
Item ** place
Definition: sql_class.h:530
Item * new_value
Definition: sql_class.h:532
Item_change_record()=default
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:802
Definition: sql_list.h:433
Tables that were locked with LOCK TABLES statement.
Definition: locked_tables_list.h:88
An interface to separate the MDL module from the THD, and the rest of the server code.
Definition: mdl.h:84
Context of the owner of metadata locks.
Definition: mdl.h:1409
void set_explicit_duration_for_all_locks()
Set explicit duration for all locks in the context.
Definition: mdl.cc:4620
Savepoint for MDL context.
Definition: mdl.h:1314
A granted metadata lock.
Definition: mdl.h:982
Table modification plan for JOIN-less statements (update/delete)
Definition: opt_explain.h:81
Storage for backup of Open_tables_state.
Definition: sql_class.h:680
MDL_savepoint mdl_system_tables_svp
When we backup the open tables state to open a system table or tables, we want to save state of metad...
Definition: sql_class.h:689
Class that holds information about tables which were opened and locked by the thread.
Definition: sql_class.h:544
MYSQL_LOCK * lock
Definition: sql_class.h:612
TABLE * open_tables
List of regular tables in use by this thread.
Definition: sql_class.h:591
MYSQL_LOCK * extra_lock
Definition: sql_class.h:619
Open_tables_state()
This constructor initializes Open_tables_state instance which can only be used as backup storage.
Definition: sql_class.h:666
uint state_flags
Definition: sql_class.h:659
void reset_open_tables_state()
Definition: sql_class.cc:618
Reprepare_observer * pop_reprepare_observer()
Definition: sql_class.h:578
void push_reprepare_observer(Reprepare_observer *o)
Definition: sql_class.h:574
enum_flags
Definition: sql_class.h:651
@ BACKUPS_AVAIL
Definition: sql_class.h:652
@ SYSTEM_TABLES
Definition: sql_class.h:653
enum enum_locked_tables_mode locked_tables_mode
Definition: sql_class.h:649
Reprepare_observer * get_reprepare_observer() const
Definition: sql_class.h:569
TABLE * temporary_tables
List of temporary tables used by this thread.
Definition: sql_class.h:597
void reset_reprepare_observers()
Definition: sql_class.h:584
void set_open_tables_state(Open_tables_state *state)
Definition: sql_class.cc:603
Prealloced_array< Reprepare_observer *, 4 > m_reprepare_observers
A stack of Reprepare_observer-instances.
Definition: sql_class.h:566
A per-session context which is always available at any point of execution, because in practice it's a...
Definition: opt_trace_context.h:89
Profiling state for a single THD; contains multiple QUERY_PROFILE objects.
Definition: sql_profile.h:225
Internal state of the parser.
Definition: sql_lex.h:4516
Plugin array helper class.
Definition: sql_plugin_ref.h:109
A typesafe replacement for DYNAMIC_ARRAY.
Definition: prealloced_array.h:70
Container for all prepared statements created/used in a connection.
Definition: sql_class.h:470
Prepared_statement_map()
Definition: sql_class.cc:2028
void claim_memory_ownership(bool claim)
Definition: sql_class.cc:2090
Prepared_statement * find_by_name(const LEX_CSTRING &name)
Find prepared statement by name.
Definition: sql_class.cc:2065
int insert(Prepared_statement *statement)
Insert a new statement to the thread-local prepared statement map.
Definition: sql_class.cc:2034
Prepared_statement * m_last_found_statement
Definition: sql_class.h:512
~Prepared_statement_map()
Definition: sql_class.cc:2114
void reset()
Definition: sql_class.cc:2096
void erase(Prepared_statement *statement)
Erase all prepared statements (calls Prepared_statement destructor).
Definition: sql_class.cc:2079
collation_unordered_map< std::string, Prepared_statement * > names_hash
Definition: sql_class.h:511
malloc_unordered_map< ulong, std::unique_ptr< Prepared_statement > > st_hash
Definition: sql_class.h:510
Prepared_statement * find(ulong id)
Find prepared statement by ID.
Definition: sql_class.cc:2070
Prepared_statement: a statement that can contain placeholders.
Definition: sql_prepare.h:345
Definition: protocol_classic.h:238
Definition: protocol_classic.h:51
Class used for the old (MySQL 4.0 protocol).
Definition: protocol_classic.h:216
Definition: protocol.h:32
Definition: sql_class.h:335
enum_state get_state() const
Definition: sql_class.h:398
bool is_stmt_prepare_or_first_stmt_execute() const
Definition: sql_class.h:403
T * memdup_typed(const T *mem)
Definition: sql_class.h:421
enum_state
Definition: sql_class.h:354
@ STMT_INITIALIZED
Definition: sql_class.h:355
@ STMT_ERROR
Definition: sql_class.h:360
@ STMT_REGULAR_EXECUTION
Definition: sql_class.h:358
@ STMT_PREPARED
Definition: sql_class.h:357
@ STMT_INITIALIZED_FOR_SP
Definition: sql_class.h:356
@ STMT_EXECUTED
Definition: sql_class.h:359
bool is_repreparing
To check whether a reprepare operation is active.
Definition: sql_class.h:346
bool is_stmt_prepare() const
Definition: sql_class.h:399
LEX_CSTRING strmake(LEX_CSTRING str)
Definition: sql_class.h:428
void reset_item_list()
Definition: sql_class.h:393
char * mem_strdup(const char *str)
Definition: sql_class.h:424
void free_items()
Definition: sql_class.cc:1992
Item * m_item_list
Definition: sql_class.h:341
void * alloc(size_t size)
Definition: sql_class.h:409
Query_arena(MEM_ROOT *mem_root_arg, enum enum_state state_arg)
Definition: sql_class.h:380
bool is_regular() const
Definition: sql_class.h:407
void set_query_arena(const Query_arena &set)
Copies memory-managing members from set.
Definition: sql_class.cc:2003
char * strmake(const char *str, size_t size) const
Definition: sql_class.h:425
enum_state state
Definition: sql_class.h:377
void set_item_list(Item *item)
Definition: sql_class.h:394
void add_item(Item *item)
Definition: sql_class.cc:1987
void * mem_calloc(size_t size)
Definition: sql_class.h:410
void swap_query_arena(const Query_arena &source, Query_arena *backup)
Copy the current arena to backup and set the current arena to match source
Definition: sql_class.cc:2009
void set_state(enum_state state_arg)
Definition: sql_class.h:397
T * alloc_typed()
Definition: sql_class.h:416
Query_arena()
Definition: sql_class.h:387
Item * item_list() const
Definition: sql_class.h:392
bool is_stmt_prepare_or_first_sp_execute() const
Definition: sql_class.h:400
void * memdup(const void *str, size_t size)
Definition: sql_class.h:434
MEM_ROOT * mem_root
Definition: sql_class.h:344
virtual ~Query_arena()=default
Definition: query_result.h:51
Definition: sql_lex.h:2465
Definition: rpl_rli.h:201
An interface that is used to take an action when the locking module notices that a table version has ...
Definition: sql_prepare.h:80
Common base class for all row-containing log events.
Definition: log_event.h:2704
Definition: rpl_context.h:280
A set of THD members describing the current authenticated user.
Definition: sql_security_ctx.h:53
Definition: sys_vars_resource_mgr.h:67
Definition: session_tracker.h:128
Sql_cmd_common_signal represents the common properties of the SIGNAL and RESIGNAL statements.
Definition: sql_signal.h:87
Sql_cmd_resignal represents a RESIGNAL statement.
Definition: sql_signal.h:167
Sql_cmd_signal represents a SIGNAL statement.
Definition: sql_signal.h:147
Representation of a SQL condition.
Definition: sql_error.h:57
enum_severity_level
Enumeration value describing the severity of the condition.
Definition: sql_error.h:62
Using this class is fraught with peril, and you need to be very careful when doing so.
Definition: sql_string.h:166
Used to save context when executing a function or trigger.
Definition: sql_class.h:730
ulonglong option_bits
Definition: sql_class.h:732
bool enable_slow_log
Definition: sql_class.h:741
ulong client_capabilities
Definition: sql_class.h:739
ulonglong first_successful_insert_id_in_cur_stmt
Definition: sql_class.h:734
ha_rows examined_row_count
Definition: sql_class.h:738
SAVEPOINT * savepoints
Definition: sql_class.h:742
ulonglong current_found_rows
Definition: sql_class.h:736
ha_rows sent_row_count
Definition: sql_class.h:738
ulonglong previous_found_rows
Definition: sql_class.h:737
enum enum_check_fields check_for_truncated_fields
Definition: sql_class.h:743
Discrete_intervals_list auto_inc_intervals_forced
Definition: sql_class.h:735
ha_rows num_truncated_fields
Definition: sql_class.h:738
uint in_sub_stmt
Definition: sql_class.h:740
ulonglong first_successful_insert_id_in_prev_stmt
Definition: sql_class.h:733
A derived from THD::Attachable_trx class allows updates in the attachable transaction.
Definition: sql_class.h:1992
bool is_read_only() const override
Definition: sql_class.h:1994
Attachable_trx_rw(const Attachable_trx_rw &)
Attachable_trx_rw & operator=(const Attachable_trx_rw &)
Attachable_trx_rw(THD *thd)
Definition: sql_class.cc:534
Class representing read-only attachable transaction, encapsulates knowledge how to backup state of cu...
Definition: sql_class.h:1949
THD * m_thd
THD instance.
Definition: sql_class.h:1960
Transaction_state m_trx_state
Transaction state data.
Definition: sql_class.h:1971
virtual ~Attachable_trx()
Definition: sql_class.cc:490
Attachable_trx * m_prev_attachable_trx
Attachable_trx which was active for the THD before when this transaction was started (NULL in most ca...
Definition: sql_class.h:1968
Attachable_trx(THD *thd, Attachable_trx *prev_trx)
Definition: sql_class.cc:395
virtual bool is_read_only() const
Definition: sql_class.h:1956
enum_reset_lex m_reset_lex
Definition: sql_class.h:1962
Attachable_trx * get_prev_attachable_trx() const
Definition: sql_class.h:1953
Attachable_trx(const Attachable_trx &)
Attachable_trx & operator=(const Attachable_trx &)
Query plan for EXPLAINable commands, should be locked with LOCK_query_plan before using.
Definition: sql_class.h:1356
void set_query_plan(enum_sql_command sql_cmd, LEX *lex_arg, bool ps)
Set query plan.
Definition: sql_class.cc:2669
void assert_plan_is_locked_if_other() const
Asserts that current_thd has locked this plan, if it does not own it.
Definition: sql_class.cc:2664
bool is_single_table_plan() const
Definition: sql_class.cc:2987
THD *const thd
Definition: sql_class.h:1358
Query_plan & operator=(const Query_plan &)
not defined
Query_plan(const Query_plan &)
not defined
bool is_ps_query() const
Definition: sql_class.h:1411
LEX * lex
LEX of topmost statement.
Definition: sql_class.h:1362
bool is_ps
True if query is run in prepared statement.
Definition: sql_class.h:1366
const Modification_plan * modification_plan
Query plan for UPDATE/DELETE/INSERT/REPLACE.
Definition: sql_class.h:1364
Modification_plan const * get_modification_plan() const
Definition: sql_class.h:1407
enum_sql_command get_command() const
Definition: sql_class.h:1399
LEX * get_lex() const
Definition: sql_class.h:1403
Query_plan(THD *thd_arg)
Definition: sql_class.h:1381
enum_sql_command sql_command
Original sql_command;.
Definition: sql_class.h:1360
void set_modification_plan(Modification_plan *plan_arg)
Definition: sql_class.cc:2685
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_class.h:922
bool is_being_disposed() const
Check if THD is being disposed (i.e.
Definition: sql_class.cc:1321
enum_vio_type get_vio_type() const
Definition: sql_class.cc:1921
std::atomic< mysql_cond_t * > current_cond
Pointer to the condition variable the thread owning this THD is currently waiting for.
Definition: sql_class.h:1515
bool has_gtid_consistency_violation
Definition: sql_class.h:3828
friend void my_message_sql(uint, const char *, myf)
All global error messages are sent here where the first one is stored for the client.
Definition: mysqld.cc:3712
Rpl_thd_context rpl_thd_ctx
Definition: sql_class.h:3773
struct THD_timer_info * timer
Holds active timer object.
Definition: sql_class.h:1773
void notify_hton_post_release_exclusive(const MDL_key *mdl_key) override
Notify interested storage engines that we have just released exclusive lock for the key.
Definition: sql_class.cc:3014
uint fill_variables_recursion_level
Definition: sql_class.h:1589
thd_scheduler scheduler
Definition: sql_class.h:3890
ulonglong first_successful_insert_id_in_prev_stmt_for_binlog
Definition: sql_class.h:2093
mysql_mutex_t LOCK_thd_query
Protects THD::m_query_string.
Definition: sql_class.h:1206
PSI_statement_locker * m_statement_psi
Current statement instrumentation.
Definition: sql_class.h:2367
std::unique_ptr< dd::cache::Dictionary_client > m_dd_client
Definition: sql_class.h:995
void disconnect(bool server_shutdown=false)
Disconnect the associated communication endpoint.
Definition: sql_class.cc:1613
bool m_is_admin_conn
Definition: sql_class.h:1529
PSI_transaction_locker_state m_transaction_state
Current transaction instrumentation state.
Definition: sql_class.h:2377
PSI_stage_progress * m_stage_progress_psi
Current stage progress instrumentation.
Definition: sql_class.h:2358
std::atomic< bool > m_is_system_user
Flag that indicates if the user of current session has SYSTEM_USER privilege.
Definition: sql_class.h:4584
void cleanup_connection(void)
Definition: sql_class.cc:1157
Gtid owned_gtid
The GTID of the currently owned transaction.
Definition: sql_class.h:3664
sql_digest_state * m_digest
Current statement digest.
Definition: sql_class.h:2360
Diagnostics_area m_query_rewrite_plugin_da
Definition: sql_class.h:4297
void clear_binlog_local_stmt_filter()
Definition: sql_class.h:1758
struct System_status_var * initial_status_var
Definition: sql_class.h:1120
ulonglong first_successful_insert_id_in_cur_stmt
Definition: sql_class.h:2099
void store_globals()
Definition: sql_class.cc:1682
Secondary_engine_optimization m_secondary_engine_optimization
This flag tells if a secondary storage engine can be used to execute a query in this session.
Definition: sql_class.h:4577
void push_lock_usec(ulonglong &top)
Definition: sql_class.h:1557
rpl_event_coordinates binlog_next_event_pos
Definition: sql_class.h:1634
void reset_n_backup_open_tables_state(Open_tables_backup *backup, uint add_state_flags)
Definition: sql_class.cc:2158
void claim_memory_ownership(bool claim)
Claim all the memory used by the THD object.
Definition: sql_class.cc:2911
void inc_status_select_range()
Definition: sql_class.cc:2406