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