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