MySQL 8.0.32
Source Code Documentation
rpl_rli.h
Go to the documentation of this file.
1/* Copyright (c) 2005, 2022, Oracle and/or its affiliates.
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is also distributed with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have included with MySQL.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License, version 2.0, for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
22
23#ifndef RPL_RLI_H
24#define RPL_RLI_H
25
26#include <sys/types.h>
27#include <time.h>
28#include <atomic>
29#include <memory>
30#include <string>
31#include <string_view>
32#include <vector>
33
34#include "lex_string.h"
36#include "m_string.h"
37#include "map_helpers.h"
38#include "my_bitmap.h"
39#include "my_dbug.h"
40#include "my_inttypes.h"
41#include "my_io.h"
42#include "my_loglevel.h"
43#include "my_psi_config.h"
44#include "my_sys.h"
49#include "mysql/thread_type.h"
50#include "prealloced_array.h" // Prealloced_array
51#include "sql/binlog.h" // MYSQL_BIN_LOG
52#include "sql/log_event.h" //Gtid_log_event
53#include "sql/psi_memory_key.h"
54#include "sql/query_options.h"
55#include "sql/rpl_gtid.h" // Gtid_set
56#include "sql/rpl_info.h" // Rpl_info
57#include "sql/rpl_mta_submode.h" // enum_mts_parallel_type
59#include "sql/rpl_tblmap.h" // table_mapping
61#include "sql/rpl_utility.h" // Deferred_log_events
62#include "sql/sql_class.h" // THD
64#include "sql/table.h"
65
67class Master_info;
68class Rpl_filter;
71class Slave_worker;
72class String;
73struct LEX_MASTER_INFO;
75
77
79
80typedef struct slave_job_item {
85
86/**
87 This class is used to store the type and value for
88 Assign_gtids_to_anonymous_transactions parameter of Change master command on
89 slave.
90*/
92 public:
93 /**
94 This accepted value of the type of the
95 Assign_gtids_to_anonymous_transactions info OFF : Anonymous gtid events
96 won't be converted to Gtid event. LOCAL: Anonymous gtid events will be
97 converted to Gtid event & the UUID used while create GTIDs will be the one
98 of replica which is the server where this transformation of anonymous to
99 gtid event happens. UUID: Anonymous gtid events will be converted to Gtid
100 event & the UUID used while create GTIDs will be the one specified via
101 Change master command to the parameter
102 ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS
103 */
105 /**
106 The default constructor initializes parameters to their default value
107 */
110 m_sidno = 0;
111 }
112 rpl_sidno get_sidno() const { return m_sidno; }
113 enum_type get_type() const;
114 std::string get_value() const;
115 /*
116 Here the assign_gtids_to_anonymous_transactions_value contains the textual
117 representation of the UUID used while creating a GTID.
118 */
119 bool set_info(enum_type assign_gtids_to_anonymous_transactions_type,
120 const char *assign_gtids_to_anonymous_transactions_value);
121
122 private:
123 /** This stores the type of Assign_gtids_to_anonymous_transactions info */
125 /** Stores the UUID in case the m_type is not OFF */
126 std::string m_value;
127 // The sidno corresponding to the UUID value.
129};
130/*******************************************************************************
131Replication SQL Thread
132
133Relay_log_info contains:
134 - the current relay log
135 - the current relay log offset
136 - master log name
137 - master log sequence corresponding to the last update
138 - misc information specific to the SQL thread
139
140Relay_log_info is initialized from a repository, i.e. table or file, if there is
141one. Otherwise, data members are initialized with defaults by calling
142init_relay_log_info().
143
144The relay.info table/file shall be updated whenever: (i) the relay log file
145is rotated, (ii) SQL Thread is stopped, (iii) while processing a Xid_log_event,
146(iv) after a Query_log_event (i.e. commit or rollback) and (v) after processing
147any statement written to the binary log without a transaction context.
148
149The Xid_log_event is a commit for transactional engines and must be handled
150differently to provide reliability/data integrity. In this case, positions
151are updated within the context of the current transaction. So
152
153 . If the relay.info is stored in a transactional repository and the server
154 crashes before successfully committing the transaction the changes to the
155 position table will be rolled back along with the data.
156
157 . If the relay.info is stored in a non-transactional repository, for instance,
158 a file or a system table created using MyIsam, and the server crashes before
159 successfully committing the transaction the changes to the position table
160 will not be rolled back but data will.
161
162In particular, when there are mixed transactions, i.e a transaction that updates
163both transaction and non-transactional engines, the Xid_log_event is still used
164but reliability/data integrity cannot be achieved as we shall explain in what
165follows.
166
167Changes to non-transactional engines, such as MyIsam, cannot be rolled back if a
168failure happens. For that reason, there is no point in updating the positions
169within the boundaries of any on-going transaction. This is true for both commit
170and rollback. If a failure happens after processing the pseudo-transaction but
171before updating the positions, the transaction will be re-executed when the
172slave is up most likely causing an error that needs to be manually circumvented.
173This is a well-known issue when non-transactional statements are executed.
174
175Specifically, if rolling back any transaction, positions are updated outside the
176transaction boundaries. However, there may be a problem in this scenario even
177when only transactional engines are updated. This happens because if there is a
178rollback and such transaction is written to the binary log, a non-transactional
179engine was updated or a temporary table was created or dropped within its
180boundaries.
181
182In particular, in both STATEMENT and MIXED logging formats, this happens because
183any temporary table is automatically dropped after a shutdown/startup.
184See BUG#26945 for further details.
185
186Statements written to the binary log outside the boundaries of a transaction are
187DDLs or maintenance commands which are not transactional. These means that they
188cannot be rolled back if a failure happens. In such cases, the positions are
189updated after processing the events. If a failure happens after processing the
190statement but before updating the positions, the statement will be
191re-executed when the slave is up most likely causing an error that needs to be
192manually circumvented. This is a well-known issue when non-transactional
193statements are executed.
194
195The --sync-relay-log-info does not have effect when a system table, either
196transactional or non-transactional is used.
197
198To correctly recovery from failures, one should combine transactional system
199tables along with the --relay-log-recovery.
200*******************************************************************************/
201class Relay_log_info : public Rpl_info {
202 friend class Rpl_info_factory;
203
204 public:
205 /**
206 Set of possible return values for the member methods related to
207 `PRIVILEGE_CHECKS_USER` management.
208 */
209 enum class enum_priv_checks_status : int {
210 /** Function ended successfully */
211 SUCCESS = 0,
212 /** Value for user is anonymous (''@'...') */
214 /** Value for the username part of the user is larger than 32 characters */
216 /** Value for the hostname part of the user is larger than 255 characters */
218 /** Value for the hostname part of the user has illegal characters */
220 /**
221 Value for the username part of the user is NULL but the value for the
222 hostname is not NULL.
223 */
225 /**
226 Provided user doesn't exists.
227 */
229 /**
230 Provided user doesn't have the necessary privileges to execute the needed
231 operations.
232 */
234 /** Values provided for the internal variables are corrupted. */
236 /**
237 Provided user doesn't have `FILE` privileges during the execution of a
238 `LOAD DATA`event.
239 */
241 };
242
243 enum class enum_require_row_status : int {
244 /** Function ended successfully */
245 SUCCESS = 0,
246 /** Value for `privilege_checks_user` is not empty */
248 };
249
250 /*
251 The per-channel filter associated with this RLI
252 */
254 /**
255 Flags for the state of the replication.
256 */
258 /** The replication thread is inside a statement */
260
261 /** Flag counter. Should always be last */
263 };
264
265 /**
266 Identifies what is the replica policy on primary keys in tables.
267 */
269 /**No policy, used on PFS*/
271 /**
272 The replica sets the value of sql_require_primary_key according to
273 the source replicated value.
274 */
276 /** The replica enforces tables to have primary keys for a given channel*/
278 /** The replica does not enforce any policy around primary keys*/
280 /** The replica generates GIPKs for incoming keyless tables*/
282 };
283
284 /**
285 Stores the information related to the ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS
286 parameter of CHANGE MASTER
287 */
290
291 /*
292 The SQL thread owns one Relay_log_info, and each client that has
293 executed a BINLOG statement owns one Relay_log_info. This function
294 returns zero for the Relay_log_info object that belongs to the SQL
295 thread and nonzero for Relay_log_info objects that belong to
296 clients.
297 */
298 inline bool belongs_to_client() {
299 assert(info_thd);
300 return !info_thd->slave_thread;
301 }
302/* Instrumentation key for performance schema for mts_temp_table_LOCK */
303#ifdef HAVE_PSI_INTERFACE
305#endif
306 /*
307 Lock to protect race condition while transferring temporary table from
308 worker thread to coordinator thread and vice-versa
309 */
311 /*
312 Lock to acquire by methods that concurrently update lwm of committed
313 transactions and the min waited timestamp and its index.
314 */
317 /*
318 If true, events with the same server id should be replicated. This
319 field is set on creation of a relay log info structure by copying
320 the value of ::replicate_same_server_id and can be overridden if
321 necessary. For example of when this is done, check sql_binlog.cc,
322 where the BINLOG statement can be used to execute "raw" events.
323 */
325
326 /*
327 Protected with internal locks.
328 Must get data_lock when resetting the logs.
329 */
331
332 /*
333 Identifies when the recovery process is going on.
334 See sql/rpl_replica.h:init_recovery for further details.
335 */
337
338 /* The following variables are safe to read any time */
339
340 /*
341 When we restart slave thread we need to have access to the previously
342 created temporary tables. Modified only on init/end and by the SQL
343 thread, read only by SQL thread.
344 */
346
347 /* parent Master_info structure */
349
350 /* number of temporary tables open in this channel */
351 std::atomic<int32> atomic_channel_open_temp_tables{0};
352
353 /** the status of the commit timestamps for the relay log */
354 enum {
355 /*
356 no GTID log event has been processed, so it is not known if this log
357 has commit timestamps
358 */
360 // the immediate master does not support commit timestamps
362 // the immediate master supports commit timestamps
365
366 /**
367 @return the pointer to the Gtid_monitoring_info.
368 */
371 }
372
373 /**
374 Stores the details of the transaction which has just started processing.
375
376 This function is called by the STS applier or MTS worker when applying a
377 Gtid.
378
379 @param gtid_arg the gtid of the trx
380 @param original_ts_arg the original commit timestamp of the transaction
381 @param immediate_ts_arg the immediate commit timestamp of the transaction
382 @param skipped true if the transaction was gtid skipped
383 */
384 void started_processing(Gtid gtid_arg, ulonglong original_ts_arg,
385 ulonglong immediate_ts_arg, bool skipped = false) {
386 gtid_monitoring_info->start(gtid_arg, original_ts_arg, immediate_ts_arg,
387 skipped);
388 }
389
390 /**
391 Stores the details of the transaction which has just started processing.
392
393 This function is called by the MTS coordinator when queuing a Gtid to
394 a worker.
395
396 @param gtid_log_ev_arg the gtid log event of the trx
397 */
398 void started_processing(Gtid_log_event *gtid_log_ev_arg) {
399 Gtid gtid = {0, 0};
400 if (gtid_log_ev_arg->get_type() == ASSIGNED_GTID) {
401 gtid = {gtid_log_ev_arg->get_sidno(true), gtid_log_ev_arg->get_gno()};
402 }
403 started_processing(gtid, gtid_log_ev_arg->original_commit_timestamp,
404 gtid_log_ev_arg->immediate_commit_timestamp);
405 }
406
407 /**
408 When the processing of a transaction is completed, that timestamp is
409 recorded, the information is copied to last_processed_trx and the
410 information in processing_trx is cleared.
411
412 If the transaction was "applied" but GTID-skipped, the copy will not
413 happen and the last_processed_trx will keep its current value.
414 */
416
417 /**
418 @return True if there is a transaction being currently processed
419 */
422 }
423
424 /**
425 Clears the processing_trx structure fields. Normally called when there is an
426 error while processing the transaction.
427 */
429
430 /**
431 Clears the Gtid_monitoring_info fields.
432 */
434
435 /**
436 When a transaction is retried, the error number and message, and total number
437 of retries are stored. The timestamp for this error is also set here.
438
439 @param transient_errno_arg Transient error number.
440 @param transient_err_message_arg Transient error message.
441 @param trans_retries_arg Number of times this transaction has been
442 retried so far.
443 */
444 void retried_processing(uint transient_errno_arg,
445 const char *transient_err_message_arg,
446 ulong trans_retries_arg) {
448 transient_errno_arg, transient_err_message_arg, trans_retries_arg);
449 }
450
451 /*
452 If on init_info() call error_on_rli_init_info is true that means
453 that previous call to init_info() terminated with an error, RESET
454 SLAVE must be executed and the problem fixed manually.
455 */
457
458 /**
459 Retrieves the username part of the `PRIVILEGE_CHECKS_USER` option of `CHANGE
460 MASTER TO` statement.
461
462 @return a string holding the username part of the user or an empty string.
463 */
464 std::string get_privilege_checks_username() const;
465
466 /**
467 Retrieves the host part of the `PRIVILEGE_CHECKS_USER` option of `CHANGE
468 MASTER TO` statement.
469
470 @return a string holding the host part of the user or an empty string.
471 */
472 std::string get_privilege_checks_hostname() const;
473
474 /**
475 Returns whether or not there is no user configured for
476 `PRIVILEGE_CHECKS_USER`.
477
478 @return true if there is no user configured for `PRIVILEGE_CHECKS_USER` and
479 false otherwise.
480 */
482
483 /**
484 Returns whether or not the internal data regarding `PRIVILEGE_CHECKS_USER`
485 is corrupted. This may happen, for instance, if the user tries to change the
486 Relay_log_info repository manually or after a server crash.
487
488 @return true if the data is corrupted, false otherwise.
489 */
491
492 /**
493 Clears the info related to the data initialized from
494 `PRIVILEGE_CHECKS_USER`.
495 */
497
498 /**
499 Sets the flag that tells whether or not the data regarding the
500 `PRIVILEGE_CHECKS_USER` is corrupted.
501
502 @param is_corrupted the flag value.
503 */
504 void set_privilege_checks_user_corrupted(bool is_corrupted);
505
506 /**
507 Initializes data related to `PRIVILEGE_CHECKS_USER`, specifically the user
508 name and the user hostname.
509
510 @param param_privilege_checks_username the username part of the user.
511 @param param_privilege_checks_hostname the hostname part of the user.
512
513 @return a status code describing the state of the data initialization.
514 */
516 char const *param_privilege_checks_username,
517 char const *param_privilege_checks_hostname);
518
519 /**
520 Checks the validity and integrity of the data related to
521 `PRIVILEGE_CHECKS_USER`, specifically the user name and the user
522 hostname. Also checks if the user exists.
523
524 This method takes no parameters as it checks the values stored in the
525 internal member variables.
526
527 @return a status code describing the state of the data initialization.
528 */
530
531 /**
532 Checks the validity and integrity of the data related to
533 `PRIVILEGE_CHECKS_USER`, specifically the user name and the user
534 hostname. Also checks if the user exists.
535
536 @param param_privilege_checks_username the username part of the user.
537 @param param_privilege_checks_hostname the hostname part of the user.
538
539 @return a status code describing the state of the data initialization.
540 */
542 char const *param_privilege_checks_username,
543 char const *param_privilege_checks_hostname);
544 /**
545 Checks the existence of user provided as part of the `PRIVILEGE_CHECKS_USER`
546 option.
547
548 @param param_privilege_checks_username the username part of the user.
549 @param param_privilege_checks_hostname the host part of the user.
550
551 @return a status code describing the state of the data initialization.
552 */
554 char const *param_privilege_checks_username,
555 char const *param_privilege_checks_hostname);
556
557 /**
558 Returns a printable representation of the username and hostname currently
559 being used in the applier security context or empty strings other wise.
560
561 @return an `std::pair` containing the username and the hostname printable
562 representations.
563 */
564 std::pair<const char *, const char *>
566
567 /**
568 Outputs the error message associated with applier thread user privilege
569 checks error `error_code`.
570
571 The output stream to which is outputted is decided based on `to_client`
572 which, if set to `true` will output the message to the client session and if
573 `false` will output to the server log.
574
575 @param level the message urgency level, e.g., `ERROR_LEVEL`,
576 `WARNING_LEVEL`, etc.
577 @param status_code the status code to output the associated error message
578 for.
579 @param to_client a flag indicating if the message should be sent to the
580 client session or to the server log.
581 @param channel_name name of the channel for which the error is being
582 reported.
583 @param user_name username for which the error is being reported.
584 @param host_name hostname for which the error is being reported.
585 */
587 enum_priv_checks_status status_code,
588 bool to_client,
589 char const *channel_name = nullptr,
590 char const *user_name = nullptr,
591 char const *host_name = nullptr) const;
592
593 /**
594 Initializes the security context associated with the `PRIVILEGE_CHECKS_USER`
595 user that is to be used by the provided THD object.
596
597 @return a status code describing the state of the data initialization.
598 */
600 /**
601 Initializes the security context associated with the `PRIVILEGE_CHECKS_USER`
602 user that is to be used by the applier thread.
603
604 @return a status code describing the state of the data initialization.
605 */
607
608 /**
609 Returns whether the slave is running in row mode only.
610
611 @return true if row_format_required is active, false otherwise.
612 */
613 bool is_row_format_required() const;
614
615 /**
616 Sets the flag that tells whether or not the slave is running in row mode
617 only.
618
619 @param require_row the flag value.
620 */
621 void set_require_row_format(bool require_row);
622
623 /**
624 Returns what is the slave policy concerning primary keys on
625 replicated tables.
626
627 @return STREAM if it replicates the source values, ON if it enforces the
628 need on primary keys, OFF if it does no enforce any restrictions,
629 GENERATE if a GIPK is added to the table.
630 */
632
633 /**
634 Sets the field that tells what is the slave policy concerning primary keys
635 on replicated tables.
636
637 @param require_pk the policy value.
638 */
641
642 /*
643 This will be used to verify transactions boundaries of events being applied
644
645 Its output is used to detect when events were not logged using row based
646 logging.
647 */
649
650 /**
651 Marks the applier position information as being invalid or not.
652
653 @param invalid value to set the position/file info as invalid or not
654 */
656
657 /**
658 Returns if the applier positions are marked as being invalid or not.
659
660 @return true if applier position information is not reliable,
661 false otherwise.
662 */
664
665 /*
666 Let's call a group (of events) :
667 - a transaction
668 or
669 - an autocommitting query + its associated events (INSERT_ID,
670 TIMESTAMP...)
671 We need these rli coordinates :
672 - relay log name and position of the beginning of the group we currently are
673 executing. Needed to know where we have to restart when replication has
674 stopped in the middle of a group (which has been rolled back by the slave).
675 - relay log name and position just after the event we have just
676 executed. This event is part of the current group.
677 Formerly we only had the immediately above coordinates, plus a 'pending'
678 variable, but this dealt wrong with the case of a transaction starting on a
679 relay log and finishing (committing) on another relay log. Case which can
680 happen when, for example, the relay log gets rotated because of
681 max_binlog_size.
682 */
683 protected:
684 /**
685 Event group means a group of events of a transaction. group_relay_log_name
686 and group_relay_log_pos record the place before where all event groups
687 are applied. When slave starts, it resume to apply events from
688 group_relay_log_pos. They will be initialized to the begin of the first
689 relay log file if it is a new slave(including SLAVE RESET). Then,
690 group_relay_log_pos is advanced after each transaction is applied
691 successfully in single thread slave. For MTS, group_relay_log_pos
692 is updated by mts checkpoint mechanism. group_relay_log_pos and
693 group_relay_log_name are stored into relay_log_info file/table
694 periodically. When server startup, they are loaded from relay log info
695 file/table.
696 */
700 /* The suffix number of relay log name */
704
705 /* current event's start position in relay log */
707 /*
708 Original log name and position of the group we're currently executing
709 (whose coordinates are group_relay_log_name/pos in the relay log)
710 in the master's binlog. These concern the *group*, because in the master's
711 binlog the log_pos that comes with each event is the position of the
712 beginning of the group.
713
714 Note: group_master_log_name, group_master_log_pos must only be
715 written from the thread owning the Relay_log_info (SQL thread if
716 !belongs_to_client(); client thread executing BINLOG statement if
717 belongs_to_client()).
718 */
721
722 private:
724 /*
725 Identifies when this object belongs to the SQL thread and was not
726 created for a client thread or some other purpose including
727 Slave_worker instance initializations. Ends up serving the same
728 purpose as the belongs_to_client method, but its value is set
729 earlier on in the class constructor.
730 */
732 /* Flag that ensures the retrieved GTID set is initialized only once. */
734
735 /**
736 Stores information on the last processed transaction or the transaction
737 that is currently being processed.
738
739 STS:
740 - timestamps of the currently applying/last applied transaction
741
742 MTS:
743 - coordinator thread: timestamps of the currently scheduling/last scheduled
744 transaction in a worker's queue
745 - worker thread: timestamps of the currently applying/last applied
746 transaction
747 */
749
750 /**
751 It will be set to true when receiver truncated relay log for some reason.
752 The truncated data may already be read by applier. So applier need to check
753 it each time the binlog_end_pos is updated.
754 */
756
757 /**
758 The user name part of the user passed on to `PRIVILEGE_CHECKS_USER`.
759 */
761
762 /**
763 The host name part of the user passed on to `PRIVILEGE_CHECKS_USER`.
764 */
766
767 /**
768 Tells whether or not the internal data regarding `PRIVILEGE_CHECKS_USER` is
769 corrupted. This may happen if the user tries to change the Relay_log_info
770 repository by hand.
771 */
773
774 /**
775 Tells if the slave is only accepting events logged with row based logging.
776 It also blocks
777 Operations with temporary table creation/deletion
778 Operations with LOAD DATA
779 Events: INTVAR_EVENT, RAND_EVENT, USER_VAR_EVENT
780 */
782
783 /**
784 Identifies what is the slave policy on primary keys in tables.
785 If set to STREAM it just replicates the value of sql_require_primary_key.
786 If set to ON it fails when the source tries to replicate a table creation
787 or alter operation that does not have a primary key.
788 If set to OFF it does not enforce any policies on the channel for primary
789 keys.
790 If set to GENERATE it adds GIPKs to tables that are created without a PK
791 in the replica applier threads.
792 */
794
795 /**
796 Are positions invalid. If true it means the applier related position
797 information (group_master_log_name and group_master_log_pos) might
798 be outdated.
799
800 Check also is_group_master_log_pos_invalid
801 */
803
804 public:
806
808
810
813 assert(sidno <= get_sid_map()->get_max_sidno());
814 gtid_set->ensure_sidno(sidno);
815 gtid_set->_add_gtid(sidno, gno);
816 }
817
818 /**
819 Adds a GTID set to received GTID set.
820
821 @param gtid_set the gtid_set to add
822
823 @return RETURN_STATUS_OK or RETURN_STATUS_REPORTED_ERROR.
824 */
826
827 const Gtid_set *get_gtid_set() const { return gtid_set; }
828
829 bool reinit_sql_thread_io_cache(const char *log, bool need_data_lock);
830
831 /**
832 Check if group_relay_log_name is in index file.
833
834 @param [out] errmsg An error message is returned if error happens.
835
836 @retval false It is valid.
837 @retval true It is invalid. In this case, *errmsg is set to point to
838 the error message.
839*/
840 bool is_group_relay_log_name_invalid(const char **errmsg);
841 /**
842 Reset group_relay_log_name and group_relay_log_pos to the start of the
843 first relay log file. The caller must hold data_lock.
844
845 @param[out] errmsg An error message is set into it if error happens.
846
847 @retval false Success
848 @retval true Error
849 */
850 bool reset_group_relay_log_pos(const char **errmsg);
851 /*
852 Update the error number, message and timestamp fields. This function is
853 different from va_report() as va_report() also logs the error message in the
854 log apart from updating the error fields.
855 */
856 void fill_coord_err_buf(loglevel level, int err_code,
857 const char *buff_coord) const;
858
859 /**
860 Flag that the group_master_log_pos is invalid. This may occur
861 (for example) after CHANGE MASTER TO RELAY_LOG_POS. This will
862 be unset after the first event has been executed and the
863 group_master_log_pos is valid again.
864
865 Check also m_is_applier_position_info_invalid
866 */
868
869 /*
870 Handling of the relay_log_space_limit optional constraint.
871 ignore_log_space_limit is used to resolve a deadlock between I/O and SQL
872 threads, the SQL thread sets it to unblock the I/O thread and make it
873 temporarily forget about the constraint.
874 */
876 std::atomic<bool> ignore_log_space_limit;
877
878 /*
879 Used by the SQL thread to instructs the IO thread to rotate
880 the logs when the SQL thread needs to purge to release some
881 disk space.
882 */
883 std::atomic<bool> sql_force_rotate_relay;
884
886
887 /**
888 Reset the delay.
889 This is used by RESET SLAVE to clear the delay.
890 */
892
893 /*
894 Needed for problems when slave stops and we want to restart it
895 skipping one or more events in the master log that have caused
896 errors, and have been manually applied by DBA already.
897 */
899 volatile ulong abort_pos_wait; /* Incremented on change master */
902
903 /*
904 Condition and its parameters from START SLAVE UNTIL clause.
905
906 UNTIL condition is tested with is_until_satisfied() method that is
907 called by exec_relay_log_event(). is_until_satisfied() caches the result
908 of the comparison of log names because log names don't change very often;
909 this cache is invalidated by parts of code which change log names with
910 notify_*_log_name_updated() methods. (They need to be called only if SQL
911 thread is running).
912 */
913 enum {
923
925
926 /*
927 trans_retries varies between 0 to replica_transaction_retries and counts how
928 many times the slave has retried the present transaction; gets reset to 0
929 when the transaction finally succeeds. retried_trans is a cumulative
930 counter: how many times the slave has retried a transaction (any) since
931 slave started.
932 */
934
935 /*
936 If the end of the hot relay log is made of master's events ignored by the
937 slave I/O thread, these two keep track of the coords (in the master's
938 binlog) of the last of these events seen by the slave I/O thread. If not,
939 ign_master_log_name_end[0] == 0.
940 As they are like a Rotate event read/written from/to the relay log, they
941 are both protected by rli->relay_log.LOCK_binlog_end_pos.
942 */
945
946 /*
947 Identifies where the SQL Thread should create temporary files for the
948 LOAD DATA INFILE. This is used for security reasons.
949 */
952
953 /**
954 Identifies the last time a checkpoint routine has been executed.
955 */
956 struct timespec last_clock;
957
958 /**
959 Invalidates cached until_log_name and event_relay_log_name comparison
960 result. Should be called after switch to next relay log if
961 there chances that sql_thread is running.
962 */
965 down_cast<Until_position *>(until_option)->notify_log_name_change();
966 }
967
968 /**
969 Receiver thread notifies that it truncated some data from relay log.
970 data_lock will be acquired, so the caller should not hold data_lock.
971 */
973 /**
974 Applier clears the flag after it handled the situation. The caller must
975 hold data_lock.
976 */
978
979 /**
980 The same as @c notify_group_relay_log_name_update but for
981 @c group_master_log_name.
982 */
985 down_cast<Until_position *>(until_option)->notify_log_name_change();
986 }
987
990 }
991
992 /**
993 Last executed event group coordinates are updated and optionally
994 forcibly flushed to a repository.
995 @param log_pos a value of the executed position to update to
996 @param need_data_lock whether data_lock should be acquired
997 @param force the value is passed to eventual flush_info()
998 */
999 int inc_group_relay_log_pos(ulonglong log_pos, bool need_data_lock,
1000 bool force = false);
1001
1002 int wait_for_pos(THD *thd, String *log_name, longlong log_pos,
1003 double timeout);
1004 /**
1005 Wait for a GTID set to be executed.
1006
1007 @param thd The thread for status changes and kill status
1008 @param gtid A char array with a GTID set
1009 @param timeout Number of seconds to wait before timing out
1010 @param update_THD_status Shall the method update the THD stage
1011
1012 @retval 0 The set is already executed
1013 @retval -1 There was a timeout waiting for the set
1014 @retval -2 There was an issue while waiting.
1015 */
1016 int wait_for_gtid_set(THD *thd, const char *gtid, double timeout,
1017 bool update_THD_status = true);
1018 /**
1019 Wait for a GTID set to be executed.
1020
1021 @param thd The thread for status changes and kill status
1022 @param gtid A String with a GTID set
1023 @param timeout Number of seconds to wait before timing out
1024 @param update_THD_status Shall the method update the THD stage
1025
1026 @retval 0 The set is already executed
1027 @retval -1 There was a timeout waiting for the set
1028 @retval -2 There was an issue while waiting.
1029 */
1030 int wait_for_gtid_set(THD *thd, String *gtid, double timeout,
1031 bool update_THD_status = true);
1032 /**
1033 Wait for a GTID set to be executed.
1034
1035 @param thd The thread for status changes and kill status
1036 @param wait_gtid_set A GTID_set object
1037 @param timeout Number of seconds to wait before timing out
1038 @param update_THD_status Shall the method update the THD stage
1039
1040 @retval 0 The set is already executed
1041 @retval -1 There was a timeout waiting for the set
1042 @retval -2 There was an issue while waiting.
1043 */
1044 int wait_for_gtid_set(THD *thd, const Gtid_set *wait_gtid_set, double timeout,
1045 bool update_THD_status = true);
1046
1048
1049 RPL_Table_ref *tables_to_lock; /* RBR: Tables to lock */
1050 uint tables_to_lock_count; /* RBR: Count of tables to lock */
1051 table_mapping m_table_map; /* RBR: Mapping table-id to table */
1052 /* RBR: Record Rows_query log event */
1054
1055 bool get_table_data(TABLE *table_arg, table_def **tabledef_var,
1056 TABLE **conv_table_var) const {
1057 assert(tabledef_var && conv_table_var);
1058 for (Table_ref *ptr = tables_to_lock; ptr != nullptr;
1059 ptr = ptr->next_global)
1060 if (ptr->table == table_arg) {
1061 *tabledef_var = &static_cast<RPL_Table_ref *>(ptr)->m_tabledef;
1062 *conv_table_var = static_cast<RPL_Table_ref *>(ptr)->m_conv_table;
1063 DBUG_PRINT("debug", ("Fetching table data for table %s.%s:"
1064 " tabledef: %p, conv_table: %p",
1065 table_arg->s->db.str, table_arg->s->table_name.str,
1066 *tabledef_var, *conv_table_var));
1067 return true;
1068 }
1069 return false;
1070 }
1071
1072 /**
1073 Last charset (6 bytes) seen by slave SQL thread is cached here; it helps
1074 the thread save 3 @c get_charset() per @c Query_log_event if the charset is
1075 not changing from event to event (common situation). When the 6 bytes are
1076 equal to 0 is used to mean "cache is invalidated".
1077 */
1079 bool cached_charset_compare(char *charset) const;
1080
1081 void cleanup_context(THD *, bool);
1083 void clear_tables_to_lock();
1084 int purge_relay_logs(THD *thd, const char **errmsg, bool delete_only = false);
1085
1086 /*
1087 Used to defer stopping the SQL thread to give it a chance
1088 to finish up the current group of events.
1089 The timestamp is set and reset in @c sql_slave_killed().
1090 */
1092
1093 /* The original master commit timestamp in microseconds since epoch */
1095
1096 /*
1097 A container to hold on Intvar-, Rand-, Uservar- log-events in case
1098 the slave is configured with table filtering rules.
1099 The withhold events are executed when their parent Query destiny is
1100 determined for execution as well.
1101 */
1103
1104 /*
1105 State of the container: true stands for IRU events gathering,
1106 false does for execution, either deferred or direct.
1107 */
1109
1110 /*****************************************************************************
1111 WL#5569 MTS
1112
1113 legends:
1114 C - Coordinator;
1115 W - Worker;
1116 WQ - Worker Queue containing event assignments
1117 */
1118 // number's is determined by global replica_parallel_workers
1120
1121 // To map a database to a worker
1122 malloc_unordered_map<std::string,
1125 bool inited_hash_workers; // flag to check if mapping_db_to_worker is inited
1126
1127 mysql_mutex_t slave_worker_hash_lock; // for mapping_db_to_worker
1128 mysql_cond_t slave_worker_hash_cond; // for mapping_db_to_worker
1129
1130 /*
1131 For the purpose of reporting the worker status in performance schema table,
1132 we need to preserve the workers array after worker thread was killed. So, we
1133 copy this array into the below vector which is used for reporting
1134 until next init_workers(). Note that we only copy those attributes that
1135 would be useful in reporting worker status. We only use a few attributes in
1136 this object as of now but still save the whole object. The idea is
1137 to be future proof. We will extend performance schema tables in future
1138 and then we would use a good number of attributes from this object.
1139 */
1140
1141 std::vector<Slave_worker *> workers_copy_pfs;
1142
1143 /*
1144 This flag is turned ON when the workers array is initialized.
1145 Before destroying the workers array we check this flag to make sure
1146 we are not destroying an uninitialized array. For the purpose of reporting
1147 the worker status in performance schema table, we need to preserve the
1148 workers array after worker thread was killed. So, we copy this array into
1149 workers_copy_pfs array which is used for reporting until next
1150 init_workers().
1151 */
1153
1154 volatile ulong pending_jobs;
1157 mysql_mutex_t exit_count_lock; // mutex of worker exit count
1159 ulonglong mts_pending_jobs_size; // actual mem usage by WQ:s
1160 ulonglong mts_pending_jobs_size_max; // max of WQ:s size forcing C to wait
1161 bool mts_wq_oversize; // C raises flag to wait some memory's released
1163 *last_assigned_worker; // is set to a Worker at assigning a group
1164 /*
1165 master-binlog ordered queue of Slave_job_group descriptors of groups
1166 that are under processing. The queue size is @c checkpoint_group.
1167 */
1169 /*
1170 Container for references of involved partitions for the current event group
1171 */
1172 // CGAP dynarray holds id:s of partitions of the Current being executed Group
1174 // deferred array to hold partition-info-free events
1176
1177 bool curr_group_seen_gtid; // current group started with Gtid-event or not
1178 bool curr_group_seen_begin; // current group started with B-event or not
1179 bool curr_group_isolated; // current group requires execution in isolation
1180 bool mts_end_group_sets_max_dbs; // flag indicates if partitioning info is
1181 // discovered
1182 volatile ulong
1183 mts_wq_underrun_w_id; // Id of a Worker whose queue is getting empty
1184 /*
1185 Ongoing excessive overrun counter to correspond to number of events that
1186 are being scheduled while a WQ is close to be filled up.
1187 `Close' is defined as (100 - mts_worker_underrun_level) %.
1188 The counter is incremented each time a WQ get filled over that level
1189 and decremented when the level drops below.
1190 The counter therefore describes level of saturation that Workers
1191 are experiencing and is used as a parameter to compute a nap time for
1192 Coordinator in order to avoid reaching WQ limits.
1193 */
1194 volatile long mts_wq_excess_cnt;
1195 long mts_worker_underrun_level; // % of WQ size at which W is considered
1196 // hungry
1197 ulong mts_coordinator_basic_nap; // C sleeps to avoid WQs overrun
1198 ulong
1199 opt_replica_parallel_workers; // cache for ::opt_replica_parallel_workers
1200 ulong
1201 replica_parallel_workers; // the one slave session time number of workers
1202 ulong
1203 exit_counter; // Number of workers contributed to max updated group index
1205 ulong recovery_parallel_workers; // number of workers while recovering
1206 uint rli_checkpoint_seqno; // counter of groups executed after the most
1207 // recent CP
1208 uint checkpoint_group; // cache for ::opt_mta_checkpoint_group
1209 MY_BITMAP recovery_groups; // bitmap used during recovery
1211 ulong mts_recovery_group_cnt; // number of groups to execute at recovery
1212 ulong mts_recovery_index; // running index of recoverable groups
1214
1215 /*
1216 While distributing events based on their properties MTS
1217 Coordinator changes its mts group status.
1218 Transition normally flowws to follow `=>' arrows on the diagram:
1219
1220 +----------------------------+
1221 V |
1222 MTS_NOT_IN_GROUP => |
1223 {MTS_IN_GROUP => MTS_END_GROUP --+} while (!killed) => MTS_KILLED_GROUP
1224
1225 MTS_END_GROUP has `->' loop breaking link to MTS_NOT_IN_GROUP when
1226 Coordinator synchronizes with Workers by demanding them to
1227 complete their assignments.
1228 */
1229 enum {
1230 /*
1231 no new events were scheduled after last synchronization,
1232 includes Single-Threaded-Slave case.
1233 */
1235
1236 MTS_IN_GROUP, /* at least one not-terminal event scheduled to a Worker */
1237 MTS_END_GROUP, /* the last scheduled event is a terminal event */
1238 MTS_KILLED_GROUP /* Coordinator gave up to reach MTS_END_GROUP */
1240
1241 /*
1242 MTS statistics:
1243 */
1244 ulonglong mts_events_assigned; // number of events (statements) scheduled
1245 ulonglong mts_groups_assigned; // number of groups (transactions) scheduled
1246 volatile ulong
1247 mts_wq_overrun_cnt; // counter of all mts_wq_excess_cnt increments
1248 ulong wq_size_waits_cnt; // number of times C slept due to WQ:s oversize
1249 /*
1250 Counter of how many times Coordinator saw Workers are filled up
1251 "enough" with assignments. The enough definition depends on
1252 the scheduler type.
1253 */
1255 std::atomic<longlong>
1256 mts_total_wait_overlap; // Waiting time corresponding to above
1257 /*
1258 Stats to compute Coordinator waiting time for any Worker available,
1259 applies solely to the Commit-clock scheduler.
1260 */
1262 ulong mts_wq_overfill_cnt; // counter of C waited due to a WQ queue was full
1263 /*
1264 Statistics (todo: replace with WL5631) applies to either Coordinator and
1265 Worker. The exec time in the Coordinator case means scheduling. The read
1266 time in the Worker case means getting an event out of Worker queue
1267 */
1270 struct timespec ts_exec[2]; // per event pre- and post- exec timestamp
1271 struct timespec stats_begin; // applier's bootstrap time
1272
1274 /* end of MTS statistics */
1275
1276 /**
1277 Storage for holding newly computed values for the last executed
1278 event group coordinates while the current group of events is
1279 being committed, see @c pre_commit, post_commit.
1280 */
1285
1286 /* Returns the number of elements in workers array/vector. */
1287 inline size_t get_worker_count() {
1289 return workers.size();
1290 else
1291 return workers_copy_pfs.size();
1292 }
1293
1294 /*
1295 Returns a pointer to the worker instance at index n in workers
1296 array/vector.
1297 */
1300 if (n >= workers.size()) return nullptr;
1301
1302 return workers[n];
1303 } else if (workers_copy_pfs.size()) {
1304 if (n >= workers_copy_pfs.size()) return nullptr;
1305
1306 return workers_copy_pfs[n];
1307 } else
1308 return nullptr;
1309 }
1310
1311 /**
1312 The method implements updating a slave info table. It's
1313 specialized differently for STS and MTS.
1314 */
1315 virtual bool commit_positions();
1316
1317 /*Channel defined mts submode*/
1319 /* MTS submode */
1321
1322 /* most of allocation in the coordinator rli is there */
1323 void init_workers(ulong);
1324
1325 /* counterpart of the init */
1326 void deinit_workers();
1327
1328 /**
1329 returns true if there is any gap-group of events to execute
1330 at slave starting phase.
1331 */
1332 inline bool is_mts_recovery() const { return mts_recovery_group_cnt != 0; }
1333
1338 recovery_groups_inited = false;
1339 }
1340 }
1341
1342 /**
1343 returns true if events are to be executed in parallel
1344 */
1345 inline bool is_parallel_exec() const {
1346 bool ret = (replica_parallel_workers > 0) && !is_mts_recovery();
1347
1348 assert(!ret || !workers.empty());
1349
1350 return ret;
1351 }
1352
1353 /**
1354 returns true if Coordinator is scheduling events belonging to
1355 the same group and has not reached yet its terminal event.
1356 */
1357 inline bool is_mts_in_group() {
1359 }
1360
1361 /**
1362 Check if it is time to compute MTS checkpoint.
1363
1364 @retval true It is time to compute MTS checkpoint.
1365 @retval false It is not MTS or it is not time for computing checkpoint.
1366 */
1368 /**
1369 While a group is executed by a Worker the relay log can change.
1370 Coordinator notifies Workers about this event. Worker is supposed
1371 to commit to the recovery table with the new info.
1372 */
1374
1375 /**
1376 While a group is executed by a Worker the relay log can change.
1377 Coordinator notifies Workers about this event. Coordinator and Workers
1378 maintain a bitmap of executed group that is reset with a new checkpoint.
1379 */
1380 void reset_notified_checkpoint(ulong count, time_t new_ts,
1381 bool update_timestamp = false);
1382
1383 /**
1384 Called when gaps execution is ended so it is crash-safe
1385 to reset the last session Workers info.
1386 */
1387 bool mts_finalize_recovery();
1388 /*
1389 * End of MTS section ******************************************************/
1390
1391 /* The general cleanup that slave applier may need at the end of query. */
1392 inline void cleanup_after_query() {
1394 }
1395 /* The general cleanup that slave applier may need at the end of session. */
1397 if (deferred_events) delete deferred_events;
1398 }
1399
1400 /**
1401 Helper function to do after statement completion.
1402
1403 This function is called from an event to complete the group by
1404 either stepping the group position, if the "statement" is not
1405 inside a transaction; or increase the event position, if the
1406 "statement" is inside a transaction.
1407
1408 @param event_log_pos
1409 Master log position of the event. The position is recorded in the
1410 relay log info and used to produce information for <code>SHOW
1411 SLAVE STATUS</code>.
1412 */
1413 int stmt_done(my_off_t event_log_pos);
1414
1415 /**
1416 Set the value of a replication state flag.
1417
1418 @param flag Flag to set
1419 */
1421
1422 /**
1423 Get the value of a replication state flag.
1424
1425 @param flag Flag to get value of
1426
1427 @return @c true if the flag was set, @c false otherwise.
1428 */
1429 bool get_flag(enum_state_flag flag) { return m_flags & (1UL << flag); }
1430
1431 /**
1432 Clear the value of a replication state flag.
1433
1434 @param flag Flag to clear
1435 */
1437
1438 private:
1439 /**
1440 Auxiliary function used by is_in_group.
1441
1442 The execute thread is in the middle of a statement in the
1443 following cases:
1444 - User_var/Intvar/Rand events have been processed, but the
1445 corresponding Query_log_event has not been processed.
1446 - Table_map or Row events have been processed, and the last Row
1447 event did not have the STMT_END_F set.
1448
1449 @retval true Replication thread is inside a statement.
1450 @retval false Replication thread is not inside a statement.
1451 */
1452 bool is_in_stmt() const {
1453 bool ret = (m_flags & (1UL << IN_STMT));
1454 DBUG_PRINT("info", ("is_in_stmt()=%d", ret));
1455 return ret;
1456 }
1457 /**
1458 Auxiliary function used by is_in_group.
1459
1460 @retval true The execute thread is inside a statement or a
1461 transaction, i.e., either a BEGIN has been executed or we are in
1462 the middle of a statement.
1463 @retval false The execute thread thread is not inside a statement
1464 or a transaction.
1465 */
1466 bool is_in_trx_or_stmt() const {
1467 bool ret = is_in_stmt() || (info_thd->variables.option_bits & OPTION_BEGIN);
1468 DBUG_PRINT("info", ("is_in_trx_or_stmt()=%d", ret));
1469 return ret;
1470 }
1471
1472 public:
1473 /**
1474 A group is defined as the entire range of events that constitute
1475 a transaction or auto-committed statement. It has one of the
1476 following forms:
1477
1478 (Gtid)? Query(BEGIN) ... (Query(COMMIT) | Query(ROLLBACK) | Xid)
1479 (Gtid)? (Rand | User_var | Int_var)* Query(DDL)
1480
1481 Thus, to check if the execute thread is in a group, there are
1482 two cases:
1483
1484 - If the master generates Gtid events (5.7.5 or later, or 5.6 or
1485 later with GTID_MODE=ON), then is_in_group is the same as
1486 info_thd->owned_gtid.sidno != 0, since owned_gtid.sidno is set
1487 to non-zero by the Gtid_log_event and cleared to zero at commit
1488 or rollback.
1489
1490 - If the master does not generate Gtid events (i.e., master is
1491 pre-5.6, or pre-5.7.5 with GTID_MODE=OFF), then is_in_group is
1492 the same as is_in_trx_or_stmt().
1493
1494 @retval true Replication thread is inside a group.
1495 @retval false Replication thread is not inside a group.
1496 */
1497 bool is_in_group() const {
1498 bool ret = is_in_trx_or_stmt() || info_thd->owned_gtid.sidno != 0;
1499 DBUG_PRINT("info", ("is_in_group()=%d", ret));
1500 return ret;
1501 }
1502
1504
1505 /**
1506 Initialize the relay log info. This function does a set of operations
1507 on the rli object like initializing variables, loading information from
1508 repository, setting up name for relay log files and index, MTS recovery
1509 (if necessary), calculating the received GTID set for the channel and
1510 storing the updated rli object configuration into the repository.
1511
1512 When this function is called in a change master process and the change
1513 master procedure will purge all the relay log files later, there is no
1514 reason to try to calculate the received GTID set of the channel based on
1515 existing relay log files (they will be purged). Allowing reads to existing
1516 relay log files at this point may lead to put the server in a state where
1517 it will be no possible to configure it if it was reset when encryption of
1518 replication log files was ON and the keyring plugin is not available
1519 anymore.
1520
1521 @param skip_received_gtid_set_recovery When true, skips the received GTID
1522 set recovery.
1523
1524 @retval 0 Success.
1525 @retval 1 Error.
1526 */
1527 int rli_init_info(bool skip_received_gtid_set_recovery = false);
1528 void end_info();
1529
1530 /** No flush options given to relay log flush */
1531 static constexpr int RLI_FLUSH_NO_OPTION{0};
1532 /** Ignore server sync options and flush */
1533 static constexpr int RLI_FLUSH_IGNORE_SYNC_OPT{1 << 0};
1534 /** Flush disresgarding the value of GTID_ONLY */
1535 static constexpr int RLI_FLUSH_IGNORE_GTID_ONLY{1 << 1};
1536
1537 int flush_info(const int flush_flags);
1538 /**
1539 Clears from `this` Relay_log_info object all attribute values that are
1540 not to be kept.
1541
1542 @returns true if there were a problem with clearing the data and false
1543 otherwise.
1544 */
1545 bool clear_info();
1546 /**
1547 Checks if the underlying `Rpl_info` handler holds information for the fields
1548 to be kept between slave resets, while the other fields were cleared.
1549
1550 @param previous_result the result return from invoking the `check_info`
1551 method on `this` object.
1552
1553 @returns function success state represented by the `enum_return_check`
1554 enumeration.
1555 */
1557 const enum_return_check &previous_result) const;
1558 int flush_current_log();
1560
1563 }
1566 }
1567
1568 inline const char *get_group_master_log_name() const {
1569 return group_master_log_name;
1570 }
1571 inline const char *get_group_master_log_name_info() const {
1572 if (m_is_applier_source_position_info_invalid) return "INVALID";
1574 }
1576 return group_master_log_pos;
1577 }
1580 return get_group_master_log_pos();
1581 }
1582 inline void set_group_master_log_name(const char *log_file_name) {
1584 sizeof(group_master_log_name) - 1);
1585 }
1587 group_master_log_pos = log_pos;
1588 // Whenever the position is set, it means it is no longer invalid
1590 }
1591
1592 inline const char *get_group_relay_log_name() { return group_relay_log_name; }
1594 inline void set_group_relay_log_name(const char *log_file_name) {
1596 sizeof(group_relay_log_name) - 1);
1597 }
1598 inline void set_group_relay_log_name(const char *log_file_name, size_t len) {
1600 }
1601 inline void set_group_relay_log_pos(ulonglong log_pos) {
1602 group_relay_log_pos = log_pos;
1603 }
1604
1605 inline const char *get_event_relay_log_name() { return event_relay_log_name; }
1607 inline void set_event_relay_log_name(const char *log_file_name) {
1609 sizeof(event_relay_log_name) - 1);
1612 }
1613
1616 event_relay_log_number = number;
1617 }
1618
1619 /**
1620 Given the extension number of the relay log, gets the full
1621 relay log path. Currently used in Slave_worker::retry_transaction()
1622
1623 @param [in] number extension number of relay log
1624 @param[in, out] name The full path of the relay log (per-channel)
1625 to be read by the slave worker.
1626 */
1627 void relay_log_number_to_name(uint number, char name[FN_REFLEN + 1]);
1628 uint relay_log_name_to_number(const char *name);
1629
1632
1633 inline void set_event_relay_log_pos(ulonglong log_pos) {
1634 event_relay_log_pos = log_pos;
1635 }
1636 inline const char *get_rpl_log_name() const {
1638 ? "INVALID"
1640 }
1641
1642 static size_t get_number_info_rli_fields();
1643
1644 /**
1645 Sets bits for columns that are allowed to be `NULL`.
1646
1647 @param nullable_fields the bitmap to hold the nullable fields.
1648 */
1649 static void set_nullable_fields(MY_BITMAP *nullable_fields);
1650
1651 /**
1652 Indicate that a delay starts.
1653
1654 This does not actually sleep; it only sets the state of this
1655 Relay_log_info object to delaying so that the correct state can be
1656 reported by SHOW SLAVE STATUS and SHOW PROCESSLIST.
1657
1658 Requires rli->data_lock.
1659
1660 @param delay_end The time when the delay shall end.
1661 */
1662 void start_sql_delay(time_t delay_end);
1663
1664 /* Note that this is cast to uint32 in show_slave_status(). */
1665 time_t get_sql_delay() { return sql_delay; }
1666 void set_sql_delay(time_t _sql_delay) { sql_delay = _sql_delay; }
1668
1669 Relay_log_info(bool is_slave_recovery,
1670#ifdef HAVE_PSI_INTERFACE
1671 PSI_mutex_key *param_key_info_run_lock,
1672 PSI_mutex_key *param_key_info_data_lock,
1673 PSI_mutex_key *param_key_info_sleep_lock,
1674 PSI_mutex_key *param_key_info_thd_lock,
1675 PSI_mutex_key *param_key_info_data_cond,
1676 PSI_mutex_key *param_key_info_start_cond,
1677 PSI_mutex_key *param_key_info_stop_cond,
1678 PSI_mutex_key *param_key_info_sleep_cond,
1679#endif
1680 uint param_id, const char *param_channel, bool is_rli_fake);
1681 ~Relay_log_info() override;
1682
1683 /*
1684 Determines if a warning message on unsafe execution was
1685 already printed out to avoid clutering the error log
1686 with several warning messages.
1687 */
1689
1690 /*
1691 'sql_thread_kill_accepted is set to true when killed status is recognized.
1692 */
1694
1696
1698 if (row_stmt_start_timestamp == 0) row_stmt_start_timestamp = time(nullptr);
1699
1701 }
1702
1704
1706
1709 }
1710
1712
1713 public:
1714 /**
1715 Delete the existing event and set a new one. This class is
1716 responsible for freeing the event, the caller should not do that.
1717
1718 @return 1 if an error was encountered, 0 otherwise.
1719 */
1721
1722 /**
1723 Return the current Format_description_log_event.
1724 */
1726 return rli_description_event;
1727 }
1728
1729 /**
1730 adaptation for the slave applier to specific master versions.
1731 */
1733 ulong adapt_to_master_version_updown(ulong master_version,
1734 ulong current_version);
1735 uchar slave_version_split[3]; // bytes of the slave server version
1736 /*
1737 relay log info repository should be updated on relay log
1738 rotate. But when the transaction is split across two relay logs,
1739 update the repository will cause unexpected results and should
1740 be postponed till the 'commit' of the transaction is executed.
1741
1742 A flag that set to 'true' when this type of 'forced flush'(at the
1743 time of rotate relay log) is postponed due to transaction split
1744 across the relay logs.
1745 */
1747
1749
1751 commit_order_mngr = mngr;
1752 }
1753
1754 /*
1755 Following set function is required to initialize the 'until_option' during
1756 MTS relay log recovery process.
1757
1758 Ideally initialization of 'until_option' is done through
1759 rli::init_until_option. This init_until_option requires the main server
1760 thread object and it makes use of the thd->lex->mi object to initialize the
1761 'until_option'.
1762
1763 But MTS relay log recovery process happens before the main server comes
1764 up at this time the THD object will not be available. Hence the following
1765 set function does the initialization of 'until_option'.
1766 */
1769 until_option = option;
1771 }
1772
1775 if (until_option) {
1776 delete until_option;
1777 until_option = nullptr;
1778 }
1780 }
1781
1782 bool set_info_search_keys(Rpl_info_handler *to) override;
1783
1784 /**
1785 Get coordinator's RLI. Especially used get the rli from
1786 a slave thread, like this: thd->rli_slave->get_c_rli();
1787 thd could be a SQL thread or a worker thread
1788 */
1789 virtual Relay_log_info *get_c_rli() { return this; }
1790
1791 const char *get_for_channel_str(bool upper_case = false) const override;
1792
1793 /**
1794 Set replication filter for the channel.
1795 */
1796 inline void set_filter(Rpl_filter *channel_filter) {
1797 rpl_filter = channel_filter;
1798 }
1799
1800 protected:
1802
1803 private:
1804 /*
1805 Commit order manager to order commits made by its workers. In context of
1806 Multi Source Replication each worker will be ordered by the corresponding
1807 corrdinator's order manager.
1808 */
1810
1811 /**
1812 Delay slave SQL thread by this amount of seconds.
1813 The delay is applied per transaction and based on the immediate master's
1814 commit time. Exceptionally, if a server in the replication chain does not
1815 support the commit timestamps in Gtid_log_event, the delay is applied per
1816 event and is based on the event timestamp.
1817 This is set with CHANGE MASTER TO MASTER_DELAY=X.
1818
1819 Guarded by data_lock. Initialized by the client thread executing
1820 START SLAVE. Written by client threads executing CHANGE MASTER TO
1821 MASTER_DELAY=X. Read by SQL thread and by client threads
1822 executing SHOW SLAVE STATUS. Note: must not be written while the
1823 slave SQL thread is running, since the SQL thread reads it without
1824 a lock when executing flush_info().
1825 */
1827
1828 /**
1829 During a delay, specifies the point in time when the delay ends.
1830
1831 This is used for the SQL_Remaining_Delay column in SHOW SLAVE STATUS.
1832
1833 Guarded by data_lock. Written by the sql thread. Read by client
1834 threads executing SHOW SLAVE STATUS.
1835 */
1837
1839
1840 /*
1841 Before the MASTER_DELAY parameter was added (WL#344), relay_log.info
1842 had 4 lines. Now it has 5 lines.
1843 */
1845
1846 /*
1847 Before the WL#5599, relay_log.info had 5 lines. Now it has 6 lines.
1848 */
1850
1851 /*
1852 Before the Id was added (BUG#2334346), relay_log.info
1853 had 6 lines. Now it has 7 lines.
1854 */
1856
1857 /*
1858 Add a channel in the slave relay log info
1859 */
1861
1862 /*
1863 Represents line number in relay_log.info to save PRIVILEGE_CHECKS_USERNAME.
1864 It is username part of PRIVILEGES_CHECKS_USER column in
1865 performance_schema.replication_applier_configuration.
1866 */
1868
1869 /*
1870 Maximum length of PRIVILEGE_CHECKS_USERNAME.
1871 */
1872 static const int PRIV_CHECKS_USERNAME_LENGTH = 32;
1873
1874 /*
1875 Represents line number in relay_log.info to save PRIVILEGE_CHECKS_HOSTNAME.
1876 It is hostname part of PRIVILEGES_CHECKS_USER column in
1877 performance_schema.replication_applier_configuration.
1878 */
1880
1881 /*
1882 Maximum length of PRIVILEGE_CHECKS_USERNAME.
1883 */
1884 static const int PRIV_CHECKS_HOSTNAME_LENGTH = 255;
1885
1886 /*
1887 Represents line number in relay_log.info to save REQUIRE_ROW_FORMAT
1888 */
1890
1891 /*
1892 Represents line number in relay_log.info to save
1893 REQUIRE_TABLE_PRIMARY_KEY_CHECK
1894 */
1895 static const int
1897
1898 /*
1899 Represent line number in relay_log.info to save
1900 ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_TYPE.
1901 */
1902 static const int
1904 13;
1905
1906 /*
1907 Represent line number in relay_log.info to save
1908 ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_VALUE.
1909 */
1910 static const int
1912 14;
1913 /*
1914 Total lines in relay_log.info.
1915 This has to be updated every time a member is added or removed.
1916 */
1919
1920 bool read_info(Rpl_info_handler *from) override;
1921 bool write_info(Rpl_info_handler *to) override;
1922
1925
1926 /*
1927 Runtime state for printing a note when slave is taking
1928 too long while processing a row event.
1929 */
1932
1933 /**
1934 sets the suffix required for relay log names in multisource
1935 replication. When --relay-log option is not provided, the
1936 names of the relay log files are relaylog.0000x or
1937 relaylog-CHANNEL.00000x in the case of MSR. However, if
1938 that option is provided, then the names of the relay log
1939 files are <relay-log-option>.0000x or
1940 <relay-log-option>-CHANNEL.00000x in the case of MSR.
1941
1942 The function adds a channel suffix (according to the channel to
1943 file name conventions and conversions) to the relay log file.
1944
1945 @todo: truncate the log file if length exceeds.
1946
1947 @param[in, out] buff buffer to store the complete relay log file name
1948 @param[in] buff_size size of buffer buff
1949 @param[in] base_name the base name of the relay log file
1950 */
1951 const char *add_channel_to_relay_log_name(char *buff, uint buff_size,
1952 const char *base_name);
1953
1954 /*
1955 Applier thread InnoDB priority.
1956 When two transactions conflict inside InnoDB, the one with
1957 greater priority wins.
1958 Priority must be set before applier thread start so that all
1959 executed transactions have the same priority.
1960 */
1962
1963 /**
1964 If the SQL thread should or not ignore the set limit for
1965 write set collection
1966 */
1968
1969 /**
1970 Even if a component says all transactions require write sets,
1971 this variable says the SQL thread transactions can drop them
1972 */
1974
1975 /* The object stores and handles START SLAVE UNTIL option */
1977
1978 public:
1979 /*
1980 The boolean is set to true when the binlog (rli_fake) or slave
1981 (rli_slave) applier thread detaches any engine ha_data
1982 it has dealt with at time of XA START processing.
1983 The boolean is reset to false at the end of XA PREPARE,
1984 XA COMMIT ONE PHASE for the binlog applier, and
1985 at internal rollback of the slave applier at the same time with
1986 the engine ha_data re-attachment.
1987 */
1989 /**
1990 Reference to being applied event. The member is set at event reading
1991 and gets reset at the end of the event lifetime.
1992 See more in @c RLI_current_event_raii that provides the main
1993 interface to the member.
1994 */
1996
1997 /**
1998 Raised when slave applies and writes to its binary log statement
1999 which is not atomic DDL and has no XID assigned. Checked at commit
2000 time to decide whether it is safe to update slave info table
2001 within the same transaction as the write to binary log or this
2002 should be deferred. The deferred scenario applies for not XIDed events
2003 in which case such update might be lost on recovery.
2004 */
2006
2008
2010
2011 void set_ignore_write_set_memory_limit(bool ignore_limit) {
2012 m_ignore_write_set_memory_limit = ignore_limit;
2013 }
2014
2017 }
2018
2019 void set_allow_drop_write_set(bool does_not_require_ws) {
2020 m_allow_drop_write_set = does_not_require_ws;
2021 }
2022
2024
2025 const char *get_until_log_name();
2028 return until_option != nullptr &&
2030 }
2032 return until_option != nullptr &&
2034 }
2036 return until_option != nullptr &&
2038 }
2039 /**
2040 Initialize until option object when starting slave.
2041
2042 @param[in] thd The thread object of current session.
2043 @param[in] master_param the parameters of START SLAVE.
2044
2045 @return int
2046 @retval 0 Succeeds to initialize until option object.
2047 @retval <> 0 A defined error number is return if any error happens.
2048 */
2049 int init_until_option(THD *thd, const LEX_MASTER_INFO *master_param);
2050
2051 /**
2052 Detaches the engine ha_data from THD. The fact
2053 is memorized in @c m_is_engine_ha_data_detached flag.
2054
2055 @param thd a reference to THD
2056 */
2057
2058 void detach_engine_ha_data(THD *thd);
2059
2060 /**
2061 Reattaches the engine ha_data to THD. The fact
2062 is memorized in @c m_is_engine_ha_data_detached flag.
2063
2064 @param thd a reference to THD
2065 */
2066
2067 void reattach_engine_ha_data(THD *thd);
2068
2069 /**
2070 Checks whether engine ha data is detached from THD
2071 @retval true if the data is detached
2072 @retval false if the data is not detached
2073 */
2075
2076 /**
2077 Execute actions at replicated atomic DLL post rollback time.
2078 This include marking the current atomic DDL query-log-event
2079 as having processed.
2080 This measure is necessary to avoid slave info table update execution
2081 when @c pre_commit() hook is called as part of DDL's eventual
2082 implicit commit.
2083 */
2085 static_cast<Query_log_event *>(current_event)->has_ddl_committed = true;
2086 }
2087
2088 /**
2089 The method implements a pre-commit hook to add up a new statement
2090 typically to a DDL transaction to update the slave info table.
2091 Note, in the non-transactional repository case the slave info
2092 is updated after successful commit of the main transaction.
2093
2094 @return false as success, otherwise true
2095 */
2096 bool pre_commit() {
2097 bool rc = false;
2098
2099 if (is_transactional()) {
2100 static_cast<Query_log_event *>(current_event)->has_ddl_committed = true;
2101 rc = commit_positions();
2102 }
2103 return rc;
2104 }
2105 /**
2106 Cleanup of any side effect that pre_commit() inflicts, including
2107 restore of the last executed group coordinates in case the current group
2108 has been destined to rollback, and signaling to possible waiters
2109 in the positive case.
2110
2111 @param on_rollback when true the method carries out rollback action
2112 */
2113 virtual void post_commit(bool on_rollback);
2114};
2115
2116/**
2117 Negation operator for `enum_priv_checks_status`, to facilitate validation
2118 against `SUCCESS`. To test for error status, use the `!!` idiom.
2119
2120 @param status the status code to check against `SUCCESS`
2121
2122 @return true if the status is `SUCCESS` and false otherwise.
2123 */
2125
2126/**
2127 Negation operator for `enum_require_row_status`, to facilitate validation
2128 against `SUCCESS`. To test for error status, use the `!!` idiom.
2129
2130 @param status the status code to check against `SUCCESS`
2131
2132 @return true if the status is `SUCCESS` and false otherwise.
2133 */
2135
2137
2138/**
2139 @param thd a reference to THD
2140 @return true if thd belongs to a Worker thread and false otherwise.
2141*/
2142inline bool is_mts_worker(const THD *thd) {
2144}
2145
2146/**
2147 Auxiliary function to check if we have a db partitioned MTS
2148 */
2150
2151/**
2152 Checks whether the supplied event encodes a (2pc-aware) DDL
2153 that has been already committed.
2154
2155 @param ev A reference to Query-log-event
2156 @return true when the event is already committed transactional DDL
2157*/
2158inline bool is_committed_ddl(Log_event *ev) {
2159 return ev->get_type_code() == binary_log::QUERY_EVENT &&
2160 /* has been already committed */
2161 static_cast<Query_log_event *>(ev)->has_ddl_committed;
2162}
2163
2164/**
2165 Checks whether the transaction identified by the argument
2166 is executed by a slave applier thread is an atomic DDL
2167 not yet committed (see @c Query_log_event::has_ddl_committed).
2168 THD::is_operating_substatement_implicitly filters out intermediate
2169 commits done by non-atomic DDLs.
2170 The error-tagged atomic statements are regarded as non-atomic
2171 therefore this predicate returns negative in such case.
2172
2173 Note that call to is_atomic_ddl() returns "approximate" outcome in
2174 this case as it misses information about type of tables used by the DDL.
2175
2176 This can be a problem for binlogging slave, as updates to slave info
2177 which happen in the same transaction as write of binary log event
2178 without XID might be lost on recovery. To avoid this problem
2179 RLI::ddl_not_atomic flag is employed which is set to true when
2180 non-atomic DDL without XID is written to the binary log.
2181
2182 "Approximate" outcome is always fine for non-binlogging slave as in
2183 this case commit happens using one-phase routine for which recovery
2184 is always correct.
2185
2186 @param thd a pointer to THD describing the transaction context
2187 @return true when a slave applier thread is set to commit being processed
2188 DDL query-log-event, otherwise returns false.
2189*/
2191 assert(thd);
2192
2193 Relay_log_info *rli = thd->rli_slave;
2194
2195 /* Early return is about an error in the SQL thread initialization */
2196 if (!rli) return false;
2197
2198 return ((thd->system_thread == SYSTEM_THREAD_SLAVE_SQL ||
2200 rli->current_event)
2201 ? (rli->is_transactional() &&
2202 /* has not yet committed */
2203 (rli->current_event->get_type_code() ==
2205 !static_cast<Query_log_event *>(rli->current_event)
2206 ->has_ddl_committed) &&
2207 /* unless slave binlogger identified non-atomic */
2208 !rli->ddl_not_atomic &&
2209 /* slave info is not updated when a part of multi-DROP-TABLE
2210 commits */
2212 (is_atomic_ddl(thd, true) &&
2214 /* error-tagged atomic DDL do not update yet slave info */
2215 static_cast<Query_log_event *>(rli->current_event)
2216 ->error_code == 0)
2217 : false;
2218}
2219
2220/**
2221 RAII class to control the slave applier execution context binding
2222 with a being handled event. The main object of control is Query-log-event
2223 containing DDL statement.
2224 The member RLI::current_event is set to refer to an event once it is
2225 read, e.g by next_event() and is reset to NULL at exiting a
2226 read-exec loop. Once the event is destroyed RLI::current_event must be reset
2227 or guaranteed not be accessed anymore.
2228 In the MTS execution the worker is reliably associated with an event
2229 only with the latter is not deferred. This includes Query-log-event.
2230*/
2233
2234 public:
2236 : m_rli(rli_arg) {
2237 m_rli->current_event = ev;
2238 }
2241};
2242
2243/**
2244 @class MDL_lock_guard
2245
2246 Utility class to allow RAII pattern with `MDL_request` and `MDL_context`
2247 classes.
2248 */
2250 public:
2251 /**
2252 Constructor that initializes the object and the target `THD` object but
2253 doesn't try to acquire any lock.
2254
2255 @param target THD object, source for the `MDL_context` to use.
2256 */
2257 MDL_lock_guard(THD *target);
2258 /**
2259 Constructor that initializes the object and the target `THD` object and tries
2260 to acquire the lock identified by `namespace_arg` with MDL type identified by
2261 `mdl_type_arg`.
2262
2263 If the `blocking` parameter is true, it will instantly try to acquire the
2264 lock and block. If the `blocking` parameter is false, it will first test if
2265 the lock is already acquired and only try to lock if no conflicting lock is
2266 already acquired.
2267
2268 @param target THD object, source for the `MDL_context` to use.
2269 @param namespace_arg MDL key namespace to acquire the lock from.
2270 @param mdl_type_arg MDL acquisition type
2271 @param blocking whether or not the execution should block if the lock is
2272 already acquired.
2273 */
2274 MDL_lock_guard(THD *target, MDL_key::enum_mdl_namespace namespace_arg,
2275 enum_mdl_type mdl_type_arg, bool blocking = false);
2276 /**
2277 Destructor that unlocks all acquired locks.
2278 */
2279 virtual ~MDL_lock_guard();
2280
2281 /**
2282 Uses the target `THD` object MDL context to acquire the lock identified by
2283 `namespace_arg` with MDL type identified by `mdl_type_arg`.
2284
2285 If the `blocking` parameter is true, it will instantly try to acquire the
2286 lock and block. If the `blocking` parameter is false, it will first test if
2287 the lock is already acquired and only try to lock if no conflicting lock is
2288 already acquired.
2289
2290 The lock is determined to have been acquired if the `THD` object MDL context
2291 hasn't already a lock and the lock is acquired. In other words, if the MDL
2292 context already has acquired the lock, the method will return failure.
2293
2294 @param namespace_arg MDL key namespace to acquire the lock from.
2295 @param mdl_type_arg MDL acquisition type
2296 @param blocking whether or not the execution should block if the lock is
2297 already acquired.
2298
2299 @return false if the lock has been acquired by this method invocation and
2300 true if not.
2301 */
2302 bool lock(MDL_key::enum_mdl_namespace namespace_arg,
2303 enum_mdl_type mdl_type_arg, bool blocking = false);
2304 /**
2305 Returns whether or not the lock as been acquired within this object
2306 life-cycle.
2307
2308 @return true if the lock has been acquired within this object life-cycle.
2309 */
2310 bool is_locked();
2311
2312 private:
2313 /** The `THD` object holding the MDL context used for acquiring/releasing. */
2315 /** The MDL request holding the MDL ticket issued upon acquisition */
2317};
2318
2319/**
2320 @class Applier_security_context_guard
2321
2322 Utility class to allow RAII pattern with `Security_context` class.
2323
2324 At initiliazation, if the `THD` main security context isn't already the
2325 appropriate one, it copies the `Relay_log_info::info_thd::security_context`
2326 and replaces it with the one initialized with the `PRIVILEGE_CHECK_USER` user.
2327 At deinitialization, it copies the backed up security context.
2328
2329 It also deals with the case where no privilege checks are required, meaning,
2330 `PRIVILEGE_CHECKS_USER` is `NULL`.
2331
2332 Usage examples:
2333
2334 (1)
2335 @code
2336 Applier_security_context_guard security_context{rli, thd};
2337 if (!security_context.has_access({SUPER_ACL})) {
2338 return ER_NO_ACCESS;
2339 }
2340 @endcode
2341
2342 (4)
2343 @code
2344 Applier_security_context_guard security_context{rli, thd};
2345 if (!security_context.has_access(
2346 {{CREATE_ACL | INSERT_ACL | UPDATE_ACL, table},
2347 {SELECT_ACL, table}})) {
2348 return ER_NO_ACCESS;
2349 }
2350 @endcode
2351 */
2352
2354 public:
2355 /**
2356 If needed, backs up the current `thd` security context and replaces it with
2357 a security context for `PRIVILEGE_CHECKS_USER` user.
2358
2359 @param rli the `Relay_log_info` object that holds the
2360 `PRIVILEGE_CHECKS_USER` info.
2361 @param thd the `THD` for which initialize the security context.
2362 */
2363 Applier_security_context_guard(Relay_log_info const *rli, THD const *thd);
2364 /**
2365 Destructor that restores the backed up security context, if needed.
2366 */
2368
2369 // --> Deleted constructors and methods to remove default move/copy semantics
2371 delete;
2374 const Applier_security_context_guard &) = delete;
2376 delete;
2377 // <--
2378
2379 /**
2380 Returns whether or not privilege checks may be skipped within the current
2381 context.
2382
2383 @return true if privilege checks may be skipped and false otherwise.
2384 */
2385 bool skip_priv_checks() const;
2386 /**
2387 Checks if the `PRIVILEGE_CHECKS_USER` user has access to the privilieges
2388 passed on by `extra_privileges` parameter as well as to the privileges
2389 passed on at initialization time.
2390
2391 This particular method checks those privileges against a given table and
2392 against that table's columns - the ones that are used or changed in the
2393 event.
2394
2395 @param extra_privileges set of privileges to check, additionally to those
2396 passed on at initialization. It's a list of
2397 (privilege, TABLE*, Rows_log_event*) tuples.
2398
2399 @return true if the privileges are included in the security context and
2400 false, otherwise.
2401 */
2402 bool has_access(
2403 std::vector<std::tuple<ulong, TABLE const *, Rows_log_event *>>
2404 &extra_privileges) const;
2405 /**
2406 Checks if the `PRIVILEGE_CHECKS_USER` user has access to the privilieges
2407 passed on by `extra_privileges` parameter as well as to the privileges
2408 passed on at initialization time.
2409
2410 @param extra_privileges set of privileges to check, additionally to those
2411 passed on at initialization. It's a list of
2412 privileges to be checked against any database.
2413
2414 @return true if the privileges are included in the security context and
2415 false, otherwise.
2416 */
2417 bool has_access(
2418 std::initializer_list<std::string_view> extra_privileges) const;
2419
2420 /**
2421 Checks if the `PRIVILEGE_CHECKS_USER` user has access to the privilieges
2422 passed on by `extra_privileges` parameter as well as to the privileges
2423 passed on at initialization time.
2424
2425 @param extra_privileges set of privileges to check, additionally to those
2426 passed on at initialization. It's a list of
2427 privileges to be checked against any database.
2428
2429 @return true if the privileges are included in the security context and
2430 false, otherwise.
2431 */
2432 bool has_access(std::initializer_list<ulong> extra_privileges) const;
2433
2434 /**
2435 Returns the username for the user for which the security context was
2436 initialized.
2437
2438 If `PRIVILEGE_CHECKS_USER` was configured for the target `Relay_log_info`
2439 object, that one is returned.
2440
2441 Otherwise, the username associated with the `Security_context` initialized
2442 for `Relay_log_info::info_thd` will be returned.
2443
2444 @return an `std::string` holding the username for the active security
2445 context.
2446 */
2447 std::string get_username() const;
2448 /**
2449 Returns the hostname for the user for which the security context was
2450 initialized.
2451
2452 If `PRIVILEGE_CHECKS_USER` was configured for the target `Relay_log_info`
2453 object, that one is returned.
2454
2455 Otherwise, the hostname associated with the `Security_context` initialized
2456 for `Relay_log_info::info_thd` will be returned.
2457
2458 @return an `std::string` holding the hostname for the active security
2459 context.
2460 */
2461 std::string get_hostname() const;
2462
2463 private:
2464 /**
2465 The `Relay_log_info` object holding the info required to initialize the
2466 context.
2467 */
2469 /**
2470 The `THD` object for which the security context will be initialized.
2471 */
2472 THD const *m_thd;
2473 /** Applier security context based on `PRIVILEGE_CHECK_USER` user */
2475 /** Currently in use security context */
2477 /** Backed up security context */
2479 /** Flag that states if privilege check should be skipped */
2481 /** Flag that states if there is a logged user */
2483
2485 std::vector<std::string> &columns) const;
2486};
2487
2488#endif /* RPL_RLI_H */
Contains the classes representing events occurring in the replication stream.
Utility class to allow RAII pattern with Security_context class.
Definition: rpl_rli.h:2353
Applier_security_context_guard(Applier_security_context_guard &&)=delete
void extract_columns_to_check(TABLE const *table, Rows_log_event *event, std::vector< std::string > &columns) const
Definition: rpl_rli.cc:3499
virtual ~Applier_security_context_guard()
Destructor that restores the backed up security context, if needed.
Definition: rpl_rli.cc:3417
Applier_security_context_guard(Relay_log_info const *rli, THD const *thd)
If needed, backs up the current thd security context and replaces it with a security context for PRIV...
Definition: rpl_rli.cc:3366
bool skip_priv_checks() const
Returns whether or not privilege checks may be skipped within the current context.
Definition: rpl_rli.cc:3425
Security_context m_applier_security_ctx
Applier security context based on PRIVILEGE_CHECK_USER user.
Definition: rpl_rli.h:2474
bool m_privilege_checks_none
Flag that states if privilege check should be skipped.
Definition: rpl_rli.h:2480
Applier_security_context_guard & operator=(const Applier_security_context_guard &)=delete
std::string get_username() const
Returns the username for the user for which the security context was initialized.
Definition: rpl_rli.cc:3487
THD const * m_thd
The THD object for which the security context will be initialized.
Definition: rpl_rli.h:2472
Security_context * m_previous
Backed up security context.
Definition: rpl_rli.h:2478
Security_context * m_current
Currently in use security context.
Definition: rpl_rli.h:2476
bool m_logged_in_acl_user
Flag that states if there is a logged user.
Definition: rpl_rli.h:2482
std::string get_hostname() const
Returns the hostname for the user for which the security context was initialized.
Definition: rpl_rli.cc:3493
Applier_security_context_guard & operator=(Applier_security_context_guard &&)=delete
bool has_access(std::vector< std::tuple< ulong, TABLE const *, Rows_log_event * > > &extra_privileges) const
Checks if the PRIVILEGE_CHECKS_USER user has access to the privilieges passed on by extra_privileges ...
Definition: rpl_rli.cc:3453
Relay_log_info const * m_target
The Relay_log_info object holding the info required to initialize the context.
Definition: rpl_rli.h:2468
Applier_security_context_guard(const Applier_security_context_guard &)=delete
This class is used to store the type and value for Assign_gtids_to_anonymous_transactions parameter o...
Definition: rpl_rli.h:91
bool set_info(enum_type assign_gtids_to_anonymous_transactions_type, const char *assign_gtids_to_anonymous_transactions_value)
Definition: rpl_rli.cc:3297
rpl_sidno m_sidno
Definition: rpl_rli.h:128
enum_type get_type() const
Definition: rpl_rli.cc:3293
enum_type m_type
This stores the type of Assign_gtids_to_anonymous_transactions info.
Definition: rpl_rli.h:124
Assign_gtids_to_anonymous_transactions_info()
The default constructor initializes parameters to their default value.
Definition: rpl_rli.h:108
std::string m_value
Stores the UUID in case the m_type is not OFF.
Definition: rpl_rli.h:126
enum_type
This accepted value of the type of the Assign_gtids_to_anonymous_transactions info OFF : Anonymous gt...
Definition: rpl_rli.h:104
rpl_sidno get_sidno() const
Definition: rpl_rli.h:112
std::string get_value() const
Definition: rpl_rli.cc:3288
This has the functionality of mysql_rwlock_t, with two differences:
Definition: rpl_gtid.h:308
void assert_some_lock() const
Assert that some thread holds either the read or the write lock.
Definition: rpl_gtid.h:545
On a replica and only on a replica, this class is responsible for committing the applied transactions...
Definition: rpl_replica_commit_order_manager.h:196
Definition: rpl_utility.h:523
void rewind()
Definition: rpl_utility.cc:1299
For binlog version 4.
Definition: log_event.h:1501
This is a subclass if Gtid_event and Log_event.
Definition: log_event.h:3734
rpl_sidno get_sidno(bool need_lock)
Return the SIDNO relative to the global sid_map for this GTID.
Definition: log_event.cc:13382
enum_gtid_type get_type() const
Return the gtid type for this Gtid_log_event: this can be either ANONYMOUS_GTID, AUTOMATIC_GTID,...
Definition: log_event.h:3839
rpl_gno get_gno() const
Return the GNO for this GTID.
Definition: log_event.h:3875
Stores information to monitor a transaction during the different replication stages.
Definition: rpl_gtid.h:1310
void clear()
Clear all monitoring information.
Definition: rpl_gtid_misc.cc:419
void finish()
Sets the final information, copy processing info to last_processed and clears processing info.
Definition: rpl_gtid_misc.cc:486
void start(Gtid gtid_arg, ulonglong original_ts_arg, ulonglong immediate_ts_arg, bool skipped_arg=false)
Sets the initial monitoring information.
Definition: rpl_gtid_misc.cc:446
bool is_processing_trx_set()
Returns true if the processing_trx is set, false otherwise.
Definition: rpl_gtid_misc.cc:516
void store_transient_error(uint transient_errno_arg, const char *transient_err_message_arg, ulong trans_retries_arg)
Stores the information about the last transient error in the current transaction, namely: the error n...
Definition: rpl_gtid_misc.cc:534
void clear_processing_trx()
Clear only the processing_trx monitoring info.
Definition: rpl_gtid_misc.cc:426
Represents a set of GTIDs.
Definition: rpl_gtid.h:1454
enum_return_status ensure_sidno(rpl_sidno sidno)
Allocates space for all sidnos up to the given sidno in the array of intervals.
Definition: rpl_gtid_set.cc:131
void _add_gtid(rpl_sidno sidno, rpl_gno gno)
Adds the given GTID to this Gtid_set.
Definition: rpl_gtid.h:1516
Sid_map * get_sid_map() const
Return the Sid_map associated with this Gtid_set.
Definition: rpl_gtid.h:1886
This is the abstract base class for binary log events.
Definition: log_event.h:547
Log_event_type get_type_code() const
Definition: log_event.h:804
Utility class to allow RAII pattern with MDL_request and MDL_context classes.
Definition: rpl_rli.h:2249
bool lock(MDL_key::enum_mdl_namespace namespace_arg, enum_mdl_type mdl_type_arg, bool blocking=false)
Uses the target THD object MDL context to acquire the lock identified by namespace_arg with MDL type ...
Definition: rpl_rli.cc:3338
bool is_locked()
Returns whether or not the lock as been acquired within this object life-cycle.
Definition: rpl_rli.cc:3364
THD * m_target
The THD object holding the MDL context used for acquiring/releasing.
Definition: rpl_rli.h:2314
MDL_lock_guard(THD *target)
Constructor that initializes the object and the target THD object but doesn't try to acquire any lock...
Definition: rpl_rli.cc:3328
MDL_request m_request
The MDL request holding the MDL ticket issued upon acquisition.
Definition: rpl_rli.h:2316
virtual ~MDL_lock_guard()
Destructor that unlocks all acquired locks.
Definition: rpl_rli.cc:3357
A pending metadata lock request.
Definition: mdl.h:800
Definition: binlog.h:139
Definition: rpl_mi.h:86
Definition: rpl_mta_submode.h:54
bool empty() const
Definition: prealloced_array.h:225
size_t size() const
Definition: prealloced_array.h:226
A Query event is written to the binary log whenever the database is modified on the master,...
Definition: log_event.h:1273
RAII class to control the slave applier execution context binding with a being handled event.
Definition: rpl_rli.h:2231
Relay_log_info * m_rli
Definition: rpl_rli.h:2232
void set_current_event(Log_event *ev)
Definition: rpl_rli.h:2239
~RLI_current_event_raii()
Definition: rpl_rli.h:2240
RLI_current_event_raii(Relay_log_info *rli_arg, Log_event *ev)
Definition: rpl_rli.h:2235
Definition: rpl_rli.h:201
bool curr_group_seen_begin
Definition: rpl_rli.h:1178
uint checkpoint_group
Definition: rpl_rli.h:1208
static constexpr int RLI_FLUSH_IGNORE_SYNC_OPT
Ignore server sync options and flush.
Definition: rpl_rli.h:1533
static const int LINES_IN_RELAY_LOG_INFO_WITH_WORKERS
Definition: rpl_rli.h:1849
enum_return_check check_if_info_was_cleared(const enum_return_check &previous_result) const
Checks if the underlying Rpl_info handler holds information for the fields to be kept between slave r...
Definition: rpl_rli.cc:1958
enum_require_table_primary_key m_require_table_primary_key_check
Identifies what is the slave policy on primary keys in tables.
Definition: rpl_rli.h:793
Prealloced_array< Slave_job_item, 8 > curr_group_da
Definition: rpl_rli.h:1175
enum_priv_checks_status check_applier_acl_user(char const *param_privilege_checks_username, char const *param_privilege_checks_hostname)
Checks the existence of user provided as part of the PRIVILEGE_CHECKS_USER option.
Definition: rpl_rli.cc:3051
Format_description_log_event * get_rli_description_event() const
Return the current Format_description_log_event.
Definition: rpl_rli.h:1725
ulonglong mts_events_assigned
Definition: rpl_rli.h:1244
char cached_charset[6]
Definition: rpl_rli.h:924
volatile uint32 slave_skip_counter
Definition: rpl_rli.h:898
std::atomic< int32 > atomic_channel_open_temp_tables
Definition: rpl_rli.h:351
TABLE * save_temporary_tables
Definition: rpl_rli.h:345
int stmt_done(my_off_t event_log_pos)
Helper function to do after statement completion.
Definition: rpl_rli.cc:1229
ulong wq_size_waits_cnt
Definition: rpl_rli.h:1248
mysql_cond_t log_space_cond
Definition: rpl_rli.h:901
ulonglong get_group_master_log_pos_info() const
Definition: rpl_rli.h:1578
bool reset_group_relay_log_pos(const char **errmsg)
Reset group_relay_log_name and group_relay_log_pos to the start of the first relay log file.
Definition: rpl_rli.cc:509
void set_event_start_pos(my_off_t pos)
Definition: rpl_rli.h:1630
bool is_in_group() const
A group is defined as the entire range of events that constitute a transaction or auto-committed stat...
Definition: rpl_rli.h:1497
bool cached_charset_compare(char *charset) const
Definition: rpl_rli.cc:1219
int count_relay_log_space()
Definition: rpl_rli.cc:488
int flush_current_log()
Definition: rpl_rli.cc:1859
ulonglong max_updated_index
Definition: rpl_rli.h:1204
Rows_query_log_event * rows_query_ev
Definition: rpl_rli.h:1053
bool is_long_find_row_note_printed()
Definition: rpl_rli.h:1711
void notify_relay_log_change()
Invalidates cached until_log_name and event_relay_log_name comparison result.
Definition: rpl_rli.h:963
int init_until_option(THD *thd, const LEX_MASTER_INFO *master_param)
Initialize until option object when starting slave.
Definition: rpl_rli.cc:2704
bool set_info_search_keys(Rpl_info_handler *to) override
To search in the slave repositories, each slave info object (mi, rli or worker) should use a primary ...
Definition: rpl_rli.cc:2294
bool is_in_trx_or_stmt() const
Auxiliary function used by is_in_group.
Definition: rpl_rli.h:1466
void set_filter(Rpl_filter *channel_filter)
Set replication filter for the channel.
Definition: rpl_rli.h:1796
volatile ulong pending_jobs
Definition: rpl_rli.h:1154
volatile long mts_wq_excess_cnt
Definition: rpl_rli.h:1194
bool curr_group_seen_gtid
Definition: rpl_rli.h:1177
Gtid_set * gtid_set
Definition: rpl_rli.h:723
ulong mts_wq_no_underrun_cnt
Definition: rpl_rli.h:1254
const char * get_group_master_log_name() const
Definition: rpl_rli.h:1568
MY_BITMAP recovery_groups
Definition: rpl_rli.h:1209
table_mapping m_table_map
Definition: rpl_rli.h:1051
ulong mts_slave_worker_queue_len_max
Definition: rpl_rli.h:1158
static const int LINES_IN_RELAY_LOG_INFO_WITH_CHANNEL
Definition: rpl_rli.h:1860
mysql_cond_t logical_clock_cond
Definition: rpl_rli.h:316
bool is_in_stmt() const
Auxiliary function used by is_in_group.
Definition: rpl_rli.h:1452
ulonglong mts_groups_assigned
Definition: rpl_rli.h:1245
bool reinit_sql_thread_io_cache(const char *log, bool need_data_lock)
@ UNTIL_SQL_VIEW_ID
Definition: rpl_rli.h:920
@ UNTIL_MASTER_POS
Definition: rpl_rli.h:915
@ UNTIL_NONE
Definition: rpl_rli.h:914
@ UNTIL_SQL_BEFORE_GTIDS
Definition: rpl_rli.h:917
@ UNTIL_SQL_AFTER_GTIDS
Definition: rpl_rli.h:918
@ UNTIL_SQL_AFTER_MTS_GAPS
Definition: rpl_rli.h:919
@ UNTIL_DONE
Definition: rpl_rli.h:921
@ UNTIL_RELAY_POS
Definition: rpl_rli.h:916
void close_temporary_tables()
Definition: rpl_rli.cc:1001
ulong retried_trans
Definition: rpl_rli.h:933
struct timespec last_clock
Identifies the last time a checkpoint routine has been executed.
Definition: rpl_rli.h:956
Checkable_rwlock * get_sid_lock()
Definition: rpl_rli.h:809
void detach_engine_ha_data(THD *thd)
Detaches the engine ha_data from THD.
Definition: rpl_rli.cc:2784
mysql_mutex_t pending_jobs_lock
Definition: rpl_rli.h:1155
bool inited_hash_workers
Definition: rpl_rli.h:1125
void set_event_relay_log_pos(ulonglong log_pos)
Definition: rpl_rli.h:1633
ulonglong group_relay_log_pos
Definition: rpl_rli.h:698
uchar slave_version_split[3]
Definition: rpl_rli.h:1735
ulong mts_coordinator_basic_nap
Definition: rpl_rli.h:1197
size_t slave_patternload_file_size
Definition: rpl_rli.h:951
char ign_master_log_name_end[FN_REFLEN]
Definition: rpl_rli.h:943
bool recovery_groups_inited
Definition: rpl_rli.h:1210
ulonglong event_relay_log_pos
Definition: rpl_rli.h:702
void end_info()
Definition: rpl_rli.cc:1839
bool rli_fake
Definition: rpl_rli.h:731
ulong opt_replica_parallel_workers
Definition: rpl_rli.h:1199
void set_allow_drop_write_set(bool does_not_require_ws)
Definition: rpl_rli.h:2019
std::atomic< longlong > mts_total_wait_overlap
Definition: rpl_rli.h:1256
time_t get_sql_delay()
Definition: rpl_rli.h:1665
void clear_gtid_monitoring_info()
Clears the Gtid_monitoring_info fields.
Definition: rpl_rli.h:433
char group_master_log_name[FN_REFLEN]
Definition: rpl_rli.h:719
void clear_mts_recovery_groups()
Definition: rpl_rli.h:1334
Prealloced_array< db_worker_hash_entry *, 4 > curr_group_assigned_parts
Definition: rpl_rli.h:1173
const char * get_for_channel_str(bool upper_case=false) const override
Definition: rpl_rli.cc:2669
ulonglong ign_master_log_pos_end
Definition: rpl_rli.h:944
void cleanup_after_query()
Definition: rpl_rli.h:1392
Commit_order_manager * get_commit_order_manager()
Definition: rpl_rli.h:1748
ulong trans_retries
Definition: rpl_rli.h:933
void init_workers(ulong)
The method to invoke at slave threads start.
Definition: rpl_rli.cc:263
~Relay_log_info() override
Definition: rpl_rli.cc:284
uint32 m_flags
Definition: rpl_rli.h:1838
void clear_tables_to_lock()
Definition: rpl_rli.cc:1364
const char * get_until_log_name()
Definition: rpl_rli.cc:2686
void post_rollback()
Execute actions at replicated atomic DLL post rollback time.
Definition: rpl_rli.h:2084
my_off_t event_start_pos
Definition: rpl_rli.h:706
static const int LINES_IN_RELAY_LOG_INFO_WITH_PRIV_CHECKS_HOSTNAME
Definition: rpl_rli.h:1879
bool m_is_engine_ha_data_detached
Definition: rpl_rli.h:1988
static size_t get_number_info_rli_fields()
Definition: rpl_rli.cc:2032
bool reported_unsafe_warning
Definition: rpl_rli.h:1688
static const int LINES_IN_RELAY_LOG_INFO_WITH_ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_VALUE
Definition: rpl_rli.h:1911
void set_require_table_primary_key_check(enum_require_table_primary_key require_pk)
Sets the field that tells what is the slave policy concerning primary keys on replicated tables.
Definition: rpl_rli.cc:3274
RPL_Table_ref * tables_to_lock
Definition: rpl_rli.h:1049
uint64 original_commit_timestamp
Definition: rpl_rli.h:1094
mysql_cond_t pending_jobs_cond
Definition: rpl_rli.h:1156
@ MTS_KILLED_GROUP
Definition: rpl_rli.h:1238
@ MTS_NOT_IN_GROUP
Definition: rpl_rli.h:1234
@ MTS_IN_GROUP
Definition: rpl_rli.h:1236
@ MTS_END_GROUP
Definition: rpl_rli.h:1237
void set_commit_order_manager(Commit_order_manager *mngr)
Definition: rpl_rli.h:1750
std::vector< Slave_worker * > workers_copy_pfs
Definition: rpl_rli.h:1141
static const int LINES_IN_RELAY_LOG_INFO_WITH_REQUIRE_TABLE_PRIMARY_KEY_CHECK
Definition: rpl_rli.h:1896
void set_thd_tx_priority(int priority)
Definition: rpl_rli.h:2007
void fill_coord_err_buf(loglevel level, int err_code, const char *buff_coord) const
Update the error number, message and timestamp fields.
Definition: rpl_rli.cc:553
volatile ulong mts_wq_overrun_cnt
Definition: rpl_rli.h:1247
enum_return_status add_gtid_set(const Gtid_set *gtid_set)
Adds a GTID set to received GTID set.
Definition: rpl_rli.cc:2676
bool replicate_same_server_id
Definition: rpl_rli.h:324
void add_logged_gtid(rpl_sidno sidno, rpl_gno gno)
Definition: rpl_rli.h:811
bool is_time_for_mta_checkpoint()
Check if it is time to compute MTS checkpoint.
Definition: rpl_rli.cc:2920
void set_flag(enum_state_flag flag)
Set the value of a replication state flag.
Definition: rpl_rli.h:1420
std::string m_privilege_checks_hostname
The host name part of the user passed on to PRIVILEGE_CHECKS_USER.
Definition: rpl_rli.h:765
mysql_mutex_t slave_worker_hash_lock
Definition: rpl_rli.h:1127
ulong exit_counter
Definition: rpl_rli.h:1203
int rli_init_info(bool skip_received_gtid_set_recovery=false)
Initialize the relay log info.
Definition: rpl_rli.cc:1493
void reset_notified_relay_log_change()
While a group is executed by a Worker the relay log can change.
Definition: rpl_rli.cc:344
static void set_nullable_fields(MY_BITMAP *nullable_fields)
Sets bits for columns that are allowed to be NULL.
Definition: rpl_rli.cc:2036
bool m_is_applier_source_position_info_invalid
Are positions invalid.
Definition: rpl_rli.h:802
void set_master_info(Master_info *info)
Definition: rpl_rli.cc:1868
bool gtid_retrieved_initialized
Definition: rpl_rli.h:733
ulonglong stats_exec_time
Definition: rpl_rli.h:1268
bool force_flush_postponed_due_to_split_trans
Definition: rpl_rli.h:1746
volatile ulong mts_wq_underrun_w_id
Definition: rpl_rli.h:1183
void clear_processing_trx()
Clears the processing_trx structure fields.
Definition: rpl_rli.h:428
void deinit_workers()
The method to invoke at slave threads stop.
Definition: rpl_rli.cc:282
void clear_privilege_checks_user()
Clears the info related to the data initialized from PRIVILEGE_CHECKS_USER.
Definition: rpl_rli.cc:2957
my_off_t get_event_start_pos()
Definition: rpl_rli.h:1631
bool get_ignore_write_set_memory_limit()
Definition: rpl_rli.h:2015
virtual void post_commit(bool on_rollback)
Cleanup of any side effect that pre_commit() inflicts, including restore of the last executed group c...
Definition: rpl_rli.cc:2856
void start_sql_delay(time_t delay_end)
Indicate that a delay starts.
Definition: rpl_rli.cc:2044
void cached_charset_invalidate()
Last charset (6 bytes) seen by slave SQL thread is cached here; it helps the thread save 3 get_charse...
Definition: rpl_rli.cc:1212
static const int LINES_IN_RELAY_LOG_INFO_WITH_ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_TYPE
Definition: rpl_rli.h:1903
uint tables_to_lock_count
Definition: rpl_rli.h:1050
std::atomic< bool > ignore_log_space_limit
Definition: rpl_rli.h:876
int get_thd_tx_priority()
Definition: rpl_rli.h:2009
bool mts_recovery_group_seen_begin
Definition: rpl_rli.h:1213
bool long_find_row_note_printed
Definition: rpl_rli.h:1931
Deferred_log_events * deferred_events
Definition: rpl_rli.h:1102
Rpl_filter * rpl_filter
Definition: rpl_rli.h:253
ulong replica_parallel_workers
Definition: rpl_rli.h:1201
@ COMMIT_TS_FOUND
Definition: rpl_rli.h:363
@ COMMIT_TS_NOT_FOUND
Definition: rpl_rli.h:361
@ COMMIT_TS_UNKNOWN
Definition: rpl_rli.h:359
ulonglong log_space_limit
Definition: rpl_rli.h:875
Until_option * until_option
Definition: rpl_rli.h:1976
ulonglong mts_total_wait_worker_avail
Definition: rpl_rli.h:1261
int flush_info(const int flush_flags)
Stores the file and position where the execute-slave thread are in the relay log:
Definition: rpl_rli.cc:1924
bool is_relay_log_recovery
Definition: rpl_rli.h:336
Relay_log_info(bool is_slave_recovery, PSI_mutex_key *param_key_info_run_lock, PSI_mutex_key *param_key_info_data_lock, PSI_mutex_key *param_key_info_sleep_lock, PSI_mutex_key *param_key_info_thd_lock, PSI_mutex_key *param_key_info_data_cond, PSI_mutex_key *param_key_info_start_cond, PSI_mutex_key *param_key_info_stop_cond, PSI_mutex_key *param_key_info_sleep_cond, uint param_id, const char *param_channel, bool is_rli_fake)
Definition: rpl_rli.cc:107
bool workers_array_initialized
Definition: rpl_rli.h:1152
bool write_info(Rpl_info_handler *to) override
Definition: rpl_rli.cc:2302
time_t sql_delay_end
During a delay, specifies the point in time when the delay ends.
Definition: rpl_rli.h:1836
void set_ignore_write_set_memory_limit(bool ignore_limit)
Definition: rpl_rli.h:2011
bool mts_wq_oversize
Definition: rpl_rli.h:1161
bool m_privilege_checks_user_corrupted
Tells whether or not the internal data regarding PRIVILEGE_CHECKS_USER is corrupted.
Definition: rpl_rli.h:772
enum_state_flag
Flags for the state of the replication.
Definition: rpl_rli.h:257
@ IN_STMT
The replication thread is inside a statement.
Definition: rpl_rli.h:259
@ STATE_FLAGS_COUNT
Flag counter.
Definition: rpl_rli.h:262
uint event_relay_log_number
Definition: rpl_rli.h:701
enum Relay_log_info::@148 commit_timestamps_status
the status of the commit timestamps for the relay log
ulong mts_recovery_group_cnt
Definition: rpl_rli.h:1211
time_t row_stmt_start_timestamp
Definition: rpl_rli.h:1930
static constexpr int RLI_FLUSH_IGNORE_GTID_ONLY
Flush disresgarding the value of GTID_ONLY.
Definition: rpl_rli.h:1535
void set_group_master_log_name(const char *log_file_name)
Definition: rpl_rli.h:1582
void clear_flag(enum_state_flag flag)
Clear the value of a replication state flag.
Definition: rpl_rli.h:1436
ulong mts_wq_overfill_cnt
Definition: rpl_rli.h:1262
bool belongs_to_client()
Definition: rpl_rli.h:298
void set_future_event_relay_log_pos(ulonglong log_pos)
Definition: rpl_rli.h:1564
bool curr_group_isolated
Definition: rpl_rli.h:1179
void set_long_find_row_note_printed()
Definition: rpl_rli.h:1705
void set_privilege_checks_user_corrupted(bool is_corrupted)
Sets the flag that tells whether or not the data regarding the PRIVILEGE_CHECKS_USER is corrupted.
Definition: rpl_rli.cc:2964
char group_relay_log_name[FN_REFLEN]
Event group means a group of events of a transaction.
Definition: rpl_rli.h:697
time_t get_row_stmt_start_timestamp()
Definition: rpl_rli.h:1695
ulonglong get_future_event_relay_log_pos()
Definition: rpl_rli.h:1561
time_t get_sql_delay_end()
Definition: rpl_rli.h:1667
void cleanup_context(THD *, bool)
Definition: rpl_rli.cc:1276
char new_group_master_log_name[FN_REFLEN]
Storage for holding newly computed values for the last executed event group coordinates while the cur...
Definition: rpl_rli.h:1281
Slave_worker * get_worker(size_t n)
Definition: rpl_rli.h:1298
mysql_mutex_t log_space_lock
Definition: rpl_rli.h:900
ulong adapt_to_master_version(Format_description_log_event *fdle)
adaptation for the slave applier to specific master versions.
Definition: rpl_rli.cc:2505
bool is_engine_ha_data_detached()
Checks whether engine ha data is detached from THD.
Definition: rpl_rli.h:2074
bool is_mts_recovery() const
returns true if there is any gap-group of events to execute at slave starting phase.
Definition: rpl_rli.h:1332
void notify_group_master_log_name_update()
The same as notify_group_relay_log_name_update but for group_master_log_name.
Definition: rpl_rli.h:983
enum_require_row_status
Definition: rpl_rli.h:243
@ PRIV_CHECKS_USER_NOT_NULL
Value for privilege_checks_user is not empty.
@ SUCCESS
Function ended successfully.
Assign_gtids_to_anonymous_transactions_info m_assign_gtids_to_anonymous_transactions_info
Stores the information related to the ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS parameter of CHANGE MAST...
Definition: rpl_rli.h:289
virtual Relay_log_info * get_c_rli()
Get coordinator's RLI.
Definition: rpl_rli.h:1789
void clear_sql_delay()
Reset the delay.
Definition: rpl_rli.h:891
Log_event * current_event
Reference to being applied event.
Definition: rpl_rli.h:1995
time_t mts_last_online_stat
Definition: rpl_rli.h:1273
my_off_t get_until_log_pos()
Definition: rpl_rli.cc:2695
Mts_submode * current_mts_submode
Definition: rpl_rli.h:1320
time_t set_row_stmt_start_timestamp()
Definition: rpl_rli.h:1697
Slave_committed_queue * gaq
Definition: rpl_rli.h:1168
bool is_relay_log_truncated()
Definition: rpl_rli.h:805
bool m_ignore_write_set_memory_limit
If the SQL thread should or not ignore the set limit for write set collection.
Definition: rpl_rli.h:1967
my_off_t new_group_master_log_pos
Definition: rpl_rli.h:1282
bool clear_info()
Clears from this Relay_log_info object all attribute values that are not to be kept.
Definition: rpl_rli.cc:1986
void clear_until_option()
Definition: rpl_rli.h:1773
ulonglong stats_read_time
Definition: rpl_rli.h:1269
bool is_privilege_checks_user_null() const
Returns whether or not there is no user configured for PRIVILEGE_CHECKS_USER.
Definition: rpl_rli.cc:2946
void set_sql_delay(time_t _sql_delay)
Definition: rpl_rli.h:1666
static const int PRIV_CHECKS_HOSTNAME_LENGTH
Definition: rpl_rli.h:1884
bool is_applier_source_position_info_invalid() const
Returns if the applier positions are marked as being invalid or not.
Definition: rpl_rli.cc:3284
bool is_group_master_log_pos_invalid
Flag that the group_master_log_pos is invalid.
Definition: rpl_rli.h:867
void reset_row_stmt_start_timestamp()
Definition: rpl_rli.h:1703
MYSQL_BIN_LOG relay_log
Definition: rpl_rli.h:330
static const int LINES_IN_RELAY_LOG_INFO_WITH_ID
Definition: rpl_rli.h:1855
bool m_require_row_format
Tells if the slave is only accepting events logged with row based logging.
Definition: rpl_rli.h:781
void reset_notified_checkpoint(ulong count, time_t new_ts, bool update_timestamp=false)
While a group is executed by a Worker the relay log can change.
Definition: rpl_rli.cc:371
bool m_allow_drop_write_set
Even if a component says all transactions require write sets, this variable says the SQL thread trans...
Definition: rpl_rli.h:1973
uint rli_checkpoint_seqno
Definition: rpl_rli.h:1206
uint get_event_relay_log_number()
Definition: rpl_rli.h:1614
bool is_until_satisfied_at_start_slave()
Definition: rpl_rli.h:2027
std::pair< const char *, const char * > print_applier_security_context_user_host() const
Returns a printable representation of the username and hostname currently being used in the applier s...
Definition: rpl_rli.cc:3077
static const int MAXIMUM_LINES_IN_RELAY_LOG_INFO_FILE
Definition: rpl_rli.h:1917
void set_group_master_log_pos(ulonglong log_pos)
Definition: rpl_rli.h:1586
volatile my_off_t group_master_log_pos
Definition: rpl_rli.h:720
long mts_worker_underrun_level
Definition: rpl_rli.h:1195
bool is_until_satisfied_before_dispatching_event(const Log_event *ev)
Definition: rpl_rli.h:2031
ulonglong get_group_relay_log_pos()
Definition: rpl_rli.h:1593
void set_group_relay_log_name(const char *log_file_name, size_t len)
Definition: rpl_rli.h:1598
int inc_group_relay_log_pos(ulonglong log_pos, bool need_data_lock, bool force=false)
Last executed event group coordinates are updated and optionally forcibly flushed to a repository.
Definition: rpl_rli.cc:929
ulonglong log_space_total
Definition: rpl_rli.h:875
bool is_group_relay_log_name_invalid(const char **errmsg)
Check if group_relay_log_name is in index file.
Definition: rpl_rli.cc:523
Relay_log_info & operator=(const Relay_log_info &info)
const char * get_rpl_log_name() const
Definition: rpl_rli.h:1636
void set_until_option(Until_option *option)
Definition: rpl_rli.h:1767
void finished_processing()
When the processing of a transaction is completed, that timestamp is recorded, the information is cop...
Definition: rpl_rli.h:415
enum_priv_checks_status set_privilege_checks_user(char const *param_privilege_checks_username, char const *param_privilege_checks_hostname)
Initializes data related to PRIVILEGE_CHECKS_USER, specifically the user name and the user hostname.
Definition: rpl_rli.cc:2970
int purge_relay_logs(THD *thd, const char **errmsg, bool delete_only=false)
Purges relay logs.
Definition: rpl_rli.cc:1033
bool is_privilege_checks_user_corrupted() const
Returns whether or not the internal data regarding PRIVILEGE_CHECKS_USER is corrupted.
Definition: rpl_rli.cc:2953
bool is_until_satisfied_after_dispatching_event()
Definition: rpl_rli.h:2035
enum_priv_checks_status initialize_security_context(THD *thd)
Initializes the security context associated with the PRIVILEGE_CHECKS_USER user that is to be used by...
Definition: rpl_rli.cc:3219
void set_group_relay_log_pos(ulonglong log_pos)
Definition: rpl_rli.h:1601
const char * get_group_relay_log_name()
Definition: rpl_rli.h:1592
enum_priv_checks_status check_privilege_checks_user()
Checks the validity and integrity of the data related to PRIVILEGE_CHECKS_USER, specifically the user...
Definition: rpl_rli.cc:3000
const char * get_event_relay_log_name()
Definition: rpl_rli.h:1605
virtual int set_rli_description_event(Format_description_log_event *fdle)
Delete the existing event and set a new one.
Definition: rpl_rli.cc:2385
Gtid_monitoring_info * gtid_monitoring_info
Stores information on the last processed transaction or the transaction that is currently being proce...
Definition: rpl_rli.h:748
const char * add_channel_to_relay_log_name(char *buff, uint buff_size, const char *base_name)
sets the suffix required for relay log names in multisource replication.
Definition: rpl_rli.cc:1180
size_t get_worker_count()
Definition: rpl_rli.h:1287
ulonglong get_group_master_log_pos() const
Definition: rpl_rli.h:1575
const char * get_group_master_log_name_info() const
Definition: rpl_rli.h:1571
void report_privilege_check_error(enum loglevel level, enum_priv_checks_status status_code, bool to_client, char const *channel_name=nullptr, char const *user_name=nullptr, char const *host_name=nullptr) const
Outputs the error message associated with applier thread user privilege checks error error_code.
Definition: rpl_rli.cc:3095
enum_require_table_primary_key
Identifies what is the replica policy on primary keys in tables.
Definition: rpl_rli.h:268
@ PK_CHECK_ON
The replica enforces tables to have primary keys for a given channel.
Definition: rpl_rli.h:277
@ PK_CHECK_STREAM
The replica sets the value of sql_require_primary_key according to the source replicated value.
Definition: rpl_rli.h:275
@ PK_CHECK_OFF
The replica does not enforce any policy around primary keys.
Definition: rpl_rli.h:279
@ PK_CHECK_GENERATE
The replica generates GIPKs for incoming keyless tables.
Definition: rpl_rli.h:281
@ PK_CHECK_NONE
No policy, used on PFS.
Definition: rpl_rli.h:270
void started_processing(Gtid gtid_arg, ulonglong original_ts_arg, ulonglong immediate_ts_arg, bool skipped=false)
Stores the details of the transaction which has just started processing.
Definition: rpl_rli.h:384
bool pre_commit()
The method implements a pre-commit hook to add up a new statement typically to a DDL transaction to u...
Definition: rpl_rli.h:2096
void retried_processing(uint transient_errno_arg, const char *transient_err_message_arg, ulong trans_retries_arg)
When a transaction is retried, the error number and message, and total number of retries are stored.
Definition: rpl_rli.h:444
static constexpr int RLI_FLUSH_NO_OPTION
No flush options given to relay log flush.
Definition: rpl_rli.h:1531
bool sql_thread_kill_accepted
Definition: rpl_rli.h:1693
static const int PRIV_CHECKS_USERNAME_LENGTH
Definition: rpl_rli.h:1872
void slave_close_thread_tables(THD *)
Definition: rpl_rli.cc:1405
enum_priv_checks_status
Set of possible return values for the member methods related to PRIVILEGE_CHECKS_USER management.
Definition: rpl_rli.h:209
@ USERNAME_NULL_HOSTNAME_NOT_NULL
Value for the username part of the user is NULL but the value for the hostname is not NULL.
@ USER_DOES_NOT_HAVE_PRIVILEGES
Provided user doesn't have the necessary privileges to execute the needed operations.
@ USER_ANONYMOUS
Value for user is anonymous (''@'...')
@ USERNAME_TOO_LONG
Value for the username part of the user is larger than 32 characters.
@ HOSTNAME_TOO_LONG
Value for the hostname part of the user is larger than 255 characters.
@ LOAD_DATA_EVENT_NOT_ALLOWED
Provided user doesn't have FILE privileges during the execution of a LOAD DATAevent.
@ USER_DATA_CORRUPTED
Values provided for the internal variables are corrupted.
@ USER_DOES_NOT_EXIST
Provided user doesn't exists.
@ SUCCESS
Function ended successfully.
@ HOSTNAME_SYNTAX_ERROR
Value for the hostname part of the user has illegal characters.
bool ddl_not_atomic
Raised when slave applies and writes to its binary log statement which is not atomic DDL and has no X...
Definition: rpl_rli.h:2005
bool get_flag(enum_state_flag flag)
Get the value of a replication state flag.
Definition: rpl_rli.h:1429
static const int LINES_IN_RELAY_LOG_INFO_WITH_REQUIRE_ROW_FORMAT
Definition: rpl_rli.h:1889
void inc_event_relay_log_pos()
Definition: rpl_rli.h:988
volatile ulong abort_pos_wait
Definition: rpl_rli.h:899
bool read_info(Rpl_info_handler *from) override
Definition: rpl_rli.cc:2050
void started_processing(Gtid_log_event *gtid_log_ev_arg)
Stores the details of the transaction which has just started processing.
Definition: rpl_rli.h:398
struct timespec stats_begin
Definition: rpl_rli.h:1271
mysql_mutex_t exit_count_lock
Definition: rpl_rli.h:1157
void notify_relay_log_truncated()
Receiver thread notifies that it truncated some data from relay log.
Definition: rpl_rli.cc:2909
uint relay_log_name_to_number(const char *name)
Definition: rpl_rli.cc:2661
Sid_map * get_sid_map()
Definition: rpl_rli.h:807
time_t last_event_start_time
Definition: rpl_rli.h:1091
ulonglong get_event_relay_log_pos()
Definition: rpl_rli.h:1606
void relay_log_number_to_name(uint number, char name[FN_REFLEN+1])
Given the extension number of the relay log, gets the full relay log path.
Definition: rpl_rli.cc:2648
ulong adapt_to_master_version_updown(ulong master_version, ulong current_version)
The method compares two supplied versions and carries out down- or up- grade customization of executi...
Definition: rpl_rli.cc:2585
enum_priv_checks_status initialize_applier_security_context()
Initializes the security context associated with the PRIVILEGE_CHECKS_USER user that is to be used by...
Definition: rpl_rli.cc:3255
static const int LINES_IN_RELAY_LOG_INFO_WITH_PRIV_CHECKS_USERNAME
Definition: rpl_rli.h:1867
ulonglong mts_pending_jobs_size
Definition: rpl_rli.h:1159
Format_description_log_event * rli_description_event
Definition: rpl_rli.h:1801
bool mts_finalize_recovery()
Called when gaps execution is ended so it is crash-safe to reset the last session Workers info.
Definition: rpl_rli.cc:428
enum Relay_log_info::@150 mts_group_status
void set_group_relay_log_name(const char *log_file_name)
Definition: rpl_rli.h:1594
int thd_tx_priority
Definition: rpl_rli.h:1961
my_off_t new_group_relay_log_pos
Definition: rpl_rli.h:1284
void clear_relay_log_truncated()
Applier clears the flag after it handled the situation.
Definition: rpl_rli.cc:2915
enum Relay_log_info::@149 until_condition
Replication_transaction_boundary_parser transaction_parser
Definition: rpl_rli.h:648
char slave_patternload_file[FN_REFLEN]
Definition: rpl_rli.h:950
ulong mts_recovery_index
Definition: rpl_rli.h:1212
void unset_long_find_row_note_printed()
Definition: rpl_rli.h:1707
mysql_mutex_t mts_temp_table_LOCK
Definition: rpl_rli.h:310
bool deferred_events_collecting
Definition: rpl_rli.h:1108
bool m_relay_log_truncated
It will be set to true when receiver truncated relay log for some reason.
Definition: rpl_rli.h:755
bool is_mts_in_group()
returns true if Coordinator is scheduling events belonging to the same group and has not reached yet ...
Definition: rpl_rli.h:1357
time_t last_master_timestamp
Definition: rpl_rli.h:885
bool is_parallel_exec() const
returns true if events are to be executed in parallel
Definition: rpl_rli.h:1345
int wait_for_gtid_set(THD *thd, const char *gtid, double timeout, bool update_THD_status=true)
Wait for a GTID set to be executed.
Definition: rpl_rli.cc:769
malloc_unordered_map< std::string, unique_ptr_with_deleter< db_worker_hash_entry > > mapping_db_to_worker
Definition: rpl_rli.h:1124
bool error_on_rli_init_info
Definition: rpl_rli.h:456
std::string get_privilege_checks_username() const
Retrieves the username part of the PRIVILEGE_CHECKS_USER option of CHANGE MASTER TO statement.
Definition: rpl_rli.cc:2938
static const int LINES_IN_RELAY_LOG_INFO_WITH_DELAY
Definition: rpl_rli.h:1844
Master_info * mi
Definition: rpl_rli.h:348
std::atomic< bool > sql_force_rotate_relay
Definition: rpl_rli.h:883
std::string m_privilege_checks_username
The user name part of the user passed on to PRIVILEGE_CHECKS_USER.
Definition: rpl_rli.h:760
bool is_processing_trx()
Definition: rpl_rli.h:420
bool is_row_format_required() const
Returns whether the slave is running in row mode only.
Definition: rpl_rli.cc:3260
const Gtid_set * get_gtid_set() const
Definition: rpl_rli.h:827
void cleanup_after_session()
Definition: rpl_rli.h:1396
PSI_mutex_key m_key_mta_temp_table_LOCK
Definition: rpl_rli.h:304
virtual bool commit_positions()
The method implements updating a slave info table.
Definition: rpl_rli.cc:2805
char event_relay_log_name[FN_REFLEN]
Definition: rpl_rli.h:699
enum_require_table_primary_key get_require_table_primary_key_check() const
Returns what is the slave policy concerning primary keys on replicated tables.
Definition: rpl_rli.cc:3270
Slave_worker_array workers
Definition: rpl_rli.h:1119
bool get_allow_drop_write_set()
Definition: rpl_rli.h:2023
ulonglong future_event_relay_log_pos
Definition: rpl_rli.h:703
Commit_order_manager * commit_order_mngr
Definition: rpl_rli.h:1809
struct timespec ts_exec[2]
Definition: rpl_rli.h:1270
std::string get_privilege_checks_hostname() const
Retrieves the host part of the PRIVILEGE_CHECKS_USER option of CHANGE MASTER TO statement.
Definition: rpl_rli.cc:2942
Gtid_monitoring_info * get_gtid_monitoring_info()
Definition: rpl_rli.h:369
char new_group_relay_log_name[FN_REFLEN]
Definition: rpl_rli.h:1283
void set_event_relay_log_name(const char *log_file_name)
Definition: rpl_rli.h:1607
void set_applier_source_position_info_invalid(bool invalid)
Marks the applier position information as being invalid or not.
Definition: rpl_rli.cc:3280
int wait_for_pos(THD *thd, String *log_name, longlong log_pos, double timeout)
Waits until the SQL thread reaches (has executed up to) the log/position or timed out.
Definition: rpl_rli.cc:589
void set_require_row_format(bool require_row)
Sets the flag that tells whether or not the slave is running in row mode only.
Definition: rpl_rli.cc:3264
void reattach_engine_ha_data(THD *thd)
Reattaches the engine ha_data to THD.
Definition: rpl_rli.cc:2794
bool mts_end_group_sets_max_dbs
Definition: rpl_rli.h:1180
time_t sql_delay
Delay slave SQL thread by this amount of seconds.
Definition: rpl_rli.h:1826
mysql_cond_t slave_worker_hash_cond
Definition: rpl_rli.h:1128
Relay_log_info(const Relay_log_info &info)
Slave_worker * last_assigned_worker
Definition: rpl_rli.h:1163
ulong recovery_parallel_workers
Definition: rpl_rli.h:1205
ulonglong mts_pending_jobs_size_max
Definition: rpl_rli.h:1160
bool get_table_data(TABLE *table_arg, table_def **tabledef_var, TABLE **conv_table_var) const
Definition: rpl_rli.h:1055
enum_mts_parallel_type channel_mts_submode
Definition: rpl_rli.h:1318
void set_event_relay_log_number(uint number)
Definition: rpl_rli.h:1615
mysql_mutex_t mts_gaq_LOCK
Definition: rpl_rli.h:315
This is the class for verifying transaction boundaries in a replication event stream.
Definition: rpl_trx_boundary_parser.h:50
Common base class for all row-containing log events.
Definition: log_event.h:2598
It is used to record the original query for the rows events in RBR.
Definition: log_event.h:3561
Rpl_filter.
Definition: rpl_filter.h:213
Definition: rpl_info_factory.h:43
Definition: rpl_info_handler.h:57
Definition: rpl_info.h:42
mysql_mutex_t data_lock
Definition: rpl_info.h:57
bool is_transactional() const
Definition: rpl_info.h:110
THD * info_thd
Definition: rpl_info.h:77
A set of THD members describing the current authenticated user.
Definition: sql_security_ctx.h:53
Represents a bidirectional map between SID and SIDNO.
Definition: rpl_gtid.h:723
Checkable_rwlock * get_sid_lock() const
Return the sid_lock.
Definition: rpl_gtid.h:826
Group Assigned Queue whose first element identifies first gap in committed sequence.
Definition: rpl_rli_pdb.h:350
Definition: rpl_rli_pdb.h:497
Using this class is fraught with peril, and you need to be very careful when doing so.
Definition: sql_string.h:166
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:33
Gtid owned_gtid
The GTID of the currently owned transaction.
Definition: sql_class.h:3708
bool slave_thread
Definition: sql_class.h:2676
Relay_log_info * rli_slave
Definition: sql_class.h:1065
enum enum_thread_type system_thread
Definition: sql_class.h:2469
System_variables variables
Definition: sql_lexer_thd.h:61
bool is_commit_in_middle_of_statement
Definition: sql_class.h:3866
bool is_operating_substatement_implicitly
Definition: sql_class.h:2292
Definition: table.h:2755
Table_ref * next_global
Definition: table.h:3448
This is the abstract base class for slave start until options.
Definition: rpl_replica_until_options.h:55
bool is_satisfied_after_dispatching_event()
check if the until option is satisfied after applied or dispatched a event.
Definition: rpl_replica_until_options.h:96
bool is_satisfied_before_dispatching_event(const Log_event *ev)
check if the until option is satisfied before applying or dispatching a event.
Definition: rpl_replica_until_options.h:82
bool is_satisfied_at_start_slave()
Check if the until option is already satisfied at coordinator starting.
Definition: rpl_replica_until_options.h:66
unsigned long long int original_commit_timestamp
Timestamp when the transaction was committed on the originating master.
Definition: control_events.h:995
unsigned long long int immediate_commit_timestamp
Timestamp when the transaction was committed on the nearest master.
Definition: control_events.h:997
uint16_t error_code
Definition: statement_events.h:559
std::unordered_map, but with my_malloc, so that you can track the memory used using PSI memory keys.
Definition: map_helpers.h:147
A table definition from the master.
Definition: rpl_utility.h:247
Maps table id's (integers) to table pointers.
Definition: rpl_tblmap.h:50
#define mysql_mutex_lock(M)
Definition: mysql_mutex.h:49
#define mysql_mutex_unlock(M)
Definition: mysql_mutex.h:56
#define base_name(A)
Definition: my_sys.h:705
uint sql_replica_skip_counter
a copy of active_mi->rli->slave_skip_counter, for showing in SHOW GLOBAL VARIABLES,...
Definition: rpl_replica.cc:8765
bool is_atomic_ddl(THD *thd, bool using_trans_arg)
The function lists all DDL instances that are supported for crash-recovery (WL9175).
Definition: log_event.cc:3719
unsigned int PSI_mutex_key
Instrumented mutex key.
Definition: psi_mutex_bits.h:51
static int flag
Definition: hp_test1.cc:39
std::string log_file_name(const Log_files_context &ctx, Log_file_id file_id)
Provides name of the log file with the given file id, e.g.
Definition: log0files_io.cc:728
Binary log event definitions.
char * strmake(char *dst, const char *src, size_t length)
Definition: strmake.cc:42
std::unique_ptr< T, void(*)(T *)> unique_ptr_with_deleter
std::unique_ptr, but with a custom delete function.
Definition: map_helpers.h:88
void bitmap_free(MY_BITMAP *map)
Definition: my_bitmap.cc:157
#define DBUG_PRINT(keyword, arglist)
Definition: my_dbug.h:180
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:55
ulonglong my_off_t
Definition: my_inttypes.h:71
unsigned char uchar
Definition: my_inttypes.h:51
long long int longlong
Definition: my_inttypes.h:54
uint64_t uint64
Definition: my_inttypes.h:68
uint32_t uint32
Definition: my_inttypes.h:66
Common #defines and includes for file and socket I/O.
#define FN_REFLEN
Definition: my_io.h:82
Definition of the global "loglevel" enumeration.
loglevel
Definition: my_loglevel.h:40
Defines various enable/disable and HAVE_ macros related to the performance schema instrumentation sys...
#define HAVE_PSI_INTERFACE
Definition: my_psi_config.h:38
Common header for many mysys elements.
static int count
Definition: myisam_ftdump.cc:42
Instrumentation helpers for conditions.
ABI for instrumented mutexes.
Log info(cout, "NOTE")
@ QUERY_EVENT
Definition: binlog_event.h:288
const std::string charset("charset")
static bool timeout(bool(*wait_condition)())
Timeout function.
Definition: log0meb.cc:495
std::vector< T, ut::allocator< T > > vector
Specialization of vector which uses allocator.
Definition: ut0new.h:2872
Instrumentation helpers for mutexes.
PSI_memory_key key_memory_db_worker_hash_entry
Definition: psi_memory_key.cc:103
Instrumentation helpers for mutexes.
#define OPTION_BEGIN
Definition: query_options.h:74
required uint32 status
Definition: replication_asynchronous_connection_failover.proto:60
required uint32 priority
Definition: replication_group_member_actions.proto:34
required string event
Definition: replication_group_member_actions.proto:31
enum_return_status
Generic return type for many functions that can succeed or fail.
Definition: rpl_gtid.h:121
int rpl_sidno
Type of SIDNO (source ID number, first component of GTID)
Definition: rpl_gtid.h:95
binary_log::gtids::gno_t rpl_gno
GNO, the second (numeric) component of a GTID, is an alias of binary_log::gtids::gno_t.
Definition: rpl_gtid.h:102
@ ASSIGNED_GTID
Specifies that the transaction has been assigned a GTID (UUID:NUMBER).
Definition: rpl_gtid.h:3698
enum_return_check
Definition: rpl_info_handler.h:50
enum_mts_parallel_type
Definition: rpl_mta_submode.h:46
bool operator!(Relay_log_info::enum_priv_checks_status status)
Negation operator for enum_priv_checks_status, to facilitate validation against SUCCESS.
Definition: rpl_rli.cc:2930
Prealloced_array< Slave_worker *, 4 > Slave_worker_array
Definition: rpl_rli.h:78
struct slave_job_item Slave_job_item
bool is_mts_worker(const THD *thd)
Definition: rpl_rli.h:2142
bool is_committed_ddl(Log_event *ev)
Checks whether the supplied event encodes a (2pc-aware) DDL that has been already committed.
Definition: rpl_rli.h:2158
bool is_atomic_ddl_commit_on_slave(THD *thd)
Checks whether the transaction identified by the argument is executed by a slave applier thread is an...
Definition: rpl_rli.h:2190
bool mysql_show_relaylog_events(THD *thd)
Execute a SHOW RELAYLOG EVENTS statement.
Definition: rpl_rli.cc:1448
bool is_mts_db_partitioned(Relay_log_info *rli)
Auxiliary function to check if we have a db partitioned MTS.
Definition: rpl_rli.cc:2665
Replication transaction boundary parser.
enum_mdl_type
Type of metadata lock request.
Definition: sql_lexer_yacc_state.h:105
case opt name
Definition: sslopt-case.h:32
TODO: Move this structure to libbinlogevents/include/control_events.h when we start using C++11.
Definition: rpl_gtid.h:1065
rpl_sidno sidno
SIDNO of this Gtid.
Definition: rpl_gtid.h:1067
Structure to hold parameters for CHANGE MASTER, START SLAVE, and STOP SLAVE.
Definition: sql_lex.h:350
enum_mdl_namespace
Object namespaces.
Definition: mdl.h:399
const char * str
Definition: mysql_lex_string.h:40
Definition: my_bitmap.h:42
Extend the normal Table_ref with a few new fields needed by the slave thread, but nowhere else.
Definition: rpl_utility.h:511
LEX_CSTRING table_name
Definition: table.h:771
LEX_CSTRING db
Definition: table.h:770
Definition: table.h:1395
TABLE_SHARE * s
Definition: table.h:1396
Legends running throughout the module:
Definition: rpl_rli_pdb.h:73
An instrumented cond structure.
Definition: mysql_cond_bits.h:49
An instrumented mutex structure.
Definition: mysql_mutex_bits.h:49
Definition: rpl_rli.h:80
Log_event * data
Definition: rpl_rli.h:81
my_off_t relay_pos
Definition: rpl_rli.h:83
uint relay_number
Definition: rpl_rli.h:82
static bool update_timestamp(THD *thd, set_var *var)
Definition: sys_vars.cc:5597
@ SYSTEM_THREAD_SLAVE_WORKER
Definition: thread_type.h:41
@ SYSTEM_THREAD_SLAVE_SQL
Definition: thread_type.h:36
Include file for Sun RPC to compile out of the box.
unsigned int uint
Definition: uca-dump.cc:29
int n
Definition: xcom_base.cc:508