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