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