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