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