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