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